MeasuredBenchmarks · every script named

Every number. Losses included.

What Chronos DB does fast, what it does slowly, and against whom. Each figure comes with the machine it ran on, the day, the build and the command that reruns it.

1.4 µs
to fork a world, with 100,000 open
57–73×
Postgres, 1,000 agents writing at once
4 of 6
BranchBench jobs finished first
17
losses on record, each one listed
A fork, timedGiving an agent its own copy of the database, with 1,000 agents asking at once.median · log scale
Chronos DBon disk, 64 workers
0.008 ms
Dolt 2.3.5DOLT_BRANCH, 64 workers
24 ms
Postgres 17a template database, 25 workers
2,133 ms
SQLitea file copy, 64 workers
2,762 ms

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28Chronos and Dolt: two runsbuild 8db2f701Chronos and Dolt from one harness, Postgres and SQLite from the other, same machineBENCHMARKS.md §1

With one thread per agent (1,000 threads on disk) Chronos's median fork is 65–73 ms. At equal workers it is 8 µs.

Worlds

A world costs microseconds. The hundred-thousandth costs the same.

A fresh database on disk with 100,000 rows in main, then 10 to 100,000 worlds forked from it, each writing one row of its own.

Worlds forked from one main · each cell is one world

100,000 worlds

Fork, median
1.4 µs
Fork, 99th percentile
3.5 µs
First write, median
8.2 µs
On disk, a world
564 B
Memory added
103 MB
Point query, main / world
23 / 21 µs

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28queries are averages of 20 runsBENCHMARKS.md §9

1.4µs

to fork a world, with 100,000 already open

The median. With 10 worlds open it is 2.0 µs; the 99th percentile at 100,000 is 3.5 µs.

564B

on disk for a world with one changed row

And 1.0 KB of memory. With 100,000 worlds the folder is 64.0 MB after a checkpoint; with 10 it is 7.5 MB.

23 / 21µs

a point query in main, and in one of 100,000 worlds

A query in a world is as fast as in main: a whole-table aggregate takes 5.0 and 4.8 ms.

The whole sweep · 10 to 100,000 worlds
WorldsFork p50Fork p99First write p50Point query, main / worldAggregate, main / worldDisk per worldMemory addedCheckpointReopen
102.0 µs17 µs8.8 µs16 / 15 µs5.1 / 4.7 ms503 B0.0 MB16 ms3 ms
1001.8 µs11 µs8.0 µs15 / 16 µs4.8 / 4.6 ms521 B0.0 MB18 ms3 ms
1,0001.7 µs7 µs7.9 µs21 / 14 µs4.8 / 4.7 ms551 B0.3 MB20 ms4 ms
10,0001.5 µs3.5 µs8.1 µs21 / 21 µs4.8 / 4.7 ms557 B1.4 MB72 ms14 ms
100,0001.4 µs3.5 µs8.2 µs23 / 21 µs5.0 / 4.8 ms564 B103 MB868 ms166 ms

Agents

A thousand agents writing at once. On disk, 57–73× Postgres.

Each agent forks main, writes 1,000 rows and merges back, over 100,000 seed rows. Chronos runs in process; the others through their usual clients, on the same machine.

Agent rows a second, 1,000 agentsLonger is better

Chronos DB, in memoryno log: the ceiling
1.29M
Chronos DB, on disk64 workers · fsync on every merge
713k–716k
Chronos DB, on diskone thread per agent
554k–568k
Dolt 2.3.564 workers · a real DOLT_MERGE
28.3k–28.4k
Postgres 17template databases · 25 workers
9.8k
SQLitefile copies · 64 workers
2.5k

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28two rounds eachbuild main with #23 and #29the Dolt runs are of build 8db2f701's day and weren't repeatedBENCHMARKS.md §1

57–73×

Postgres 17, with 1,000 agents, on disk

