How Trubase works.
For the technical audience. The Tokio runtime, the timeline storage engine, quorum durability, and the backend lifecycle — explained in depth.
Tokio green-thread multiplexing
Every incoming TCP connection is accepted by tokio::net::TcpListener. Each connection spawns a tokio::spawn async task that runs the full backend lifecycle: handshake → authentication → query loop → response. Each task weighs a few KB of state machine memory.
Tokio's multi-threaded work-stealing scheduler distributes these tasks across all CPU cores automatically. When one core finishes its work, it steals tasks from another core's queue — perfect load distribution. No OS processes. No shared memory segments. No fork().
This is not a proxy sitting in front of Postgres. The Tokio task IS the backend. It runs the wire protocol parser, the SQL lexer, the query executor, the buffer pool lookups, the WAL writes — everything.
The WAL is the database
Trubase DB has no data directory. Committed write-ahead log is the single source of truth; pages are derived from it, materialized on demand at any position in history. State lives as immutable image and delta layers on object storage.
Every read names the point in history it wants to see. That one read path serves live queries, time-travel queries, restores, replicas, and branches — they differ only in which timeline and which moment.
10,000 branches of a backend holding 1TB = 1TB plus only the divergent writes. Storage scales with actual divergence, never with the number of branches.
Stateless compute, bottomless storage
Engine nodes hold no permanent state — only caches. The layers live on object storage; any node can materialize any backend. When a node dies, its backends re-wake on another node from shared storage.
Durability is layered correctly: a commit returns only after the WAL is acknowledged by a quorum of engine nodes. Layers then upload asynchronously to object storage, which provides eleven-nines durability and effectively infinite capacity.
Backend lifecycle
A backend is a value with a lifecycle: mint → wake → suspend → dispose. Minting allocates nothing — it's a metadata write. Traffic attracts resources automatically; silence releases them.
Suspension is a spectrum, not a switch. First a backend dozes: its tasks drop but its cache stays warm — wake is microseconds. Then it sleeps: cache demoted to local NVMe — wake is sub-millisecond. Finally it hibernates: everything on object storage — one batched storage round trip.