Your devices, working as one computer.
CroakOS makes a collection of machines (at home, at your family’s houses, on your phones, in other cities) operate as one computer. That lets people own private networks that keep working when the Internet doesn’t, and lets developers build distributed applications without the usual networking machinery.
A small box that changes what your family can do.
Imagine a small box — about the size of a deck of cards — plugged in at your house. Your mother has one at her house. Your sister has one at her flat in London. Each box costs about what you’d spend on a nice dinner out.
Plug them in and they find each other. You do not configure anything. You do not set up accounts. You do not pick a service plan. The boxes form a private, encrypted network that runs a photo gallery, a family chat, a shared calendar, a bulletin board for sticky notes, a family map that shows where everyone is, and video calling — all on hardware that belongs to your family and nobody else.
Your photos are not on iCloud. Your messages are not on WhatsApp. Your location is not sold to data brokers. Everything stays on your boxes.
The ongoing cost is a few dollars a month — a small region-host subscription (one cloud machine) that lets your phones reach the network when you’re away from home. That is all. No per-person fees. No storage tiers. No annual price increases. No surprise changes to the terms of service.
The whole plain-English account, with what you pay today for the same things →
Proposed The box itself is a proposed product. The software in it is available today: it installs on a Raspberry Pi or a mini-PC. Install it
Private, hard to break, simple, and cheap to run.
Private
Your information stays on machines you own. Between sites it travels encrypted, through a hub you control.
Keeps working
Lose the Internet and everything at home still works. Get it back and the pieces join up by themselves.
Nothing to set up
Plug it in. The devices find each other and sort out the rest. No accounts to make, no servers to run, nothing to configure.
Cheap to run
A few dollars a month, on hardware you already have or a box that costs about a dinner out.
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.
The same system runs databases, AI training and the Internet’s own protocols.
The same system underneath, CroakOS, is a distributed operating system: it makes the machines on a network one computer. Each of these is an existing system rebuilt on it and checked against the original’s own tests.
AI training on the computers you already have
A model trained on data spread over five ordinary machines in two cities finished in seconds instead of minutes, with the same result.
With the training algorithm rewritten so the data comes to the compute: 1,018 s against 3.09 s, stock PyTorch DDP, same held-out loss. The backend conversion alone ran level with gloo. The case study
An Internet routing service that keeps up
A reference implementation of an Internet protocol, rebuilt: more correct, and it keeps answering long after the original stops.
0 of 78 tests failed against 14; about 140× less CPU. The case study
The same behaviour, much less to maintain
Rebuilt systems do the same job with a fraction of the machinery behind them.
Ribbit-LISP against lispers.net; Redis with about a tenth of the server code. The record
Video calls on a very thin connection
A call that stays up as the link is squeezed, with audio kept clear first.
160×120 at 24 fps over a 900 MHz radio link; 1280×720 at 1.2–1.5 Mb/s. The Communicator
Messaging between devices, faster
An everyday device-messaging server, rebuilt, carrying several times the traffic.
101,483 against 27,485 messages a second, Mosquitto’s own suite passing. The record
Mesh radios with every app unchanged
Meshtastic nodes sharing one memory instead of passing packets, and the existing apps can’t tell.
Meshtastic’s own CLI tests. FrogTastic-RAM
Choose your way in.
What could I use it for?
Thirteen systems already built on it, from AI training to emergency operations.
See the usesHow does it work?
CroakOS explained as one computer: memory, roles, held reads, splits and recovery.
How it worksWork with John
Bring your system, its contract and its tests. Assessments, conversions, training.
Work with John