§01The map

How FrogNet compares.

You already know things this resembles. So first, the measuring stick: a real, full FrogNet is a complete network that installs itself onto whatever hardware is present — discovery, elections, routing over any transports multiplexed together, shared memory as the programming model, a media ladder, and the applications, complete on a LAN with no broker and no tunnel in it. Every comparison below starts there: the whole of them against the whole of us. We will not compare a part of FrogNet to the whole of something else. No matrix — each neighbor gets one plain statement, and where a question is settled elsewhere on this site, it says so and points there.

Current implementation: the shared-RAM contract and engineering record

Key/value stores.

A key/value interface can resemble a cell operation. The Ribbit programming discipline also specifies ownership, latest versus distinct addresses, held views, marks and coordination as state. The difference must be visible in the application and its contract, not asserted from a label.

Distributed shared-memory systems.

Do not infer transparent machine-pointer coherence, replication or a global heap from Network Shared RAM. The state is explicitly addressed by tuples. Placement and recovery policy belong to the deployment and region.

Message brokers.

Applications publish present truth and hold the state they depend on. A record that must be observed distinctly has its own address. There is no general promise that repeatedly replacing one cell retains every previous value. The transports still exchange protocol messages below the application.

VPNs and overlays.

FD&F provides shared-state membership and path construction. Its current packet bridge uses WireGuard and a TUN. The application does not configure peers; the region provides the facts and policy. A comparison that says it uses no tunnel technology would erase an actual implementation dependency.

Existing systems as controls.

FrogTorch compares against Gloo, Redis behavior against Redis, lispers.net wire output against the incumbent, and RINA flows against their required semantics. The comparison is useful only with its test, workload and conditions. Read those records.

§02CRDTs & local-first

Automerge, Yjs, and the local-first world.

The whole of a CRDT library is a data structure inside your application — a merge law and its bookkeeping, linked into a program you already had to build, on a network you already had to have. The whole of FrogNet is the network, the memory, and the application platform, installed onto bare hardware. The resemblance lives in one corner of one layer — both ends hold the same structure and only differences cross the wire — and even there the two are built toward opposite goals. A CRDT's goal is convergence: every replica must provably arrive at one identical merged state, so it carries the machinery of merge — causal history, tombstones, a merge law per data type. UnREST doesn't have that goal. Its goal is operation: each node acts now on the current value of what it can reach. Current value wins, stale values are reaped rather than reconciled, and nothing ever blocks waiting for agreement.

The diff on the wire isn't consensus machinery; it's economy — the reason a live picture fits over links where full payloads never did. A CRDT is a data structure that guarantees agreement. FrogNet is a fabric that guarantees operation — and the fabric, not the merge law, is the product: discovery, elections, routing, media, and the applications, running on a LAN pond that is complete with no tunnel and no broker in it. The model is specified in Magnum Croakus § 25 →

§03Distributed shared memory

Mether, Munin, TreadMarks — and why this isn't that.

This is the first objection anyone with the background will raise, and it deserves answering in a table rather than in a thread. FrogNet is not 1990s DSM. Those systems replicated memory across machines with no serialization point, so they had to manufacture an order out of message traffic — and that manufacture is where the latency came from, which is why the field moved on. FrogNet has a serialization point: one elected database per network, so one order, structurally. Different problem, not a better solution to the same one.

What you get in exchange is narrower than what DSM promised. Bounded-stale current state, with a timestamp so a reader can judge staleness. A write replaces the named value at the store. In modern Ribbit, independent participants own separate addresses and use write-order ids; competing application truths are not reconciled by a last-write-wins merge. No consensus, no total order, no two values moving as one. When the problem needs an order, FrogNet elects for order rather than letting the shared picture pretend to be the order. The full boundary, stated as limits →

§04Reticulum & ham

The closest neighbor.

The whole of Reticulum is a networking stack — addressing, encryption, routing — with no IP, no sockets, and applications written natively to its API. It is the strongest thing anyone can bring to this table: genuinely transport-agnostic, encrypted at the foundation, infrastructure-free, and respect where it's due. The whole of FrogNet is that layer and everything above and below it: it hosts the applications you already have on the addressing you already use, elects its services, ships its media, and installs itself. Reticulum could ride under FrogNet as one more transport, the way Wi-Fi or a LoRa radio does — but FrogNet doesn't need it. Transports multiplexed in one topology — Magnum Croakus § 5 →

