Nexir
In active development

The Redis‑compatible database, rebuilt for reliability

Nexir is a highly available, distributed key-value database with a native Redis protocol interface. Raft-replicated, durably stored, transactional under the hood — and engineered in Rust, correctness first.

$ redis-cli -h db.example.com
nexir> SET user:42 "ada"
OK
nexir> GET user:42
"ada"
nexir> INCR visits
(integer) 1
# replicated · durable · snapshot-isolated
The database

Your Redis clients. A database underneath.

Keep the tools, libraries, and muscle memory you already have. Nexir speaks the Redis protocol natively while giving your data what a cache never could: consensus-backed replication, durable storage, and real transactions.

Redis protocol, native

A first-class RESP interface — connect with the Redis clients and tooling you already use. No proxies, no translation layers.

Highly available

Writes replicate through Raft consensus. Node failures are absorbed by the cluster — no manual failover, no split-brain.

Durable by default

Backed by RocksDB persistent storage. Your data survives restarts, crashes, and power loss — durability is not an add-on.

Transactional

MVCC snapshot isolation with multi-key atomic operations and conditional writes — consistent reads without blocking writers.

Deterministic core

The transaction engine is a pure state machine — no wall clocks, no hidden I/O. Every state transition is replayable and testable.

Engineered in Rust

Memory safety without garbage collection pauses. Predictable latency and a codebase built to be reasoned about.

Architecture

Boring where it should be. Rigorous where it counts.

Every write flows through one ordered, replicated, transactional path — so what your clients see is always a consistent view of what the cluster agreed on.

Redis clientsRESP protocol
Nexir servercommand engine
Raft consensusordered replication
MVCC enginesnapshot isolation
RocksDBdurable storage
The MVCC engine at the heart of this pipeline is open source.
Open source · now on crates.io

nexir‑mvcc‑core

The transaction engine Nexir runs on, released as a standalone Rust library. Deterministic MVCC with timestamp-ordered versions, two-phase intent transactions, guarded compare-and-swap batches, and incremental GC — behind one clean storage trait, with a conformance suite for your own backend.

Dual-licensed under MIT or Apache 2.0, at your option.

$ cargo add nexir-mvcc-core

// deterministic MVCC in a few lines
let engine = MvccEngine::new(backend);
engine.prewrite_batch(txn, start_ts, writes)?;
engine.commit_batch(txn, start_ts, commit_ts, keys)?;

// snapshot reads at any timestamp
let value = engine.read(key, read_ts)?;