turbokv 0.6.0

A fast, embedded key-value store in Rust

TurboKV is an async embedded key-value database with atomic batches, ordered range scans, configurable durability, compression, and background compaction.

Installation

cargo add turbokv
cargo add tokio --features full

Or add the dependencies directly:

[dependencies]
turbokv = "0.6"
tokio = { version = "1", features = ["full"] }

TurboKV's persisted Bloom-filter format uses hardware AES. Build x86/x86_64 targets with RUSTFLAGS="-C target-feature=+aes,+sse2", and ARM/AArch64 targets with RUSTFLAGS="-C target-feature=+aes,+neon". You may instead use -C target-cpu=native when the binary will run only on the same CPU model or a feature superset.

Quick start

use turbokv::{Db, DbOptions, WriteBatch};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = Db::open_with_options("./my-database", DbOptions::durable()).await?;

    db.insert(b"user:1", b"Ada").await?;
    assert_eq!(db.get(b"user:1").await?, Some(b"Ada".to_vec()));

    let mut batch = WriteBatch::new();
    batch.put(b"user:2", b"Grace");
    batch.put(b"user:3", b"Linus");
    batch.delete(b"user:1");
    db.write_batch(&batch).await?;

    for (key, value) in db.scan_prefix(b"user:").await? {
        println!(
            "{} = {}",
            String::from_utf8_lossy(&key),
            String::from_utf8_lossy(&value)
        );
    }

    db.close().await?;
    Ok(())
}

Runnable examples:

• basic: insert, get, update, and remove
• batch_writes: atomic puts and deletes
• range_queries: ordered range and prefix scans
• concurrent: shared access from Tokio tasks
• persistence: paranoid WAL recovery
• configuration: cache, memtable, and compression options

API breakdown

Durability presets

One open Db or Engine exclusively owns its data directory. Use close() or close_with_status() for a clean shutdown; dropping a handle is not a clean shutdown contract.

Database operations

DbOptions exposes memtable_size, block_cache_size, and compression. Compression supports LZ4 (default), Snappy, Zstd, and no compression. WriteBatch::put and WriteBatch::delete build one atomic visibility update.

Benchmarks

This historical retained release benchmark compares only Rust-native embedded stores: TurboKV 0.5.0, fjall 2.11.2, and redb 2.6.3. The table reports median durable single-key acknowledgement throughput from three repetitions; higher is better.

Protocol: 200,000 deterministic 20-byte keys, 400-byte values (84 MB logical input, above the 64 MiB memtable), one caller, one-entry transactions, compression and block cache disabled, and an uncleared OS page cache. Each engine acknowledges its documented process-crash-durable operating-system persistence boundary. Cross-engine settled timings are not compared.

These numbers were measured before the final production-readiness documentation and portability changes; they are retained evidence, not a current-HEAD run. Measured on 2026-08-28 with an Apple M4 (Mac16,1), 32 GiB RAM, macOS 15.3.2 (24D81), APFS, and rustc 1.88.0. Sequential-fill dispersion was high, so treat the near-tie as noise rather than a stable advantage. Exact raw repetitions, latency percentiles, dispersion, dependency versions, byte accounting, and amplification are in the JSON artifact and its text report. The full methodology and rerun command are in benchmarks/README.md.