Structured data has patterns. Your database should notice.

Meet HolaDB — an independent database system exploring a different approach to structured data storage and retrieval. Built from the ground up in Rust.

A conceptual illustration, not a description of how HolaDB stores hotel data. Not every dataset has a useful pattern; when it doesn't, HolaDB uses conventional storage. Either way, queries return the original records.

Data is more than individual records.

A table is not a pile of unrelated rows. It is the trace of a process, and processes are regular.

Most storage engines write each row down as it arrives and leave that regularity for a compressor to find later. HolaDB explores a different arrangement: letting the storage engine itself describe recurring structure in sealed data, so that the structure becomes part of how the data is represented and read back.

For an application nothing changes. You create tables, write SQL and open transactions. What changes is underneath, and it is checked: a representation is kept only if it reproduces the original data exactly.

  • Keys count up.

    An identifier is usually the one before it, plus one.

  • Values repeat.

    A status, a country or a currency takes a handful of values across millions of rows.

  • Settings rarely change.

    Many columns hold the same value for long stretches, then change once.

From a connection
to the disk.

Seven layers, each a separate Rust crate with its own tests. Follow a path through them, or select a layer to see what it is responsible for.

Query path

What happens to a SELECT.

  1. ApplicationThe application sends SQL through a driver or SDK.
  2. ProtocolThe frame or PostgreSQL message is decoded into a request.
  3. ServerThe session is authenticated and the statement checked against the user's privileges.
  4. SQL engineThe text is parsed, bound to the catalog and planned.
  5. Transaction engineThe statement reads the latest committed state, plus its own transaction's writes.
  6. StoreRows are located by key or through a secondary index.
  7. Storage engineRecords are read from current state; sealed segments are checked against their hashes before data is returned.
  • The engine is independent of SQL, the catalog and the protocol.
  • SQL is independent of how data is stored.
  • The backup format is independent of the network protocol.

What makes HolaDB different.

Four themes, and for each one what is built, why it matters, and how far along it is.

  • Implemented and tested
  • Experimental
  1. Pattern-aware storage

    Experimental
    What is built
    Sealed segments can be stored conventionally or in a compact representation the engine derives from the data. A controller with explicit states and a journal makes that decision, verifies every representation against the original before trusting it, and falls back to conventional storage otherwise.
    Why it matters
    This is the question the project exists to investigate. The mechanism is implemented and tested; how much it helps, and on which kinds of data, is still being measured and is not claimed here.
  2. Structured data retrieval

    Implemented and tested
    What is built
    The engine keeps the current state of every row and a persisted record index, so a read by key does not replay history. Secondary indexes, ordered scans and paged cursors sit on top, and the representation underneath never changes a query's result.
    Why it matters
    A storage idea is only useful if ordinary reads stay ordinary. Whatever form a segment is kept in, the row that comes back is the row that went in.
  3. Conventional database capabilities

    Implemented and tested
    What is built
    A defined SQL subset with tables, indexes, filters, ordering and aggregates. Multi-statement transactions. A PostgreSQL wire-protocol endpoint and client SDKs. Users, roles and privileges.
    Why it matters
    You should not have to learn a new model to try a new engine. The subset is deliberately small: joins, subqueries and GROUP BY are not implemented, and a statement that needs them is refused with an error that names the construct.
  4. Reliability and recovery engineering

    Implemented, endurance testing under way
    What is built
    Writes are synced before they are acknowledged. Segments carry content hashes. Recovery runs on every open. Backups are verified file by file and can be restored to an earlier commit.
    Why it matters
    A database earns the right to experiment with representation only by being strict about durability first. Long-running endurance and recovery testing is in progress before the first beta.

Familiar from the first command.

Tables, SQL, transactions and the drivers you already use. The examples here are taken from the project's own documentation, not written for this page.

