Hi HN! I've posted SirixDB here before, back in 2019 and again in 2023.

The core idea behind SirixDB is, that history is a first-class citizen. Every commit stores a lightweight, queryable revision. You can query any point in time, even individual nodes (for instance JSON values), diff arbitrary revisions, and efficiently track how data evolved without replaying events.

Unlike traditional event stores, historical states do not need to be reconstructed by replaying events nor do we have to think about projections. Revisions are directly queryable.

A simple example:

Jan 1: Record "Price = $100, valid from Jan 1". Stored on Jan 1 (transaction time).

Jan 20: Discover price was actually $95 on Jan 1. Commit correction.

After correction, you can ask across both axes:

- "What did we THINK the price was on Jan 16?" -> $100 (Transaction time)

- "What WAS the price on Jan 1?" -> $95 (Valid time)

I've worked on this in my spare time since 2013, following its academic precursor (Idefix/Treetank) at the University of Konstanz. The architecture relies on an append-only physical log and a copy-on-write page trie.

A high level view of the architecture:

Physical Log (append-only, sequential writes)

  ┌────────────────────────────────────────────────────────────────────────┐
  │ [R1:Root] [R1:P1] [R1:P2] [R2:Root] [R2:P1'] [R3:Root] [R3:P2'] ...    │
  └────────────────────────────────────────────────────────────────────────┘
       t=0      t=1     t=2      t=3      t=4       t=5       t=6    → time

Each revision is indexed, whereas unchanged pages are shared among revisions (even unchanged nodes in pages with changes mostly):

Revision Roots Page Trie (persistent, copy-on-write)

        │
        ▼
     [Rev 3] ─────────────────┬────────────────┐
        │                     │                │
     [Rev 2] ──────────┬──────┤                │
        │              │      │                │
     [Rev 1] ───┐      │      │                │
                │      │      │                │
                ▼      ▼      ▼                ▼
             [Root₁][Root₂][Root₃]         [Pages...]
                │      │      │
                ▼      ▼      ▼

Unchanged pages are shared between revisions. Beneath the root pages sit node indexes and secondary indexes, which also use a novel sliding-snapshot algorithm to balance read and write performance. Everything is queryable using JSONiq via the Brackit compiler.

Back in 2019, and even in 2023, SirixDB was very slow due to GC pressure. Unlike most other document stores, SirixDB stores fine-grained nodes, and I came to realize that an on-heap (JVM) representation made up of lots of small objects simply didn't make sense. I measured it with async-profiler — with some help from Andrei Pangin himself — and the result was that the poor throughput was due to the sheer amount of allocations which scaled almost linearly with the number of open transactions.

Working a full-time software engineering job, I lacked the energy for a massive spare-time rewrite. About a year ago, I started experimenting with AI. It turned out to be ideal for automating the tedious, repetitive parts of migrating the storage layer to Java's Foreign Function & Memory API, storing pages completely off-heap.

Looking further ahead, the append-only, immutable-page design maps naturally onto object storage like S3 and distributed logs like Kafka for a cloud version, and initial prototypes already exist. Maybe that becomes a commercial service one day, but for now, I'm just thrilled to see these core design principles finally proven out.There's an interactive demo, documentation, and the code is on GitHub. I'd love feedback and am happy to answer questions!

kind regards

Johannes

[1] https://sirix.io | https://github.com/sirixdb/sirix

[2] https://sirix.io/docs/architecture.html

[3] https://demo.sirix.io

[4] https://sirix.io/docs/

[5] http://brackit.io

They Prefer the App

A Palantir-ish dashboard for family trip planning

Ottawa fixed the buyer's problem. The SME's four problems are still ours

Spinel on Rails

Ask HN: Does it still make sense to write code by hand?

Effort Is the Whole Game

Fuel System Components Eyed in NetJets Citation Crash

Show HN: Sign in with your ChatGPT account for free AI

Trustmux

Show HN: A photo editor that develops RAW files in the browser

Was I wrong about Etched?

You don't need another idea. You need a faster no

How to Make Your AI Agent's Actions Reliable (No Code)

Backblaze Drive Stats for Q1 2026

You only need the frontier model for one single edit

Show HN: SirixDB 1.0 Beta – Git-Like Versioning, Diffs, Time-Travel Queries

Nat Slipstreaming v2.0 allows an attacker to remotely access any TCP/UDP service

Making something on your own(without any LLM) feels so good

Aerosols and hydrocarbons in the atmosphere of a white dwarf planet

Apple's lawyer mixed up Asian OpenAI employees before lawsuit

Lego Considering Bondi Blue iMac G3 Set

Now, defenders are embracing the prompt injection, too

Over 400 CLOs Tabbed for Upgrade in Pivot That Fans '08 Fears

LLM-as-a-Verifier: A General-Purpose Verification Framework

Show HN: Homestead – Build apps for you, your family, and your agents

Show HN: Generalized – AI agent skills with community proof

When A.I. Is a Member of the Family

The age of the Universe from a large sample of the oldest Galactic stars

Brightspeed's Fiber Asset Bet Meets $11B Debt Test

Running Gemma 4 26B at 5 tokens/SEC on a 13-year-old Xeon with no GPU

I'd Rule the World