On amateur radio, both stacks are out — the same rule, for the same reason — and the full treatment of that, along with how ham traffic actually crosses distance today, lives where connectivity is settled: Connectivity — what's in, what's out, and why →

§05VPN overlays

Tailscale, Nebula, ZeroTier, Yggdrasil.

The whole of an overlay is a private wire between your machines plus the coordination service that arranges it — and that service is the network's center; without it, so much for the network. The whole of FrogNet is a network that is complete before any of that exists. The resemblance is the WireGuard underneath, and it ends there. FrogNet's tunnels are one bearer among several, used for one case: crossing the public internet. The broker introduces nodes and holds no authority — and though it terminates the cross-internet tunnels, it runs none of the semantic stack, so what crosses it is label-stripped diffs and codec-less frames it cannot reconstruct — while the network is complete on a LAN with no tunnel and no broker anywhere in it. An overlay connects your machines. FrogNet operates them: discovery, elections, services, media, applications. The broker, and what it can and can't see — Magnum Croakus § 19 →

§06Traditional VPN

The tunnel to someone else's gateway.

The whole of a traditional VPN — the corporate concentrator, the commercial exit node — is a single encrypted tunnel from your device to a hub someone else runs: reach the office LAN, or borrow an IP on the way to the internet. It connects one endpoint to one hub, and that hub is the entire point and the single throat; lose it and there is nothing left. It moves your packets. It does not form a network among your own machines, hold any shared state, elect a service, or outlive the concentrator. The whole of FrogNet is a peer network with no hub to lose: nodes discover each other, elect their own services, and operate on a LAN with nothing in the middle at all. Where FrogNet does cross the public internet it rides a WireGuard tunnel as one bearer among several — a road it drives on, not the thing it is. A VPN gives you a private pipe to somewhere. FrogNet is the somewhere. WireGuard as one bearer among several — Magnum Croakus § 21 →

§07Traditional mesh

BATMAN, OLSR, 802.11s — the routing layer.

The whole of a traditional mesh — BATMAN-adv, OLSR, 802.11s, the AREDN and community-mesh world — is multi-hop packet routing: it finds paths across radios that cannot all hear each other and forwards frames along them. That is real, and hard, and FrogNet respects it — but it is one layer, the road under the traffic. It hands you a routed link and stops; what runs on that link is still yours to build, on hardware you still have to provision, with services you still have to stand up. The whole of FrogNet is everything above that road: it discovers who is present, elects the services, carries shared memory as the programming model, ships an adaptive media ladder, hosts the applications, and installs the whole of itself onto bare hardware — over whatever transports are present, a traditional mesh among them where one exists. A traditional mesh moves packets between nodes. FrogNet makes the nodes a network. Transports multiplexed above the routing layer — Magnum Croakus § 5 →

§08The wire & the model

“Isn’t this just delta encoding, or QUIC?”

This is where the reflex is strongest, so take it head-on. Semantic compression looks like delta encoding — and at the bit level, it is a diff. The difference is where the template comes from and what it is welded to. gRPC and protobuf need a schema you write and version ahead of time; a byte-differ needs a matched pair of blobs to compare. FrogNet learns the template from the first real exchange, keys it by the stable parts of the request, and diffs the canonical value — so two replies that differ only in formatting cross as a 21-byte SAME. And it is not a library you call: it is fused to the memory model — SAME / DIFF / FULL against a reference both ends hold, reaped rather than reconciled — so discovery, coordination, and application traffic all get it for free, without anyone reaching for it.

Multiplexed streams look like QUIC. The independent channel-sets that keep a bulk file transfer from stalling a live call are solving the same head-of-line problem HTTP/3 solves — but the transport is not the point. FrogNet is transport-agnostic: QUIC would be a fine bearer under it, right next to TCP, a WireGuard tunnel, or a 900 MHz radio. What wins the constrained link is not the multiplexing; it is that the thing crossing it is a difference against shared memory, not a request re-stated from scratch. QUIC moves your bytes faster. FrogNet sends far fewer of them. FNWP-1, the wire — Magnum Croakus § 27 →

