Work with FrogNet.

The Node.

Install the frozen FrogNet world on any Linux box — a Raspberry Pi, a mini-PC, an old laptop — and it becomes a lillypad: a sovereign node that configures its own networking, stands up its own Wi-Fi when there is no wire, discovers every neighbour it can reach, and takes on whatever role it is most capable of. No controller, no account, no cloud. Its identity is a GUID minted once at install; its address is its own. Pull the uplink and it keeps working — a lost link is normal weather, not an outage.

One node is a complete network. Add a second and they find each other; add a tenth and nothing changes but the reach.

Ham is out — up front, before anything else. FrogNet's wire traffic is differences against state the far end already holds — frames a third party cannot read without the memory they refer to. The prevailing reading of FCC Part 97.113(a)(4) treats that as a message encoded to obscure its meaning, and amateur bands prohibit those. So FrogNet does not transmit on amateur radio bands — stated here the same way it's stated in the book. And Reticulum is out with it, on the same rule for the same reason: every Reticulum packet is encrypted by design, and by the project's own account that cannot be turned off. Whatever you think of either stack, neither one can legally carry its traffic over ham spectrum in the US.

Now the honest part about the alternative. Look at how amateur traffic actually moves. The RF hop is audio — software modems pushing tones through a voice radio, the same idea as a dial-up modem and at kindred speeds: 1200-baud packet still keys the Bell 202 tones of the acoustic-coupler era, and even the best modern HF modes deliver a few kilobits. And the moment the message needs to go farther than the radio reaches, it backhauls over the internet: Winlink through CMS servers, AREDN islands joined by tunnels over home broadband, EchoLink voice over IP by name. The screech does the last mile; the internet does the miles — in the clear, because the bands require it. FrogNet was built on accepting that fact instead of dressing it up: when the path must cross the internet, it crosses inside a WireGuard tunnel you own, on your own flat 10/8, through a relay that cannot read a byte.

One pond, three ways in and out — every link two-way, every methodology different

The same property is what makes FrogNet mobile. A device does not care what the transport is, so when it comes in contact with another FrogNet it latches onto whatever medium is available — with no operator intervention in most cases. A node has been driven through Queens at traffic speed on exactly this behavior: the topology changed under the mesh block by block and the walk re-formed it, nobody touching anything. That is the differentiator with a human face: people do not have to be network or RF engineers to get things up and working in the field.

transport independence → discovery & route optimization → route resilience & fault tolerance → system survivability

Each stage exists because the one before it feeds it. Survivability isn't a feature bolted on at the top — it's the last link of a chain that begins with refusing to care what the wire is. The wire and the radio — Magnum Croakus § 5 →

UnREST — the programming model you build on.

The web asks; UnREST remembers. Not a new protocol and not a faster transport — the same primitives you already use, arranged so both ends hold the same structure and only the difference crosses the wire — SAME when nothing changed, DIFF for what did, FULL only to teach a template once. That is UnREST Core, and every exchange gets it for free: only what changed on the wire, and a transport that keeps the wire full instead of idle between round trips.

UnREST Unleashed is the extension layer — write a handler, fill its slots, and you have an entirely new protocol on the same interface. SotF and the game protocol are built exactly this way. And you don't have to rewrite to start: drop the codec onto the wire you already run and the bandwidth win arrives before the rewrite does. See the three-stage on-ramp →

The Broker & the pond.

Nodes on the same LAN find each other unaided. To join sites across the internet, a broker introduces them and hands out WireGuard tunnels — and then gets out of the application layer. It holds no authoritative state: its whole picture is rebuilt from what nodes tell it, and its working set is a single SQLite file. Cross-site traffic does transit it — it terminates the tunnels — but it holds no node identity and no pond secret and runs none of the semantic stack, so it parses and stores nothing — but the traffic is in the clear at that seam, so assume it can see it. Lose the broker and every existing link keeps carrying traffic.

Membership is a redeemed passcode, not an account. A pond is simply the set of nodes that belong together — coast to coast, one flat 10.0.0.0/8, addressed the same whether they share a switch or a continent.

And where the pond has to accept something from a stranger — a license request, a contact form — the public side is a drop box, not a door: it writes files into a watched folder the inside pulls from and inspects. It has no route into the network, so compromising it yields a folder of files, not a foothold. That's what lets a FrogNet host a public form without putting a single node within reach.

