75 releases (22 breaking)

0.34.4 Sep 10, 2020
0.34.2 Jul 29, 2020
0.31.0 Jan 31, 2020
0.30.3 Dec 27, 2019
0.14.1 Sep 9, 2017

#1 in Database implementations

Download history 2810/week @ 2020-06-01 2552/week @ 2020-06-08 3286/week @ 2020-06-15 3158/week @ 2020-06-22 3287/week @ 2020-06-29 3472/week @ 2020-07-06 3880/week @ 2020-07-13 3823/week @ 2020-07-20 3678/week @ 2020-07-27 4408/week @ 2020-08-03 5217/week @ 2020-08-10 4663/week @ 2020-08-17 5229/week @ 2020-08-24 4747/week @ 2020-08-31 5531/week @ 2020-09-07 5770/week @ 2020-09-14

17,436 downloads per month
Used in 83 crates (66 directly)

MIT/Apache and maybe GPL-3.0

14K SLoC

key value
buy a coffee for us to convert into databases
chat about databases with us

sled - it's all downhill from here!!!

A (beta) modern embedded database. Doesn't your data deserve a (beta) beautiful new home?

let tree = sled::open("/tmp/welcome-to-sled").expect("open");

// insert and get, similar to std's BTreeMap
tree.insert("KEY1", "VAL1");
assert_eq!(tree.get(&"KEY1"), Ok(Some(sled::IVec::from("VAL1"))));

// range queries
for kv in tree.range("KEY1".."KEY9") {}

// deletion

// atomic compare and swap
tree.compare_and_swap("KEY1", Some("VAL1"), Some("VAL2"));

// block until all operations are stable on disk
// (flush_async also available to get a Future)

If you would like to work with structured data without paying expensive deserialization costs, check out the structured example!


  • LSM tree-like write performance with traditional B+ tree-like read performance
  • over a billion operations in under a minute at 95% read 5% writes on 16 cores on a small dataset
  • measure your own workloads rather than relying on some marketing for contrived workloads

what's the trade-off? sled uses too much disk space sometimes. this will improve significantly before 1.0.


a note on lexicographic ordering and endianness

If you want to store numerical keys in a way that will play nicely with sled's iterators and ordered operations, please remember to store your numerical items in big-endian form. Little endian (the default of many things) will often appear to be doing the right thing until you start working with more than 256 items (more than 1 byte), causing lexicographic ordering of the serialized bytes to diverge from the lexicographic ordering of their deserialized numerical form.

  • Rust integral types have built-in to_be_bytes and from_be_bytes methods.
  • bincode can be configured to store integral types in big-endian form.

interaction with async

If your dataset resides entirely in cache (achievable at startup by setting the cache to a large enough value and performing a full iteration) then all reads and writes are non-blocking and async-friendly, without needing to use Futures or an async runtime.

To asynchronously suspend your async task on the durability of writes, we support the flush_async method, which returns a Future that your async tasks can await the completion of if they require high durability guarantees and you are willing to pay the latency costs of fsync. Note that sled automatically tries to sync all data to disk several times per second in the background without blocking user threads.

We support async subscription to events that happen on key prefixes, because the Subscriber struct implements Future<Output=Option<Event>>:

let sled = sled::open("my_db").unwrap();
let mut sub = sled.watch_prefix("");

sled.insert(b"a", b"a").unwrap();
sled.insert(b"a", b"a").unwrap();


extreme::run(async move {
    while let Some(event) = (&mut sub).await {
        println!("got event {:?}", event);

minimum supported Rust version (MSRV)

We support Rust 1.39.0 and up.


lock-free tree on a lock-free pagecache on a lock-free log. the pagecache scatters partial page fragments across the log, rather than rewriting entire pages at a time as B+ trees for spinning disks historically have. on page reads, we concurrently scatter-gather reads across the log to materialize the page from its fragments. check out the architectural outlook for a more detailed overview of where we're at and where we see things going!


  1. don't make the user think. the interface should be obvious.
  2. don't surprise users with performance traps.
  3. don't wake up operators. bring reliability techniques from academia into real-world practice.
  4. don't use so much electricity. our data structures should play to modern hardware's strengths.

known issues, warnings

  • if reliability is your primary constraint, use SQLite. sled is beta.
  • if storage price performance is your primary constraint, use RocksDB. sled uses too much space sometimes.
  • quite young, should be considered unstable for the time being.
  • the on-disk format is going to change in ways that require manual migrations before the 1.0.0 release!


  • 1.0.0 release date will be on January 19, 2021. This is sled's 5th birthday.
  • Typed Trees that support working directly with serde-friendly types instead of raw bytes, and also allow the deserialized form to be stored in the shared cache for speedy access.
  • MVCC and snapshots
  • forward-compatible binary format
  • concurrent snapshot delta generation and recovery
  • consensus protocol for PC/EC systems
  • pluggable conflict detection and resolution strategies for gossip + CRDT-based PA/EL systems
  • first-class programmatic access to replication stream

fund feature development

Want to support development? Help us out via GitHub Sponsors!

special thanks

Special thanks to Meili for providing engineering effort and other support to the sled project. They are building an event store backed by sled, and they offer a full-text search system which has been a valuable case study helping to focus the sled roadmap for the future.

Additional thanks to Arm, Works on Arm and Packet, who have generously donated a 96 core monster machine to assist with intensive concurrency testing of sled. Each second that sled does not crash while running your critical stateful workloads, you are encouraged to thank these wonderful organizations. Each time sled does crash and lose your data, blame Intel.

contribution welcome!

want to help advance the state of the art in open source embedded databases? check out CONTRIBUTING.md!



~37K SLoC