Native protocol
holadb:// on port 7433, holadbs:// with TLS
PostgreSQL protocol
Port 5433, simple and extended query
Clients
TypeScript, Python and Rust SDKs, a CLI and Studio
CREATE TABLE products (
  sku   TEXT PRIMARY KEY,
  name  TEXT NOT NULL,
  price DOUBLE PRECISION,
  stock INT DEFAULT 0
);
CREATE INDEX products_price ON products (price);

INSERT INTO products VALUES
  ('A1', 'bolt', 0.25, 500),
  ('B2', 'nut',  0.10, 800);

SELECT sku, price FROM products
 WHERE price < 0.2 ORDER BY price;

BEGIN;
UPDATE products SET stock = stock - 10 WHERE sku = 'A1';
UPDATE products SET stock = stock + 10 WHERE sku = 'B2';
COMMIT;

Schema, data and a transaction. Statements are HolaDB's own SQL subset.

Find out,
then say so.

There are no benchmark figures on this page, on purpose.

Storage, latency, recovery and endurance are measured throughout development. Those results will be published once they have been reviewed, together with the machine, the workload, the method and the limits of each test. Until then, these are the rules the engineering is held to.

  • Refuse, never approximate.

    Anything outside the supported SQL is rejected with an error that names it. Nothing is silently ignored or guessed.

  • Verify before trusting.

    Sealed segments are checked against their content hashes before any data is returned. An index that cannot be verified is rebuilt from the log.

  • Efficiency has to prove itself.

    A compact representation is kept only when it reproduces the original data exactly. Otherwise the segment stays in conventional form.

  • Durable means synced.

    A write that fails is never acknowledged and never reappears. When an outcome cannot be known, the server says so instead of picking one.

  • Crashes are an ordinary input.

    Recovery is not a special mode. It is what opening a database does, every time.

  • Measure, then write it down.

    Behaviour is tested under sustained load, and the limits found are recorded beside the results. Unsafe Rust is forbidden in every crate.

The unglamorous part, done first.

A new idea about storage is worth nothing on top of a database that loses writes. Most of the work in HolaDB is here.

CapabilityWhat HolaDB doesWhy it matters

Transactions

Changes commit together or not at all, including across tables. Isolation is read committed with optimistic validation: the first committer wins and the other retries.

Your application never observes half of a transfer.

Write-ahead logging

Every write is appended to the table's log and synced before it is acknowledged.

An acknowledged commit survives a crash or a power cut.

Persistence

The log is sealed into immutable segments that carry content hashes, checked before data is returned.

Corruption is detected and reported instead of quietly served.

Recovery

Each open replays the log, discards a torn tail, rolls back unfinished transactions and rebuilds what it cannot verify.

After a crash there is no repair procedure to remember.

Backup and restore

Offline, online and incremental backups, each file hashed with SHA-256, with log archiving for restoring to an earlier commit.

Recovery cannot undo a mistake or a failed disk. A verified backup can.

Authentication and TLS

Users, roles and per-table privileges checked on every request. SCRAM-SHA-256 on both protocols, with channel binding over TLS.

Passwords never cross the wire, and a revoked user loses access at the next statement.

No database can promise that every failure is survivable, and this one does not. Recovery does not repair storage that fails its hashes or undo a committed transaction; both need a backup. The known limits are documented with the project.

Development is ongoing

Built carefully.
Tested continuously.

HolaDB is currently undergoing extended endurance, reliability, and recovery testing as we prepare for its first public beta.

It is not ready for production workloads, and no release date has been set. This page changes when the project does.

Implemented and tested

  • SQL subset, transactions and secondary indexes
  • Native protocol and PostgreSQL wire protocol
  • Crash recovery, backups and point-in-time restore
  • Authentication, roles and TLS
  • TypeScript, Python and Rust clients
  • Linux on x86-64 and arm64

Not there yet

  • Joins, subqueries and GROUP BY
  • Snapshot isolation; reads are read committed
  • Concurrent writers; one writer at a time
  • Windows support and packaged macOS builds
  • Signed release artifacts
  • A public source repository and downloads

Built to be read.

