Mesh & routing

A control plane with no controller.

Every node floods what it knows, computes routes over the shared picture, and relays for its peers. When a node joins, moves or dies, the topology refloods and every surviving node recomputes independently, within whatever detection costs — ≈1.5–1.75 s at default probe settings.

Field-proven on the 8-node fleetOpt-in per feature
Flooding

LSAs to every established peer

Each advertisement carries the originator, a sequence number, per-neighbor links (cost = best alive RTT, aliveness, per-link RSSI), served prefixes, a human node_name — and optionally WGS-84 position with velocity, which is what the prediction layer consumes. That node_name is also the mesh’s namespace — served as DNS by every node, from this same flood. mesh DNS ↗

Hygiene

Aging, refresh, tombstones

Entries age out at 100 s, refresh every 30 s (re-stamping position; a moving node also re-advertises when it moves — see position adverts), and departed nodes leave tombstones (~300 s) so a stale advertisement can’t resurrect them. Full-database exchange on session establish; event-driven, debounced re-floods on link changes.

Positions

Three sources, auto-prioritised

Static config, live GPS fixes over the telemetry socket, or an operator typing coordinates into the dashboard’s topology tab — park a relay van, enter its position, and every peer’s map updates within an advertisement tick.

Paging

A membership update that fits one datagram

The roster travels in pages, and a page fits a single UDP datagram by construction: node ids ride as base64 (not 32-number JSON arrays), the public key left the wire entirely (identity is the key), the deprecated config block rides only on full-sync rounds, and the sealed envelope carries a 48-byte binary prefix instead of base64-in-JSON. [mesh] max_gossip_bytes defaults to 1330 — sealed, that stays under a 1500-MTU path — so losing a datagram costs one page, never the roster; the members that did not fit lead the next document to the same target. Measured to fit a 250 kbit tactical bearer.

SPF

Shortest path over measured costs

Dijkstra over the LSDB — measured-cost or hop-count mode — with dynamic peer learning behind relays and a TTL’d relay header capping paths at eight hops by default. The cap is [routing] max_hops, a setting rather than a ceiling — a long relay ladder or convoy raises it, up to 255: the origin stamps the budget and every transit hop honours it. The count is Atlas’s own hops; hops inside an 802.11s or MANET mesh underneath are not counted. the setting ↗ When the direct edge dies, traffic threads through whoever survives.

Hop honesty

Relays are trusted members of your fleet

Each leg is protected by its own Noise session: a relay decrypts the fragment from the previous hop, reassembles, makes the forwarding decision, and re-encrypts toward the next hop. That is per-hop protection by trusted nodes — not end-to-end blindness. With end-to-end sealing on, the source seals each unicast packet to its destination and a relay forwards an envelope it cannot open, so a relay need not be trusted with the payload. Both differ from hosted traversal relays, which forward opaque envelopes they cannot open. the four trust models ↗

Multipath

Next-hop diversity, deduplicated arrival

routing.path_redundancy = K computes the top-K next hops and fans every fragment across all of them — at the origin and at each transit hop — with receive-side dedup. Because candidates are separated by first hop, not by full node-disjointness, two paths can still meet further downstream; what you are guaranteed is that they leave on different neighbours. Nothing switches over, so there is no failover gap to lose packets in. Off by default (K = 1); K = 2 doubles the backbone bill. The 2× figure comes from a scripted demo scenario, not the measurement estate. Simulation

Pinned paths

Operator-pinned static routes

Named hop lists with stable path IDs and auto-failover deliberately disabled — a static FIB for rehearsed operations where predictability beats adaptivity.

Learned routes

Prefixes beyond the mesh, installed by every member

Two kinds of prefix arrive in the signed adverts besides the members’ own addresses: a plain LAN that a node serves, and a prefix of another Atlas network imported at an Interconnect seam. Each member’s daemon installs both on its own tunnel interface ([routing] install_learned_routes, on by default) and withdraws them when the advert does. A served LAN goes to the nearest node serving it; an import to the seam host every member agrees on. The longer prefix wins as always, and at equal length a node’s own addresses come first, then a served LAN, then an import. A member that already has an overlapping route of its own keeps it and logs the skip. served LANs ↗Interconnect imports ↗

