Skip to content
δ-CRDT · Zero-GC · Post-Quantum

The database engine
engineered to the laws of physics.

An off-heap δ-CRDT database with tri-temporal state, a zero-allocation hot path, and leaderless convergence measured across 100 node processes on three machines in three regions — on real silicon, not a marketing claim.

Watch the evidence 5:09Every number re-run on a fresh 32-core machine, on camera. 22 September 2026.

A product of first-principles engineering

50.7–68.3M ops/s
CRDT core · 32 cores
The in-process HAMT.Set crucible on Graviton4, Go 1.26 — no crypto/network/TLS/disk. 50,736,038 ops/s is the floor the acceptance gate enforces; this tree measured 68,278,197. Core microbench, NOT the production ingest rate.
5.7–6.0M δ/sec
Production ingest · 32 cores
The receive path, in-process: one Ed25519 verify per frame, envelope decode and CRDT apply — no socket, no disk. ~10–12× below the core number, because the core number omits the ~60µs per-frame verify.
0allocs/op
Hot path
HAMT.Set is allocation-free, gated by TestHotPathZeroAllocations. Every allocation is a future GC pause.
PQkey exchange
Hybrid transport, by default
Every node-to-node connection negotiates X25519MLKEM768, and a test asserts the negotiated curve ID rather than trusting the config — a hedge against harvest-now-decrypt-later. Hybrid Ed25519 + ML-DSA-65 signing is built and tested with both signatures required, but stays opt-in behind a flag.
Start hereWhat this is, in plain EnglishIf those numbers do not mean anything to you yet, read this first. It explains the problem the engine solves, how it works, every figure and what it does not mean, and what is still unfinished — without assuming you have written database code.Read the explainer≈12 minute readNo prior database knowledge assumedEnds with a glossary
Developer portal

Explore the documentation.

Start with the system model, trace the architecture, or run the core algorithms in your browser.

The five physical laws

Not workflow rules. Physics.

The engine is governed by five laws, each enforced by a named test gate and each tied to a measured failure mode that made it non-optional.

Memory law

0 allocs/op on the hot path. One make() on the write path at the core rate (63M+ ops/s) = stop-the-world ~every 4ms.

→ TestHotPathZeroAllocations

Cache law

128-byte stride for every contended atomic. Two atomics on one cache line at 32 cores = a HITM storm = 1.1M ops/s, 1.6% efficiency vs the 63M+ core range.

→ TestMemoryLayoutAnalysis

Lock law

No sync.Mutex on the write path. CAS + EBR only. A futex is a scheduler stall, and a stall at the core rate (63M+ ops/s) is a cliff.

→ pkg/sync · reclamation.go

WAL law

Replay restores the recorded dot — it never re-mints. Each mutation is applied at its WAL-recorded (NodeID, Counter); the tail is cut by record sequence, not a scalar clock. Re-minting double-mints, and double-minting is corruption.

→ TestStage6WALRecoveryDeterminism

Honesty law

Report numbers, not adjectives — and report the layer. “The core microbench gate passes at 50,736,038 ops/s @32 cores; this tree re-measures 68,278,197; production ingest is 5.7–6.0M δ/sec” is a fact. Quoting any peak as “sustained throughput” is the round-up we forbid.

→ TestGate_GearHonesty
What makes it different

A moat built from mechanisms, not marketing.

Every differentiator is grounded in a real package, type, and test — and where a feature is preview, stub, or dormant, it is labeled as such.

01

Tri-temporal CRDT state

Keyed by system_time × valid_time × assertion_time, materialized as a 40-byte composite key + 9-field Arrow IPC rows — answering queries a mutable-row or log-only model cannot answer without an auxiliary history store.

CRDTEntry @hamt.go · internal/database
02

Off-heap, zero-GC hot path

State lives in a mmap’d segregated-slab HamtArena (17 size classes, 256-way sharded Treiber free-lists). NodePtr is a GC-invisible uintptr — the foundation of true zero-GC.

pkg/sync/hamt_arena.go
03

