Every link in the bond is an isolated socket with its own queue, its own watchdog and its own probe clock. The scheduler never trusts configuration optimism — it trusts the last few hundred milliseconds of measurements. This page is the mechanics, with the demos inline.
Each [[link]] binds with SO_BINDTODEVICE and sends through its own worker. The expo configuration bonds six at once — two serial radios, Bluetooth-PPP, Wi-Fi ad-hoc, 802.11s mesh and Ethernet — in one daemon.
32 packets per link with a 200 ms send timeout: a saturated 64 kbps serial link sheds its own load instead of back-pressuring the TUN reader and stalling the fast links behind it.
Three consecutive send errors rebuild the socket and re-pin it to the device. An unplugged, re-enumerated USB radio — or a booth hub power-cycled mid-demo — rejoins the bond without a daemon restart.
Each link declares nominal capacity in human units ("64 kbps", "100 Mbps", "1.5 Gbps"). Delivery-time math keeps bulky fragments off thin links automatically — no manual traffic engineering.
Default cadence 250 ms per (peer, link) — RTT smoothed by EWMA (α = 0.2), jitter as windowed deviation, loss over a sliding window, dead after 5 consecutive misses. And a link is never alive before its first completed round-trip: recovery requires evidence, not hope.
[[link]] probe_interval_ms overrides the global clock per link, with timeout detection at 2× that link’s own interval. The reason it exists: probing a geostationary VSAT (~600 ms RTT) at 250 ms stacks probes inside the path latency and reads phantom loss — so the 4G link keeps 250 ms while the VSAT beside it checks at 1000 ms.
Sequence numbers piggyback on every Nth data fragment (default 10), so under bursty interference the loss the actual traffic experiences is measured directly — sparse control probes systematically underestimate it.
Adapters feed live RSSI, noise floor, buffer depth and error counters straight from the radio — signal a UDP probe can’t see. RSSI is the one the scheduler acts on, as an EWMA level and slope; the rest are there to be read, on the dashboard and in the API. adapters ↗
[[link]] quota = "20 GB", with quota_period, quota_reset_day and quota_warn_pct, gives a link a byte budget. Once it is spent the scheduler stops promoting that link while any other link is usable — but it is still used when it is the last path left, because a budget is an economic constraint, not a hard-down. Usage, remaining budget, reset time and an over-budget flag are exported per link.
Strategy is deployment policy, not vendor magic — chosen in one config line, observable in the decision log. Five of the eight are in the simulation below.
One copy per packet, on the path with the lowest size/capacity + RTT — so a bulky fragment prefers the fat link while a small control packet can take the low-latency one.
One copy per packet, dealt out in proportion to the weights you configured (8 / 3 / 1 here) rather than to anything measured. Predictable when you want the ratio fixed.
Every packet on every link; the receiver keeps the first copy to arrive and discards the rest. Maximum reliability at N× the bandwidth — for small, critical traffic.
Strictly the highest-priority link that is alive. The others carry nothing and stand by. This is failover, not bonding — and sometimes that is exactly what is wanted.
Starts on one path and escalates to two, then three mirrored paths as the best available latency degrades — then steps back down only after a dwell. Inject delay above to drive it.
Per fragment, minimise size/capacity + RTT — a bulky fragment prefers the fat link, a tiny control packet may take the low-latency one. Capacity- and size-aware bonding without configuration.
Stripe fragments across alive links proportionally to per-link weight — true aggregation when the links deserve it (the demo fleet weights its mesh : ad-hoc : Bluetooth ≈ 70 : 28 : 1.4 so the thin link never bottlenecks the bond).
Every fragment on every alive link; the receiver’s anti-replay window deduplicates. Costs N× bandwidth, survives N−1 failures — and turns loss multiplicative: three independent links at 2% each yield 0.0008% effective loss; the scripted demo delivers ~2.7% through three links each forced to 30%. Measured
Strict failover through an explicit priority_order — the primary carries everything until it dies. For pairs like a preferred serial radio with a second one as pure standby.
Switches multi-hop SPF to hop-count costs; per-fragment link choice falls back to delivery time. For meshes where hop count is the honest metric.
Cost-ratio-driven redundancy with Schmitt-trigger hysteresis: mirror when the second link’s cost approaches the best (enter 0.9 / exit 0.5), triplicate deeper (0.5 / 0.25), 5 s dwell blocking de-escalation only. Cost inflates geometrically with loss (1/(1−loss)) and jitter.
The same ladder driven purely by measured loss: two paths at 20% loss, three at 50%, de-escalation at 0.7× the entry threshold.
Escalation driven by the best link’s RTT: mirror at 40 ms, triplicate at 100 ms, shared dwell. This is the interference-adaptive mode demonstrated live — inject delay, watch redundancy engage, watch it stand down.
Plus the redundancy_factor modifier — “send on the best N links” — for topping up any non-adaptive strategy.
Real links don’t die instantly; they rot. Threshold failover keeps trusting a rotting link, then drops everything at once. Continuous scoring moves the traffic out while the link still carries.
Nothing is cut and no policy changes here — the aircraft simply flies further out. Each bearer’s usable rate falls at its own rate, so the scheduler reweights continuously; the short-reach fat link fades out of the bond long before the long-reach narrow one does.
# A 4G modem beside a geostationary VSAT — each probed on its own clock.
[[link]]
name = "wwan0"
bind_device = "wwan0"
capacity = "50 Mbps"
[[link]]
name = "vsat0"
bind_device = "eth1"
capacity = "10 Mbps"
probe_interval_ms = 1000 # don’t stack probes inside 600 ms of path latency
[scheduler]
strategy = "latency_adaptive"
latency_mirror_ms = 40
latency_triplicate_ms = 100
[link_monitor]
probe_interval_ms = 250
dead_probe_count = 5Then atlasd config check proves it loadable before any restart window, and atlasd monitor shows the decisions live.
Bring the bearer mix you actually have — VSAT beside LTE beside a 64 kbps serial radio — and watch one daemon make sense of it.