The Primitive Registry

Binds Grain flows to DWDM/flexi-grid lambda circuits and OCS paths via generalized labels (GMPLS RFC 3945/7698); data-rate and modulation agnostic, so the photonic middle survives transceiver generations (Google Apollo lesson).

UDP encapsulation for fiber/Ethernet/Internet paths with fully encrypted, greased headers — the QUIC ossification lesson; middleboxes see nothing they can freeze.

WiFi and Li-Fi under one binding (802.11bb PHY-swap discipline): identity, association, and security unchanged across radio and light.

BLE mesh advertising bearer honoring the 11-byte unsegmented cliff; Grain fragments only when the envelope says the 2–3x segmentation latency penalty is acceptable.

LoRa/RNode binding with per-node duty-cycle token bucket (EU868 1%, TTN 30 s/day) exposed to the API so applications schedule sends instead of failing at the radio; ADR trades SF7–SF12 rate against 25 dB of link budget.

AX.25/KISS TNC binding with a legal profile switch: on amateur bands it runs authenticated-plaintext (signatures only, no encryption, per Part 97), on ISM it runs full Grain crypto.

One-way broadcast binding for RDS (1187.5 bps subcarrier) and DRM datacasting (7–72+ kbps shortwave/VHF): cyclic carousels of FEC-heavy Merkle chunks so receiver-only nodes reassemble objects with no uplink (SONIC pattern pairs it with a thin LoRa/SMS return path).

ggwave-class acoustic FSK (8–16 B/s, meters) as the zero-hardware bootstrap bearer: exchange identities/keys/network hints by sound, then hand off to a real bearer.

DTN convergence adapter (RFC 9171 lineage): wraps exchanges in store-and-forward bundles with hop-by-hop custody transfer, the only sane bridge across a 9-order rate mismatch (0.3 kbps radio meets Tbps core) or an intermittent link.

Systematic block rateless coding with RFC 6330 semantics: any ~K+2 received symbols from any path or peer complete the block at 99.9999% probability, linear-time codec; collapses ACK machinery to one 'done' signal.

Sliding-window random linear coding (RFC 8681 style) over GF(2^8) for real-time lanes: bounded FEC latency, ~13% less repair traffic than block RS at >10% loss.

In-network RLNC recoding: relays re-mix coded Grains without decoding, so repair capacity composes across mesh hops instead of resetting per hop; dependency waste <0.4% per packet.

Retransmission never repeats bytes: on NACK/timeout the sender emits further repair symbols of the same block (5G IR lesson) — recovery and FEC are one mechanism with one code.

Source symbols ship verbatim first; clean paths pay zero decode cost, repair symbols flow only at the measured loss rate.

AEAD tags/checksums convert corruption into known-position erasure before the decoder — halves required parity (2t erasures vs t errors) and keeps the whole stack on cheap erasure-only codes.