CAS + EBR, no futex on the write path

Join, InsertLocal, NextDot use compare-and-swap and epoch-based reclamation with hazard pointers. The only sync.Mutex guards disk fsync in a decoupled background worker.

pkg/sync/reclamation.go
04

Spatial-ready data model (H3)

An H3 index rides every entry on the wire and in the durable tier, so time-and-place queries are first-class. The cache-line-exact SPSC ring that offloads geocoding to an isolated C++ worker is built — and the portal is explicit that wiring it in is operator-supplied, not claimed live.

CRDTEntry @hamt.go:112 · internal/spatial
05

Post-quantum from day one

X25519MLKEM768 key exchange is the default, and a test asserts the negotiated curve ID rather than trusting the config. A hybrid Ed25519 + ML-DSA-65 signature is wired with a BOTH-required verify, but it stays opt-in behind --hybrid-sign / --hybrid-verify so the default wire format is byte-identical for peers without it. A hedged (randomized-nonce) Ed25519 signer stays compatible with the unchanged classical verifier.

pkg/identity · pkg/transport
06

Honest-negative measurement culture

Every benchmark carries its hardware label, and a regression is recorded verbatim rather than re-run until it passes. The load-bearing core is pinned by content checksum so it cannot change silently.

CI gates · pkg/sync
Layered architecture

One frozen core, wrapped by seams.

A layered system organized around a single frozen δ-CRDT core, wrapped by an ingress gate stack, a durable LSM tier, a replication mesh, and operator surfaces.

CRDT core pkg/sync
The δ-CRDT engine: sharded lock-free HAMT, Lamport dot minting, the frozen merge-union Join, IBLT/strata set reconciliation, EBR + hazard-pointer reclamation, and the wire-integrity seam. The write/read hot path everything else builds on.
Storage & durability internal/database · pkg/durability
Off-heap jemalloc-backed SkipListArena MemTable, async L0 flush to per-entity Arrow IPC, L0→L1 compaction with tri-temporal dominance pruning, bitemporal Resolver (AsOf/Range) + read-your-writes LiveSource, WAL + bounded snapshot recovery.
Mesh & replication pkg/mesh · pkg/clock · pkg/admission
TLS 1.3 peer gossip, anti-entropy sweep (oversend / batched / stratified), JSON-over-mTLS control port. pkg/clock is the Byzantine HLC physical-bound cap (first ingress gate, sub-µs). pkg/admission is the per-peer Sybil-burst token bucket.
Receive & transport pkg/receive · pkg/transport
Length-prefix frame reassembly, gate-stack composition (the first production caller of Join), edge-triggered epoll ingress, eBPF SK_REUSEPORT steering, TLS 1.3 mTLS with SIGHUP rotation, zero-copy egress boundary.
Identity & crypto pkg/identity · pkg/crypto · internal/crypto · pkg/authorization
ZIP-215 Ed25519 verify gate, origin→pubkey Directory, hedged EdDSA signer, hybrid Ed25519 + ML-DSA-65 post-quantum, dev-mesh x509 CA, zero-GC PII masking, Cedar ABAC latency experiment.
Attribution & telemetry pkg/attribution · internal/telemetry · pkg/metrics
Relay-provenance envelopes + batch/digest dispatch, 24 zero-GC sharded counters, and a Prometheus bridge that surfaces new counters with no code change.
Network, spatial, capnp internal/network · internal/transport · internal/spatial · api/capnp
EPOLLET Cap’n Proto ingestion server, jittered-backoff HTTP client + bounded lock-free pool, SHA-256-prefix-sharded S3 uploader, memfd SPSC H3 ring + EpochBatcher, generated capnp wire bindings.
Chaos internal/chaos
Semantic Byzantine injector, in-memory VirtualNet partition fabric, engine-side WAL, supervisor/worker process-crash survival — the verification layer proving the hardest invariants.
Operator / developer / evidence cmd/sovereign-node · sdk/sovereign · examples · pkg/codec120 · pkg/durability120 · pkg/pqecobench
The production binary, the client SDK, examples, and the bench-only evidence tracks (codec byte-cost, durability CDFs, ML-DSA-65 PQ economics).
Honest readiness

