Let's list here crates that enhance Rust as a language.
Note: this post has reached its 32k technical limit and will not be updated anymore. Primary copy is now at GIthub Gists
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.
Procedural macros and custom derive:
-
auto-impl - Derive
Box
(and other pointers) wrappers with all methods delegated. -
derive_more - derive standard traits like
Add
orIndex
that lack built-in derive. - enum-primitive-derive, derive_builder, strum, enum-unitary - derivers for enums; enum-map - "map literal" macro for enums.
-
smart-default -
#[derive(Default)]
with your default values. -
derivative - Some additinoal derives and adjustable analogues of std derives.
Debug
with ignored fields,Clone
with overridden clone function,Default
with alternative value like in smart-default. - couted-array - Automatix size for constant fixed size arrays before RFC 2545 goes in.
- sugar-rs - List comprehensions, hashmap construction.
- match_all - A match-like block that executes multiple branches if needed.
-
if_chain - A macro crate that makes embedding a lot of
if let
nicer. Related: guard forif !let
or Swift'sguard let
. - delegate - Proxy struct methods to a field.
- overflower - proc macro that lets you annotate a function to make arithmetic operations in it wrapping, saturating or panicking.
-
def_mod - forward declare
mod
's interface, asserting that implementation (included by specifying#[path]
based on#[cfg]
) matches the declared interface. - derive_utils - helpers for implementing your own custom derive / macros for enums.
-
interpolate - string interpolation:
let world = "world."; s!("Hello, {world}")
-
taken - Sugar for
let x = x;
orlet y = y.clone();
, for use in closures. - momo - a prototype of automatic introduction of dynamic dispatch in a function using proc macro.
-
ifmt -
"inline string {interpolation}"
-
shrinkwraprs - Create
Newtype(u32)
, automatically implementing traits to make as convenient as original type. - custom_debug_derive - Derive Debug with a custom format per field.
- cxx - Generates a bridge between C++ and Rust based on schema defined in Rust code.
- genawaiter - generators for stable Rust. 3 Types.
-
vecmerge - merge compile-time-known slices of vector literals using
+
sign. - log-derive - auto insert logging for functions
- cascade - cascade expressions - multiple actions on one object.
- overloadable - macro function overloading.
-
include-flate - compress literal
inlucde_str!
/include_bytes!
buffer before compilation, lazily decompress in runtime. - ambassador - Delegate trait implementations
-
inline-proc - Procedure macros declared and used within the same crate.
#[inline_proc] mod ... { }
Enum trait
- auto_enums - allow multiple return types by automatically generated enum.
-
coalesce - Join mismatched
if
/match
branches based on enum, alternative to usage of a trait object. - impl_sum.
- auto_enums
- trait-union
Testing-related
- test-case-derive - Nightly-only. Allows adding arguments to test functions and listing sets of inputs in attributes.
-
quickcheck, proptest - Fuzz testing. Also mutagen for alternative test coverate method.
dicetest
. -
mockiato - Mocking of traits:
.expect_myfunc(...).times(2).returns(...)
- loom - test concurrent code
Threading and sleeping:
- spin_sleep - precise sleep.
-
desync
Desync<T>
where you can post operations to be executed, maybe in background. Alternative approach to threading/syncronosation. - crossbeam, rayon - Advanced threading.
- parking_lot - Synchronisation primitives (Mutex, RwLock, Once) speed up.
-
atomic - generic
Atomic<T>
type. -
arc-swap -
Arc
meetsAtomicPtr
- Likecrossbeam::ArcCell
or optimizedMutex<Arc<...>>
. Readers don't block. -
atomic_refcell - Threadsafe
RefCell
. -
arbalest - Like
Arc<AtomicRefCell<T>>
, but without some runtime check. -
qcell - Less flexible, but statically checked
RefCell
analogue.QCell
,LCell
,TCell
with detached owners for borrowing. -
flume - mpsc channel, competes with std and crossbeam's. Supports async (including mixing it with sync). Also
mp2c
. - bus - spmc broadcast lock-free channel.
- conquer-once - lazy and one-time initialisation, including for nostd
Software transactional memory (STM)
- swym - transactional memory.
-
stm-core - Clojure-like software transaction memory in Rust.
TVar
,atomically
. - lever - STM primitives, also some key-value tables
General list:
- rental - Deal with self-referential structs. Related: owning_ref. Related: ouroboros
-
take_mut, replace_with - Apply
Fn(T) -> T
to&mut T
. - type_num / peano - Simulate missing type-level integers.
- slice - Make a "view" into a Read+Write+Seek with offset and length.
- mopa - implement customized Any-like trait with your own additional methods. See also: query_interface.
- streaming_iterator - like Iterator, but with another ownership rules.
-
num, num_traits, alga - Traits for denoting algebraic properties of things and other math; rug - long arithmetic (bigint and friends); caldyn - evaluate strings like
"2+2"
; nalgebra - linear algebra. - failure, error_chain - Dealing with errors in more organized way.
- downcast-rs, vec_box, traitobject - Tricks with trait objects.
-
optional - a space efficient
Option
replacement. Related: nanbox. - lazy_static - declaring lazily evaluated statics (global variables). See also: core_memo.
- bytes, byteorder - Work with byte arrays (big-endian/little-endian).
- static_assertions - compile-time assertions.
- reflect - A proof-of-concept for making Java/Go-like reflections in Rust using procedural macros.
-
boolinator -
Option
orResult
-style methods forbool
. Also there's cratebool_ext
. - noisy_float - Floats that panic on NaN.
-
decorum -
Ordered
,NonNan
andFinite
wrappers for floats. - smallvec - On-stack small vectors. Tuner: smallvectune.
- array_tool - More methods for arrays and strings, including a Unicode grapheme iterator.
- nom, combine, lalrpop - parser combinators
-
serde - serialization. Utils:
serde_with
crate. -
mitochondria -
MoveCell
andOnceCell
. Also: once_cell, lazycell. -
either - Like
Result
, but without error semantics. -
const-concat - A
concat!
that accepts non-literal strings. -
void - A crate with a "canonical" uninhabited (zero, bottom) type, to use instead of the
!
never type before it goes stable. -
itertools - More iterator adapters like and related functions like
unfold
. - reexport-proc-macro - Re-export a custom derive.
-
array-macro - Like
[42; 3]
array literal, but with some restrictions removed. - m - pure Rust "libm" - primitive mathematical functions for nostd.
-
interpolate_idents - more powerful
concat_idents!
. Also paste. - null-terminated - NULL-terminated arrays for C interop.
-
bus - Single writer, multiple reader broadcast lockfree communication channel.
std::io::{Read,Write}
wrapper: bus-writer. -
frunk - Functinal programming toolkit:
HList
(heterogenous list of cons cell),Coproduct
for ad-hoc enums, Semigroup/Monoid like inalga
above. -
fragile -
Fragile<T>
andSticky<T>
wrappers for sending non-Send
things across threads. - double - mocking (mock testing) library.
-
joinery -
join_with
for joining to a string with separators from an Iterator. -
pipe - Generate a byte stream-based pipe, like
std::sync::mpsc
, but for bytes. Combined with my crate readwrite you can make it bi-directional, like a socket. Also newer crate duplexify. -
uninitialized - Choose
std::mem::zeroed
orstd::mem::uninitialized
based on Cargo feature flag. - failsafe - wrap function in a supervisor that prohibits execution (returns error early) for some time in case of consequtive failures of the wrapped function. Also recloser.
- corona - stackful coroutines.
- subtle - constant-time primitive ops for crypto
-
ctor - life before
main()
- auto-initialization of things beforemain()
using linker tricks. -
inventory - Typed distributed plugin registration using
ctor
crate above. -
strfmt - Like
format!()
, but with dynamically specified format string and your hashmap for available variables. - panic-never - Panic handler for no_std code that causes linker error if panics are not statically excluded from your code.
-
stdio-override - Override
std::io::std{in,out,err}
usingdup2
on Unix. - bstr - Text processing methods for UTF-8-esque byte strings.
-
async-trait - Traits for
async fn
using dynamic dispatch. See also https://crates.io/crates/real-async-trait. See also: polling-async-trait, async-trait-ext - pow - insert proof-of-work requirements using serde
- zerocopy - Utilities for zero-copy parsing and serialization
-
scopeguard -
defer!
,defer_on_unwind!
,defer_on_success!
. -
bytemuck -
Zeroable
,Pod
(plain old data) trait, safereinterpret_cast
s for some types.
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. timed_cache - another cache.
- uluru - Another LRU 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.
- containers - containers like in std, but with fallible allocation and custom allocators.
- sdset - A wrapper around a sorted+deduplicated slice providing faster set operations (union, intersection, etc.).
- intrusive-collections - no_std single- and double-linked lists, red-black tree without allocating dedicated memory for them, but by attaching things to contained objects instead.
- phf - compile-time-constructed static perfect hash table maps and sets.
- generational-arena - Safe allocator with deletions.
- rctree - DOM-like tree with ordered children, parents and siblings, based on strong and weak Rc links.
- heapless - allocation-free data structures: fixed-size vec, priority queue, hash table/set.
- voluntary-servitude - thread-safe appendable list with lock-free iterator.
-
copyless - Pre-allocate Box or Vec entry to fill it in later. Also maybe prevents extra
memcpy
call. -
ccl - Fast concurrent hashmap and timed cache, also for no_std. See also
dashmap
andchashmap
.shard_lock
. - contrie - Lock-free concurrent map and set with interface similar to HashMap.
- Evmap - A lock-free, eventually consistent, concurrent multi-value map.
- sharded_slab - Slab mutable without exclusive access, lockfree
- arrayvec - Array-backed fixed-capacity vector
- vec-utils - map and zip vector while reusing allocation.
-
elsa - append-only collections for getting references to elements. Insertion does not require exclusive (
&mut
) access. - shawshank - generic internment.
- concache - Two fast concurrent shared hash maps.
- hashcow - Hash table with copy-on-write for storing duplicated data.
Cargo-specific or code analysers:
-
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 inunsafe{}
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. -
cargo expand
- Show source code as one big file with expanded macros, like ingcc -E
. - rustig - Show places where your program can theoretically panic.
-
cargo cache
- Shows disk size of Cargo cache and allows cleaning it. -
cargo web
- Client-side web for Rust (wasm?). -
cargo tally
- Plot reverse dependencies over time. -
cargo rerast
- Applycargo fix
-like modifications according to specifiable rules. - cargo-workspaces
- https://github.com/Areredify/srcfiles - list source files used in compilation
- cargo-incversion - Increment version in
Cargo.toml
from CLI
Hosted languages designed to interoperate with Rust
- Rhai - small, inspired by Chai.
- Rune - async-friendly
- Dyon
- Mun
Unsorted links dump
(to be moved up and described properly)
- https://www.reddit.com/r/rust/comments/by9ld5/numeric_literals_01_easily_cope_with_numeric/
- https://www.reddit.com/r/rust/comments/bxsokc/public_release_of_warnalyzer_to_scan_multicrate/
- https://www.reddit.com/r/rust/comments/bucriz/nameof_crate_provides_a_macro_akin_to_cs_nameof/
- https://www.reddit.com/r/rust/comments/btwmc7/my_second_crate_leg_elegant_logging_made_simple/
- https://www.reddit.com/r/rust/comments/btr1x5/vecmerge_a_macro_for_merging_vectors/
- https://www.reddit.com/r/rust/comments/bstv3q/ccl_the_fastest_concurrent_hashmap_yet/
- https://github.com/dtolnay/select-rustc
- https://github.com/japaric/cast.rs
- https://github.com/interact-rs/interact
- slice_group_by - Rust
- https://github.com/JoshMcguigan/multi_try
- sccache
- https://www.reddit.com/r/rust/comments/bx75zh/once_cell_021_100_macrofree_lazystatic/
- https://www.reddit.com/r/rust/comments/bwr2yg/the_design_and_implementation_of_a_lockfree/
- rusty_fork - Rust
- https://www.reddit.com/r/rust/comments/c1c0ez/traitcast_dynamically_cast_from_dyn_any_to/
- https://crates.io/crates/state
- https://crates.io/crates/powerset-enum
- https://www.reddit.com/r/rust/comments/c9iltj/announcing_hazptr_dynamic_lockfree_memory/
- https://github.com/chris-morgan/anymap
- https://www.reddit.com/r/rust/comments/cfn0u2/show_rrust_treelike_implement_content_and/
- https://github.com/praezi/rust/ - global crates.io-wide callgraph attempt
- Siderophile: Expose your Crate’s Unsafety | Trail of Bits Blog
- https://crates.io/crates/prettytable-rs
- https://gist.github.com/est31/3d9e880be746c3a443c699d9ff1888d2 - cargo-udeps unused deps
- ordered_float::NotNaN - Rust
- https://www.reddit.com/r/rust/comments/d0vu1s/cargowalk_run_a_command_for_each_package_root/
- https://www.reddit.com/r/rust/comments/dknbys/my_tool_to_analyse_how_stack_trace_changes_during/
- https://crates.io/crates/const_env
- https://www.reddit.com/r/rust/comments/dr3ktd/cargohack_a_tool_to_work_around_some_limitations/
- LTS — Rust/Cargo add-on // Lib.rs
- https://crates.io/crates/accurate
- pin-cell
- uom - units of measurements
- https://github.com/pitdicker/valet_parking - nostd thread parking
- https://github.com/o0Ignition0o/cargo-scout - run clippy on diffs
- lazy_format
- stowaway - pack data into pointers
- fasteval - math expressions eval with compiling and user-defined functions
- faux - mocking for testing without traits
- alias - mutate data while aliased
- trapper - allows for the creation of transparent type wrappers
- cow_utils - partially zero-alloc string operarions like to_lower or replace.
- pointer_utils
- tap - run closure on something, then return it
- quit - exit process with a specified code, but also running destructors on the way
- Scripting in rust with self-interpreting source code | The NeoSmart Files - shell script header for running Rust file
- https://github.com/maciejhirsz/beef - Copy-on-write for strings that is smaller size
- typic - embed memory layout information into type system
-
Unshared
orSyncWrapper
trick to take away&self
and giveSync
. - hibitset - Like
HashSet<u32>
, but with optimised storage -
https://github.com/dureuill/questionmark - alternative
std::ops::Try
trait proposal - waitmap - A map that you can asyncly await if there is no entry you need in it yet.
- fail - inject errors for testing
- slice_as_array
- ufmt - a smaller, faster and panic-free alternative to core::fmt
- archery - Abstract over the atomicity of reference-counting pointers in rust
- https://github.com/llogiq/momo - transparently turn generic into dynamic to reduce compile time
- https://crates.io/crates/os_str_bytes
- logos - lexer proc macro
- enum_dispatch - Rust
- watt - WebAssembly-driven proc macros
- https://crates.io/crates/structural - structural typing
-
https://crates.io/crates/and_then_some - Provides an extension trait for bool with methods that return
Option<T>
. - https://github.com/Xaeroxe/c-closures-rs/ - Closures between C and Rust
- safe_arch - Rust - various tricky CPU-specific instructions like AVX or SSE
- wide - Rust - SIMD-y types for packed sets of numbers with some functions on it
- https://crates.io/crates/getset - generate getters and setters
- https://crates.io/crates/duplicate - general purpose code duplicator as a proc macro
- https://github.com/rodrimati1992/abi_stable_crates - proc macro to have more rusty rust-to-rust stable ABIs
- https://docs.rs/drop_bomb/0.1.4/drop_bomb/ - panic on drop (unless explicitly defused) - linear types?
- https://crates.io/crates/humpty_dumpty - proc macro, define types that cannot be implicitly dropped except in controlled situations.
- https://crates.io/crates/apply A tiny library for chaining free functions into method call chains.
- https://docs.rs/defer-drop/1.0.0/defer_drop/ - drop things in background thread
- https://github.com/frewsxcv/cargo-all-features - build and test all Cargo features combinations
- https://github.com/jojolepro/partialfunction - piecewise functions helpers + macro for nice syntax
- https://github.com/doctorn/trait-eval - Demonstrates possibility of trait bounds-based compile time programming
- https://github.com/jswrenn/typic - Type-safe transmutations between layout-compatible types.
- https://crates.io/crates/reffers - Additional smart pointers, ARef, custom Rc/Arc, other tricks like RMBA or Bx
- https://docs.rs/easy-parallel/3.0.0/easy_parallel/ - alternative interface for scoped threads
- https://crates.io/crates/tearor - TearCell - "atomic" cell that can hold large amount of POD, at expence of consistency.
- iter_read - Iterator<Item=u8> to impl Read
- safer_ffi
- rust_swig - like cxx, but also for Java
- https://github.com/mgattozzi/gemini - proc macro to choose sync vs async interface
- more fuzz checking: https://github.com/loiclec/fuzzcheck-rs https://github.com/microsoft/lain https://github.com/rust-fuzz/auto-fuzz-test
- https://crates.io/crates/tramp - Trampoline for recursive functions, with support for mutual recursion
- float_eq
- https://crates.io/crates/print_bytes - Display file paths (or other bytes) optionally converting to lossy Unicode depending on platform?
- doc-comment - load documentation for items from external files
- https://github.com/jonhoo/griddle - hashbrown::HashMap with incremental (instead of spiked) resizing at expence of throughput and memory.
- flurry - A port of Java's java.util.concurrent.ConcurrentHashMap to Rust.
- smol_str - Like
String
, but small about strings inlined. Also "smartstring". Support Serde. Also "tinystr". Also "smartstring". -
https://crates.io/crates/secrecy - Prevent logging of some values,
zeroize
them on drop. - https://crates.io/crates/secret_integers - constant-time arithmetic for integeres
- https://crates.io/crates/compressed_vec
- obfstr - UTF16 string literals. Compiletime string literal obfuscation for Rust.
- persy.rs - single-file database
- https://github.com/That3Percent/tree-buf - compressed serialisation
- salsa-rs - A generic framework for on-demand, incrementalized computation.
- pre - declaring and checking the assurance of precondition
- rust-embed - in debug, load file from FS, in release, embed into executable
- cargo-c - cbuild, cinstall. Expose C API in automatic way
- async-rwlock An async reader-writer lock with a fair locking strategy
- https://github.com/dtolnay/linkme - Distributed slice by using special linker sections on some platforms.
- lifeline - depenency-injection-like thing for async channels
- indoc - indended multiline string literals
- fast-floats -
-ffast-math
simulation on nightly rust - u2size - double word integral type, with some operations
-
https://github.com/TyOverby/Bark - like
Rc<T>
orArc<T>
- there are both counters. Unmaintained? - const_format. Compile-time string formatting. E.g.
concatcp
concatenates&'static str
s. -
fs-err
- Likestd::fs
, but with nicer error messages mentioning file paths - vptr - thin trait objects by embedding vtage pointer in the struct
- dangerous, untrusted - somehow deal with parsing untrusted input.
- https://docs.rs/stable_deref_trait/1.2.0/stable_deref_trait/trait.StableDeref.html
- resister - A collection of helpful iterator adaptors for iterating over
Result<T, E>
. - duct - a library for running child processes.
- normpath - Normalize filesystem path. Like canonicalisation, but without
\\?\
. - https://github.com/djmcgill/rich_phantoms - An implementation of phantom types in rust with control over variance and inheritance of send/sync.
- dyn-clone, dyn-clonable
- https://crates.io/crates/postfix-macros
- enumx, cex - Ad-hoc enums, checked exceptions emulation
- https://crates.io/crates/drop-bin - a place to move objects, deferring their Drop. E.g. to move things to other thread, away from the hot path, and rate-limit the drops there.
- act-zero - actors
- https://crates.io/crates/continuation - simulate try/catch or setjmp/jongjmp with call_with_escape_continuation and call_with_repeat_continuation
- gridly - managing fixed-size discrete 2D spaces. Grids, cardinal directions, etc.
- https://github.com/jonhoo/left-right - synchronisation primitive that keeps two copies of the data - for reading and for writing
- context_allocator - Memory allocation for no_std and other custom things.
MemorySource
trait. - static-alloc - Bump allocator for turning a static bytes array into a global allocator
"If you're looking to get structs (possibly dynamically sized) consider using zerocopy (or scroll, or structview). If you need to turn bytes into trivial types such as u16 or arrays thereof, use bytemuck (or safe-transmute)."
Please suggest additions, replacements or removals.