← the Dry Stack

Facts

A time-series store that lives inside your process and answers in microseconds.

8.7× DuckDB's ingest rate. Facts on 1 core, DuckDB on 32. 0.2 µs for the latest value, in-process. DuckDB takes 4.3 ms. 15× QuestDB's ingest over the wire, on one connection against eight. 39 µs for the latest value over the network. InfluxDB takes 56 ms.

The honest loss: Facts stores about 96 bytes per point, while DuckDB and QuestDB compress to about 25. That's the price of keeping columns raw for SIMD scans.

What it is
An embedded time-series engine. No server to deploy and no network hop to query. It holds billions of timestamped facts and answers range, tag, scan and aggregate queries with SIMD.
The problem
Lots of time-series data, queried fast, usually means a cluster of database nodes to run, tune and pay for. Facts does it on one box.
For example
Store every tick from thousands of sensors, then ask what device 4200 did between 09:00 and 09:05. The answer arrives before a network round-trip would have finished.

A fact is a timestamp and a tag. Attach typed columns for fixed-size fields and a blob for everything else. Simple records are why it's fast.

the core

Timestamp + tag

The timestamp orders the fact. The tag names its series: a device, a symbol, a driver, a log source.

Everything is indexed on that pair, so "this tag, this window" works with nothing else declared.

fixed size

Columns

Typed columns for a price, a temperature, an RPM. They're stored columnar, so a SIMD kernel streams one column at full memory bandwidth.

A query reads only the column it asks for, never the rest of the row.

variable size

Blob

Log lines, JSON, packets, Dry.Wire records. Stored opaque, with an optional plug-in codec such as LZ4 that decompresses transparently on read.

Good for logs and journals. See the Log Viewer.

capacity

Limits

Billions of records per box. The ceiling is your disk, with optional retention that evicts the oldest data.

Up to about 16 million series per shard and 256 MiB per blob.

scale out

Shards

Independent shards for parallel ingest and query. Throughput scales with cores, with no cross-shard coordination on the hot path.

on disk

Segments

Immutable, self-describing segments, each checksummed and recoverable on its own. One bad block never takes the dataset down.

stays up

Failover

Replication with veto-based failover. A stale replica can't win an election, so there's never a split-brain and the loss window is bounded. Break it yourself.

crash-safe

Durability

A periodic checkpoint sets the maximum loss window, and every segment verifies itself on open. Power loss doesn't corrupt the store.

runs anywhere

Reach

SIMD-tuned for Intel, AMD and ARM, on Windows and Linux. The same engine on a server rack or a $35 board.

DuckDB is a fast in-process analytical engine. Same TSBS dataset (8.19 million rows of the standard time-series benchmark), same machine, warm. Facts ran on one core. DuckDB got all 32.

Ingesthigher is better
Facts (1 core)20 M/s
DuckDB (32 cores)2.3 M/s
8.7×faster
Latest valuepoint query, lower is better
Facts (1 core)~0.2 µs
DuckDB (32 cores)~4.3 ms
~21,000×faster
High-CPU filterTSBS query, higher is better
Facts (1 core)107 M/s
DuckDB (32 cores)47 M/s
2.3×faster
Full-range aggregatelower is better
Facts (1 core)1.6 ms
DuckDB (32 cores)7.9 ms
4.9×faster
Columnar scanSIMD kernel, higher is better
Facts (1 core)66 GB/s
DuckDB (32 cores)7 GB/s
9.4×faster
Storage per pointlower is better, our loss
Facts†96 B
DuckDB25 B
3.8×more

Medians from our benchmark harness (Facts.Benchmarks) on real TSBS cpu-only data. DuckDB got every advantage: all cores, its fastest bulk load (Parquet COPY) and a host index. Facts wins every speed test on one core and loses on storage density, because DuckDB compresses and Facts keeps data raw and memory-mapped.

† Facts compresses blob payloads with a plug-in codec but keeps column data uncompressed on purpose: the hot columnar path stays raw for SIMD scans while bulky blobs still pack down.