And the idea underneath — coordinate through shared values, not messages — is not new, and we do not pretend it is: Gelernter and Carriero’s tuple spaces named it in 1986. UnREST is that idea carried to the wide area, with the two changes that let it survive a real network — current value wins, and a read never blocks. The compression it rests on — Magnum Croakus § 26 →

§09Not the same thing

Four filing errors, preempted.

Each of these, taken whole, is one instrument. FrogNet, taken whole, is the bench they'd sit on.

Meshtastic, whole, is text and telemetry over LoRa — and FrogNet carries it as a friend, not a competitor: Meshtastic and LoRa bridges write radio-delivered readings straight into shared memory as sensor rows.

MQTT, whole, is a message bus. FrogNet is memory, not messages — nothing subscribes, nothing queues, nothing replays; every node acts on the current value of what it can reach, and stale is reaped.

Realtime backends — Firebase, Convex, Liveblocks, a WebSocket-plus-pub/sub tier — are hosted services that push updates to subscribers over a socket you rent, a vendor’s cloud in the middle holding the truth. FrogNet gives the same live-update feel with no socket tier, no subscriptions, and no vendor: presence is a value in shared memory, an update is a diff, and it runs on a LAN with nothing in the middle at all.

Syncthing, whole, synchronizes files — durable artifacts, eventually. FrogNet's transient plane is the opposite instrument: the always-there current value, with the permanent store standing separately as the authority.

Secure Scuttlebutt, whole, is an append-only log that gossips history. FrogNet keeps no history on the wire at all — the present is the protocol.

Comparisons are where it is easiest to be unfair without meaning to be. If you work on any of these systems and a sentence here misrepresents it, tell me — corrections get made publicly with credit to whoever caught them.

§Mechanism, not marketing

The same eleven questions, asked of each of them.

The prose above compares whole systems to whole systems, which is the fair way to do it and the reason there is no matrix up there. This is the other thing a reader wants: the mechanism, side by side, where the differences are load-bearing rather than rhetorical. Every row is a design decision somebody made on purpose, and the answers differ because the problems differ.

	FrogNet	CRDT Automerge, Yjs	Mesh VPN Tailscale, Nebula	Broker MQTT, NATS	DSM TreadMarks, Munin
copies of a value	one	one per replica	n/a — no data plane	one per subscriber	one per node, paged
who resolves conflict	nothing to resolve	the merge law, per type	n/a	the application	the coherence protocol
history kept	none	full causal history	n/a	retained messages, optional	none
ordering	one serialization point	partial, per CRDT	n/a	per topic, per broker	release / lazy consistency
partition behaviour	each side reads what it can reach; nothing merges on heal	diverge, then converge	tunnel drops	queue or drop	stall or fault
addressing	three coordinates you name	document + path	IP	topic string	virtual address
producer knows consumer	no	no	yes — it is an address	no	no
consumer must be running	no	no	yes	no, if retained	yes
wire on no change	21 bytes	nothing, or a heartbeat	full payload	full payload	nothing
staleness	bounded by the reader’s freshness window; absent rather than wrong	eventual	n/a	whatever last arrived	bounded by the model
spans a WAN	yes, by design	yes	yes	yes	no — cluster interconnect

Three rows are where most of the misfiling happens. Copies: FrogNet is the only column with one, and almost every wrong description of it starts by assuming otherwise. History: a CRDT needs it to merge, and FrogNet gave it up, which is what buys “nothing to resolve.” Wire on no change: twenty-one bytes is not a small payload, it is the absence of one — an opcode, an identifier, and the framing around them.

The DSM column is the closest ancestor and the most instructive difference. TreadMarks and Munin moved pages between machines on a cluster interconnect, with a coherence protocol deciding who could write and when. FrogNet moves no pages, has no coherence protocol, and runs across the public internet over links that drop. What it kept from them is the idea that the network can be addressed like memory. What it abandoned is every mechanism they used to do it.

The row that is not in the table.

“What does the application code look like” has no comparable answer, because in four of these columns the application still contains the communication and in one it does not. That is the whole claim, and a table is the wrong instrument for it. The programming surface →

Still filing it somewhere?

Then try the standing invitation: reproduce the result with the stack you'd file it under — and if it can't, that's the interesting part, not a gotcha.

Questions people get wrong → Read the claim →See it run →