The full overview

The whole argument, on one page.

Everything the homepage used to carry: the architecture, the simulator, the programming difference, the evidence, security and the Guild.

The whole system

Stop building a distributed system out of computers. Build a computer out of a distributed system.

A computer has storage, I/O, cores and RAM. A network has everything but the RAM. CroakOS gives it one: a shared memory every machine reads and writes, with one owner per fact and reads that wait for the answer. Formation, discovery, routing, roles, naming, placement, split and recovery are the operating system’s job, not the application’s.

CroakOS grew through working experiments: learn what is necessary, apply the fundamentals, build it, and test what happened.

Before: a distributed system built out of computers app A app B app C app D broker /server requests, replies, retries a copy in every app After: a computer built out of a distributed system one shared memoryeach fact has one owner; reads can wait threadSeattle threadNew York threada phone threada Pi on a radio write your own truthread the others' truths
Left: every program carries its own networking, its own copy of the state and its own error handling, and talks to the others through servers. Right: CroakOS makes the machines one computer. Programs use its memory and its scheduling, held reads, and their threads happen to run on different machines.
Ribbit: the programming surfaceRegions, tuples, one owner per fact, held reads. Determine your truth, write your truth, read the other truths, go. the memory: SystemRam, ControlRam, AppRams, each a role held by one hostcapabilities announced, hosts selected, owners reassert after a split or merge; nothing is copied or reconciled FrogNet: the LAN transportself-forming: discovery, naming, elections, routes between /24ssplits and merges as links come and goFNWP-1 wire, BLDC-1 semantic compression FD&F across the Internet, implemented by CroakOSRINA names, LISP locates, Ribbit holds the stateeach site's gateway holds one WireGuard link to the region hubsites never tunnel to each other: member, hub, member
Three architectures meet at explicit boundaries. Ribbit is the programming surface. FrogNet and FD&F are two different transports; FrogNet serves the LAN. FD&F is the architecture and CroakOS is its implementation, the distributed operating system that turns the machines into one computer.
See it run

Watch the network form, split, heal and adapt, on one machine.

The simulator runs the production code: real CroakOS processes for every member, the real discovery and route planner, the recorded hardware topologies, and links shaped down to geostationary and HaLow.

members on one memory20040,000 pairs verified
cold start6.4 sto the full memory
between sites238 / 238through the region hub
after every event0 wronglink down, egress lost, churn
region hubfdf-hub A_gw A_w1 B_gw B_end1 B_end2 C_hub C_s1 C_s2 site A LANsite B chainsite C star WireGuard to the hub
topo_asym_three_sites, as the simulator ran it on 15 November 2026 with real fdf-ram and fdf-client processes over mixed simulated links. All 64 pairs reached; all 42 pairs between sites go through the hub, for example A_w1 → A_gw → hub → B_gw → B_end1, and no pair inside a site does. This hardware topology once had a WireGuard mesh between the gateways. In CroakOS the sites meet only through the hub.
It started with a practical problem

A useful network should keep helping when the connection gets bad.

FrogNet was built for places where connectivity cannot be assumed: a home or farm that still needs to work when the Internet is down, a rural site behind one fragile upstream link, a ship, a disaster site, or any system that cannot afford to turn into a collection of "Connection Lost" screens.

The call kept going

In this recorded Communicator experiment, the available bandwidth is driven down by hand from 987 to 637 to 450 Kbps. Video degrades as the link tightens, audio keeps priority, and the call recovers as capacity returns. A separate demonstrated operating point reached bidirectional 160×120 at 24 fps with uninterrupted audio at about 121 Kbps.

Watch the Communicator evidence →

The same idea at home

An earlier single-LAN FrogNet ran at home throughout development to keep IoT devices separated. The point is the same whether the network is one house or crosses a continent: local systems should remain useful locally, and outside connectivity should extend them rather than become a prerequisite for them.

Start with ordinary hardware

You do not need a datacenter to begin. Raspberry Pi 4 hardware has run as a FrogNet node, and two machines are enough to form a network and watch discovery happen.

Start with two machines →
A familiar application

Chat exposes the programming difference without requiring a new application concept.

The shipped FrogChat client is the useful evidence: a 253-line client (ribbit/examples/chat, C++ and Python together) with no application backend; the first version was 471 lines. Presence and multi-recipient operation were added without changing the RAM server. The program writes state and blocks on the state it needs.

Message-oriented program

