List of crates that improves or experiments with Rust, but may be hard to find


Let’s list here crates that enhance Rust as a language.

It not “batteries” like in stdx, but Rust-specific crates for workarounds for various missing features and experimental ideals from non-accepted/postponed RFCs, or just hacky tricks.

The list is supposed to contain (mostly) crates that are internal to Rust, not ones for making Rust deal with “external world” like other languages bindings, file formats, protocols and so on.

Primary focus should be on crates that are not easy to find by conventional means (e.g. no algorithm name, format or protocol to search for).

Note that quality of the listed crates may vary from proof-of-concept to stable-and-widely-used.

General list:

Allocation or data structures:

  • slab - Hands out integer handles instead of actual pointers. My own additions: slab_typesafe, compactmap.
  • non-empty, vec1 - A non-empty vector or maybe other things. See also a reddit thread.
  • lru_time_cache - A cache.
  • im, rpds - Immutable collection data types.
  • fst - Specialized compact data structure for pre-ordered data.
  • internment - Interning strings or data. Stores data permanently/to Rc/to Arc and gives a handle. Same data => same handle.
  • tendril - compact string/buffer type, optimized for zero-copy parsing.
  • slotmap - like slab, but handles are protected against accidental reuse (there is counter inside).
  • froggy - like slab, but with iteration, reference counting and weak pointers.

Cargo-specific, testing or related tools:

  • cargo bloat - Show what takes space in your binary
  • cargo license, cargo-lichking - List all dependencies by licence.
  • cargo outdated - Show which packages have newer version available.
  • cargo clippy - Additional warnings
  • cargo fmt (rustfmt) - Automatically format the code. Also installable by rustup.
  • cargo geiger - Measure “unsafeness” of the project by counting expressions in unsafe{} blocks and other unsafe things. Prototype: cargo-osha
  • cargo make - Define and run targets in a toml file like in Makefile.
  • cargo add, cargo rm and so on - Manage dependencies from command line.
  • cargo tarpaulin - code coverage for tests.
  • cargo asm - display the assembly or llvm-ir generated for Rust source code (a single function can be specified).
  • cargo audit - Scan dependencies (Cargo.lock) for reported security vulnerabilities.

Please suggest additions, replacements or removals.


There’s a peano crate, succeeded by typenum.


optional - a space efficient Option replacement.


lazy_static - declaring lazily evaluated statics.


Is this still needed with the new notch optimizations? The readme says

Not only does OptionBool improve space efficiency as opposed to Option<bool>

But nowadays bool, Option<bool>, and even Option<Option<bool>> and beyond are all the same size.


I think the original bool use case is gone, but I could see myself using that crate for storing optional floats, using NaN as the None value.


That’s exactly what I plan to use it for.


typenum has no underscore nor does it use a lowly Peano encoding (it’s a binary encoding!)

(edit: okay the peano thing was fixed, but that underscore is still there silently taunting at me)


I tried to be careful how I mentioned peano followed by typenum:man_shrugging:



Extended the list from relevant “Crate of the Week” posts.


Can you please link the ‘cargo-specific or related tools’ section?




cargo license - List all dependencies by licence. There is also some alternative implementation, but I forgot the name.

cargo-lichking. Haven’t researched them for their strengths or weaknesses.


proptest probably derserves a mention alongside quickcheck :slight_smile:


Maintainer of optional here. I was about to deprecate OptionBool when re-running the benchmarks still showed some measurable differences. So yes, it no longer has a space advantage, but it may sometimes have a time advantage.

Even without OptionBool, the crate still has option replacements for other types.


Have you filed bugs for those?


cargo-make rust build tool and task runner.
comes with many default tasks to make any project development easier and automated.


rules was an incomplete experiment to bring Perl 6 style regex to rust. There is a lot which could be done to extend the project. I’m not sure if this is the type of thing you’re looking for.

I definitely think this type of thing might be really positive in the long run but it would have be more fully implemented to verify in any fashion.


I made some crates that I think could fit onto the list.

  • array-macro - vec![something; 4] for arrays, not requiring a Copy implementation
  • reexport-proc-macro - probably useless with Rust 2018 where you can go pub use crate_derive::Trait, but allows reexporting a procedural derive, not requiring an user of a crate to have a dependency on derive crate
  • - just like EnumMap in Java, except for Rust, a map implementation optimized for enums implemented as an array