The mesh control plane

Push a config. Watch it spread. Cut the wire and push again.

Membership is a CRDT with authenticated join and liveness heartbeats; configuration travels as Ed25519-signed epochs over encrypted gossip. Any node can author; every node verifies, applies through the commit-confirmed lifecycle, and gossips its status back.

Eight nodes, no controller — push from anywhereSimulation
v1config epoch
8 / 8nodes converged
—time to converge
nonecontrollers involved
The real machinery behind this picture: signed epochs with a section whitelist (identity, peers and auth can never be pushed remotely — a security boundary), rollback protection, per-node commit-confirmed apply with a deadman revert, and status gossip so the author watches the fleet converge. All of it on operations, proven end-to-end in the epoch suite.
Why no controller

Nothing to stand up. Nothing to capture. Nothing to lose.

The mesh needs no orchestrator because its three jobs are already distributed:

Membership

A conflict-free replicated registry with Lamport clocks, authenticated join via a shared mesh secret, heartbeats and expiry. Anti-entropy syncs with a random member every few seconds, always at an address the node reaches it on, so updates spread hop by hop. On long chains, shorter gossip and heartbeat timers keep distant members fresh.

Confidential gossip

Since gossip v2, every mesh body crosses the wire as ChaCha20-Poly1305 ciphertext under a key derived from the mesh secret, with per-opcode domain separation and replay damping — an eavesdropper on any underlay no longer gets a free map of the fleet. (A compatibility flag exists for mixed fleets mid-upgrade.)

Authority

Knowing the mesh secret means you may see the mesh; only an Ed25519 author key means you may change it — and even an author cannot rewrite a node’s identity or peer set remotely. Partition-tolerant by construction: both sides keep operating and reconcile on reconnection.

The swarm fabric

The fleet doesn’t use the network. It is the network.

Give every airframe a node and the formation becomes its own transport fabric: spatial diversity (routes thread around losses) and spectral diversity (edges on different bands fail differently) — with reconvergence on the event rather than on a timer, doing the flying-formation bookkeeping.

Six airframes, two bands — take away an airframe, or take away a whole bandSimulation
Destroy an airframe
Degrade a band
6 / 6airframes flying
5hops on the path
9 Mbpspath bottleneck
0SPF recomputations
What you're watching: a simulation routing with Dijkstra SPF on measured cost, where every edge belongs to exactly one band — 5.8 GHz between neighbouring airframes (solid, short reach, fat), 2.4 GHz across the formation (dashed, long reach, thin). Destroying an airframe removes one node; degrading a band removes every edge on it at once, which is why the two losses look different on the stage and are recovered separately. Both ends hold an edge on each band, so no single band failure can strand either of them. What was demonstrated for real: at HEMUS 2026, an 8-node mixed fleet — laptops, field relays, an airborne node — carried MAVLink C2, H.265 video and gimbal control through physical link kills and induced degradation. Controlled link-degradation trials; no live RF jamming. The full rig is on the demonstrations page; the operator-depth patterns are in the playbooks.
Use 802.11s

As a link, it’s excellent

A radio segment that self-forms at Layer 2 is a perfectly good Atlas underlay — the standing fleet bonds one alongside five other link types. Atlas treats the whole mesh segment as one measured path.

Never both

One multi-hop layer per set of radios

Two routing layers fighting over the same RF is the one bad configuration: HWMP path changes race Atlas’s dead-detection, the L2 mesh advertises capacity it can’t deliver over N hops, RSSI is first-hop-only, and broadcast amplifies. Rule: if Atlas is doing the relaying, the radio layer underneath must not — and vice versa.

Research

Bonding-only segments

A proposed forwarding = "bonding-only" link attribute would keep a mesh-underlay link fully in the bond between its endpoints while making it structurally impossible to use as a transit hop — the recommended tactical layout, enforced by the config instead of by discipline. roadmap ↗

Where the two layers meet

Every hop of the path is itself a bond.

Bonding and meshing compose: the mesh decides which nodes carry the traffic, and between each pair of them the bond decides over what. That gives a path two independent ways to survive — and two failure modes that look identical on a topology map until you draw the hops honestly.

