Build reliably on object storage.

SlateDB is an OSS embedded key-value database and LSM-engine built on object storage.

Read the docs GitHub

+ add your logo

used by

Object storage is the foundation that holds up modern cloud-native systems: strongly consistent, absurdly durable, and priced like background noise. SlateDB embeds within your system and provides online, transactional access to object storage. Build a database, a cache, a feature store, a ledger, a workflow engine or anything on top of object storage and SlateDB is the layer that makes the writes correct, the reads fast, and the ops boring.

the engine

Fig. 1 ref /docs/design/overview/

Fig. 2 ref /docs/design/readers/

Fig. 3 ref /docs/design/consistency/

Fig. 4 ref /docs/operations/tuning/

Fig. 5 ref /docs/design/clones/

Zero-disk architecture

Persist data directly to object storage. Keep 99.999999999% durability and cost profile of S3-class storage without local disks or cross-AZ storage traffic.

ref /docs/design/overview/

Flexible deployment

SlateDB ensures a single writer through a formally verified manifest fencing protocol but supports multiple readers for read-side scaling. Compaction can run embedded or as a separate process to enforce separation of concerns.

ref /docs/design/readers/

Transactional semantics

Transactions, snapshots, and optimistic concurrency control mechanisms ensure that SlateDB is suitable for the most demanding transactional workloads.

ref /docs/design/consistency/

Tunable performance

Writes can trade between API request cost and durability latency while reads can leverage hybrid memory/disk caching to avoid cold latency penalties.

ref /docs/operations/tuning/

Clones, branches & rescaling

Checkpointing is a zero-copy operation and functions as the basis for a clone or fork. Rescaling is also zero-copy, enabling O(1) splits and merges of Slates.

ref /docs/design/clones/

quickstart

full quickstart →

$ cargo add slatedb tokio --features tokio/macros,tokio/rt-multi-thread

use slatedb::Db;
use slatedb::object_store::memory::InMemory;

let store = std::sync::Arc::new(InMemory::new());
let db = Db::builder("demo", store).build().await?;

db.put(b"hello", b"world").await?;
let value = db.get(b"hello").await?;

$ go get slatedb.io/slatedb-go

store, _ := slatedb.ObjectStoreResolve("memory:///")
builder := slatedb.NewDbBuilder("demo", store)
db, _ := builder.Build()

db.Put([]byte("hello"), []byte("world"))
value, _ := db.Get([]byte("hello"))

$ implementation 'io.slatedb:slatedb-uniffi'

ObjectStore store = ObjectStore.resolve("memory:///");
DbBuilder builder = new DbBuilder("demo", store);
Db db = builder.build().get();

db.put("hello".getBytes(), "world".getBytes()).get();
byte[] value = db.get("hello".getBytes()).get();

$ npm install @slatedb/uniffi

const store = ObjectStore.resolve("memory:///");
const builder = new DbBuilder("demo", store);
const db = await builder.build();

await db.put(Buffer.from("hello"), Buffer.from("world"));
const value = await db.get(Buffer.from("hello"));

$ pip install slatedb

store = ObjectStore.resolve("memory:///")
builder = DbBuilder("demo", store)
db = await builder.build()

await db.put(b"hello", b"world")
value = await db.get(b"hello")

Ready to build?

The full reference covers architecture, operations, tutorials, and the RFC archive.

Read the docs View on GitHub