From the IETF 127 CroakOS talk? Start here →Technical users click here →
CroakOS · FrogNet Living Network

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.

What it feels like

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

Why people want 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.

See it happen

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.

command posthospitalphonephoneradio Pione network, one computercommand posthospitalphonephoneradio Pione network, one computercommand postmemory + loghospitalphonephoneradio Pione network, one computercommand postmemory + loghospitalphonephoneradio Pistill workingstill working✕out of coveragecommand postmemory + loghospitalphonephoneradio Pimemory + logone network, one computercommand postmemory + loghospitalphonephoneradio Pione network, one computercommand postmemory + loghospitalphonephonereadingradio Pi
  1. 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
  2. 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
  3. 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
  4. 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
  5. 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
  6. 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
  7. 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 engineering underneath

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.

329× faster

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.

17× the lookups

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.

68% less code

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.

~121 kb/s

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.

3.7×

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.

40 / 40

Meshtastic’s own CLI tests. FrogTastic-RAM

Where to next

Choose your way in.

See it working

Demonstrations, recordings and the simulator’s runs. Nothing to install.

Watch

What could I use it for?

Thirteen systems already built on it, from AI training to emergency operations.

See the uses

Try it

Run the simulator on one Linux machine, or form a network with two.

Try it

How does it work?

CroakOS explained as one computer: memory, roles, held reads, splits and recovery.

How it works

Work with John

Bring your system, its contract and its tests. Assessments, conversions, training.

Work with John
Go deeper

The whole argument, the architecture and the record.