One path, four hops, six radio links — break either layerSimulation
Kill a relay
Cut one link of a hop
4hops on the path
6 / 6links carrying
52 Mbpspath bottleneck
0SPF recomputations
What you're watching: a simulation routing on hop-count cost, so a hop costs the same whether it rides one link or two — which is exactly why cutting half a bond never moves the route, and why the SPF counter stays put while the capacity number falls. Both behaviours are real: a bond is formed between two adjacent nodes, so a relayed path is a chain of bonds, each leg with its own Noise session and its own scheduler. Exhaust every link of a hop and the mesh takes over again.
Paths with room Shipped

Control takes the path with room.

Priority at a hop cannot reorder what already sits in a radio’s buffer or a modem’s queue further along the path. Path choice can. Every node advertises how loaded each of its links is, and Control traffic routes on a second shortest-path map that counts that load, so a command steers around a relay that is busy carrying video while the video keeps its cheapest path.

Ground stationcomputes both maps R1relay · carrying video R2relay · idle DroneControl and video destination two shortest paths, one per class 90 % · 300 MS QUEUE 5 % · 0 MS QUEUE default map: Video and every other class, through the shorter path Control map: around the busy hop
R1 → DRONE90 % utilised, 300 ms of queue: the default path, still carrying the video
R2 → DRONE5 % utilised, no queue: Control goes this way
GROUND STATIONtwo shortest paths, one per class
Ground stationorigin of Control DroneUHF radio · satcom Sat gatewaynode at the teleport UHF · 250 KBIT/S, CARRYING 200 advertised 100 % · queue 150 ms · RTT 100 ms wired · RTT 10 ms SATELLITE · RTT 600 MS · IDLE Control via UHF: 100 RTT + 150 queue + 400 utilisation penalty = 650 Control via satellite: 10 + 600 = 610, so Control takes the satellite Telemetry keeps the default map, RTT only: 100 against 610, so it stays on UHF
UHF HOP · CONTROL COST100 RTT + 150 queue + 400 penalty = 650
SATELLITE PATH · CONTROL COST10 + 600 = 610: Control takes the satellite
TELEMETRY · DEFAULT MAP100 against 610: it stays on UHF
The advert

What the advert carries

Each link-state advert carries two figures per neighbour link. Utilisation is the bytes sent over the last two seconds against the link’s declared capacity, or against its measured drain rate when that is lower, in 10-point steps. Queue delay comes from the standing-queue signal, in 50 ms steps. A step counts only once a reading is a quarter step past the boundary and has stayed there for one probe interval, so a link that hovers on a boundary does not reflood. Both figures are left out when they are zero: an idle mesh sends the same adverts it always did.

The second map

A second shortest path

Every node runs a second Dijkstra over the same graph, with the same two-way and non-transit rules and the same tie-breaks. Its edge cost is the link’s RTT plus its advertised queue delay, plus a utilisation penalty above 70 %: RTT·((util − 70)/30)²·4. A saturated hop costs up to five times its RTT, plus its queue. The classes listed in [routing] headroom_classes follow this map at the origin and at every transit hop, chosen by the class byte the packet carries. The default list is Control; it can name more classes, every class, or none.

Loop-free

Why it cannot loop

Every node computes the headroom map from the same flooded figures. A node routes on what it advertised, never on a fresher local reading, so the next hop of a shortest path holds the rest of that path as its own shortest path and never hands the packet back. The class byte travels unchanged, so a packet stays on one map from end to end, and with path redundancy on, the redundant paths come from the same map.

Operator view

The Control route, shown where it differs

atlasd status and the dashboard’s Mesh & Routes view list the Control route under its prefix whenever it leaves by a different next hop. The topology draws a link at 70 % utilisation or 50 ms of queue heavier, with a badge such as 70% or 90% · q150, red from 90 %. When a hop fills, Control moves to the path with room within about three seconds and returns once the hop drains; under steady load the route holds still. Measured

Boundaries

Coarse figures, one advert behind

The advertised figures lag by one advert interval plus the hysteresis, and utilisation is only as accurate as the link’s declared capacity until its queue builds and the measured drain rate takes over. Load is measured per underlay link, so every neighbour reached over one shared link shows the same figure. Operator-pinned paths and multicast trees keep the default map, and a packet whose record clamps it out of Control follows the default map for the rest of its path.

