← back to the storm

The Dry Stack

Most systems are glued together from three separate pieces: a database to store data, a message queue to move it, and a serializer to pack it on the wire. Every seam between them is a copy, a serialization pass, and a point of latency.

Drylane is all three, fused into one stack that runs on a single box — ingesting tens of millions of records a second and answering queries in microseconds. No cluster required to be fast.

Database store the data

copyserializehop

Message Queue move the data

copyserializehop

Serializer pack the data

three systems · glue at every seam

→

fused

DRYLANE

store

stream

serialize

one process · zero copies · no hops

Runs on Windows and Linux, tuned down to the SIMD for Intel, AMD and ARM — the same engine from a server rack to a Raspberry Pi.

The core is C++, with idiomatic C# wrappers on top — write your app in C# and get native, zero-copy speed underneath, no glue code to maintain.

Everything below is running live. Click any card — the demos are real engines serving real queries, not screenshots.

The three pieces

A time-series store that answers in microseconds — SIMD query surfaces over billions of records.

Replaces the database. Where you'd reach for InfluxDB or Timescale, on one box, far faster.

The zero-copy network layer — hundreds of millions of messages/second, low-microsecond round-trips over loopback.

Replaces the message queue. Where you'd reach for Kafka, without the copies and the hops.

Serialization at memcpy speed — tiered codegen reaching tens of GB/s on the fast path.

Replaces the serializer. Where you'd reach for Protobuf, at the speed of a raw memory copy.

Built on the stack

Durable pub/sub composed from the three — Nio moves the bytes, Facts is the log they live in. Publish is an append; replay runs at 50M msg/s, delivery in microseconds.

Not a fourth box — an extension of the stack. Messaging where the log itself is the broker, so history reads at engine speed.

See it live

The full query benchmark suite, run live on the box — every API surface with its median and p99 latency, straight from the engine.

A live command-center wall ingesting synthetic market data, with queries running continuously against the stream.

A real Formula 1 race ingested once, then replayed and queried — point-in-time and whole-race aggregates in microseconds.

Replication & Failover

A two-node cluster you can break on purpose: cut the link, force a failover, watch it heal — no split-brain, bounded loss.

Epoch-based async replication with veto failover — a stale node can't win an election, so two leaders can never exist.

Relay rides a failover

Kill the leader and watch a messaging consumer keep delivering — the counter climbs straight through, zero gaps, zero duplicates, no reconnect.

A durable subject is a replicated stream, so failover comes from the storage layer — the consumer never notices.

A virtualized browser over a huge live log — only the visible window is read, including the unsealed tail.

The same engine on a $35 ARM board — the stack is small enough to run where the data is born.

Write the code

Real C# snippets — open a store and query it, send messages, serialize a struct — plus a peek at the C++ core, straight from the samples.

Read the whole argument

Technical overview — PDF

The full case for optimization, every benchmark, in one shareable, printable document — six pages. Feed it to your favourite model and interrogate it; the numbers hold up.

Page size: A4 · US Letter.

Want to talk, build on it, or just kick the tires? info@drylane.io · About