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.
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
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
What the backend stores can leak, be subpoenaed or change owner, for every user at once.
phones unreachable
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.
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.
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
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 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
The app calls a procedure by name and the mesh finds who offers it. Nobody has to know a server address.
tell
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
For more than one answer, the app opens a stream: from the app that answers, to it, or both ways.
come back
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
The app shares a file from the phone itself, and whoever fetches it checks every piece against the file's id.
grant
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.
no open door
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
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
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
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
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
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.
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.
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
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
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
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.
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