One-to-many Shipped · opt-in

One stream, many watchers.

Ten operators watching one drone feed used to cost the trunk ten copies — and inner multicast was worse: for flat-mesh correctness a packet to 224.0.0.0/4 replicates at the source, once per peer. [multicast] changes the shape: groups on its list are carried as source-rooted distribution trees — every shared segment carries the stream once, and copies are made only where subscriber paths diverge.

Nexus Atlas: Multicast2:13 · plays from YouTube
PER-VIEWER UNICAST ISRsends one copy per watcher ×3 Relay droneairborne relay ×3 · EVERY HOP Forward dronelast shared hop GS-1 GS-2 GS-3 three watchers — three copies of every frame on every trunk hop DISTRIBUTION TREE ISRsends once ×1 Relay droneairborne relay ×1 · EVERY HOP Forward dronefork point fork — one copy per branch GS-1 GS-2 GS-3 three watchers — one copy per trunk hop, forked only where paths diverge
PER-VIEWER UNICASTthree copies of every frame, on every trunk hop
DISTRIBUTION TREEone trunk copy — forked only where subscriber paths diverge
The tree

Computed, never configured

Subscriptions ride the LSA flood as an additive field, so every node holds the same picture; each derives its (source, group) role — reverse-path parent, subscriber-pruned children — straight from the SPF graph, cached and re-derived whenever the topology or the subscriptions change. No IGMP, no PIM, no rendezvous point: the classically hard parts of multicast were already solved by the LSDB.

The forwarding

Relay-framed, RPF-checked, forked at the branch

Tree traffic rides the existing relay envelope with the group as its final destination and a hop limit bounding any transient loop. A relay accepts the stream only from its tree parent, delivers to its own TUN when subscribed, and forks one re-encrypted copy per child branch. A branch with no subscribers below it carries nothing — and a group nobody subscribes to costs zero packets on the air.

Measured

Trunk 1× at any fan-out, re-roots on loss

On the eight-container verification rig — ISR → relay drones → forward drones → three subscribed ground stations — five minutes of Full-HD-rate video (6.00 Mbit/s: 187,500 packets, ≈225 MB) crossed the mesh with 187,466 / 187,454 / 187,466 of the 187,500 packets delivered at the three stations — and the structural counters were exact: the scarce trunk carried 187,500 copies — one per packet — where per-viewer unicast would have put 562,500, the fork layer emitted exactly 562,500 at the divergence, and reverse-path drops were zero. (At 2 Mbit/s the same setup delivers loss-free.) The invariant is the real result — the trunk count equals the packet count, at any rate, any duration, any number of watchers; add seven more ground stations and the trunk cost does not move. Stopping the carrying forward drone mid-stream re-rooted the branches through the survivor with the delivery counters still climbing; the five-daemon netns suite pins the same properties in CI, including that a subscriber-less group sends nothing.

Outside the fleet

One feed out, by link

When someone outside the fleet must watch one group, a gateway takes it off the tree and publishes it outward to a feed server; viewers open a link with a per-viewer token and never touch the mesh. A dedicated gateway host joins as a sink — a member that may receive and never send — and with [multicast] redundant_parents = 2 is fed by a second neighbour that already carries the stream, so the last hop is redundant. the feed gateway ↗

Boundaries

Video-shaped by design

Delivery is unreliable-with-FEC: no ACK trees, no retransmit fan-in — reliable one-to-many stays store-carry-forward’s job. Applications stay unmodified: the sender writes UDP to a group, receivers join it on the atlas interface, and the kernel’s own multicast filtering applies exactly as on a LAN. Groups outside the configured list keep the flat fan-out; disabled, the data path is byte-identical. Mixed fleets: enable only once every node carries the build, with identical group lists.

config.toml — [multicast]
[multicast]
enabled = true
groups = ["239.31.0.1"]        # fleet-wide list
subscribe = ["239.31.0.1"]     # this node wants the feed
Interconnect Shipped · opt-in

Join networks you do not run.

An Atlas network is sealed: its own keys, its own address space, forwarding only among its own members. When one operator owns every node, the answer is one network. When the networks belong to other people — a partner’s drones, an agency’s sensors — and the job is only to join them, the operator runs one daemon per network on one host and joins the two daemons at a seam. Nothing changes on any member of either network.