The Communicator.

Presence, chat, calls, setup, and a game table — one application over one shared memory. Being present is not a service call; it is a tuple you write. The flagship piece is SotF, the Song of the Frogs Adaptive Communications Protocol: a live media ladder that trades fidelity for continuity as the link tightens. It has held an HD call across the country over a 900 MHz radio, stepped it down toward 300 Kbps and, when the link starved, all the way to a one-byte heartbeat — and climbed back without a re-dial.

Live media cannot be diffed, so this is where the rewrite earns its keep: not by shrinking frames, but by degrading a call instead of dropping it.

For the guild · open problem

241 unassigned opcodes.

FNWP-1 defines a handful of opcodes and leaves 241 unassigned. What belongs in them is genuinely open, and it is the part headed for an open standard — so the argument is worth having in public. Get the source → — open source under the GPL, nothing to request. If you want to work on this, say so in Discussions and say which; that is a courtesy, not a condition.

Overlapping 10-space between sites is the network administrator's problem, as it is today with any router. What FrogNet guarantees is that it will not create the problem: a subnet whose .1 does not answer never acquires a route.

VLANs and everything else below the insertion point are untouched. FrogNet works on the addresses that arrive and does not need to know how many broadcast domains produced them.

One node does not mean one node per subnet. A node serves a single /24 — its own segment, not a claim on yours. A site with twelve VLANs needs one node, because the L3 switch already routes between them.

Two questions an architect asks next — what happens to internet connectivity when the node is down, and what insertion does to line rate — have not been measured yet, and this page will not carry a number until they have.

Distributed systems are usually taught as toy examples and papers, because the real ones are proprietary, enormous, or both. This one is neither. It is small enough to hold in your head, it runs on hardware you can afford, and the two books derive every part of it from the problem that forced it rather than presenting it finished. You can read why an election algorithm scores nodes the way it does, then go and watch it re-elect one.

What is actually in here, as coursework: leader election and convergence under partition. Routing that rebuilds itself with no central authority. A codec that learns templates and diffs against them. Transport adaptation under real degradation, with the measurements. Tuple spaces and coordination models going back to Gelernter and Carriero in 1985. Shared memory semantics, and the freshness bound that a network forces on them. Each of those is a lecture somewhere; here they are one system that has to make them work together, which is the part the lectures leave out.

The simulator matters most if you have no hardware. It runs the real discovery, routing and election code against a modelled topology on a laptop, so you can break things, model a fifty-node pond you could never afford to build, and watch what happens — without owning a single Raspberry Pi.

And this section is not charity.

Some of the best work on any system comes from people nobody assigned to it. A student with a weekend and no mandate tries the thing that was never scoped, on hardware nobody tested, in a topology nobody drew. That is not a smaller version of professional work — it is a different search, and it covers ground a roadmap cannot, because a roadmap is a list of things somebody already thought of.

The particular thing this cohort does better than anyone is check whether done is true. I have declared parts of this complete, some of those declarations are wrong, and I am the worst-placed person to find out which — I know what I intended, so I test what I intended. Somebody who does not know what I meant does the thing I never anticipated. If it holds, that is worth something. If it breaks, that is worth a great deal more than agreement.

Then the unglamorous one, which goes uncredited nearly everywhere and shouldn't. Reproduction. A report that says it broke is a rumour. A report that says here is the topology, here are the steps, here is what I expected, here is what happened, and it does it every single time — that is an oracle, and somebody can act on it the same afternoon. It is real engineering work, it is often done by people who would not call themselves engineers, and it is appreciated here.

So take it, and play with it, and do the unexpected with it. If something surprising falls out, I want to hear about it — john@fawcettinnovations.com. And if nothing does, you still have the books.

I built it from one perspective — mine — and I know some of what I have done will turn out to be wrong. That is not an admission that undermines the release. For something this size, claiming otherwise would. There is a difference between I know it is wrong, so it is not ready and I know some of it must be wrong, so it is ready for more perspectives, and this is the second one.

I am not afraid of being wrong, and you do not have to take that on faith. Seven subsystems in this tree were replaced wholesale, and the reversals are annotated in the source with the reasoning that caused them rather than quietly deleted — a cache layer shipped and then partly reverted when one part of it turned out to be load-bearing; an entire merge path replaced, with the oracles that asserted the old rule retired by name instead of removed; a scoring term thrown out on the grounds that a benchmark run on a busy box measures the busy and not the box. A contributor reading those learns the thing that actually decides whether it is worth arguing with me: an argument here can change something.