The application owns a conversation

It must address a service, construct and send a request, receive a reply, and attach application meaning to that exchange. The exact bytes and latency depend on the concrete protocol and implementation, so FrogNet does not invent a favorable REST transaction here.

Ribbit / shared RAM

The application publishes state

The shipped FrogChat demonstration writes a line to the recipient's cell, while the receiving thread blocks on its own cell. That is the implementation the 253-line client demonstrates. Where every individual write must survive concurrent writers, the Memory contract also provides the distinct-state pattern: each value occupies its own address rather than replacing the current value in one cell.

FrogChat: write recipient cell
receiver: blocking read on own cell

The comparison that matters is in the running client: application networking machinery disappears without replacing it with an application server.

The programming surface

State is addressed directly.Writers publish their own state.Readers read the state they depend on.Networking mechanics stay below the application.

Evidence before belief

You should not have to take a claim this large on faith.

Each result is measured against the system it replaces, judged by that system’s own tests, and linked to its code and its report.

Psychedelic FrogTorch

329×

PyTorch training rewritten so the data comes to the compute, at batch 64, 40 steps, on a five-node Internet mesh: stock DDP with gloo 1,018 s, meshfeed 3.09 s, the same held-out loss. At batch 4096: 5.5×. The backend conversion alone ran level with gloo.

Ribbit-LISP

17×

lispers.net’s map-server over the Internet: 1,468 lookups/s against 87, 7.9× the registrations, about 140× less CPU, 0 of 78 tests failed against 14.

The simulator

40,000 pairs

Two hundred members on one memory, every path verified hop by hop, full memory 6.4 s from a cold start, an event in the memory in 48–64 ms.

Mosquitto on Ribbit

3.7×

101,483 QoS 1 messages a second against stock Mosquitto’s 27,485, with Mosquitto’s own suite passing as on stock.

Redis on Ribbit

a tenth the code

Redis’s own suite, with about a tenth of the server code. A resharding that moves 24,936 keys in 23.3 s on stock moves none.

Less code

68% · 66%

Matched audits against the incumbents: Ribbit-LISP against lispers.net, and the PyTorch backend against gloo’s stack. meshfeed, the rewrite: 98% less.

Two ways in

You do not have to learn the whole network before using the programming model.

01

Internet RAM Today

Start at the application. Use a familiar chat program to learn the RAM contract, held reads, distinct state, Regions and Ribbit without first building a FrogNet fabric.

Short path: chat → shared RAM → Internet RAM → Ribbit → Regions → familiar systems such as Redis and PyTorch.

Take the short path
02

Integrate Network Shared Memory into a Complete Workflow

Start where FrogNet started. Install it, watch it discover itself, understand routing and failure, cross the Internet, work with sensors and services, and arrive at shared Memory with the machinery underneath already understood.

Long path: install → discovery → network → Internet → services/sensors → semantic transport → Memory → Ribbit.

Take the complete path
Living Network security

FrogNet applications can span sites without publishing their own Internet-facing protocols.

Specification: §7 Internet extension: the region · §12 Security and trust boundaries

LAN

A local FrogNet application is not exposed as a public Internet endpoint. The local network has to be reached before the application can be reached.

WAN

Across sites each node keeps one WireGuard tunnel to its region’s hub, and the region host answers the Internet on that one UDP port and nothing else of its own. The broker that did this before was removed on 12 October 2026. The application still does not publish its own protocol as an Internet-facing service.

Internet RAM is separate

Internet RAM Regions are independently governed. Their vendors are responsible for securing them; that security is not supplied by the shared-RAM programming contract.

Security and exposure →
What runs on it

One programming model, from training runs to radios.

Thirteen systems built or converted, each judged by the incumbent’s own tests or a real deployment. The record

Compute

PyTorch distributed on machines you already have, across sites. Psychedelic FrogTorch · Compute

Protocols

lispers.net’s LISP map-server, Redis, Mosquitto’s MQTT, rlite’s RINA, DHCPv6 failover, each on its own wire. Ribbit-LISP

Communications

The Communicator’s calls hold up as the link degrades; chat is a 253-line client with no server. The Communicator

Sensors and devices

Sensor readings and device state, read by anyone who needs them. The monitor

Emergency operations

OpenEOC: roster, radio log, map, assignments and messages on desktops and phones, through splits. OpenEOC

Mesh

Meshtastic nodes on shared memory with every existing app unchanged. FrogTastic-RAM

