The distributed collection is the computer.
I built CroakOS, a distributed operating system. The machines on a network, at one site or spread across the Internet, become one computer. Programs use its memory and its scheduling, and their threads happen to run on different machines.
What does that let you do?
Build the application, not the plumbing
Programs use shared network memory: information every program can read and update, wherever it runs. So the programmer works on the application instead of arranging conversations between machines: no servers to write, no messages to retry, no copies to keep in step.
Services that follow the work
Each machine takes on a role: the job it currently performs, such as keeping the radio log. When machines come and go, roles move. Applications use a service by its name, without having to know which machine supplies it right now.
Instant updates without anyone asking
A program that needs new information makes a held read: it waits for the information it needs, and gets it the moment someone writes it. Nothing checks over and over, so things stay fast and quiet on slow links.
Keep working when the connection goes
When the network splits, each side keeps running with what it can reach. When it comes back, the pieces join up. Nobody has to restart, resync or re-enter anything.
All of this is done by CroakOS, the distributed operating system I built. It turns the machines on a network into one computer. How it works
Ribbit, FrogNet and FD&F meet at explicit boundaries.
Each is a separate architecture, and none is an implementation detail of another.
Ribbit is the programming surface
Shared Regions, tuple-shaped state, one owner per fact, held reads. A program determines its truth, writes its truth, reads the other truths and goes on. Ribbit does not route packets and does not decide how its memory is reached. Programming
FrogNet is the LAN transport
Nodes on connected LANs discover each other, name each other, elect a database host and route to each other’s /24s. They split, heal and merge as links come and go, with no outside service. The Living Network
FD&F is the other transport; CroakOS implements it
FD&F (Farinacci, Day & Fawcett): RINA names, LISP locates, Ribbit holds the state, and members reach each other only through the shared memory. CroakOS is the software that runs it, from opt/fdf. FD&F
One emergency, start to finish: the whole computer at work.
A command post, a hospital and a field team, each with ordinary devices, running OpenEOC. Follow it from switching on to losing the connection and getting it back. Each step says what CroakOS does underneath, and links to the test that shows it.
- Five devices switch on: a laptop at the command post, a PC at the hospital, two phones, and a small computer on a radio with the field team.
Each machine writes its own facts (its addresses, its links, its uplink) into the shared memory. Nothing is configured. netns-lan-only-test.sh, 19/19 - They find each other and become one network. Nobody configures a server or types an address.
Discovery: every machine reads the same facts and derives the same graph, so routes agree everywhere without a coordinator. the simulator: 40,000 pairs at 200 members - The network picks which machine keeps the shared memory, and which one runs the radio log. Everyone reaches them by name.
Each machine announces what it can do; the same selection, run on every machine, gives the same answer. The chosen host is bound to a name, so programs never need to know which machine it is. test_fdf_app.py, steps 3–6 - Everyone logs. An entry typed at the command post is on the hospital’s screen almost at once.
Each device writes its own entries; every screen holds a read on the log, and the write wakes it. No messages, no polling: 209 ms from one post to the other. OpenEOC results - The team drives out of coverage and the link drops. Both sides keep working: the team’s side now keeps its own memory and log.
Each side recomputes what it can reach and runs the same selection over the machines it has, so each side gets a memory host of its own. The team keeps logging on it. OpenEOC: post B’s uplink cut - Back in coverage, the two sides become one network again, and the team’s entries appear at the command post within seconds.
The selection runs over the reunited machines and names one memory host. Each device writes its own entries again where they are missing. Nothing is copied or reconciled: each owner reasserts its own truth. OpenEOC: the cut-off entries back in 7.1–7.5 s - Work carries on. A phone that has never joined before opens the board and sees all 58 entries, newest first. Nobody restarted, resynced or re-entered anything.
A new device is just another reader of the same memory: no setup, no sync. OpenEOC: the board on a fresh phone
The emergency application implements none of this: not discovery, not placement, not naming, not recovery. It writes its own entries and reads the others. The same holds for a family’s private network, or a sensor at a remote property.
Everything an operating system does, done by the network itself.
These are not separate features. They are the parts of one machine, and the walkthrough above follows one application through all of them. Each is code in the tree, run by the simulator and on hardware.
Formation
A machine that installs a node becomes a member. On a LAN, the node holding a segment’s .1 gives the leases; each member writes its own facts, its addresses and links, into the memory. Across sites, a member attaches at the region’s droplet. Attaching is that machine’s only special job.
Discovery
Discovery reconstructs from what members wrote; it never patches. Every node reads the same facts and derives the same graph (fdf_graph.py). The simulator holds this to the twenty recorded hardware topologies and to generated ones with every path stated.
Routing
Each host keeps one upward link toward its exit, so every path is unique and there are no loops. The exit is the fastest live uplink, then the lowest .1, not the fewest hops. Between sites, traffic goes member → hub → member.
Capabilities
Every service announces what its machine can do as capability tuples in the SystemRam, written by the service and removed with it. A dead machine is not a candidate.
Roles
A role, the job a machine currently performs, is held by exactly one host. The SystemRam (databasehost.frognet) holds capabilities and each machine’s answers; the ControlRam (databasehost_control.frognet) holds configuration; each application has AppRams. Independent roles live on every node; floating roles are held by one host among the machines that can see each other.
Naming
Selection binds a role to a name: the merge’s elections write databasehost.frognet, <app>Host.frognet and <team>Host.<app> into /etc/hosts. A program reaches a role by its name and never needs to know which machine holds it.
Memory
One store; nothing is copied. Each fact has one writer, and its owner’s identity is part of its address. There is no conflict resolution, because there is never a second value.
Scheduling: held reads
A held read is a program waiting for information it needs: state-driven scheduling of application work. The reader names what it reads and waits; the memory parks the read; the writer’s write answers it. Nothing polls and nothing is re-asked. That is the scheduler: a thread runs when the state it needs exists.
Application placement
Each application’s deterministic selection over the capability tuples places its AppRams. Every node computes the same answer, so placement needs no coordinator.
Split
When a site loses the region, the daemon withdraws the region’s routes, names and tunnels and the LAN’s own elections and roles take over. Applications keep running on the side they are on.
Reassertion
At a merge, the same selection run over the merged tuples gives one answer. Owners write their own truth again where it is missing. Nothing is moved or reconciled.
Recovery
Removal is a session ending: the writer’s cells go with it and the reads on them fire. Every wait ends on an event, such as a write, a name changing or a session closing, never on a timer.
Applications span sites without publishing their own Internet-facing protocols.
Exposure
Each site’s gateway keeps one WireGuard link to the region hub; the region host answers the Internet on that one UDP port. Applications publish nothing of their own to the Internet. Security
Organisational roles
An application’s access definition (teams and their password verifiers) is in its configuration tuples. Login is a read at the device’s own edge: no login server, and no check on each request after it. Passwords are never stored or logged, only their verifiers.
Independent Regions
Internet RAM Regions are separately governed memories with their own domain APIs. They compose with a FrogNet, can back each other, and keep their data where their owners put it. Internet RAM
Repeated observation of state is cheap on the wire.
BLDC-1 is not a cache: for a repeated operation the far end runs against the real origin again, and an unchanged result is 21 bytes. It sits under the programming surface and never changes what a program sees. The semantic engine · §11 Wire
The simulator runs this machine on one computer.
Two hundred members, forty thousand pairs verified, every recorded hardware topology, splits, heals and slow links: the production code under a simulated environment.
Who does what.
| name | what it is |
|---|---|
| CroakOS | the distributed operating system: the software that makes the machines one computer, across the Internet |
| FD&F | the architecture CroakOS implements: RINA names, LISP locates, Ribbit holds the state |
| FrogNet | the LAN transport and operating environment: machines on connected LANs form, split and merge by themselves |
| Ribbit | the programming surface: shared memory, one owner per fact, held reads |
| UnREST | the memory-first programming model, in place of request and reply |
| FNWP-1, BLDC-1 | the wire protocol, and the semantic compression on it |
The Major Paradigm Shifts You MUST Make to Work with FrogNet
We explicitly reject much of the plumbing and architecture that has defined distributed programming for the last 50 years. The underlying transports haven't changed, and neither have the results applications need to produce, but the way we get to those results is radically different.
You cannot understand FrogNet by thinking about it as a conventional distributed system with some of the pieces renamed. Many of those pieces simply aren't here. Others have moved out of the application entirely.
If something seems to be missing, don't assume we forgot it. Before asking how FrogNet implements the conventional solution, ask whether the problem that required that solution still exists.
Redis took 4 days, PyTorch 5 and lispers.net 6. Removing the infrastructure the message-oriented model imposes got each one to parity or better. Rewriting the core algorithms as a multithreaded program on one computer then took PyTorch to 329× and lispers.net to 17×. That was expected. We removed work. The method