NETWORK A · 10.0.101.0/24 OPERATOR HOST NETWORK B · 10.0.9.0/24 A host10.0.101.2 · unchanged daemon Aserves .202 daemon Bserves .102 B host10.0.9.2 · unchanged seam · loopback link, data only 1 · LEAVES THE A HOST 10.0.101.2 → 10.0.101.202 an address in its own subnet 2 · CROSSES THE SEAM destination becomes 10.0.9.2 checksums repaired in flight 3 · ARRIVES AT THE B HOST 10.0.9.102 → 10.0.9.2 the A host, seen inside B no routes, keys, adverts or gossip cross — only packets between mapped, exported hosts
NETWORK Asends to 10.0.101.202 — an address in its own subnet
THE SEAMrewrites the destination to 10.0.9.2 and the source to 10.0.9.102
NETWORK Bsees an ordinary host in its own subnet — nothing changed on either side
Two modes

Address maps, and routed prefixes

In mapped mode each remote host the operator maps gets an address inside this network’s subnet, which the seam daemon advertises in its link-state flood as an address it serves; members reach it with the subnet route and the shortest-path tree they already have, older builds and the mobile app included. In prefix mode the seam daemon imports a prefix of the other Atlas network and advertises it in its signed adverts, and each member’s daemon installs it on its own tunnel interface, so members reach the far members by their real addresses with nothing rewritten; the far seam daemon imports this network’s prefix the same way for the replies. Both modes can share one seam. Interconnect, served LANs and subnet routers ↗

The seam

Two daemons, one loopback link, one rewrite each way

The two daemons peer over a link type that config load refuses to bind anywhere but loopback. Egress rewrites the destination to the host’s real address and crosses; ingress accepts only a mapped source toward an exported host, rewrites the source to its local view, and routes it into the network exactly like traffic from the host itself. IPv4 and TCP/UDP checksums are repaired incrementally. Each side writes only its own map — where the other network’s hosts appear in its address plan — so nobody renumbers anybody.

Isolation

Two control planes that never meet

Link-state adverts, full topology exchanges and membership gossip are never sent across the seam and are ignored if they arrive; the seam is not even listed as a link. Neither network learns the other’s topology, keys or admission decisions. Each daemon is an ordinary member of its own network, so each owner revokes the operator like any member — and the export list on each side decides which of its hosts take part, in both directions.

No loops

Parallel seams, never transit

Nothing is redistributed, and a packet that crossed one seam is never sent across another, so loops cannot form by construction. Two operator hosts bridging the same pair become two parallel seams advertising the same mapped addresses: every member agrees on one owner, and the other takes over within seconds when the first one becomes unreachable.

In practice

Works with the members you already have

Members need nothing new for it: all a member ever sees is one more address in its own subnet. Across the seam a host reaches its mapped counterpart with echo replies and byte-identical bulk transfers, while neither network’s topology gains a single node of the other; an unexported host can neither be reached nor send across; the far network revoking the operator stops the traffic at once; and two operator hosts bridging the same pair answer every echo exactly once, the second carrying the traffic when the first goes down. Boundaries: the seam opens and re-seals end-to-end payload encryption, the inner tunnel is IPv4, and the two networks must not share an address space.

net-a.toml — the A-side daemon
[[link]]
name = "seam"
type = "local"                  # loopback only
bind_device = "lo"
bind_address = "127.0.0.1"
listen_port = 51841

[[peer]]                        # the B-side daemon, same host
public_key = "…"
endpoint_per_link = { "seam" = "127.0.0.1:51831" }
allowed_ips = ["10.0.9.0/24"]   # B's real address space

[peer.interconnect]
export = ["10.0.101.2/32"]      # which A hosts take part

[[peer.interconnect.map]]       # B's host, as A sees it
remote = "10.0.9.2/32"
local = "10.0.101.202/32"

[[peer.interconnect.route]]     # B's members, real addresses
prefix = "10.0.9.128/25"
Served LANs Opt-in

A plain LAN behind one node.

