data.semurg.io · measured on our box, reproduced on yours

Reproduce the wired lanes on your own hardware.

Every number on this page is measured internally on our reference node, a single query, answered the same way by every engine, on the same data. We do not ask you to trust it. Download the kit, run one command, and print the same decomposed, equal-answer board on your own machine for the wired lanes (relational, key-value, time-series, document); the graph head-to-head (Semurg vs Neo4j vs Kuzu, in-core and the out-of-core survive-vs-DNF crown) and the OLAP head-to-head (Semurg vs DuckDB) reproduce today via run --graph and run --olap; the vector lane is being wired.

Get the kit Single-domain head-to-heads Multi-domain workflows

$ curl -fsSL /kit | sh

Then semurg-arena run --all, the wired-lane board and the public-license engines, computed side by side on your silicon. Equal-answer: every engine answers the identical query on the identical data. The graph head-to-head (run --graph: Semurg vs Neo4j vs Kuzu, in-core + the out-of-core survive-vs-DNF crown) and the OLAP head-to-head (run --olap: Semurg vs DuckDB) reproduce today; the vector lane is being wired.

Runs on Linux x86_64 (Ubuntu 24.04)

Semurg needs Linux on x86_64. On macOS, Windows, or ARM, run the kit inside a Linux x86_64 VM (Multipass, WSL2, or any VM) and use the same one line.

Not sure? Your box is fine if uname -m prints x86_64.

Measured internally, reproduce it yourself

Semurg's own absolute numbers, on the reference node.

Reference hardware: one node, one AMD EPYC 4345P (8 cores / 16 threads), 60 GB RAM, 2× NVMe. Nothing here is a third-party published benchmark, and our numbers are our numbers on our box — which is precisely why we would rather you had the full report, or ran it yourself, than took a figure off a marketing page.

Sequential scan
cold (disk) → warm (RAM) → hot (L3), the whole conveyor.

Point-get
cold and hot, at deep queue depth.

Substrate ops/s
measured across all three tiers.

Storage compaction
block collapse once the janitor packs by co-access.

k-hop traversal
out-of-core survival to depth 131,072 at flat memory.

Model serve
tokens/s, single-user and aggregate, weights streamed from disk.

Two ways to get the actual numbers

Run it yourself

The kit is the proof, not our word. It ships the equal-answer harness and prints every figure on your hardware — including the ones where we lose.

semurg-arena run --all

Ask us for the report

Full per-task benchmarking across all ten domains against every public incumbent, with method, dataset, equal-answer verification and every concession stated.

hello@semurg.org

The board at a glance

Ten domains, one look, before you scroll into the detail.

Each row is the engine set Semurg is measured against in that domain, on the same hardware, equal-answer. Incumbents are tagged embedded (in-process library) or external (client-server); Semurg itself runs embedded / in-app. License-restricted engines are named on their detail card only, never with a number, here or anywhere.

The board at a glance10 domains · equal-answer · figures on request or reproduce with the kit

Domain	Measured against	Status
Relational / OLTP	PostgreSQL ext, SQLite emb, MySQL ext, MariaDB ext	Win
OLAP / columnar	DuckDB embClickHouse ext, measuring (lane not yet run)	Win
Graph	Kuzu emb, Neo4j extequal-answer head-to-head + out-of-core crown: semurg-arena run --graph	Win
Key-value	Redis ext, RocksDB embrestricted incumbent named below, no number	Win
Time-series	TimescaleDB ext, QuestDB extrestricted incumbent named below, no number	Win
Document	MongoDB ext	Win
Full-text / search	OpenSearch ext; ranked BM25 buildingrestricted incumbent named below, no number	Win: class BM25 building
Vector	Faiss emb exact top-k, width-matched to binary-flat; sublinear ANN buildinghead-to-head reproduce-lane coming	Win: exact ANN building
Streaming	Kafka ext; consumer-groups / offset-replay building	Building
Object storage	MinIO ext; large-object / multipart building	Building

Status: Win = a measured, equal-answer advantage over the public incumbent. Building = the mechanism exists but the head-to-head is not yet banked (marked, never invented). Measuring = a public incumbent we name but have not yet run, an honest empty cell, not a fabricated number. No license-restricted metric appears here or anywhere.

Page 1

Single-domain head-to-heads

All ten domains in per-task detail, every public incumbent, embedded and external, with the method and the command that reproduces it on your own box.

