Ockam VS nearcore

disclosure: I work at Ockam.

The Portals for Mac app is an example of the type of thing you could build using the open source stack of protocols. The README (linked by parent) links out to all of the relevant parts of the protocol documentation to explain how these work together. The NAT Traversal (https://github.com/build-trust/ockam/blob/develop/examples/a...) part of the README is probably the best explanation of why the free relay you get via Ockam Orchestrator is a useful part of this demo.

As for why would anyone trust this: The protocols are designed so you absolutely don't have to trust the relay. Trust is pushed out to the edges that you control and so you're not susceptible to a MITM attack if something like a relay is compromised. The protocol design for all of this is open and documented, and was independently audited by (IMO) some of the best in the business, Trail of Bits: https://docs.ockam.io/reference/protocols.

🚀 Portals for Mac – A macOS app built in Swift that uses the Ockam Rust library to privately share a service on your Mac with anyone, anywhere. The service is shared securely over an end-to-end encrypted and mutually authenticated Ockam Portal. Your friends will have access to it on their localhost! This app is a great example of the kinds of things you can build with Ockam 👉

Ockam is a suite of programming libraries, command line tools, and managed cloud services to orchestrate end-to-end encryption, mutual authentication, key management, credential management, and authorization policy enforcement — all at massive scale. Ockam's end-to-end secure channels guarantee authenticity, integrity, and confidentiality of all data-in-motion at the application layer.

We’ve been working on something (https://github.com/build-trust/ockam) that enables exactly this, among a whole host of other use cases. If you check out some of the code examples in the docs you’ll see how to setup a tunnel using the CLI.

For other use cases there’s also the programming libraries (only Rust atm, though I was spiking a TypeScript/Node PoC this week) which might provide more flexibility. Personally I’m excited by the idea of being able to move this kind of secure by design connectivity all the way into the application layer though.

If you're not already an active contributor to an open source project or two it can seem very daunting. You don't want to do the wrong thing and embarrass yourself. Remove that anxiety for people by giving them an easy way to do something low risk. Matt did that a couple of years ago by creating a long-lived issue for people to simply say hello. That's it. Say hi, introduce yourself. It's a safe place to make a first step.

And here's a full blockchain PoS ecosystem built on Rust called NEAR protocol: https://github.com/near/nearcore

NEAR is introducing near.org—a composable frontend for Web3. It allows end users to effortlessly discover all of Web3's possibilities in one seamless experience. For developers, it's a playground to create and code interfaces with the ability to fork a host of components, making app development faster and more efficient than ever before.

On near.org, users will be prompted to opt-in to the new push notification system on their desktop and iOS/Android mobile browsers. To enable browser push notifications on iOS, users need to update their device to at least iOS 16.4 and add the near.org website as an app icon to their home screen. Once users accept the prompt, they will start receiving notifications for baseline social activities on their accounts. All notifications can be viewed in the notification center, and users can customize their notification preferences through the designated settings menu.

NEAR Protocol - Developer-friendly blockchain built for performance and usability. Supports development in Rust and AssemblyScript.

DESCRIPTION: NEAR DevHub is an open-source ecosystem that has funding from NEAR stakeholders to evolve developer experience building apps on NEAR (https://near.org). NEAR is a permissionless protocol that enables projects that don't have a single point of trust to be deployed. NEAR reference implementation is implemented in Rust, and thanks to Wasm runtime apps for NEAR can also be built in Rust, so there is a whole stack of developer tools in Rust: https://github.com/near. NEAR DevHub is happy to compensate contributors to the open-source developer tools on NEAR, and there is an excellent onboarding Fellowship Program to do that efficiently.

How about https://near.org ?

We foresee that NEAR Protocol would gain the attention of builders with their account model, which already implemented Multiple keypairs as the secret key.

▪ Network Usage with network processing more than $272million worth of crypto payments 🔥 ▪ 9 New payment chains, including the 1st non-EVM chain, NEAR Protocol ▪ New features, including payment streams, escrow and batch payments ▪ New builder Huma Finance, & what else is in store for 2023 👀