What ships. What’s opt-in. What’s a stub.

The engine reports its own readiness — production-wired, opt-in, dormant, bench-only, or stub — with the test that proves each claim.

CapabilityReadinessEvidence
δ-CRDT core (Join, HAMT, IBLT, EBR)VerifiedThe merge law and wire schema are frozen and property-tested; property tests + partition-heal convergence; 0 allocs/op on the hot path
Per-shard point readsVerifiedO(log N) reads against one shard — retired the whole-state read that rebuilt the index on every call
Wire-integrity + skew boundVerifiedDigest, attribution, and Lamport-skew checks run before any merge
TLS 1.3 mTLS mesh + control portVerifiedTLS 1.3-only, mutual authentication; the client API rides the same trust root
Certificate + CA + revocation hot-reloadVerifiedA revoked or expired certificate is rejected at the handshake; rotation needs no restart
Admission (rate + clock)VerifiedPer-peer Sybil-burst isolation plus a Byzantine clock cap, before the signature check
WAL + bounded snapshot recoveryVerifiedGroup commit — one fsync per batch; exact-dot replay; a recovered node re-equals the fleet
WAL + snapshot integrity (CRC32C)VerifiedEvery record is checksummed; corruption fails loud and never replays silently
Checkpoint decouple + delta-batchVerifiedCheckpoint fsyncs moved off the commit path (110,000 → 0 per checkpoint)
Convergence — 100 node processes on 3 machines, 3 regionsVerifiedThe sub-10-second target is met on the published run (8.95 s) and on six of seven logged runs; one run missed at 10.15 s
Crash recovery + integrity verificationVerifiedBounded recovery re-equals the checkpoint root with the integrity check armed
Retention horizon (auto-inferred)VerifiedTracks the live query frontier; never retreats below the operator-set floor
Read-your-writesVerifiedAn insert is immediately queryable — no wait for the next checkpoint
Ed25519 verify + hedged signerVerifiedA canonical-verify gate plus a randomized-nonce signer that stays compatible with it
Post-quantum transportVerifiedX25519MLKEM768 key exchange on by default; hybrid Ed25519 + ML-DSA-65 signing is opt-in
Region-aware gossipOpt-inIntra-region mesh + inter-region fan-out; off by default
IBLT digest exchangeOpt-inShips only the minimal difference; the saturation bound is disclosed, not hidden
Peer provisioningOpt-inA pre-provisioned peer directory lets a node verify a peer before first contact
L0→L1 compaction + pruningOpt-inOff by default; the operator sets the retention horizon
L0 reaperOpt-inOff by default; never runs unless enabled
eBPF SK_REUSEPORT steeringVerifiedKernel-level flow pinning — 0/1000 mis-routes measured on silicon; ships behind a build tag
Zero-GC PII maskingVerifiedDeterministic redaction on the write path with no allocation
Telemetry → PrometheusVerifiedNew counters surface on /metrics automatically; the scrape reads cumulative values
Skip-list range iteratorDormantProven correct but not yet wired into the durable scan path
EPOLLET Cap’n Proto ingestionPartialProven end-to-end on a Unix socket; not the default ingest path
H3 spatial (C++ worker)PartialA reserved spatial axis on the data model and wire; the indexing pipeline is built but not wired in
aws-lc hedged bridgeStubA placeholder; the real CGO bridge is not built
Development PKIDev onlyRotation + revocation are wired; it remains a development CA, not production PKI
Cedar ABACBench-onlyBenchmarked, but no authorization engine is wired into the request path
Chaos harnessBench-onlyThe verification layer; the process-crash survival test is opt-in

Readiness is per-capability: a “Verified” badge means the capability is wired into the serving path and backed by a named test gate or a silicon run — not that the engine as a whole is production-ready. Sovereign Engine is a research preview, not production-ready software.

Engineered from first principles to solve the distributed state problem without the latency tax of traditional consensus.