HolaDB is being prepared for release as open source. A database asks for trust, and the plainest way to earn it is to show the code.

The repository is not public yet. It opens together with the first beta, as a clean project that anyone can clone, build and test on their own machine, with a committed lockfile and the same checks the project runs on every change.

  • What will be published

    The server and command-line client, the SQL layer, transactions, persistence and recovery, backup and restore, the client SDKs, Studio, the migration tools and the user documentation. The exact contents will be listed with the release, including anything that is not part of it.

  • Licence

    The intended licence is dual MIT or Apache-2.0, at your choice, the convention across the Rust ecosystem. It takes effect when the source is published; until then nothing is licensed for use.

  • Contributing

    Issues and pull requests open with the repository. Contribution guidelines and a code of conduct ship alongside the code, and every change is reviewed against the same test gates the project uses itself.

  • Security reports

    Vulnerabilities are handled privately through a coordinated disclosure process that is already written: a private report, an acknowledgement within three business days, a fix, then an advisory.

The beta release.

This is where the first public beta will be published. Nothing is available to download yet.

First public beta

In preparation, not yet released

  • Linux, x86-64 Server and command-line client, glibc
    Planned
  • Linux, arm64 Server and command-line client, glibc
    Planned
  • Source archive Builds with the pinned Rust toolchain and committed lockfile
    Planned
  • Container image Runs as a non-root user
    Planned
  • Checksums SHA-256 for every file in every bundle
    Planned

macOS is tested but will be built from source. Windows is not supported. Release files will carry checksums, not signatures.

What the first five minutes will look like

A database is a directory. Create one, serve it, and connect with psql or open Studio in a browser. These are the commands from the project's own quick start.

holadb init ./shop
holadb serve ./shop \
  --listen 127.0.0.1:7433 --pg 127.0.0.1:5433

psql postgresql://me@127.0.0.1:5433/holadb
holadb studio holadb://127.0.0.1:7433

What to expect from a beta

  • It is for evaluation and feedback, not for data you cannot afford to lose.
  • The SQL surface is a defined subset and will grow.
  • Known limitations will be listed with the release, not discovered by you.

Questions,
answered plainly.

Is HolaDB a fork of PostgreSQL?

No. HolaDB is written from scratch in Rust and shares no code with PostgreSQL. It implements the PostgreSQL wire protocol so that psql and existing drivers can connect, but the SQL it accepts is its own subset and the storage engine is its own.

What is different about how it stores data?

Writes go to an append-only log, which is periodically sealed into immutable segments. A sealed segment can be kept in a compact representation that the engine derives from regularities in the data. That representation is accepted only after it is checked against the original, and conventional storage remains the fallback. It is an internal matter: queries, the protocol and backups look the same either way.

Can I use it in production?

Not yet. HolaDB is pre-1.0 and still in extended reliability and endurance testing. The first beta is meant for evaluation, experiments and feedback.

Which SQL does it support?

Creating and altering tables and indexes, inserts, updates, deletes, filtered and ordered selects with limit and offset, whole-table aggregates, EXPLAIN, transactions, and statements for users, roles and privileges. Joins, subqueries and GROUP BY are not implemented. Types cover booleans, integers, floats, text, bytes, timestamps and JSON; there is no decimal, UUID or date type yet.

How does it protect my data?

A commit is acknowledged only after the write-ahead log is synced to disk. Sealed segments carry content hashes that are checked before data is returned, so corruption is reported instead of read past. Recovery runs automatically on every open, and backups are verified file by file with SHA-256.

How does it handle concurrency?

The server runs a thread per connection with one writer at a time. Transactions are read committed with optimistic validation at commit: if a row you wrote was changed by someone else first, your commit fails cleanly and you retry.

Which platforms does it run on?

Linux on x86-64 and arm64 are the supported targets. macOS on Apple silicon is tested and can be built from source. Windows is not supported.

When will the beta be released?

No date has been set. The beta follows the current round of endurance and recovery testing, and this page will be updated when it is published.