The original on-ramp still matters

FrogNet can be approached from the RAM or from the network.

What it is not

Not a cloud service, not a VPN, not a database, and not merely a compression tool. Those technologies can participate in FrogNet; none defines it.

Start small

The long path begins with ordinary Linux hardware, installation and discovery. The point is to watch the network form before asking you to accept the programming model.

Follow the complete workflow →

Physical evidence

A New York lamp was actuated from Seattle through the shared-state path, about 2,400 miles each way: roughly 4,800 network miles to cross a room.

See the evidence record →
The Guild

The Guild is where unfinished work goes.

FrogNet is running software, not a declaration that every answer is final. Open problems are documented so somebody else can attack them, reproduce them, disagree with them, or replace them with something better.

Challenge a claim

Find the assumption, build the counterexample and bring the measurement.

Take an open problem

The region’s real ceiling is one example. The broker-era fifty-six-node allocator is gone; its replacement allocates one edge address per member, 64,008 per region, and nobody has measured where a region actually stops.

Try something new

The complete capability inventory is evidence of what has been tried, not a boundary around what FrogNet is for.

By my own engineering estimate, the earlier work would have taken six months longer and a second programmer.

Dated record · the homepage of October 2026

What the homepage said before the November results.

Kept as it was, for the measurements and demonstrations it records.

The network itself became an application of RAM.

FD&F combines RINA’s names and scope, LISP’s separation of identity from location, and Network Shared RAM. Members publish their own facts. Each node derives the network graph and applies its part. The Windows bridge and Android member bring devices into that network without asking the application to configure its peers.

The current demonstration shows ping, SSH, the monitor and live map, two runMerge rebuilds at 4.9 s and 0.79 s, and a Windows–Android call at 1280×720, 20 fps, roughly 1.2–1.5 Mb/s on the receive-side display. It reports under 35,000 system lines and under 6,000 Android lines. The earlier 121 Kbps experiment is a separate 160×120 operating point.

The line counts are reported in the October 12 demonstration, not a fresh source audit. A reproducible LOC comparison requires the checkout, counting tool and exclusions for tests, third-party/vendor code, generated files and build output.

FD&F architecture and ownership · The current demonstration · Programming Ribbit

Evidence before belief

You should not have to take a claim this large on faith.

FrogNet is built to be challenged with running code, external contracts and measurements. These are examples of the evidence already produced.

Semantic transport

2.3×–8,741×

Published pipe_workload.py workload ratios, from the deliberately bad case through mostly-static megabyte data with six live fields. The harness ships so the comparison can be repeated.

Same application, less latency

201 → 118 ms

Published echo workload: direct Apache averaged 201 ms; hot FrogNet SAME/DIFF averaged 118 ms on the recorded run.

Communicator

~121 Kbps

Bidirectional 160×120 at 24 fps with uninterrupted prioritized audio over the real Seattle → broker → New York → 900 MHz path.

Psychedelic FrogTorch

1.03–1.95×

Same-campaign Gloo time / FrogNet time while preserving ordinary DDP semantics in the compared arm, with matching correctness evidence.

Redis-on-Ribbit

1,502 OK

Redis's own behavior used as an external oracle rather than replacing the contract with a FrogNet-specific test.

Physical network

10 nodes · 3 cities

Real Ethernet, Wi-Fi, WireGuard, Internet and radio paths rather than a topology that exists only in a simulator.

What else can use it?

The same programming surface has already been pushed far beyond chat.

The point of these experiments is not that everybody needs Redis or distributed training. It is that the same small shared-state model keeps turning up in applications that normally require very different networking machinery.

Ship the app, not another backend

FrogChat is a 253-line client with no application backend to deploy. Presence and multi-recipient operation were added without changing the RAM server.

Put spare machines to work

Psychedelic FrogTorch has trained across heterogeneous machines in Seattle and New York while preserving the required training result. The application can work against shared state instead of being built around where every worker lives. That is the beginning of a virtual-datacenter resource model: useful distributed compute assembled from machines you already have rather than requiring a homogeneous datacenter fabric. It describes what resources can participate, not a claim that FrogNet reproduces a conventional datacenter scheduler, management plane or interconnect.

Keep familiar software familiar

Redis-on-Ribbit implements a mature, independently designed API over the same Memory model and checks the result against Redis's own test suite. Existing application contracts do not have to disappear just because the machinery underneath them changes.