We’ve been heads down on building the future of the decentralized web. There’s plenty to do, but we feel it’s important to keep you in the loop. So today, we’ve got some updates for you form our Platform Team, which is comprised of some of our top-notch engineers, product, and design resources.

Here’s what we’ve been up to in September.

0.1 Milestone Release

We hit an important milestone this month that we called our 0.1 Release. You can see more details that one of our engineers, Paul Le Cam, described in a recent Show & Tell.

The quick-and-dirty release notes for this milestone are essentially two main flows of our developer and end user experiences on the Mainframe platform:

Developers can author, sign, and deploy dApps to Swarm End users can install and run dApps from Swarm

To get started playing with the 0.1 release, go here.

Show & Tell

Due to our workloads and wanting to stay as focused as possible, we decided to move our Show & Tell frequency to once a month rather than bi-weekly. This lets us show more and ship more! 👏👏👏

Check out our September Show & Tell here.

Clement Jaquier demoing an upcoming version of the homepage

Roundtables

Every week we spend time on air discussing various engineering topics. Some are theoretical, some are very close to the ground level of the problems we’re solving. We had some great discussions this month on topics such as:

Team and Service Layer Updates

Mainframe is a platform for developers that enables them to build bulletproof decentralized applications. Our platform is a big undertaking that consists of SDKs, service layers that provide developers needed functionality in their dApps, and components, services and tools developers will need to easily author, sign, ship, and deploy their dApps to the decentralized ecosystem.

A snapshot of the Mainframe platform

Service Layer Update: Communications

Shane Howley

This month we spent time reviewing assumptions that we previously made for our path and direction towards the 0.2 release. We re-evaluated our goals and steps that would deliver the most value immediately to potential developers on the Mainframe platform.

Our discussions have culminated in realigning the next release as a developer ready platform release with as much service layer functionality exposed as we can possibly manage! We also plan to deliver a number of example dApps launching alongside that will demonstrate some of the functionality that developers will be able to leverage on the Mainframe platform.

Service Layer Update: Architecture and Tooling

Paul Le Cam and Adam Clarke

On the architecture and tooling team we’ve been focused on releasing our first milestone, the alpha v0.1, in order to bootstrap our internal app creation.

Most of our efforts have been towards improving the developer experience of the app creation flow, allowing developers to interact with their app locally before publishing it.

We are now focusing on implementing new user flows and platform features, notably supporting wallets, payments and smart contracts in a secure and trusted way.

Watch/listen to Paul reviewing the 0.1 release in a recent Roundtable here.

Adam and Paul also demoed their latest work in our Show & Tell.

Adam Clarke demoing some updates in the “Launcher”

Service Layer Update: Storage

Miloš Mošić and Doug Leonard

Much of the storage team’s work has been focused on a Javscript library for swarm which we named Erebos. This is exciting news! Erebos is the only well-supported Swarm library in Javascript, and has the support of the core Swarm team.

Recently, Miloš and Paul described the release of Erebos and what it aims to accomplish in a separate blog post.

Service Layer Update: Identity

Duane Johnson

We’ve re-prioritized our short-term goals for Identity in order to build essential capabilities for our January release of Mainframe Terminal.

Most of the reference dApps that we’d like to show early next year rely on some kind of “identity” interaction with Terminal — interaction that provides the user with an opportunity to consent to or refuse actions that affect his or her identity and personal contacts. With that in mind, we’ve decided to wait until after the first release of Terminal to implement decentralized, Self-Sovereign Identity (SSI), and focus on the immediate capabilities of the platform UI.

That said, the parts that we build will lead into SSI in the future: what we’re building now is necessary in all cases, so it is not a diversion from the ultimate goal of SSI. Here are some of the features we’ve determined will be essential in both the short-run and the long-run as we work towards true decentralized identity:

the user will be able to enter information about him/herself (i.e. make “self-claims”)

dApps will be able to request self-claimed information from the user

the user will be able to create a contact list (aka Address Book)

dApps will be able to request to use entries in the contact list

users will be able to exchange keys out-of-band in order to communicate securely (private connection)

users will be able to advertise a public front door in order to invite anyone to start a chat (public connection)

With regard to the public front door, we’re interested in finding the right balance of privacy, ease-of-use, and time-to-implement. Our roundtable discussion this week focused on the technical options we’ve considered for a “first contact” scenario, with various pros and cons.

Service Layer Update: Compute

Camron Levanger

Verifiable Computing

There are numerous rabbit holes in which to dive. Can we make reasonable use of fully homomorphic encryption (FHE) without incurring latency that renders the computing layer useless? What about using or implementing a VC (verifiable computing) library? These are large and complicated subjects in themselves. But, our desire to provide functionality to our developers as quickly as possible certainly plays an important role in what, and how we execute.

Right now our efforts will be focused on using secure enclaves such as Intel’s SGX. Mainframe nodes will advertise themselves as a computing resource. Developers will be able to post “functions” (docker images containing the code to be run) to the network and have their code securely, and privately executed by (N) worker nodes. Client and server will negotiate services and exchange keys up front. The code and the results of the function will be fully encrypted between client/server to ensure both security and privacy. Additionally, the node operator will not be able to read the code or results out of the secure enclave. This deterministic computing architecture will verify the results of the function by using more than 1 worker node. N number of worker nodes will pick up the job and execute, after which the results from all nodes will be compared in order to verify. Functions will have access to our Erebos library in all computing nodes and additional functionality wrapping push notifications, etc. will be implemented.

We are very excited to be partnering with well-known and experienced cryptography experts to help us provide the most sound platform possible right out of the gate. Our goal is to quickly provide needed computing resources on our platform while still being as private and secure as possible. We feel that the outlined architecture is the best way to achieve that goal at this time. But, we fully intend to continue iterating. With the many areas to be researched, such as the potential to deploy VC on top of FHE, our partnership with these cryptographers will be key in the success of this platform layer.

dApps Update

Sarah Wiley

This past week I researched, worked on, jumped through sufficient hoops, and ultimately successfully created a reference web2 app that integrates a number of relevant libraries, including @erebos/swarm-browser, @morpheus-ui/core, and bluzelle. The main purpose of the app was a learning exercise for me, and served as proof of concept merely that it could be done.

You can see Sarah working through her POC in a recent Show & Tell here.

Sarah’s POC

If you want to follow along, check out a walkthrough here.

Overall both Bluzelle and Erebos were easy to use and very responsive and performant. I ran into a CORS header issue inside the swarm node which I was able to fix in my local build and alerted the swarm team who will fix it in a future release. Next I plan to integrate my reference app with the Mainframe Launcher and integrate with the Mainframe SDK so I can legitimately call it a Mainframe dApp.

Watch Sarah demo her sample dApp in a recent Show & Tell here.

How to Get Involved

As we’ve said before, we’re up to the task, but we want to work with you to build the future. Come and help us build a secure, private world, the way data was meant to be shared. Here’s how you can help.

Check out our Jobs page

Participate in our weekly Roundtable on our YouTube channel

Join our developer discussion forum

Ask a question in our real-time chat

Watch for Show & Tell’s being broadcast on our YouTube channel

Thanks for reading, and here’s to the future! 🥂