Printers, cameras, a file server, a controller: the hosts on a site’s flat network run nothing, and nothing is installed on them. One node with an interface on that LAN serves its prefix into the mesh. Every member learns the route from that node’s signed advert and installs it on its own tunnel interface, so a laptop behind a radio relay reaches the printer at the printer’s own address. It is the role a subnet router plays, inside one Atlas network.

OpenWrt Integration6:11 · plays from YouTube
ATLAS MESH · 10.0.101.0/24 SERVING NODE PLAIN LAN · 192.168.10.0/24 signed advert: 192.168.10.0/24 Operator laptop10.0.101.4 · learns the route Radio relay10.0.101.5 · forwards Drone10.0.101.9 · learns the route Ground station10.0.101.2 · serves on eth1eth1 192.168.10.1 LISTED SOURCES ONLY the rest is refused and counted Printer192.168.10.20 · runs nothing Camera192.168.10.31 · runs nothing LAN gatewayroute 10.0.101.0/24 via 192.168.10.1 the one static route, for real addresses only 1 · SERVED one [[serve]] block on one node nothing installed on the LAN 2 · LEARNED every member installs the route itself nearest serving node · failover in seconds 3 · BOTH WAYS masquerade on: the LAN sees the node off, plus the gateway route: real addresses a served LAN never crosses an Interconnect seam · members configure nothing
SERVEDone node with an interface on the LAN serves its prefix; nothing is installed on the LAN
LEARNEDevery member installs the route from the signed advert and uses the nearest serving node
BOTH WAYSthe mesh reaches the LAN; with one static route on the LAN gateway, the LAN reaches the mesh at real addresses
Mesh to LAN

Reached at real addresses, with nothing on the LAN

The serving node floods the prefix in its signed advert, and each member’s daemon installs it on its own tunnel interface ([routing] install_learned_routes, on by default), so a member reaches every host on the LAN by the address it already has, through as many mesh hops as the path takes. With masquerade on, the default, the serving node translates the source of what it forwards onto the LAN to its own LAN address: the LAN’s hosts answer the node and need no route back.

LAN to mesh

One static route on the LAN’s gateway

With masquerade = false nothing is translated in either direction. One static route on the LAN’s gateway, the mesh subnet via the serving node’s LAN address, brings the replies back, and lets the LAN’s hosts open connections to the members allowed to cross; both ends see each other’s real address. No other host on the LAN changes.

Who may cross

Listed sources only; the rest is refused and counted

for names who may reach the LAN: the whole mesh by default, or named records, node ids or tunnel addresses. The serving node forwards only from those sources to the LAN and only from the LAN back to them, and drops everything else; the refusals are counted in its status, its snapshot and its journal. In a fleet run from signed records, a node’s record bounds which prefixes it may serve, so no member can pull a LAN’s traffic to itself by announcing it.

The seam

A served LAN never crosses an Interconnect seam

A served prefix lies outside the network’s own subnet, and a seam exports only addresses inside it, so a served LAN cannot be exported to a partner network; a packet that arrived through a seam is dropped at the serving node as well. This is not a setting. A served LAN belongs to the network its node is a member of. the seam ↗

Two servers

The nearest one, and the other within seconds

Two nodes may serve the same LAN. Each member routes to the nearest one it can reach, and traffic moves to the other within seconds when one goes away; a clean stop withdraws the route from the members before the serving node removes its forwarding rules. With masquerade on, connections that the departed node had translated start again through the other one.

Boundaries

Linux, IPv4, one prefix per LAN interface

The serving node runs Linux and forwards through a firewall table of its own; the inner tunnel is IPv4; each LAN interface carries one served prefix. atlasd status and the dashboard’s learned-routes table name every route a member holds as a served LAN or an Interconnect import, and the serving node lists its own LANs with their forwarded and refused counts.

ground-station.toml — the serving node
[[serve]]
prefix = "192.168.10.0/24"
iface = "eth1"
masquerade = true          # false: real addresses both ways
for = ["*"]                # the whole mesh, or records / tunnel addresses

# on the LAN gateway, only with masquerade = false:
# ip route add 10.0.101.0/24 via 192.168.10.1
Request an evaluation

Your fleet is the infrastructure.

Every node a relay, every relay measured, every route recomputed the moment the topology moves — with nothing in the middle to capture or lose.