Open the domain board → Page 2

Multi-domain workflows

Six workflows where one substrate replaces a whole stack, each showing the boxes it collapses and the ETL it deletes, with honest build status.

Open the workflows →

Run it on your own box

The kit is the proof, not our word.

$ curl -fsSL /kit | sh

Or download directly: the kit tarball and its SHA256. Verify the checksum before running.

Semurg R11 installer. The same signed, checksum-verified release from one.semurg.io, compiled native on your box.

Public-license engine lanes. Stood up locally, run the identical equal-answer workload, printed beside Semurg, the reproduce path behind every headline.

semurg-arena. One orchestrator: run --all, list, run <lane>, --dry-run.

License-restricted engines run in a separate opt-in step (semurg-arena run --licensed) that installs them from the vendor under your own licence and keeps those results entirely local, never uploaded, never shown on this page.

Page 1 · single-domain head-to-heads

One database face at a time, against its incumbents.

Ten database domains, per task, because Semurg wins task by task, not just on an average. For each, Semurg's own measured result against the engines that own that category, plus the command that reproduces it on your box. The kit stands up each public-license engine locally and runs the identical equal-answer workload beside Semurg.

Public-license engine, the measured head-to-head number, reproducible with the kit. License-restricted engine, named in its category, benchmarked under our own licence, no number shown.

Each incumbent is tagged EMBEDDED (in-process library, DuckDB, SQLite, RocksDB, Faiss, Kuzu) or EXTERNAL (client-server over a socket). Semurg itself runs embedded / in-app, that is the whole point of a substrate. Against an embedded library it is a pure engine-vs-engine comparison with no wire tax on either side (the cleanest, strongest compare). Against an external server, the server pays a network/wire tax that Semurg-in-app does not, so we decompose engine-core vs wire-tax vs end-to-end rather than bank the wire tax as raw engine speed.

Relational / OLTP

SQL

A stored, co-located foreign key beats a join planned at query time; analytical queries fold the resident store, the joins are already there. 3-table star, 10M orders, equal-answer hash verified every row.

Incumbent	Result
PostgreSQL external	measured — full per-task figures on request, or reproduce with the kit
SQLite embedded	measured — full per-task figures on request, or reproduce with the kit
MySQL 8.4 external	measured — full per-task figures on request, or reproduce with the kit
MariaDB 11 external	measured — full per-task figures on request, or reproduce with the kit

Honest: MySQL/MariaDB pick a pathological per-row PK nested-loop (real weakness, but plan-dependent, PK+FK-indexed+ANALYZE'd, not handicapped); lead with PostgreSQL, not the pathological outlier. SQLite with synchronous=OFF (weaker durability) is faster on single unbatched writes; Semurg wins at matched durability. Embedded compare (SQLite) = pure engine-vs-engine, no wire; external (PG/MySQL/MariaDB) = server pays a wire tax, analytical wins are engine-to-engine (the returned scalar's RTT is negligible), point/OLTP wins are where in-app avoids the many round-trips.

reproduce: semurg-arena run relational

OLAP / columnar

Analytics

The 8-byte column fold, materialized at ingest and folded resident, is bandwidth-bound, it out-executes a morsel engine at thread parity. 100M rows, equal-answer (grand-sum 922416622259008426906557300).

Incumbent	Semurg advantage, per task
DuckDB 1.1.3 embedded	measured — full per-task figures on request, or reproduce with the kit
ClickHouse external	measuring lane not yet run, no number invented

Honest: DuckDB is embedded, the cleanest engine-vs-engine compare, no wire on either side; the win is execution efficiency at parity (bandwidth-bound fold vs morsel/int128). The kit prints both the fold lever and the un-folded row path.

reproduce: semurg-arena run --olap

Graph

Traversal

Reach on 2M nodes / 12M edges, equal-answer (1399 / 8580 / 50994 = groundtruth). Semurg's stored-edge point-get stays flat as depth grows; a join-per-hop climbs.

Incumbent	Semurg advantage, per hop
Kuzu 0.11.3 embedded	measured — full per-task figures on request, or reproduce with the kit
Neo4j external	measured — full per-task figures on request, or reproduce with the kit

License-restricted · no number shown

TigerGraph external · Memgraph external

Benchmarked internally under our own licence, reproduce under yours.

