Every platform built on Grassroots rests on a common foundation: the infrastructure that turns an ordinary smartphone into part of a working network, with no central server anywhere. This is the hardest part of the project to build, and the part everything else depends on. It answers a deceptively simple question — if there is no company in the middle, how do people’s phones find each other, talk to each other, and trust each other?
The problem with having no middle
Conventional platforms solve coordination by putting a company’s servers at the centre. Every message, every match, every transaction passes through that central point. It is what makes the platform work — and also what lets the company watch everything, charge for everything, and switch the service off at will. Remove the centre, and all the work it was doing has to happen another way: directly, between the devices of the people taking part. The infrastructure layer is what makes that possible.
A language for apps with no server
Writing software that runs across many independent phones, with no central coordinator, is genuinely difficult — ordinary programming tools assume a server sits somewhere keeping everything in order. The project is therefore building its own programming language, designed from the ground up for this setting, together with the runtime that executes it on everyday iOS and Android phones.
Two things make this foundation unusually dependable. The language has a type system that catches whole classes of mistake before a program is ever run, so errors are found at the writing stage rather than after something has gone wrong in the field. And the runtime that carries programs onto the phone has been mathematically proved to behave as its design specifies — a guarantee ordinary app development almost never has. The result is a base on which cooperative apps can be built with confidence, one that handles the hard parts of serverless coordination so developers can concentrate on the app itself.
The language is also written for the way this project builds software. Rather than being programmed by hand, each part of the system is first set out in full in a peer-reviewed scientific paper, and AI writes and tests the working code from it; where the code exposes a gap, the paper is corrected and the code regenerated from it. It is what allows a small academic team to build infrastructure of this scope.
Phones that find and recognise each other
For phones to work together directly, each one needs to be able to find the others it wants to reach and be sure of who it is dealing with. Grassroots gives every participant a secure digital identity that lives on their own device and is not issued by any central authority. People connect as one might in real life — directly, or through a mutual acquaintance who can vouch for a newcomer. From these connections a social network forms, on which messaging, groups, and everything built above can operate without ever passing through a company's servers.
Losing a phone without losing your place
An identity that lives only on your own device raises an obvious question: what happens if the phone is lost or stolen, or the key that secures it is destroyed? On a conventional platform you would ask the company to reset your account — but here there is no company to ask. Grassroots answers this the way it answers everything else: through people. Each participant chooses in advance a small group of trusted friends to act as custodians, who can together restore a lost identity and the information tied to it — with the person setting how many of them must agree before anything can change. Losing a phone then means getting a new one and recovering with your friends' help, rather than being locked out for good.
Trust without a central authority
A platform with no central operator still has to be able to rely on its participants’ devices behaving honestly — otherwise a single bad actor could disrupt the whole system. Grassroots solves this by drawing on security features already built into modern phones, which can confirm that an app is running as intended and has not been tampered with. This lets the network trust that everyone is playing by the same rules, without needing a central authority to police them, and keeps the whole system far simpler and more efficient as a result.
Knowing where things are, privately
Many of the most familiar platform services — booking a ride, sending a courier, finding nearby help — depend on location. Grassroots includes a location service that lets apps match people who are near one another, without that location data being gathered up in a central place. It means a ride-hailing or delivery cooperative can work as smoothly as its corporate equivalent, while the participants keep control of where they are and who can see it.
One app that hosts the others
A person enters the Grassroots world by installing a single app. Inside it, each cooperative service — a social network, a currency, a marketplace, a delivery co-op — runs as its own "mini-app," but none is a separate download and none has servers of its own. They all sit on the same foundation: the secure social graph described above. The friends you connect through, the introductions that let newcomers join, the channels that carry messages are provided once, by the app that hosts everything, and every mini-app draws on them. In effect the social graph becomes an operating system, and the services people use are applications running on it.
This is the arrangement millions of people already know from WeChat and Alipay, where a single app contains a whole economy of smaller services. The difference is decisive: here the host is the person's own phone, not a company's servers, so there is no operator beneath the services able to watch across them, take a cut, or switch them off. And because every mini-app rests on the same foundation, they work together naturally — the currency a social network uses to settle a payment, or the identity a marketplace relies on to know its members, is the same one running elsewhere in the app, not a separate account bolted on.
A first version of this already runs on an ordinary smartphone, with a social network and a digital currency operating together inside a single app — an early but real demonstration that the architecture holds.
Where this work stands
This foundation has moved from theory to working code faster than expected. The programming language and its runtime exist and run on ordinary iOS and Android phones; the type system that keeps programs sound is in place; and the core services described above — on-device identity, the social graph, and the host that lets one app carry many — have been built and tested as prototypes. Much of this was carried from published papers to running code within a single year, all released as open source.
The work now is to harden these prototypes into infrastructure that can match a commercial platform on scale, security, and reliability, and to document and release it so others can build on it and inspect it. That robust, open-source base on commodity phones is the dependable foundation on which the governance, economic, and federation layers of Grassroots are built.