Online (p, RTT) estimator that sets the proactive repair ratio to p+ε and switches FEC↔ARQ by regime: retransmit when RTT is cheap, erasure-code when RTT×loss makes waiting unacceptable (QUIC-FEC's measured lesson).

Ordered reliable byte stream with independent per-stream flow control and retransmission — loss on one stream never stalls another (QUIC streams).

Message-oriented interleaved lane (SCTP RFC 8260 I-DATA lesson) so a large message never monopolizes a send queue.

Unreliable datagrams sharing the connection's congestion controller (RFC 9221 pattern) — the real-time substrate.

Explicit path IDs with per-path packet-number spaces and per-path CC, coupled LIA/OLIA-style so N subflows through one bottleneck take one fair share; the subflow scheduler (minRTT-first, redundant-duplicate, throughput-aggregate) is application-visible.

Congestion control as a negotiated per-connection module (BCP 133 discipline): BBRv3-class model-based default, Copa-class delay-target for interactive, PCC-class utility probing for hostile/unknown links (GEO, Starlink), LEDBAT scavenger for background swarms; accepts out-of-band capacity hints (Starlink 15 s handover cadence).

Careful-resume: persist validated path capacity (BDP cache) so resumed or migrated paths skip slow-start after lightweight validation; 0-RTT early data carries an explicit idempotency contract in the API.

Per-flow packet spraying across equal-cost paths, out-of-order delivery with in-order completion, selective retransmission (UEC 1.0 pattern) — tail-latency armor, benchmarked at P99.9 not mean.

Reticulum-style cryptographic announce gossip: routes form passively from overheard signed announcements, zero routing-protocol chatter on duty-cycled airtime, no globally coordinated addressing.

Generalized forwarding label: one allocatable 'forwarding resource' abstraction spanning packet next-hop, TDM timeslot, wavelength, or whole fiber — the proven GMPLS bridge from electronic packet to photonic circuit forwarding.

TTL-bounded managed flooding with dedup cache and randomized backoff — the stateless fallback when no path state exists (BLE Mesh/Meshtastic pattern), hop-capped because shared airtime is a commons.

Optional interactive privacy mode: telescoped 3-hop circuits over fixed-size cells with months-pinned guards and mesh vanguards, CGO-class non-malleable relay encryption; adds ~300 ms–1 s and resists local adversaries, explicitly NOT a global passive adversary.

Optional async privacy mode: Sphinx uniform packets through stratified mixes with Poisson per-hop delays and self-addressed loop cover traffic (Loopix/Nym tuning levers exposed at runtime); GPA-resistant at ~50–500 ms latency plus ~Mbps-class cover bandwidth; unidirectional I2P-style send/receive paths for metadata-sensitive flows.

Topology as a schedulable resource: 'reconfigure the graph' is a costed protocol operation (ms for MEMS OCS, ns for Sirius-class wavelength scheduling) instead of an assumption of static wiring.

Noise XX for first contact (mutual auth, identity hiding), IK for reconnects to known peers, all patterns formally verified; single-Grain handshake variant sized for the 500-byte MTU floor because multi-RTT handshakes are unusable at seconds-per-packet.

X25519 + ML-KEM-768 secrets concatenated into one HKDF (X25519MLKEM768/PQXDH pattern) from day one — security holds if either assumption holds; closes harvest-now-decrypt-later.

Two-layer forward secrecy: ephemeral hop keys destroyed on path teardown, plus a Double-Ratchet-class per-message ratchet for store-and-forward mailbox contexts.

One fixed padded cell size for everything, budgeted to carry hybrid-PQ handshake material without fragmentation — kills size fingerprinting and hides path length/position.

Content addressing: every chunk named by its hash, every object by a Merkle root; trust moves from transport to identifier, so any peer, cache, or origin can serve any chunk.

FastCDC content-defined chunking (Gear hash, normalized chunking) so edits and insertions don't break dedup alignment; larger fixed blocks for cold bulk.

Per-file binary Merkle tree over 16 KiB leaves (BT v2 pattern): per-block verification with compact proofs, per-block banning of bad peers, identical-file dedup across swarms.

Rateless swarm mode: peers emit distinct RaptorQ repair symbols of a block, so any symbol from any peer helps and the last-block problem largely dissolves; falls back to rarest-first + endgame duplicate-cancel for verbatim-block swarms.

Kraken-model coordinator: tracker/DHT only builds the connection graph (Kademlia O(log N) when decentralized); the data plane is fully peer-to-peer, with LAN-first → regional cache → origin tiering and pinned always-on seeds as the availability floor.

Zero-copy bulk frame: tiny header of {name → dtype, shape, offset, length} + flat byte region (safetensors/Arrow pattern); wire layout equals memory layout — mmap-able, range-fetchable, never touches the control encoder.

Register memory regions once, post async scatter/gather descriptor-list transfers with out-of-order completion (NIXL/RDMA verbs shape) over pluggable backends — RDMA, TCP, NVMe-oF, object storage.

NCCL's factoring made protocol-level: fused steps (send, recv, recvReduceSend, recvCopySend) arranged by interchangeable algorithms (ring — bandwidth-optimal 2(N−1)/N, tree, NVLS-class) over interchangeable bearer functors.

seq / choice / rec / par over role-annotated actions; global protocol values are projected to per-endpoint state machines with deadlock-freedom checked before anything runs — the mechanism that certifies every composite in the registry.

Send the Information-Bottleneck minimal sufficient statistic for a declared downstream task and its distortion measure (accuracy/perceptual/effect) instead of byte-exact reconstruction — the strongest honest way to 'get past lossless' for AI traffic, because the effective source entropy is genuinely lower under a task-sufficient measure (stays inside Shannon RD).

Carry a payload over a co-trained joint source-channel mapping that degrades smoothly with link quality (no cliff effect), trading a bounded fidelity loss for continued delivery under adverse/variable channels and tight latency budgets — the DeepJSCC operating regime where separation is not tight.

Attach a declared fidelity level (lossless / task-sufficient / perceptual-generative) plus matched encoder-decoder identity and domain to every stream, so a receiver refuses or downgrades when content falls outside the trained task or when bit-exactness is actually required. Typed as a linear-logic proposition so a mismatch fails to typecheck.

Use a learned entropy model over semantic latents to spend more channel uses on informative content and less on predictable content (NTSCC-style variable-rate JSCC), aligning bandwidth to semantic importance rather than uniform bit budget.

Transmit a compact semantic descriptor (segmentation map / prompt / sparse latent) and synthesize a perceptually faithful reconstruction at the receiver, with a mandatory fidelity-vs-perception flag warning that unmodeled detail is generated, not delivered — never counting a decoder's hallucinated detail as received information.

Consume a pre-shared correlation resource to lift throughput above the channel's own unassisted capacity ceiling, with the advantage growing as the channel gets noisier. The consumed resource is metered explicitly, so the gain is never mistaken for a free capacity increase.

Compose two individually-useless (zero-capacity) or individually-lossy links/sources so their joint use carries information neither can alone — encoding quantum superadditivity/superactivation, which has no classical Shannon analog, as a first-class operator.

Reframe a point-to-point link as measure-in-the-middle at a zero-trust rendezvous node, converting linear loss/rate-vs-distance scaling into square-root scaling (the TF/MDI-QKD move) without granting the node any trust.

Establish shared secrets whose security rests on physical/mathematical impossibility (no-cloning, monogamy, Bell violation) rather than computational hardness, with eavesdropping self-revealing as physical disturbance — paired with device-independent certification of untrusted hardware from correlation statistics alone.

Address a target by both direction AND distance (a focal point) rather than direction alone, enabling discrimination of items that share one coordinate — the near-field beamfocusing analogue for precise retrieval/routing, and the reason a pure-LoS channel can carry rank > 1.

Push matrix-style computation (precoding, transforms, estimation) into the transport medium so it happens during propagation, offloading the central processor — the stacked-intelligent-metasurface analogue of computing inside the channel. Reshapes the effective channel; per-stream Shannon capacity is unchanged.

Run N independent streams over one shared substrate so aggregate throughput = N x per-stream limit. Encodes the honest SDM lesson explicitly: you multiply channels, you never beat the per-channel bound — scaling is parallelism, not a loophole.

Emit an unbounded incremental-redundancy stream from a fixed payload (spinal-hash / SPARC style) and let the receiver stop as soon as it decodes, converting a fixed rate-vs-reliability choice into an adaptive 'take what the link needs' contract with ACK feedback — the legitimate 'bent question' that operates against the higher feedback-aware curve.

Score any encode/decode pipeline against its meta-converse and RCU achievability bounds at the ACTUAL finite budget (n, error target) rather than against asymptotic capacity, exposing real remaining slack instead of a misleadingly small 'gap to capacity.' The anti-hype instrument for the whole coding stack.

A channel typed by a linear-logic proposition and used exactly once; its two endpoints must be dual (or coherent, for multiparty), so mismatched or dropped protocols fail to typecheck before any code runs. The substructural core (no silent copy/discard) that makes messages behave like real resources.

Express a protocol translation or version-adapter as a functor, so it provably preserves identities and composition (F(g.f)=F(g).F(f)) — guaranteeing behavior-preserving substitution and safe refinement, with the honest caveat that lawfulness holds only once the functor laws are actually discharged.

Retrieve a record from a shared store without revealing which record was requested — single-server lattice PIR (SimplePIR/YPIR) for cold reads, Piano-style client-preprocessing for repeated sublinear reads. Reframes privacy as retrieval-privacy (a different quantity than the trilemma's who-talks-to-whom).

Route the large fixed parallel linear transform of a workload to a fast cheap approximate channel while keeping state, nonlinearity, and control in the slow reliable channel — the photonic-tensor-core-plus-electronic-control split, generalized. Honors Miller's limit: match each sub-operation to the substrate that is cheap at it, never pretend optics does logic or RAM.