Honest: relationship = stored co-located edge, not a query-time join. Kuzu is embedded (pure engine-vs-engine); Neo4j is an external server, correct reach, timed client-observed with RTT. The flat-vs-climbing curve is the point, not the hop-1 ratio alone. These graph figures are measured internally; the Kuzu/Neo4j head-to-head reproduce-lane runs today in the kit — semurg-arena run --graph ingests the same graph into Semurg + Neo4j + Kuzu, gates on an equal answer, and reports in-core AND the out-of-core survive-vs-DNF crown.

reproduce: semurg-arena run --graph

Key-value

A key is a content address; a batch of gets fans inside one crossing. Semurg wins the read/get class; write-side atomics stay the incumbent's.

Incumbent	Semurg advantage, per task
Redis 7 external	measured — full per-task figures on request, or reproduce with the kit
RocksDB embedded	measured — full per-task figures on request, or reproduce with the kit

License-restricted · no number shown

Dragonfly external

Benchmarked internally under our own licence, reproduce under yours.

Honest: INCR / TTL / CAS atomics are conceded to Redis, Semurg wins the point/batched read class. RocksDB is embedded (pure engine-vs-engine); Redis is external, the batched MGET amortizes its wire, the in-app point-get laps it on round-trips.

reproduce: semurg-arena run kv

Time-series

10M monotonic points, equal-answer (range-count 5,000,001; agg sum 4,999,572,969,965). The 8-byte value-column fold turns the aggregate into a bandwidth-bound pass.

Incumbent	Semurg advantage, per task
TimescaleDB external	measured — full per-task figures on request, or reproduce with the kit
QuestDB external	measured — full per-task figures on request, or reproduce with the kit

License-restricted · no number shown

kdb+ / KX external

Benchmarked internally under our own licence, reproduce under yours.

Honest & decomposed: the 8B-column fold lever flips QuestDB; without it the un-folded 64B-row path loses (the kit prints both). Range on monotonic time is O(1) arithmetic, flagged distinctly from the fold. Both incumbents are external servers.

reproduce: semurg-arena run timeseries

Document

Docs

Folding a resident store beats deserializing every BSON document. 10M-order collection, equal-answer against the SQL board.

Incumbent	Semurg advantage, per task
MongoDB 7 external	measured — full per-task figures on request, or reproduce with the kit

Honest: Semurg wins full-collection aggregation and non-indexed scans; the indexed point-query and the rich document language are MongoDB's. External server, the win is folding a resident store vs per-document BSON deserialization (plus wire).

reproduce: semurg-arena run document

Full-text / search

Index-free scan over the raw bytes wins the substring / cross-token class. Ranked relevance is a different game, and an honest one to concede for now.

Incumbent	Semurg, per task
OpenSearch external	building (warm text scan)

License-restricted · no number shown

Elasticsearch external

Benchmarked internally under our own licence, reproduce under yours.

Honest: Semurg wins the raw-byte / cross-token class; ranked BM25 relevance is in build and conceded today. OpenSearch (external) has not been brought up head-to-head, no multiplier is claimed.

reproduce: semurg-arena run search

Vector

ANN

A sign code is one container, one ZMM register; Hamming top-k runs on the silicon. We win exact search; sublinear ANN is honestly in build. 512-bit, recall 1.0 on the exact path.

Incumbent	Semurg, per task
Faiss embedded	building (6425 vs 5281 q/s IndexBinaryFlat, recall 1.0)
Qdrant external	measuring lane not yet run, no number invented

Honest: Semurg wins exact search over compact binary codes (embedded, cleanest compare), width-matched against Faiss binary-flat. It does not yet win sublinear ANN, Faiss-HNSW is faster there; Semurg's HNSW-as-edges lever is in build. Against exact floating-point ground truth, recall@1 is perfect and recall@k is lower, published honestly. Qdrant (external) has not been run.

measured internally head-to-head reproduce-lane coming

Streaming

Log

Append is pure, share-nothing, and fast. Consumer groups and offset replay are the part that is being built.

Incumbent	Semurg, per task
Kafka external	building (append path; reproduce with the kit)

Honest: the raw append rate is a measured substrate capability; the Kafka head-to-head (consumer groups, offset replay) is offset-as-fold, in build, no multiplier claimed. Kafka is an external broker.

reproduce: semurg-arena run streaming

Object storage

Blobs

Small-object get is already point-get fast. The large-object / multipart face is the chunk-run that is being built.