Years ago I helped teach high-school programmers, in one of the most diverse districts in the country. What I told them about why diversity matters to an engineer was not the usual argument. It was this: there are exactly as many perspectives as there are people on the planet, and even identical twins have two. If you let me design your systems alone, you will get something that works extremely well for a burned out old hippy, and for nobody else. That is not a moral failing. It is a property of one point of view, and no amount of care escapes it.

FrogNet has the same problem. I can give it architecture, code, tests, a simulator and the first applications. I cannot give it the perspectives I do not possess.

So: bring the network I never worked on. The radio I never used. The protocol I never encountered. The application I would never think to build. Bring the assumption I got wrong, and bring the topology that turns an oracle red. If a subsystem needs fixing, fix it. If it needs replacing, replace it. If one of my architectural assumptions is wrong, demonstrate that it is wrong — which is the only part of this I would insist on, because a perspective that arrives as an opinion is an argument that goes to whoever is more persistent, and a perspective that arrives as a red oracle going green is a fact.

There is a symmetry in that worth noticing. The simulator subjects the machine to topologies I did not anticipate. The guild subjects the design to perspectives I do not possess. Both are doing the same job: finding the assumptions one person could not see.

What is fixed is the goal and what it forces — transparent and automatic, and therefore deterministic, memory-shaped, continuous, floating, frugal, and honest about failure. Everything else is this implementation, and this implementation is not sacred merely because I wrote it.

I gave FrogNet life. I am not its life.

FrogNet should accumulate authors, not followers. The reversals annotated in the source, the oracles retired by name, the spec seat whose undetermined clauses are authorship — those exist so that arguing with this project leaves a signature. The Guild belongs to its contributors.

We will measure both capability and consequence. The same discipline that instruments a claim before believing it applies to what the technology does in the world: our responsibility does not end when the technology works.

Fifty-eight nodes. Sixteen on a shared broker. It should be fifty-nine thousand.

The book's Known Limits appendix states the most legible open problem in the system in full: the per-tunnel address allocator carries a structural ceiling of roughly 58 nodes, and 16 where one broker carries a second pond. The allocator is quadratic, so more address space is the wrong lever — the square-root table in the appendix shows why a bigger namespace buys almost nothing. What the number is made of, why the obvious fix fails, and what a real fix has to preserve are all written down.

It is bounded — one allocator, one namespace builder, and the routes they install. It is measurable — a topology that fails today either joins cleanly under your change or it does not. If you read the square-root table and immediately wanted to argue with it, you are the person it is addressed to. The appendix →

Named openings, from the videos

The broker area — named in the broker-install video; rendezvous, tunnels, pond management. Per-client rate adaptation — named in the Communicator video; the book's § 53 is explicit that one stream and one rate is the current design and per-client adaptation is not built yet. Maintainers and testers — named across the set; you become one by doing the work. And the three above: the standard, the governance, the allocator.

What it pays for is unglamorous and specific: brokers and bandwidth, radios and antennas for the range tests, boards for the people doing bring-up on platforms I don't own, and the postage to get hardware into the hands of somebody who will push it somewhere I can't. Nothing here is behind a paywall and nothing will be — the books stay free, the licence stays free, and a donation buys you no standing in the guild that running the software doesn't already give you.

It is also entirely optional, and the more valuable contribution is still a reproduction case or a topology that breaks something. If you have neither the money nor the time, take the books anyway. That was always the deal.

"This is an initial implementation. I do not claim it is the best, or even the only, way to solve any or all of the many problems that had to be solved for this to work. What I do claim is that it appears to work, and work both well and correctly. I welcome contributions that can prove a better algorithm, and I want to engage with those developers. Linux has many subsystems; so do I."

And the state of the work

Don't trust me — check it. The books derive it from first principles, the licence is the GPL, the protocol is becoming a public contract, and the simulator lets you falsify me. So here is the part a brochure would leave out: FrogNet is broadly exercised in general, and thinly tested in specifics. The media path is the deep-tested exception — hardened, and on it these ideas bought roughly 9×. If one path does that, the rest is the opportunity. Hardening the specifics is precisely the work I am inviting people into, and I would rather say that now than have you find it later.

Direct line