Build reliably on object storage.
SlateDB is an OSS embedded key-value database and LSM-engine built on object storage.
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
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.
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 ensure separate concerns.
Transactional semantics
Transactions, snapshots, and optimistic concurrency control mechanisms ensure that SlateDB is suitable for the most demanding trnasactional workloads.
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.
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.