Incumbent	Semurg, per task
MinIO external	building (point-get path; MinIO is S3-HTTP-bound, not a like-for-like object-store number)

Honest: small-object get is the point-get path, not a fair object-storage comparison; the object-storage face (large blobs, S3 multipart, chunk-run) is the honest measure and is in build. MinIO is an external S3 server.

reproduce: semurg-arena run object

All public-license numbers are Semurg's own, measured internally on the reference node and equal-answer verified. The wired lanes (relational, key-value, time-series, document) reproduce with semurg-arena run <lane>; the graph head-to-head (run --graph, in-core + out-of-core crown) and the OLAP head-to-head (run --olap) reproduce today; the vector lane is being wired. License-restricted engines (kdb+/KX, Elasticsearch, TigerGraph, Memgraph, Dragonfly) are named in their category only; their figures were taken under our own licence and are not published, reproduce them under yours.

← Overview Multi-domain workflows →

Page 2 · multi-domain workflows

One substrate replacing a stack, and the ETL between the boxes.

The single-domain board puts one face against one incumbent. This is the other half: workflows that normally need several databases wired together with sync jobs. On Semurg they are faces of one store, reading one copy, so the copies collapse and the ETL between them disappears. Status is marked honestly: a demo is partly built and runnable; a designed workflow is a capability mapped onto the substrate, not yet a running demo.

Demo, partly built, runnable today. Designed, mapped onto the substrate, not yet a running demo.

GraphRAG

Demo · partly built

Replaces the stackVector DB + graph DB + chunk/document store + reranker + sync-ETL (e.g. Pinecone + Neo4j + Postgres + ETL).

Deletes the ETLThe embedding → graph → document sync and its three cross-system copies. Retrieval runs in one process on one copy.

What it provesHybrid retrieval, ANN seed → 1–2 hop graph expand → point-get text, with consistency-under-update on one copy. The stack's vector index and graph drift apart between syncs; here they cannot.

Native MoE serving

Demo · partly built

Replaces the stackGPU model server (vLLM) + separate weight store + KV-cache tier, none of which touch your data.

Deletes the ETLThe separate weight store and cache. Weights are content-addressed on the same substrate as the knowledge base, served through the same tiered read path.

What it provesModel + its knowledge = one substrate; shared experts dedup; runs out-of-core on CPU (survive-vs-DNF). Honest: CPU MoE is physics-bound, this is a capability claim (out-of-core + dedup + unified), not a tokens/s record. Serving runs via the models extension on the same substrate.

Agent long-term memory

Demo · partly built

Replaces the stackVector DB + KV + graph + SQL for agent state and memory (e.g. Redis + Postgres + vector DB).

Deletes the ETLFour memory stores and the sync between them. Each memory is one container; recall blends vector similarity + graph link-walk + recency fold.

What it provesPinned (never-forget) vs collectible (decay) is a substrate retention policy, not application code; content-addressing dedups the same fact once.

Semantic response cache

Designed

Replaces the stackVector DB (prompt embedding) + KV (response) + TTL logic.

Deletes the ETLThe embedding store and the separate cache. Prompt embedding = vector, response = co-located container, hit = ANN → point-get, TTL = retention policy.

What it provesParaphrase-level cache hits in one face; eviction as a substrate primitive.

Real-time recommendation

Designed

Replaces the stackFeature store (Redis) + item-vector DB + user-item graph + OLAP.

Deletes the ETLThe feature/graph skew and the sync between them. Embeddings + interaction edges + feature columns are co-located.

What it provesUser-vector → ANN candidates → graph co-interaction rerank → columnar velocity fold, in-process, features consistent with the graph, no skew.

Real-time fraud / anomaly

Designed

Replaces the stackKafka + graph + vector + OLAP + rules engine + ETL.

Deletes the ETLThe lag between ingest and scoring. Transactions ingest as edges, live.

What it provesFraud score = graph ring/cycle detect + vector similarity to known patterns + columnar velocity fold, with zero ETL lag, scoring inside the decision window. The stack's ETL lag is the vulnerability.

Why this is the harder claim. Any two systems can be benchmarked head-to-head (the single-domain board). The workflow claim is structural: the same bytes serve every face, so there is no second copy to keep in sync and no ETL to lag. GraphRAG, native MoE and agent-memory are the partly-built demo trio; semantic cache, recommendation and fraud are designed capabilities mapped onto the substrate, shown as such, not as running demos.

← Single-domain head-to-heads Overview →