The test above was in-process. This one goes over the network, the way you actually run QuestDB and InfluxDB, two of the most popular time-series databases. Same 8.19-million-row dataset, Ryzen 9 9950X, loopback, warm, durability matched.

One connection against eight. Both rivals got eight parallel connections, their fastest setup. Facts used one, because a single server thread already saturates the link. It still wins every speed test.
Ingesthigher is better
Facts (1 conn)24.6 M/s
QuestDB (8)1.65 M/s
InfluxDB (8)0.24 M/s
15×Quest102×Influxfaster
Latest valuepoint query, lower is better
Facts (1 conn)39 µs
QuestDB (8)260 µs
InfluxDB (8)56 ms
6.7×Quest~1,400×Influxfaster
Range readone window, lower is better
Facts (1 conn)0.25 ms
QuestDB (8)1.15 ms
InfluxDB (8)36 ms
4.6×Quest144×Influxfaster
High-CPU filterTSBS query, lower is better
Facts (1 conn)5.2 ms
QuestDB (8)105 ms
InfluxDB (8)846 ms
20×Quest163×Influxfaster
Storage per pointat rest, lower is better, our loss
Facts†96 B
QuestDB~23 B
InfluxDB~86 B
4.2×Quest1.1×Influxmore

Ingest runs about an order of magnitude ahead of QuestDB and two ahead of InfluxDB. The most common dashboard query, the latest reading for each sensor, comes back in tens of microseconds.

Medians and p99 from our benchmark harness (Facts.Benchmarks, --tier b) on real TSBS cpu-only data, each engine at its best configuration. Why the gap: Facts speaks a compact binary wire format, while QuestDB and InfluxDB use text line protocols where every number is spelled out in ASCII and parsed again. Durable, too: re-run with every engine writing to NVMe instead of RAM, Facts held 25 M rows/s. Where the rivals win: they compress columns at rest, and both are full query languages (SQL and Flux, joins, ad-hoc queries) with far bigger ecosystems. InfluxDB's v2/Flux engine is also known to be slow on these access patterns; v3 would narrow the query gap.

Every demo is a real Facts engine serving real queries.

live demo → Market Wall
A command-center wall ingesting synthetic market data while queries hit the stream nonstop.
live demo → F1 Replay
One real Formula 1 race, ingested once and replayed. Point-in-time lookups and whole-race aggregates in microseconds.
live demo → Log Viewer
Compressed blobs at work: scroll a huge live log while only the visible window is read, including the unsealed tail.
live demo → Benchmarks
The full query suite running on the box. Every API with its median and p99 latency, straight from the engine.
live demo → Replication & Failover
A two-node cluster you're meant to break. Cut the link, force a failover and watch it heal with bounded loss and no split-brain.
live demo → Raspberry Pi
The same engine on a $35 ARM board, small enough to run where the data is born.
Facts live showcase and benchmark dashboard

The harness kills the process mid-write, tears chunks on disk and corrupts the index, then checks what survives. Every test passes on both platforms.

The same run also measures reference numbers: warm, one core, synthetic data with one value column per point, best of 20.

MeasureLinuxRyzen 9 9950XWindowsRyzen 9 7950X3D
Ingest, 1 core92.7M points/s88.9M points/s
Latest value390 ns600 ns
SIMD column scan85.7 GB/s26.2 GB/s
Ingest while querying74.6M points/s57.2M points/s
Query p99 during ingest5.7 µs4.6 µs
Alert scan, 16.8M readings2.6 ms4.6 ms
Storage per point30 B30 B

This is a different harness and dataset from the head-to-heads above, so the numbers won't match them exactly. Storage is 30 B here because each point has one value column; TSBS rows carry ten.

show raw output ↓captured 20 June 2026, unedited
Want Facts in your system?

We're taking a few early users. If you have time-series data that needs to be faster, tell us what you'd build. You get Facts and direct help; we get your feedback.

info@drylane.io
Facts is part of the Dry Stack, built by Drylane.