554k–716k rows a second against 9.8k. Before two fixes of that week (#23 and #29) it was 21–55×.

25×

Dolt 2.3.5, at 64 workers each

713k–716k rows a second against 28.3k–28.4k. Measured together, before those fixes, it was 16×.

1.40s

for all 1,000 agents, at 64 workers

A million rows forked, written and merged, with a log and an fsync on every merge into main. In memory: 0.68 s.

In memory · 10, 100 and 1,000 agents
AgentsSystemFork p50Merge p50Total time
10Chronos (memory)0.009 ms3.4 ms0.01 s
10SQLite (file copy)6.3 ms190 ms0.79 s
10Postgres 17 (template DB)3,553 ms68 ms4.1 s
100Chronos (memory)0.009 ms33 ms0.07 s
100SQLite16 ms1,064 ms10.0 s
100Postgres 172,169 ms127 ms11.2 s
1,000Chronos (memory)0.005 ms322 ms0.77 s
1,000SQLite2,762 ms3,113 ms404 s
1,000Postgres 172,133 ms128 ms102 s

BranchBench

Six jobs agents do. Fastest in four, right in all six.

BranchBench is the Columbia DAP Lab’s benchmark of branching databases. The Chronos adapter and these runs are ours: five warehouses, 2.6 million rows, a two-hour cap, one run each.

BranchBench · six jobs agents do with a databasethe paper

An independent benchmark from Columbia University. Each job copies the database, changes the copies, merges or throws them away, and checks the data is right after every step. Shorter bar: finished sooner.

Training an AI

256 attempts, each in its own copy, each started from a saved point.

Chronos
994 s
Postgresa copy per agent
2,529 s
Doltgresgit for data
over 2 hours· ran out of time

Trying ideas

Draft changes in copies, undo the bad ones, catch up with main.

Chronos
2.0 s
Postgresa copy per agent
53 s
Doltgresgit for data
13 s

Many agents, one database

512 changes from agents merged into a main that keeps changing.

Chronos
4.7 s
Postgresa copy per agent
149 s
Doltgresgit for data
19 s

A coding agent

Keeps its copy current with a busy main, through a schema clash.

Chronos
580 s
Postgresa copy per agent
4,987 s
Doltgresgit for data
563 s

A bad deploy

Investigate in copies, then put the database back as it was.

Chronos
505 s
Postgresa copy per agent
1,817 s
Doltgresgit for data
634 s

Loading data

32 batches merged in, some of them rolled back.

Chronos
2,221 s
Postgresa copy per agent
2,817 s
Doltgresgit for data
1,493 s· half its data checks failed
fastest in 4 of 6 jobs · data right after every step in all 6one run each on the same cloud server · Oct 2026

GCP c2d-standard-16 · 16 vCPUs · 62 GB2026-10-25one run eachbuild main with #257 and #260Postgres 18.6 and Doltgres 1.4.0 from the run of 2026-10-24BENCHMARKS.md §16.1

10.4s

to put the database back after the bad deploy

One RESTORE WORLD … TO the commit's moment. Postgres copies took 195 s (drop and clone again); Doltgres 208 s.

One operation at a time · Chronos only, one warehouse, medians
OperationChronos DB
Branch from main0 ms
Branch from a commit 1–128 commits back4–8 ms
Commit, 1–10,000 rows written1–3 ms
Merge 1 / 1,000 / 10,000 rows1 / 10 / 94 ms
Diff of 1,000 / 10,000 rows1.8 / 14 ms
Revert 1,000 / 10,000 rows23 / 120 ms
Reset, undoing 1 / 10,000 rows7 / 33 ms
Delete a branch, any size0–2 ms

SQL

Level with Postgres on rows. Behind it, core for core, on reports.

Over the Postgres protocol, both on one machine, both flushing every commit to disk.

Rows in and out · one client, 32 cores
WorkloadChronosPostgres 17What ran
Single-row commits2,395–2,543 /s2,286–2,320 /s10,000 inserts, each its own commit
Batched rows290k–297k /s222k–223k /s1,000-row statements
Lookup by key, p5046–48 µs46 µs10,000 lookups; p99 62–63 µs against 63–66 µs
Update by key, p500.41–0.42 ms0.43–0.46 ms1,000 updates

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28two roundsbuild 0f1a19afBENCHMARKS.md §4

Five reports, three releases. Give it cores and watch the bars.

Reports over 200,000-row tables · milliseconds, shorter is better

Chronos on

count(*) of orders

0.5.2 3.2 ms
0.5.3 3.2 ms
0.5.4 3.0 ms

Postgres 4.3 msChronos ahead

count(*) where amount > 500

0.5.2 7.2 ms
0.5.3 7.2 ms
0.5.4 5.4 ms

Postgres 4.8 msPostgres ahead

group by age, count(*), max(name)

0.5.2 23.6 ms
0.5.3 16.0 ms
0.5.4 10.1 ms

Postgres 16.3 msChronos ahead

join both tables, group by, sum

0.5.2 65.1 ms
0.5.3 50.8 ms
0.5.4 40.5 ms

Postgres 29.8 msPostgres ahead

join where name like 'user 1%'

0.5.2 45.1 ms
0.5.3 29.2 ms
0.5.4 23.4 ms

Postgres 18.0 msPostgres ahead

On the same two cores it is slower on three (the filtered count 1.1×, join + group by 1.4×, join + like 1.3×) and ahead on the plain count (1.4×) and group by (1.6×).

Apple M2 laptop · 8 cores · 8 GB2026-11-16best of 3 runsbuild 0.5.2, 0.5.3, 0.5.4Postgres 18.7 in Docker, at its defaultsBENCHMARKS.md §4

0.5.3 changed the joins and 0.5.4 the scans: the filtered count is 25% faster, GROUP BY 23% on one core and 37% on two, the joins 20%. How rows are stored didn't change.

The same reports on 32 cores · ms
QueryChronosPostgres 16DuckDB, 32 threads
count(*) of orders2.7–2.86.8–7.00.4
count(*) where amount > 5004.0–4.18.8–8.90.6–0.7
group by age, count(*), max(name)9.5–9.919.5–19.64.4
join both tables, group by, sum25.4–25.767.0–69.57.2–7.7
join where name like 'user 1%'18.3–18.543.8–44.47.1–8.3
DuckDB is 2.2–7× faster than Chronos on every report; Chronos is 2.0–2.8× faster than Postgres 16 and 17 here.

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28two runs; DuckDB best of 3 rounds of 5build 0f1a19afBENCHMARKS.md §4

CH-benCHmark Q3 and Q18 · one warehouse, 2 threads
Query0.5.20.5.4Postgres 18, 2 cores
Q3187 ms88 ms64 ms
Q18598 ms137 ms226 ms
Q3 is still a loss on the same cores, 1.4×. Q18 went from 2.6× slower to 1.6× faster.

Apple M2 laptop · 8 cores · 8 GB2026-11-16best of 3 runsbuild 0.5.2 to 0.5.4BENCHMARKS.md §16.2

Found by a six-agent demo, then fixed · one statement alone on 150,600 rows
StatementBeforeAfter
Correlated EXISTS, 15,000 outer rows169 s0.17 s
DELETE with that EXISTS167 s0.25 s
Correlated NOT EXISTS173 s0.21 s
id IN (a join on lower(email))over 450 s0.26 s
company IN (15,000 values)27.4 s0.22 s
EXISTS on an indexed column330 s0.77 s
Every statement the old build finished returns the same rows on both.

GCP e2-standard-4 · 4 vCPUs · 16 GB2026-10-02one run eachbuild b8624047 to c7f90ddaBENCHMARKS.md §4

Vectors

Fast, without giving up recall. Speed alone flatters whoever finds less.

999,500 real OpenAI embeddings of 1,536 dimensions, the top 10, one client, eleven systems, each at its defaults and each run alone.

Speed against recall · up and to the left is better

Searching

0.51 ms2510 ms2050100 ms200100%90%80%70%60%
#Systemp50Recall@10
2Redis 8.100.50 ms74.2%
1Chronos DB1.34 ms98.6%
3Chroma 1.5.92.25 ms96.8%
4pgvector 0.8.62.40 ms92.8%
5Weaviate 1.39.72.48 ms98.2%
6LanceDB 0.393.43 ms85.0%
7Elasticsearch 9.5.43.56 ms94.9%
8Milvus 3.0.13.92 ms97.3%
9Qdrant 1.19.16.67 ms99.0%
10pgvectorscale 0.9.18.33 ms96.6%
11OpenSearch 3.8.010.06 ms98.5%

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28 and 29each system alone, its server started freshBENCHMARKS.md §6

1.34ms

the median search of every row, at 98.6% recall

The fastest of every system that finds more than 75% of the true top 10. Only Redis is faster, at 74.2%; only Qdrant finds more (99.0%), in 6.67 ms.

1.19ms

filtered to one user’s rows, at 100% recall

The fastest of all eleven. Elasticsearch takes 3.47 ms at 61.3% recall, Milvus 3.89 ms at 99.7%.

3.1GB

held by the server after the run

7.7 GB at its peak, while the index builds. Milvus 5.2 GB, Qdrant 6.6 GB, Weaviate 11.9 GB, Redis 13.2 GB.

Against pgvector raised to the same recall · 1M rows, p50 with one client, queries a second with eight
SearchChronosPostgres 17.11 + pgvector 0.8.7
DBpedia, 1,536 dimensions, cosine1.29 ms · 3,675 q/s · 98.5%7.44 ms · 724 q/s · 98.7%
Synthetic 768, cosine (pgvector never reached 99.8%)0.87 ms · 4,700 q/s · 99.8%3.76 ms · 1,211 q/s · 98.2%
Filtered to 1% of rows1.33 ms · 3,248 q/s · 100%40.3 ms · 168 q/s · 100%
Filtered to 10% of rows2.16 ms · 1,003 q/s · 100%211 ms · 19 q/s · 100%
Filtered to 50% of rows2.02 ms · 902 q/s · 99.96%3.90 ms · 1,289 q/s · 98.3%
Building the index, DBpedia94 s349 s
At the same recall Chronos is 4.1–5.8× faster unfiltered and 30–100× under a 1% or 10% filter. At its default beam pgvector is about as fast as Chronos, or faster under a 10% or 50% filter, at 81–92% recall.

GCP c2d-standard-16 · 16 vCPUs · 62 GB2026-10-171,000 held-out queries, one system at a timebuild 141013fBENCHMARKS.md §2

Undo

100,000 changes by an agent, undone in 1.47 seconds.

500,000 rows in main. An agent changes 100,000 of them straight in main, with no world and no approval. Then a person changes 50,000 other rows, and 100 of the agent’s.

1.47s

UNDO AGENT bot SINCE … SKIP CHANGED

99,900 rows put back, 100 left as the person changed them. None of the agent's values remain, and all 50,100 of the person's changes are kept.

The agent's 100,000 rows · each cell is 100 of them

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28runs not statedBENCHMARKS.md §7

The whole run
Step32 coresOn the 8 GB M2 laptop
Load 500,000 rows3.1 s12.0 s
The agent’s 100,000 changes1.0 s12.6 s
UNDO AGENT bot SINCE … SKIP CHANGED1.47 s6.2 s

Scale

300,000 worlds, one search. 4 minutes 40 seconds.

A supply-chain optimization. Fork 100,000 worlds from main, give each its own reorder policy, simulate it in SQL inside the world, keep the best 1%, fork 100 children from each winner. Three rounds, then the winner is merged into main.

The three rounds · on disk, 32 threads
RoundWorldsAlive afterFork them allSimulateScoreDiscard the rest
1100,0001,000729 ms50.0 s14.3 s0.31 s
2100,0001,175851 ms70.6 s23.1 s0.51 s
3100,0001,055886 ms84.6 s31.6 s0.69 s
1.29 GB at its peak. The winner's 12 policy rows went into main in 6–7 ms. About 21 minutes on the 8 GB laptop. The learning rounds added 0.3% over round 1's best.

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28runs not statedBENCHMARKS.md §10

49,402

worlds made and discarded by a tree search

Monte Carlo Tree Search playing Connect Four, every node a world: 0.84 ms an iteration, at most 230 worlds alive, 20 MB. It won 20 of 20 against a random player, which is a weak opponent.

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-2820 seeded gamesBENCHMARKS.md §11

0.30s

to discard 99,000 of 100,000 worlds, in one call

3.0 µs each; one by one, 0.35 s. Before the fix it took 54.8 s on a 4-vCPU VM.

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28runs not statedbuild 8db2f701BENCHMARKS.md §9

25×

a database bigger than its cache

842 MB of pages on a 32 MB cache: a lookup by key takes 0.052–0.064 ms at the median, a scan of everything about 0.7 s. The cache held to its cap; the process still reached 495 MB during scans and joins, which is to be looked into.

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28two runsbuild 0f1a19afBENCHMARKS.md §12

411MB

to insert 10,000,000 rows in one statement

589.4 s, flat in memory, 1.2 GB on disk. Before the change, 3,000,000 rows took 6,811 MB.

GCP VM · 4 vCPUs · 31 GBbefore 2026-09-28, not rerunruns not statedBENCHMARKS.md §12

Correctness

5,675,180 queries with known answers. None wrong that Postgres got right.

SQLite’s sqllogictest corpus, 622 files, sent over the Postgres protocol to Chronos and to a reference Postgres 17.

99.912%

of 5,675,180 records passed

5,670,175 of them. Postgres 17 passed 5,663,585 (99.796%). Most of what fails on either is SQLite's own dialect.

8

answers differed from the corpus

Postgres 17 returned the identical answer each time. There is no record where Postgres answers right and Chronos answers wrong.

63

records fail only on Chronos

A division by zero in machine-generated expressions that Postgres folds away and never evaluates. Of the 6,653 only Postgres fails, Chronos is laxer than Postgres, not better.

GCP VM · 4 vCPUs · 32 GB2026-09-27not rerun on the 32-core machineBENCHMARKS.md §13

Killed, torn and interleaved. Nothing acknowledged was lost.

The crash suite · each cell is one cut log, recovered

10,000 crash runs

Recovered exactly what reached disk
10,000 of 10,000
Time
132 s on each build

GCP c2d-standard-32 · 32 vCPUs · 128 GB2026-09-28each on two buildsbuild 8db2f701 and the PR buildBENCHMARKS.md §5

Crash suite

10,000 of 10,000 recover exactly the operations that reached disk

Cuts the log at random bytes, with torn-write garbage, then recovers.

Deterministic simulation

3,000 schedules of each scheduler pass

Agents, direct writes, checkpoints and cleanup, interleaved under controlled schedules.

Jepsen-style kills

60 kills, 31,397 acknowledged transfers: none lost, every balance matched the ledger

kill -9 the server during concurrent fork-and-merge bank transfers.

What the kills found first

Two real bugs before release, both fixed: money created from nothing (a merge took “both sides wrote the same value” for no conflict), and a write lost silently when the server died and restarted in milliseconds. Since the fixes: 300 more kill -9s and 108,178 confirmed transfers on the laptop, none lost.

88.98%

of the lines Postgres 16’s own regression suite expects; 66 of 219 files exactly the same (2026-10-27)

495

differential tests against a real Postgres 16, each giving the same rows or the same error class

7 of 7

real databases moved in with identical row checksums (Chinook, Northwind, Pagila, pgbench at 2M rows and others)

Chronos DB is a beta. Where it stands against Postgres 16, gap by gap: Postgres compatibility.

Your database

Beside the database you keep. Mostly round trips.

Attach copies your tables; agents work in worlds of the copy; each merge is written to your database first, in one checked transaction. Chronos Gateway runs the same engine in front of the database your product already has.

Merges written back to Neon · Postgres 16.15, about 60 ms away
StepDirectThrough the pooler
Attach: copy 20,200 rows in one consistent read7.7 s7.9 s
Merge 1,000 updated rows1.19 s1.20 s
Merge 1,000 inserted rows1.19 s1.19 s
Merge 500 deleted rows1.13 s1.07 s
A row changed in Neon meanwhileconflict, nothing writtenconflict, nothing written
A merge here is mostly round trips, so it grows with the distance to the database, not much with the rows: it is not a measure of Chronos itself.

Chronos on a GCP VM in Mumbai; Postgres 16.15 on Neon in Singapore, about 60 ms apart2026-10-17one run: orders of magnitudeBENCHMARKS.md §14

What checking a world's reads costs · a 100,000-row table
Readscheck_reads offOn
9,000 point lookups by key, per read40.8 µs38.3 µs
100,000 point lookups by key, per read40.5 µs42.0 µs
1,000 filtered scans, per read641 µs622 µs
Reading costs nothing measurable. The merge-time check of 1,000 filtered scans took 1,825 ms in this run; since 0.3.0 it takes 2.7 ms.

GCP c2d-standard-8 · 8 vCPUs2026-10-17one run, repeated once within 10%BENCHMARKS.md §15

Chronos Gateway. Its own overhead isn't benchmarked yet.

No table exists for what the Gateway adds to a query or a merge beside Postgres, MySQL or MongoDB, so none is shown. These are the measured figures its docs and changelog carry.

57 s → 2.7 s

Undoing a run that wrote 10,000 rows of a 20,000-row table beside Postgres

Through the gateway on an M2, before and after engine 0.5.3. The preview: 52 s to 2.8 s.

Gateway changelog, 0.3.3

13 s · 4 s

Until another gateway leads, after kill -9 and after a clean stop

Several gateways behind one address. Requests in those seconds answer 503 with Retry-After.

Gateway docs, high availability

about 30 s

Attaching 2.5 million rows of Postgres, one consistent read

On a test machine; one observation, the machine not recorded.

Gateway docs, self-host

Losses

Where Chronos DB loses. All of it, with the numbers.

The table BENCHMARKS.md opens with, as it stood on 2026-11-17, and one line more from the compatibility page.

  1. Postgres 18

    Three of five reports over 200,000-row tables, Chronos held to the 2 cores Postgres had (M2, 2026-11-16)

    Chronos DBfiltered count 5.4 ms, join + group by 40.5 ms, join + like 23.4 ms

    Against4.8, 29.8, 18.0 ms: 1.1–1.4× faster

    §4
  2. Postgres 18

    All five reports, Chronos on one core against Postgres’s two (M2, 2026-11-16)

    Chronos DB5.5–75.1 ms

    Against4.3–29.8 ms: 1.1–2.5× faster

    §4
  3. Postgres 18

    CH-benCHmark Q3, one warehouse, Chronos held to 2 cores (M2, 2026-11-16)

    Chronos DB88 ms (187 ms in 0.5.2)

    Against64 ms

    §16.2
  4. DuckDB 1.5.5

    Analytics reports over 200,000-row tables (2026-09-28, not rerun)

    Chronos DB2.8–25.4 ms

    Against0.4–8.3 ms: 2.2–7× faster

    §4
  5. Postgres 17

    Merge p50, 1,000 agents on disk, one thread per agent

    Chronos DB714–718 ms (1,231 ms before #23 and #29)

    Against128 ms (25 workers)

    §1
  6. Its own target

    Vector search inside a fork, against main, 1M rows

    Chronos DB1.55× main (no filter), 1.12× (text)

    Againsttarget: within 1.1×

    §3
  7. Its own gate

    Filtered vector search at 10%, 500k × 384, against tuned pgvector

    Chronos DB0.93 ms

    Against1.17–1.22 ms: only 1.3×, under the 5× gate

    §2
  8. Redis 8.10

    Vector search median, all rows, 76k and 1M real embeddings

    Chronos DB0.72–0.74 ms, 1.36 ms

    Against0.46 ms, 0.50 ms, at 75.0% and 74.2% recall (Chronos: 99.98%, 98.6%)

    §6
  9. Postgres 17 + pgvector 0.8.7

    Filtered vector search (50% of rows), 8 clients, 1M × 768

    Chronos DB902 q/s at 99.96% recall

    Against1,289 q/s at 98.3% (ef_search 1,000)

    §2
  10. Its own scaling

    Filtered vector search (10%, 50%), 1 to 8 clients, 1M × 768

    Chronos DB2.3× and 1.8× the throughput; p99 14.8 and 20.4 ms

    §2
  11. LanceDB 0.39

    Loading 76k × 1,536 vectors

    Chronos DB4.7 s

    Against1.0 s (in its own process, from an Arrow table)

    §6
  12. Weaviate, Redis

    One-user (1%) vector search p99, 76k

    Chronos DB2.1–2.3 ms

    Against1.46 ms, 1.23 ms

    §6
  13. Postgres 17

    One order joined to its row by key, over the protocol

    Chronos DB52 µs

    Against50 µs

    §4
  14. Redis, Weaviate

    Server memory after the 76k run

    Chronos DB1.14 GB (2.3 GB at its peak)

    Against1.05 GB, 1.10 GB

    §6
  15. Doltgres 1.4.0

    BranchBench S4: dev worlds rebasing off a busy spine, five warehouses

    Chronos DB663 s (580 s in the rerun)

    Against563 s

    §16
  16. Doltgres, Postgres copies

    The spine’s TPC-C throughput while BranchBench’s agents work (S4)

    Chronos DB28 txn/s

    Against30, 73 txn/s

    §16
  17. Postgres 16

    pgbench-style load, same machine (October 2026; not tuned yet)

    Chronos DBpoint reads at about 0.5× Postgres’s rate

    Andwrites: Chronos at a fraction of Postgres’s rate

    doc

The cause of the merge row is found and its fix is being built. No longer losses: CH Q18, unfiltered vector search at 1M (4.69 ms before, 1.36 ms since), and server memory at 1M real embeddings (7.7 GB before, 3.1 GB since).

Method

Same machine, same client, one job at a time.

Every rival ran on the machine Chronos ran on, driven by the same client, at its defaults unless the section says otherwise, and never tuned below them. Recall is always shown beside speed.

GCP c2d-standard-32 · 32 vCPUs · 128 GB
AMD EPYC 7B13, a 500 GB pd-ssd, Ubuntu 24.04. One job at a time on an otherwise idle machine.
Most of this page: the rerun of 2026-09-28
GCP c2d-standard-16 · 16 vCPUs · 62 GB
AMD EPYC 7B13, pd-ssd, Ubuntu 24.04.
BranchBench (2026-10-24 and 25) and pgvector side by side (2026-10-17)
Apple M2 laptop · 8 cores · 8 GB
4 fast and 4 efficiency cores, macOS 26. Postgres 18.7 in Docker with 2 of its cores and 2 GB.
The five reports and CH Q3 and Q18, rerun 2026-11-16 while the cloud machines were off
GCP VM · 4 vCPUs · 32 GB
Linux.
sqllogictest (2026-09-27) and the bigger-than-memory statements; not rerun since

How old these are

Nothing here was measured on the current release, Chronos DB 0.6.2.

The newest runs are the five reports and CH Q3 and Q18, on 0.5.4 (2026-11-16). Most of the page is the rerun of 2026-09-28; BranchBench is 2026-10-24 and 25. Each chart says its own day and build. Numbers from different machines don't compare with each other.

One run means one run

BranchBench, the subquery fixes and the Neon write-back are single runs: read them as sizes, not as medians. The undo, the simulation and the discards don't say how many runs stand behind them. Where a figure is a range, it is the spread of its runs.

The others

Postgres 17.11, 16.15 and 18, pgvector 0.8.6 and 0.8.7, pgvectorscale 0.9.1, SQLite, Dolt 2.3.5, Doltgres 1.4.0, DuckDB 1.5.5, Qdrant 1.19.1, Chroma 1.5.9, LanceDB 0.39, Milvus 3.0.1, Weaviate 1.39.7, Elasticsearch 9.5.4, OpenSearch 3.8.0 and Redis 8.10.2.

rerun them · from the engine's repository
cargo run --release --example bench -- 10 100 1000        # forks and merges; needs PostgresSWEEP=1 ROWS=100000 cargo run --release --example worlds   # 10 .. 100,000 worldsN=200000 cargo run --release --example report              # the five reportspython bench/vector_dbs.py [system ...]                    # one vector database per runROWS=500000 AGENT=100000 OTHERS=50000 cargo run --release --example undo_agentULTIMATE=1 cargo run --release --example simulate          # 100,000 worlds x 3 roundsCRASH_RUNS=10000 cargo test --release --test durability crash_suiteJEPSEN_KILLS=20 cargo test --release --test jepsen -- --nocapture

The raw output of every run, and the script that made it, are in the repository beside BENCHMARKS.md, which has every table this page was drawn from, and more.

Don't trust them. Rerun them.

Benchmarks · Chronos