Macula Mesh Use Build Macula for… Docs Contact

Macula · sectors · All Macula for… pages

With Macula a phone app embeds a node with its own key in the phone's keystore, so other phones and services call the app on the phone itself, through relay stations that pass the call on and keep no copy. No server, your own or Firebase, receives and stores every message. The phone dials out, so it opens no port, and every call to it is end-to-end encrypted, so the stations in between carry only ciphertext. Without Macula, by contrast, a phone app is a client of a backend, the developer's own or a cloud service such as Firebase, and every message and photo passes through it. We are looking for partners to build it with.

Without Macula: every message goes through a backend server

Almost every app treats the phone as a screen for a server: the developer's own backend, or a backend-as-a-service such as Firebase. For two phones to exchange anything, someone builds and runs that backend, and every message, every photo and every key passes through it.

a server bill

A backend of your own needs servers, accounts and a database

Even a small app needs them before two users can reach each other. When the backend goes down, so does the app.

one database leaks all

An app built on Firebase sends every photo through Google's servers

What the backend stores can leak, be subpoenaed or change owner, for every user at once.

phones unreachable

A mobile network almost never lets a connection reach a phone

Mobile networks almost always put phones behind carrier NAT or a firewall, so nothing on the internet can open a connection to one. A phone can only ask a server, so anything it offers has to be uploaded first.

With Macula: the app on the phone answers calls itself

The app embeds a Macula node. The node holds a key the phone keeps for it and dials out to the Macula Mesh, a network of stations that link up to form the mesh, keep its phonebook (a Kademlia DHT: which node offers what, and where to reach it), and relay calls and messages between authorized members. One mesh carries many Macula Realms. Each realm is an identity space on the mesh with its own key: its operator admits anything that can be given an identity, such as people, organisations, services, machines and devices, gives each a certificate signed with that key, and can revoke it. Macula runs the community realm; a company or sector body can run its own under a Macula licence. Once the phone's link is up, other nodes can call the app by name, wherever they run, and the app can say who may.

The phone connects outward, so it has no open port facing the internet. The stations relay the call and keep no copy of it or of any application data; what they hold is the mesh's phonebook, and there is no backend server to run, pay for or leak.

What an app gets

The Macula node is written in Rust and comes with Kotlin bindings for Android and Swift bindings for iOS. The app sees a handful of plain objects: a key, a pool of links, calls, streams and subscriptions. Both bindings are built and checked on every change.

its own key

The phone keeps the key

On Android the node's key is encrypted under a key in the Android Keystore. On iOS it is a keychain item that stays on that one device and goes into no backup.

answer

The app answers calls

The app offers a named procedure and other nodes call it, wherever they run. Each phone can offer services under its own id straight away, before any organisation has signed it up.

ask

Call anything on the mesh

The app calls a procedure by name and the mesh finds who offers it. Nobody has to know a server address.

tell

Publish and subscribe

The app publishes facts and hears the ones it subscribed to. Every fact carries its publisher's signature, and the app learns when it may have missed some.

flow

Streams

For more than one answer, the app opens a stream: from the app that answers, to it, or both ways.

come back

Reconnects after a network change

When the phone changes network, the node dials again and restores what it subscribed to and what it served. A publication the station had not yet taken is sent again on the next link.

share

Files served from the phone

The app shares a file from the phone itself, and whoever fetches it checks every piece against the file's id.

grant

Signed access tokens

The app's key signs a token that lets another node call a gated procedure, for as long as the token says.

The phone answers calls itself; it is not only a client of a server.

What Macula promises

no open door

No phone opens a port

Every node connects out to a station; a station never dials in. There is nothing on the phone for a scan from the internet to find.

who may call

The app says who it serves

A procedure can be gated on a token the phone's own key signed, or on a role the app's realm granted. A call without one is refused before the app's code ever runs.

signed facts

No phone can speak for another

Every published fact carries its publisher's signature, and the receiving node checks it before anything is delivered. A station that relays a fact cannot make it look like someone else's.

post-quantum

Post-quantum identities

Keys and signatures use the new methods chosen to resist future quantum computers, so a signature made today is not expected to be forgeable by one.

sealed content

End-to-end encrypted by default

Every call is sealed to the receiver's own key, and a group's facts to the group's key, so the stations in between carry only ciphertext. A call in the clear is refused unless the service has explicitly allowed it.

no backend

No server holds the conversation

Two phones reach each other through stations that pass calls on and keep no copy. No server stores what two phones say to each other. Anyone can run a station, as many as they like; the more stations, the stronger the mesh. Macula runs a number of seed stations and a community realm.

Where it fits

Apps where the data should stay on the user's phone and go only to the people the user chooses, with no company storing a copy. Two directions we want to build with partners: a phone camera that streams straight to the people you choose, and a passport on the phone that shows a verifier only what you agree to show.

Apps between people who know each otherA camera you stream to whom you chooseCredentials you hold on your phoneField teams with phones and no office serverSmall studios without a backend team

Build it with us

Partners bring the apps, the users and the ideas; we bring the node, the station software, seed stations and the bindings, and each app gets a place in the community realm or a realm of its own under a Macula licence. We are looking for partners in three roles.

ship an app

App makers

You build Android or iOS apps. Build one on the node with us, and help shape how the bindings feel to a mobile developer.

own the identity

Identity and wallet makers

You care about who holds a credential. Build with us a phone that holds it and shows a verifier only what its owner agrees to show.

run a pilot

Teams with phones in the field

You have people working with phones away from any office. Run a pilot with us: their phones reach each other and your services over the mesh, with no server of yours or Firebase's holding what they send.

In one sentence

Your app on the phone answers calls itself, with no backend to run.for app makers

A phone node with its key in the keystore, calls, streams and signed facts in Kotlin and Swift.for architects

Phone apps that keep their users' data on the phone instead of in a company's cloud.for funders and policy makers