HTAP database
An MVCC row heap takes the transactions, the .zyr columnar format takes the analytics, and background compaction moves rows between them. One engine, one connection.
ExploreZyron v0.21.0 is out
One engine.Both workloads.
Zyron runs three surfaces off one Rust codebase. An HTAP database takes transactions and analytics in a single engine, ZyronLake keeps shared-storage tables with branches and time travel, and a mesh lets one query reach every node.
What the mesh is doing
Meet the mesh
One Zyron deployment. Database nodes in a Raft group, lake nodes over a shared store, embedded nodes inside applications, and clients that can hit any of them.
Click a step to jump to it
- Queries
- Replication
- Lake commits
65.6Ktps
Peak OLTP throughput
11.9GB/s
Columnar scan throughput
35ms
Cold boot to first query
778Ktxn/s
Durable group commit peak
Measured on a single 24-core machine, release build. Every figure comes from committed result files in the repository's benchmarks directory.
How Zyron works
01 / 04
Writes arrive
Transactions land over the wire. The hot path is lock-free, and every commit is fsynced through group commit before the client sees an acknowledgement.
02 / 04
The row heap
Fresh rows live in an MVCC heap tuned for OLTP. Point reads, updates, and high-concurrency writes run under snapshot isolation.
03 / 04
Columns form
A background thread compacts committed rows into .zyr columnar segments with per-column encoding. Queries filter the encoded data directly, and only surviving rows are materialized.
04 / 04
One mesh
Nodes peer over the wire, hosting a database, a lake, or both. A single SELECT reaches local heap tables, lake segments, and remote publications, and database nodes can join a Raft group where writes commit through quorum.
Keep scrolling to move the data
Platform
Three surfaces, one codebase
A database, a lake, and a mesh that ties them together. All three are reachable from any client language over the same wire protocol.
ZyronLake
A shared-storage table format on an append-only transaction log. Branches, time travel, versioned secondary indexes, and clustering, on local disk or object storage.
ExploreThe mesh
Nodes peer over the wire, and a single SELECT joins local heap tables to remote publications or a shared lake. Database nodes can also join a Raft group where writes commit through quorum.
ExplorePeer edges carry publications, subscriptions, and foreign scans. A query entering any node can reach all of them.
Is Zyron for you
Four situations it was built for
Each one is a decision you may be facing today. If any of them reads like your setup, the page behind it goes into the details.
If
You run transactions and analytics on the same data and keep two systems in sync to do it.
Then
One engine takes both. Writes land in the row heap, compaction carries them into .zyr segments, and HybridScan reads both in one operator. No ETL between them.
The databaseIf
Your tables live on object storage and you need branches, time travel, and readers outside the engine.
Then
ZyronLake keeps immutable .zyr files against an append-only log, one version per commit, with branches and AS OF reads in the format itself.
ZyronLakeIf
Several services each need a database, and they need to query each other without a gateway in front.
Then
Nodes peer over the wire. Any client hits any node, and one SELECT joins a local table to a remote publication or a shared lake.
The meshIf
A write must survive losing a machine, and every node must answer reads with the latest committed data.
Then
Database nodes join a Raft group. Writes commit through quorum under one fsync per member, and follower reads stay linearizable through ReadIndex.
ConsensusFeatures
The whole engine, built from scratch
No embedded SQL engine, no third-party storage layer. Zyron implements its own WAL, buffer pool, B+ tree, MVCC, parser, optimizer, vectorized executor, and wire protocol.
One engine, both workloads
Fresh writes land in an MVCC row heap tuned for OLTP. A background thread compacts them into the .zyr columnar format, and HybridScan reads both in a single operator.
Lock-free hot paths
LSN assignment, the WAL ring buffer, MVCC visibility checks, the buffer pool, and the B+ tree avoid mutexes on the query and write path entirely.
Durable by default
Every commit fsyncs the WAL through group commit before the client sees an acknowledgement. A committed transaction survives power loss, with no per-page fsync tax.
Time as a first-class dimension
AS OF TIMESTAMP and VERSION AS OF queries, copy-on-write branches, and bitemporal tables, with picosecond timestamps and hybrid logical clocks underneath.
Mesh, not monolith
A node can host a database, a lake, both, or run embedded. Nodes peer over the wire, and a single SELECT joins local heap tables to remote publications or a shared lake.
ZyronLake table format
Immutable .zyr files over an append-only transaction log. Branches, time travel, versioned secondary indexes, Z-order clustering, and change feeds live in the format itself.
Query-on-encoded
Dictionary, RLE, bit-packed, and FastLanes columns are filtered without being decoded. Only the rows that survive predicates are ever materialized.
Security inside the planner
Row-level security, column masking, ABAC, and three-state privileges are evaluated during query planning, not bolted onto an application tier.
Native search and ML
BM25 full text, HNSW vector search, and graph traversal share the engine with in-database model training, forecasting, and a feature store, all in plain SQL.
Quorum-committed writes
Database nodes join a Raft group. The leader group-commits under one fsync per quorum ack, followers apply committed entries through the same operator path, and any node serves linearizable reads through ReadIndex.
Format and signature agility
Every persistent file carries a versioned envelope across 28 format kinds, and every signed artifact declares its scheme. Readers dispatch on both, so an upgrade never strands data on disk.
Upgrades without a window
A health-baselined orchestrator rolls new binaries across a Raft group with drain coordination, per-node rollback, and cluster-wide auto-pause, and catalog rows and user SQL objects migrate with it.
Online schema changes
A schema epoch in the tuple slot lets ALTER TABLE add, drop, or retype a column without rewriting a row. Index builds publish, wait for in-flight writers, scan, and flip without blocking the table.
Change streams
Every table carries a change log that a consumer reads and advances inside its own transaction, so the position moves only when the consumer commits. APPLY CHANGES lands a stream as SCD type 1 or 2.
Verifiable tables
One SHA-256 chain entry per committing transaction over a table's stored bytes, linked at apply on every consensus member. VERIFY TABLE checks the chain in full or sampled mode, and heads can be anchored outside the cluster.
SQL
Standard SQL, plus the parts it was missing
Everything below runs over an unchanged PostgreSQL connection. No extensions to install, no sidecar services to operate. Hover a highlighted clause to see what the engine does with it.
Read any table as it was, by timestamp or by version.
-- Read the table as it existed at a point in timeSELECT * FROM orders AS OF TIMESTAMP '2026-05-06 09:00:00';-- Or pin an exact committed versionSELECT * FROM orders VERSION AS OF 42;Running in the next five minutes
Prebuilt binaries for Linux and Windows, no external dependencies, one command to a running server.