toolbox_general.md

🔧 Rust Developer's Toolbox

Awesome collection of crates for productive development in Rust. It is curated by us.

You might also be interested in other tooboxes:

• 🔧 Explore : general-purpose toolbox with collection of crates.
• 🎮 Explore : multimedia toolbox with collection of crates for GameDev, Graphics, Video, Audio.
• ♾️ Explore : scientific toolbox with collection of crates for Math, Physycs, Lienar Algebra, Machine Learnign, DSP.
• 📦 Explore : distros toolbox with collection of utilities written in Rust to been distributed outside of Rust ecosystem.

⬇️ Tags legend at the end of the page.

Errors handling

( error )

• miette by Kat Marchán : error reporting facilities
• thiserror by David Tolnay : macro error for struct and enum error types
• anyhow by David Tolnay : a generic error trait
• flex-error by Soares Chen : adapter for error handling approaches

Macros

( macro )

• paste by David Tolnay : workaround of concatenating identifiers problem
• cargo-expand by David Tolnay : extension for cargo to expand macros
• syn by David Tolnay : parser for writing macros
• prettyplease by [https://github.com/dtolnay](David Tolnay) : minimal syn syntax tree pretty-printer
• quote by David Tolnay : tool to write procedure macros
• rustversion by David Tolnay : conditional compilation according to rustc compiler version
• macro_railroad by Lukas Lueg : to generate syntax diagrams for macro_rules!()
• macro_railroad as service by Lukas Lueg : a service to generate syntax diagrams for macro_rules!()
• litrs by Lukas Kalbertodt : parse Rust literals

Meta

( meta )

• treeflection by Lucas Kent ( idea ) : pseudo-reflection for structs and enums

Decorators

( meta ) ( decorator )

• cfg_aliases by Zicklag : aliasing of cfg
• maplit by bluss : literal macros for containers
• literally by estk : alternative literal macros for containers
• if_chain by Chris Wong : nested if let
• delegate by Godfrey Chan : removes some boilerplate for structs that simply delegate some of their methods to one or more of their fields
• sealed by José Duarte : macro to seal traits

Derives

( meta ) ( derive )

• derive_more by Jelte Fennema : many useful derives
• derive-new by Nick Cameron : derive new
• parse-display by Frozenlib ( parser ) ( stringification ) : derive macro Display and FromStr
• derive_is_enum_variant by Nick Fitzgerald : macro to generate the method is_variant for each variant of an enum
• field_names by Ted Driggs : derive to list names of fields bound to the structure
• strum by Peter Glotfelty ( stringification ) : enum stringification, parsing and iterating
• derive_is_enum_variant by Nick Fitzgerald : macro to generate the method is_variant for each variant of an enum

Compilers, Static Analyzers, code formatters

( compiler )

• rudra by Yechan Bae : undefined behavior detection

Interoperability

• bindgen-cli by Jyun-Yan You : automatically generates Rust FFI bindings to C (and some C++) libraries

Compile-time

( compile_time )

• databake by Shane F. Carr : data to write itself into Rust code
• phf by Steven Fackler : compile-time hashmap
• constrandom by Tom Kaitchuck : random compile-time constants
• static_assertions by Nikolai Vazquez : compile-time cecks
• reinda by Lukas Kalbertodt : embed assets
• vergen by Jason Ozias : ( hardware ) ( compile_time ) compile-time constants about process of compilation
• rust-embed by : embed files into the rust binary at compile time during release and loads the file from the fs during dev
• const_format by Rodri Mati : compile-time string formatting
• konst by Rodri Mati : const equivalents of std

Global

( global )

• 🌍 once_cell by Aleksey Kladov : single assignment cells and lazy statics without macros, the most popular
• lazy_static by Marvin Löbel : macro for defining lazy evaluated static variables

UI

( ui ) ( gui )

• stretch by Emil Sjölander : flexbox implementation

GUI

( ui ) ( gui )

• egui by Emil Ernerfeldt : an immediate mode GUI
• imgui by Joonas Javanainen : an immediate mode GUI
• iced by Héctor Ramón : cross-platform GUI inspired by Elm
• relm4 by Aaron Erhardt : inspired by Elm and based on gtk4-rs
• pw-viz by Ax9D : graph editor
• kayak_ui by John Mitchell : game UI
• eww by ElKowar : drop-down widgets
• unixbar by Greg V : UNIX-style desktop bar

Command user interface input / output

( ui ) ( cui )

• dialoguer by Armin Ronacher : command line prompts
• indicatif by Armin Ronacher : command line progress reporting

Textual user interface input / output

( ui ) ( tui )

• 🌍 tui-rs by Florian Dehau : the most popular TUI framework
• cursive by Alexandre Bury : TUI framework
• expectrl by Maxim Zhiburt ( testing ) ( os ) : controlling input/output of interactive programs

Command user interface parsing

( ui ) ( cui ) ( cui_parsing )

• 🌍 clap by Kevin K. : the most popular CUI parsing
• structopt by Guillaume P. : CUI parsing with a structure
• pico-args by Yevhenii Reizner : smallest one CUI tool

Terminal

( terminal )

• 🌍 console by Armin Ronacher : the most popular module to manipulate terminal
• termion by Ticki : low-level handling, manipulating and reading information about terminals
• crossterm by Timon : cross platform terminal
• atty by Doug Tangren : check is it a tty
• termize by Yuki Okushi : terminal size
• terminal_size by Andrew Chin : terminal size
• terminal-clipboard by Canop : text only clipboard facade
• termcolor by Andrew Gallant : terminal colors
• bunt by Lukas Kalbertodt : colored and formatted text to a terminal
• ansi-parser by David Bittner : parseing ANSI escape codes based on nom

Cloud APIs

( cloud_api )

• doapi by Kevin K. : DigitalOcean API v2
• octocrab by Erin P : GitHub API
• giphy api by Anthony Dodd : giphy API
• aws-sdk-* : AWS SDK for Rust

NodeJS and JS

( njs )

• neon by Dave Herman : native Node.js modules
• snm by Vikas Raj : environment manager, like NVM
• fnm by Gal Schlezinger : Fast and simple Node.js version manager
• volta by Dave Herman : JS Toolchains

Building and Optimization

( build )

• trunk by Anthony Dodd ( wasm ) : WebAssembly web application bundler
• cross by Jorge Aparicio ( build ) ( cross_compile ) ( testing ) : cross-compilation and cross-testing
• duckscript by Sagie Gur-Ari : utility to be cross-platform shell.
• cargo-make by Sagie Gur-Ari ( utility ) : make-like utility
• just by Casey Rodarmor ( utility ) : make-like utility
• cargo-bundle by George Burton : cross-platform bundling
• parcel_css by Devon Govett ( parser ) : CSS parser, transformer, and minifier
• minify-html by Wilson Lin ( html ) : HTML minifier
• tauri by Razvan Stoenescu : desktop applications with a web frontend
• built by Lukas Lueg : information when and how it was built
• cargo-pgo by Jakub Beránek ( reading ) ( article ) : profile guided optimzation
• cargo-sweep by Viktor Holmgren : tool for cleaning unused build files created by Cargo

Cross-compile

( cross_compile )

• cross by Jorge Aparicio ( build ) ( cross_compile ) ( testing ) : cross-compilation and cross-testing
• osxcross by Thomas Pöchtrager : cross toolchain for Linux and *BSD

Cargo extension

( cargo ) ( build )

• cargo-edit by Pascal Hertleif : utility to add, remove, upgrade cargo dependencies
• rust-script by Fredrik Fornwall : utility to interpret rust files and expressions
• cargo-watch by Félix Saparelli : utility to watch over your project's source for changes
• cargo-binutils by Jorge Aparicio : LLVM utility
• cargo-generate by ashley williams : utility to instantiate a template ( templating )
• cargo-depgraph by Jonas Platte : generate dependencies graph
• cargo_metadata by Oli Scherer : information about cargo module
• cargo-when by Kathryn Long : run conditionally upon rustc version and environment
• cargo-update by Nabijaczleweli : update installed globally executables

Cargo clean

( cargo ) ( cargo_clean )

• cargo-cache by Matthias Krüger ( cargo_clean ) : manage cargo cache, cleaning cache
• cargo-wipe by Mihai Dinculescu ( cargo_clean ) : cleaning, removing artifacts
• cargo-sweep by Viktor Holmgren ( cargo_clean ) : one more artifacts cleaner

Video

🎥

• camera_capture by Oli Scherer : webcam screenshot

Testing

( testing )

• cross by Jorge Aparicio ( build ) ( cross_compile ) ( testing ) : cross-compilation and cross-testing
• wasm-bindgen-test by Alex Crichton ( wasm ) : run tests of wasm-based application in browser
• trybuild by David Tolnay : negative testing, when error during compilation is expected result.
• expectrl by Maxim Zhiburt ( ui ) ( tui ) ( os ) : controlling input/output of interactive programs
• portpicker by Hannes Karppila ( network ) ( testing ) : pick a free unused port
• test-case by Wojciech Polak : procedural macro attribute for adding test cases
• cucumber by Brendan Molloy : BBD
• pprof by YangKeao : CPU profiler
• compiletest by Manish Goregaokar : an extraction of the compiletest utility from the Rust compiler
• cargo-fuzz by Manish Goregaokar : testing framework for fuzzy testing

Performance benchmarking

( perf_benchmark )

• drill by Ferran Basora ( network ) ( perf_benchmark ) : HTTP load testing
• goose by Jeremy Andrews ( network ) ( perf_benchmark ) : HTTP load testing
• loom by Carl Lerche : ( perf_benchmark ) concurrency permutation testing

WebAssembly

( wasm )

• trunk by Anthony Dodd ( build ) : WebAssembly web application bundler
• wasm-bindgen by Alex Crichton : interactions between WebAssembly modules and JavaScript
• wasm-server-runner by Jakob Hellermann : run in the browser
• wasm-bindgen-test by Alex Crichton ( testing ) : run tests of wasm-based application in browser
• console_error_panic_hook by Nick Fitzgerald : A panic hook for wasm
• wasm-snip by Nick Fitzgerald : utility to remove function body from a wasm file
• wasm-tools by Yury Delendik: tooling for WebAssembly
• wasmtime by Jakob Stoklund Olesen : standalone JIT-style runtime
• wasmer by Syrus Akbary error ) : Debug panics on wasm32-unknown-unknown by providing a panic hook that forwards panic messages to console
• twiggy by Nick Fitzgerald : utility to profile wasm code size
• wasm-opt by Alon Zakai : utility to optimize wasm file
• wasm-pack by ashley williams : wasn-bindgen and binaryen/wasm-opt as single utility
• wizer by Nick Fitzgerald : performance optimization by compile-time pre-initialization
• wee_alloc by Nick Fitzgerald : 1kB-size memory allocator for size-optimized builds
• parity-wasm by Nikolay Volf : read wasm files

Windowing

( windowing )

• winit by Pierre Krieger : cross-platform window creation and management
• web-view by Boscop : bindings for webview, a tiny cross-platform library

Data streams aggregation

( dsa )

• feedfinder by Wesley Moore ( html ) : auto-discovery of feeds in HTML

HTML generating / parsing / transformation

( html ) ( xml )

• feedfinder by Wesley Moore ( dsa ) : auto-discovery of feeds in HTML
• markup by Utkarsh Kukreti : template engine to generate HTML
• kuchiki by Simon Sapin : HTML/XML tree manipulation
• html5ever by Keegan McAllister : high-performance HTML5 parser
• minify-html by Wilson Lin ( build ) : HTML minifier
• comrak by Asherah Connor : GFM compatible Markdown parser and renderer
• quick-xml by Johann Tuffe : high performance XML pull reader/writer
• hard-xml by Kevin Cox : A derive-based XML parser for Rust

Web DOM

( web_frontend ) ( dom )

• console_log by Matthew Nicholson : A logger that routes messages to the browser's console
• stdweb by Koute : standard library for the client-side Web
• web-log by Douman : minimal wrapper over browser console
• web-sys by Nick Fitzgerald : Raw wasm-bindgen imports for all of the Web's APIsDescription
• js-sys by Alex Crichton ( bindings ) : Raw bindings to JS global APIs for projects using wasm-bindgen
• gloo by Nick Fitzgerald : alternative of web-sys
• wasm-bindgen-futures by Alex Crichton ( concurrency ) : bridges the gap between a Rust Future and a JavaScript Promise

Web Frontend

( web_frontend )

• sycamore by Luke Chu : reactive frontend
• yew by Denis Kolodin : Elm-inspired frontend
• ybc by Anthony Dodd : a Yew component library based on the Bulma CSS framework
• seed by David O'Connor : Elm-inspired frontend

Web Backend

( web_backend )

• 🌍 rocket by Sergio Benitez : one of the most popular web backend frameworks
• 🌍 actix by Nikolay Kim : one of the most popular web backend frameworks
• axum by David Pedersen : tokio-based web backend framework
• axum-yew-setup by Robert Krahn : starter project that sets up axum and yew for full stack
• basic-http-server by Brian Anderson : a simple static HTTP server, for learning and local development
• penguin by Lukas Kalbertodt : a static server
• reqwest by Sean McArthur : high-level HTTP client
• hyper by Sean McArthur : low-level HTTP client
• headers by Jonathan Reem : HTTP Headers for hyper
• warp by Sean McArthur : composable, web server framework
• libreauth by Rodolphe Bréard : user authentication
• cookie by https://github.com/SergioBenitez : HTTP cookie parsing and cookie jar management
• vector by Luke Steensen : data aggregator
• tungstenite by : websocket implementation
• Rust back-end frameworks comparison ( collection ) : bunch of back-end frameworks comparison
• actix-web by Actix : is a powerful, pragmatic, and extremely fast web framework for Rust
• poem by Sunli : is a full-featured and easy-to-use web framework with the Rust programming language
• salvo by Chrislearn Young : is a powerful and simple Rust web server framework
• tide by http-rs : a minimal and pragmatic Rust web application framework built for rapid development
• isahc by Stephen M. Coakley : the practical HTTP client that is fun to use
• ureq by Martin Algesten : Simple, safe HTTP client
• surf by http-rs : the web - HTTP client framework

Network

( network )

• imap by Jon Gjengset : IMAP interface
• r2d2 by Steven Fackler : agnostic connection pool
• pcap by Sean Bowe : packet sniffing
• websocat by Vitaly Shukela : CUI to communicate via WebSocket ( cui )
• netraffic by ZingerLittleBee : statistics network traffic
• portpicker by Hannes Karppila ( network ) ( testing ) : pick a free unused port
• drill by Ferran Basora ( network ) ( testing ) : HTTP load testing application
• g3 by Zhang Jingqiang ( network ) : generic proxy

Database

( db )

• ormx by NyxCode : orm-like features to sqlx
• datafusion by Jacques Nadeau ( db ) ( data_science ) : query engine from Apache
• influxdb-rust by Gero Gerke : time-series database
• meilisearch-rust by Mubelotix : stores data and provides some basic filtering and sorting capabilities
• sonic-channel by pleshevskiy : schema-less search backend. it is an alternative to traditional search engines like Elasticsearch or Solr

Key-Value Database

( db )( db_key_value )

• dynomite by Doug Tangren : DynamoDB binding
• redis by Armin Ronacher : Redis binding
• sled by Tyler Neely : an embedded database
• tikv by ngaut : distributed key-value DBMS
• rust-rocksdb by Tyler Neely : embedded database that is designed to be used as a library within an application
• lmdb-rs by Valerii Hiora : high-performance embedded key-value store designed to provide efficient storage and retrieval of data
• heed by Clément Renault : schema-less embedded database that can be used to store and retrieve data efficiently
• rsmgclient by Mario Herceg : used for interacting with the Redis key-value store
• surrealdb by Tobie Morgan Hitchcock :

Document-oriented Database

( db )( db_document_oriented )

• mongodb by Saghm Rossi : official MongoDB binding
• monger by Saghm Rossi : MongoDB version manager
• redb by Christopher Berner : provides a lightweight and efficient implementation of a document-oriented database that is optimized for performance and scalability
• heed by Clément Renault : schema-less embedded database that can be used to store and retrieve data efficiently
• darkbird by DanyalMh : in-memory database solution optimized for fast document retrieval

Relational Database

( db )( db_relational )

• 🌍 diesel by Sage Griffin : ORM and query builder
• sea-orm by Chris Tsang : ORM and query builder
• 🌍 sqlx by Ryan Leckey : SQL DBMS driver
• rusqlite by hydhknn : bindings to SQLite
• 🌍 deadpool-postgres by Michael P. Jung : async pool for PostgreSQL
• 🌍 tokio_postgres by Steven Fackler : PostgreSQL driver

Graph Database

( db )( db_graphs )

• bolt-client by Luc Street : communicate with Bolt-compatible graph databases
• neo4rs by John Vincent : based on the property graph data model, which consists of nodes, relationships, and properties
• indradb by Yusuf Simonson : uses Apache TinkerPop as its underlying graph framework
• oxigraph by Thomas Tanon : designed for the resource description framwork data model
• dgraph-rs by Swoorup Joshi : supports complex queries, aggregations and traversals using GraphQl-like syntax
• cozo by Ziyang Hu : optimized for efficient graph processing on large datasets

Data science

( data_science )

• polars by Ritchie Vink : multi-threaded DataFrame library
• datafusion by Jacques Nadeau ( db ) ( data_science ) : query engine from Apache
• arrow by Jacques Nadeau : working with bytes from Apache

Functional programming

( functional )

• itertools by bluss : extra iterator tools ???

Version control systems

( vcs )

• git2 by Alex Crichton : libgit2 binding

Virtualization

( virtualisation )

• shiplift by Doug Tangren : maneuvering docker containers
• unshare by Paul Colomiets : low-level linux containers

Async

( async )

• pin-project by Taiki Endo : synchronization primitives pin-projection
• pin-project-lite by Taiki Endo : synchronization primitives pin-projection, lite version
• blocking by Stjepan Glavina : a thread pool for isolating blocking I/O in async environment
• yatp by ngaut : generic thread pool
• async-compat by Taiki Endo : compatibility adapter between tokio and futures
• futures-signals by Pauan : reactive signals
• futures by Alex Crichton : async interfaces
• waker-fn by Stjepan Glavina : convert closures into waker

Async Runtimes

( async ) ( async_runtime )

• tokio by Carl Lerche : asynchronous application framework
• async-std by Florian Gilcher : async version of std
• pollster by Joshua Barretto : a minimal async executor
• smol by Stjepan Glavina : a small and fast async runtime for Rust

Concurrency

( concurrency )

• radium by Nika Layzell : atomic instructions fallback
• rayon by Niko Matsakis : data-parallelism
• futures-signals by Pauan : reactive signals
• crossbeam by Aaron Turon : tools for concurrent programming
• scoped_threadpool by Marvin Löbel : scoped and cached threadpools
• wasm-bindgen-rayon by Ingvar Stepanyan
• wasm-mt by j-devel

Concurrency primitives

( concurrency ) ( primitive )

• parking_lot by Amanieu d'Antras : synchronization primitives on steroids
• state by https://github.com/SergioBenitez : HTTP cookie parsing and cookie jar management
• thread_local by Amanieu d'Antras : thread-local storage
• flume by Joshua Barretto : multi-producer, multi-consumer channel
• bounded-spsc-queue by Zachary Tong : bounded, Single-producer Single-consumer queue (SPSC)
• bus by Jon Gjengset : lock-free, bounded, single-producer, multi-consumer, broadcast channel
• left-right by Jon Gjengset : lock-free, read-optimized, concurrency primitive
• evmap by Jon Gjengset ( data_structure ) : lock-free, eventually consistent, concurrent multi-value map
• dashmap by Acrimon Joel ( data_structure ) : concurrent HashMap
• atomig by Lukas Kalbertodt : type constructor of atmotics
• syncell by Dzmitry Malyshau : sync alternative to RefCell
• qcell by Jim Peters : statically-checked alternatives to RefCell and RwLock
• reffers by David Henningsson : wrappers around references, boxes and Arcs

Persistence and delayed execution

( persistence )

• schedule by Ryan Leckey : in-process cron-like scheduler

Communication

( communication )

• turbine by Zachary Tong : inter-task communication

Streams and Buffers

( streams ) ( buffers ) ( data_structure )

• peekreed by Orson Peters : peekable read streams
• bytes by Carl Lerche : working with bytes
• arrow by Jacques Nadeau : working with bytes from Apache
• scroll by m4b : a suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers

Memory management

( mem )

• byte-slice-cast by Sebastian Dröge : casting to / from byte slice
• zerocopy by Joshua Liebow-Feeser ( serialization ) : zero-copy parsing and serialization
• memmap by Dan Burkert : API for memory mapped IO
• wee_alloc by Nick Fitzgerald : 1kB-size memory allocator for size-optimized builds
• shuffling-allocator by Nick Fitzgerald : randomizing location in the heap

Serialization

( serialization )

• unique_type_id_workspace by Victor Polevoy : procedural macro for generating unique ids
• zerocopy by Joshua Liebow-Feeser ( mem ) : zero-copy parsing and serialization
• restruct by Lukas Lueg : serializing and deserializing of a tuple
• bincode by Nathan McCarty : a binary encoder / decoder implementation
• ron by Dzmitry Malyshau ( gdf ) : readable data serialization format
• 🌍 serde by David Tolnay : the most popular serialization framework
• serde-hjson by Christian Zangl : serde plugin to parse JSON with comments
• nanoserde by Fedor Logachev : minimal serialization library with zero dependencies
• speedy by Koute : another serialization alternative
• dipa by Chinedu Francis Nwafili : structures delta encoding
• rkyv (archive) by David Koloski : is a zero-copy deserialization framework for Rust
• musli by John-John Tedro : is a flexible and generic binary serialization framework
• typify by Adam Leventhal : JSON Schema -> Rust type converter

Stringification

( stringification )

• parse-display by Frozenlib ( derive ) : derive macro Display and FromStr
• strum by Peter Glotfelty ( adt ) : enum stringification, parsing and iterating
• lexical by Alexander Huszagh ( parser ) : numeric to and from string conversion
• lexical-core by Alexander Huszagh ( parser ) : minimal implementation of lexical
• humansize by Leopold Arkham : file size formatting
• ubyte by https://github.com/SergioBenitez : byte units
• num-format by Brian Myers : formatting of numbers
• tabled by Maxim Zhiburt : textual tables formatting
• const_format by Rodri Mati : compile-time string formatting

Parser generators / combinators

( parser_generator )

• chumsky by Joshua Barretto : parser combinator
• nom by Geoffroy Couprie : parser combinator framework
• combine by Markus Westerlind : parser combinators
• combine-language by Markus Westerlind : extension of combine to generate parsers of programming languages
• lalrpop by Niko Matsakis : LR(1) parser generator
• peg by Kevin Mehall : PEG parser generator
• rust-langdev by Chase Wilson ( collection ) : parser/language development toolboxs

Lexer generator

( lexer_generator )

• 🌍 logos by Maciej Hirsz : fast tokenizer, the most popular
• lexgen by Ömer Sinan Ağacan : lexer generator, as a procedural macro
• lrlex by Lukas Diekmann : lex/flex inspired lexer

Parser of a specific language

( parser )

• minimad by Canop : markdown ( MD ) parser
• parcel_css by Devon Govett ( build ) : CSS parser, transformer, and minifier
• csv by Andrew Gallant : CSV parser
• toml by Alex Crichton : TOML parser
• toml_edit by Andronik Ordian : format-preserving TOML parser
• 🌍 regex by Alex Crichton : the most popular regular expressions implementation
• ress by Robert Masen : tokenizer of JS
• ressa by Robert Masen : parser of JS
• syntect by Tristan Hume : syntax highlighting using Sublime text syntax definitions
• sg by Ömer Sinan Ağacan : syntax-aware grep-like code search
• tree-sitter-parse by Ömer Sinan Ağacan : tree-sitter-cli that can load parsers compiled to shared libraries
• fancy-regex by Robin Stocker : an implementation of regexes, supporting a relatively rich set of features, including backreferences and look-around.

Time

( time )

• 🌍 time by Jacob Pratt : the most popular date and time module
• chrono by Kang Seonghoon : date and time module, maintained poorly
• chrono-humanize by Cyril Plisko : human-friendly time expressions

Statistics

( statistics )

• getrandom by Diggory Hardy : cross-platform get random back-end
• rand by Roy Frostig : random number generation front-end
• fastrand by Stjepan Glavina : fast random number generator
• uuid by Biru Mohanathas : generate and parse UUIDs
• rusty_ulid by Jörn Huxhorn : generate and parse ULIDs, alternative of UUIDs

Abstract Data types

( adt )

• num by Josh Stone : a collection of numeric types and traits
• total_float_wrap by : hash and equal for floats

Algorithms

( data_structure ) ( algo )

• dmsort by Emil Ernerfeldt : fast novel adaptive sorting algorithm optimized for nearly-sorted data
• longest-increasing-subsequence by Nick Fitzgerald : longest increasing subsequence

Primitive data structures

( data_structure ) ( primitive )

• either by bluss : enum Either with variants Left and Right is a general purpose sum type with two cases
• ptr-union by Christopher Durham : union of pointers storing the tag in alignment bits
• erasable by Christopher Durham : produce type-less pointers
• rc-box by Christopher Durham : better Rc< Box > and Arc< Box >
• rc-borrow by Christopher Durham : borrow Rc/Arc without wrapping borrowed
• triomphe by Manish Goregaokar : FFI-focused ARC
• scopeguard by bluss : run a given closure when it goes out of scope
• beef by Maciej Hirsz : fast tokenizer

Collections

( data_structure ) ( ds_collection )

• indexmap by bluss : hash table which preserves insertion order
• hashbrown by Amanieu d'Antras : hashmap and hashset for "no std"
• rustc-hash by Niko Matsakis : fast non-cryptographic hashmap and hashset
• slice-deque by gnzlbg : contiguous-in-memory double-ended queue that derefs into a slice
• thingbuf by Eliza Weisman : in-place allocation-reusing queues
• bitvec by Alexander Payne : bitfields
• bitflags by Alex Crichton : macro to generate structures which behave like bitflags
• growable-bloom-filter by David Briggs : growable bloom filter
• associative-cache by Nick Fitzgerald : fixed-size, associative cache
• intrusive_splay_tree by Nick Fitzgerald : an intrusive, allocation-free splay tree implementation
• anymap by Chris Morgan : wrapper around HashMap< TypeId, Box< dyn Any > >
• fst by Andrew Gallant : trie-like to represent large sets and maps
• evmap by Jon Gjengset ( concurrency ) : lock-free, eventually consistent, concurrent multi-value map
• dashmap by Acrimon Joel ( concurrency ) : concurrent HashMap
• sharded-slab by Eliza Weisman ( concurrency ) : lock-free concurrent slab
• heapless by Jorge Aparicio : heapless data structures, mostly for embed

Character encoding

( string ) ( character_encoding )

• deunicode by Kornel : transliterates Unicode strings into ASCII
• widestring by Kathryn Long : a wide string Rust library for converting to and from wide Unicode strings
• unicode-width by Riad S. Wahby : displayed width
• unicode-segmentation by Riad S. Wahby : iterate graphemes of unicode string

String and slice data structures and algorithms

( data_structure ) ( string )

• edit-distance by Florian Ebeling : Levenshtein distance
• similar by Armin Ronacher : determining difference between string
• twoway by bluss : twoway substring search
• memchr by Andrew Gallant : string search routines
• aho-corasick by Andrew Gallant : finding occurrences of many patterns at once
• suffix by Andrew Gallant : finding several occurrences of the same pattern in a long text
• globset by Andrew Gallant ( fs ) : glob matching
• heck by Saoirse Shipwreckt : case conversion
• convert-case by Dave Purdum : case conversion
• slice-dst by Christopher Durham : slice-based DST allocation

Stack-based data structures

( data_structure ) ( stack_based )

• inlinable_string by Nick Fitzgerald ( string ) : stack-based string if small, otherwise heap-based, also defines String interface
• smartstring by Bodil Stokke ( string ) : stack-based string if small, otherwise heap-based
• kstring by Ed Page : stack-based string if small, otherwise heap-based, optimal as a key for hashmap
• arrayvec by bluss : stack-based vector and string
• smallvec by Simon Sapin : stack-based vector
• tinymap by John : stack-based hashmap
• storagevec by John : feature to chose stack-based containers

Self referential structures

( data_structure ) ( self_ref ) ( ownership_semantics )

• owning_ref by Marvin Löbel : references that carry their owner with them
• ouroboros by Joshua Maros : self-referential struct generation

Ownership semantic

( data_structure ) ( ownership_semantics )

• slabmap by Frozenlib : hashMap-like collection with implicit key
• slab by Carl Lerche : hashMap-like collection with implicit key
• indexing by bluss : solving indexing problem by associating lifetime with intervals
• slotmap by Orson Peters : a hashmap with implicit key
• typed-arena by Simon Sapin : homogenous allocator operating references without the ability to deallocate an individual element
• id-arena by Nick Fitzgerald : homogenous allocator operating ids without the ability to deallocate an individual element
• generational-arena by Nick Fitzgerald : homogenous allocator operating ids with the ability to deallocate an individual element
• bumpalo by Nick Fitzgerald : heterogeneous allocator operating ids without the ability to deallocate an individual element

Multidimensional data structures and algorithms

( data_structure ) ( multidimensional )

• bvh by Sven-Hendrik Haase : fast BVH using SAH

Graphs

( data_structure ) ( graphs )

• petgraph by bluss : graph data structure and algorithms

Hashing

( hashing )

• ahash by Tom Kaitchuck : fast non-cryptographic hashing
• xxhash-rust by Douman : xxhash algorithm - one of the fastest non-cryptographic hashing
• twox-hash by Jake Goulding : xxhash algorithm - one of the fastest non-cryptographic hashing
• seahash by Tom Almeida : one of the fastest non-cryptographic hashing algorithm
• by_address by Matt Brubeck ( adt ) : comparison by pointer address

Cryptography

( cryptography )

• Cupcake by Hao Chen : lattice-based additive homomorphic encryption
• elgamal-curve25519 by Christian Nyumbayire : ElGamal homomorphic encryption on Curve25519
• argonautica by Brian Myers : password hashing
• rust-argon2 by Martijn Rijkeboer : password hashing
• subtle by dalek cryptography : Pure-Rust traits and utilities for constant-time cryptographic implementations
• belt-mac by Artyom Pavlov : MAC specified by the BelT standard
• cbc-mac by Artyom Pavlov : Implementation of Cipher Block Chaining Message Authentication Code (CBC-MAC)
• cmac by Artyom Pavlov : Generic implementation of Cipher-based Message Authentication Code
• hmac by Artyom Pavlov : Generic implementation of Hash-based Message Authentication Code (HMAC)
• pmac by Artyom Pavlov : Generic implementation of Parallelizable Message Authentication Code

Compression

( compression )

• yazi by Chad Brokaw : deflate/zlib compression
• flate2 by Alex Crichton : deflate, gzip, and zlib bindings
• snap by Andrew Gallant : high speeds and reasonable compression
• smush by Graham Wihlidal : adapter of variety of compression codecs

Encoding / decoding

( encoding )

• percent-encoding by Simon Sapin : do URL percent encoding
• url by Simon Sapin : URI parsing
• hex by KokaKiwi : hexadecimal encoding

General data format

( gdf )

• flatc-rust by Vlad Frolov : FlatBuffers
• ron by Dzmitry Malyshau ( serialization ) : readable data serialization format
• rmp by Evgeny Safronov : MessagePack
• minicbor by Toralf Wittner : CBOR
• record-query by David Flemström : transform from one GDF to another one

Image reading / writing

( asset_image )

• libheif-rs by Kirill Kuzminykh : heif/heic files reading/writing
• lodepng by Kornel : PNG image reader/writer
• exifsd by Geordon Worley : exif serialization and deserialization

Image processing

( asset_image_processing )

• fast_image_resize by Kirill Kuzminykh : SIMD image resizing
• imagequant by Kornel : palette quantization library
• dssim by Kornel : image similarity comparison simulating human perception
• noise by Nick Whitney : procedural noise generation
• imageproc by image-rs : library for images processing
• anim-rs by Joylei : animation library

File system

( fs )

• directories by Simon Ochsenreither : OS's paths
• fs2 by Dan Burkert : extra system fs routines
• walkdir by Andrew Gallant : walking directories recursively
• remove_dir_all by Erin P : directory removal
• filetime by Alex Crichton : file timestamps reading / writing
• is_executable by Nick Fitzgerald : is an executable
• same-file by Andrew Gallant : two files or directories are the same
• globset by Andrew Gallant ( data_structure ) ( string ) : glob matching
• which by Harry Fei : equivalent of Unix command "which"
• vfs by Manuel Woelker : file system adapter
• inotify by Hanno Braun : track changes in file system

Operation Systems - userland

( os )

• winapi by Peter Atashian : bindings to Windows API
• wio by Peter Atashian : extra bindings to Windows API
• winapi-util by Andrew Gallant : middleware above
• rio by Tyler Neely : io_uring
• telefork by Tristan Hume : remote fork()
• expectrl by Maxim Zhiburt ( ui ) ( tui ) ( testing ) : controlling input/output of interactive programs
• nix by Carl Lerche : nix APIs
• systemstat by Greg V : system information

Operation Systems - kernel

( os ) ( kernel )

• Ion by Anhad Singh : x86_64 UEFI bootloader
• Aero by Anhad Singh : unix-like operating system
• mycelium by Eliza Weisman : operating system
• hermit-sys by Stefan Lankes : lightweight unikernel

Asm

( asm )

• faerie by m4b : ELF and Mach-o object file writer
• goblin by m4b : binary parsing
• cargo-bloat by Yevhenii Reizner : utility to profile code size
• cargo-binutils by Jorge Aparicio : LLVM utility
• elfloader by Gerd Zellweger : x86 CPUID instruction
• symtool by Caleb Zulawski : ELF and Mach-O symbols manipulation

Hardware

( hardware )

• cpuid by Gerd Zellweger : x86 CPUID instruction
• cupid by Jake Goulding : x86 CPUID instruction
• num_cpus by Sean McArthur : number of CPUs
• generic-simd by Caleb Zulawski : SIMD instructions
• multiversion by Caleb Zulawski : tool to write multiversioned architecture-specific implementations of functions
• vergen by Jason Ozias : ( hardware ) ( compile_time ) compile-time constants about process of compilation

Embedded

( embed )

• embedded-hal by Jorge Aparicio : hardware abstraction layer (HAL) for embedded systems
• serial_enumerator by eebear : serial port enumreator
• heapless by Jorge Aparicio : heapless data structures, mostly for embed
• cargo-binutils by Jorge Aparicio : LLVM utility

Foreign

( foreign )

• foreign_types by Steven Fackler : wrappers over C APIs.
• cpp by Nika Layzell : embed C++ inside rust code

Logging

( logger )

• log by Alex Crichton : lightweight logging
• log4rs by estk : configurable logging
• simplelog by Victoria Brekenfeld : simple logging
• tracing by Eliza Weisman :
• fregate by Petr Makagon : metrics, logging, environment all-in-one

Config

( config )

• config by Ryan Leckey : generic config manager
• dotenvy by Allan : environment variables from a .env file

Diagnostics tools

( daignostics )

• pretty_assertions by Colin Kiegel : pretty assert_eq

Mobile

( mobile )

• cargo-mobile by mtak- ( build ) : utility to run rust on mobile
• crossbow by David Ackerman : cross-platform rust toolkit for games
• mobile-entry-point by Francesca Lovebloom : Wraps a function to make it the entry-point for an mobile app

Android

( android )

• android-ndk-rs by Mark Barbone : libraries and tools for Rust programming on Android targets
• ndk by David Craven : interoperability library for a native Rust application with the Android framework
• ndk-sys by David Craven ( bindings ) : raw FFI bindings to the NDK
• cargo-apk by David Craven ( build ) : tool for creating Android packages
• android_logger by Nerijus Arlauskas ( logger ) : send Rust logs to Logcat

iOS

( ios )

• rust-to-ios by Wojtek Lukaszuk ( example ) : Example project for building a library for iOS.
• xcodegen by Yonas Kolb : utility to generates your Xcode project
• cargo-lipo by Tim Neumann : utility to automatically creates a universal library for use with iOS application

HPC

( bindings )

• mcl-rs by Ryan Friese : high-level bindings providing a "safe" interface to the Minos Compute Library (MCL)
• libmcl-sys by Ryan Friese : high-level bindings through an "unsafe" interface to the Minos Compute Library (MCL)

Templating

( templating )

• handlebars-rust by Ning Sun : Handlebars templating language implemented in Rust and for Rust
• cargo-generate by ashley williams : utility to instantiate a template ( cargo ) ( build )
• ramhorns by Maciej Hirsz : Mustache template engine

Messaging

( messaging )

• paho-mqtt by Frank Pagliughi : The Official Eclipse Paho MQTT Rust Client Library. This is a wrapper around the Paho C library

Utilities for development

( development )( utility )

• cargo-clippy by Manishearth : A collection of lints to catch common mistakes and improve your Rust code
• cargo-audit by Tony Arcieri : Audit Cargo.lock files for crates with security vulnerabilities reported to the RustSec Advisory Database
• cargo-udeps by est31 : Find unused dependencies in Cargo.toml
• cargo-watch by Félix Saparelli : Utility to watch over your project's source for changes
• cargo-checkmate by Nathan Wilcox : Perform a series of useful checks out of the box.
• cargo-about by Jake Shadle : Cargo plugin for generating a license listing for all dependencies of a crate
• cargo-hack by Taiki Endo : Cargo subcommand to provide various options useful for testing and continuous integration
• cargo-outdated by Kevin K. : A cargo subcommand for displaying when Rust dependencies are out of date
• cargo-miri by Scott Olson : An experimental interpreter for Rust. Can be used to detect certain classes of undefined behavior
• cargo-expand by David Tolnay : Extension for cargo to expand macros
• cargo-llvm-lines by David Tolnay : Count the number of lines of LLVM IR across all instantiations of a generic function

Tags legend

• 🌍 - the most popular module in its category
• ( collection ) - awesome collection
• ( error ) - errors handling
• ( macro ) - writing macros
• ( meta ) - meta programming : reflection, introspection and such things
• ( decorator ) - decorators for nicer code
• ( derive ) - procedural derive macroses
• ( compiler ) - compilers and static analyzers
• ( compile_time ) - non run-time
• ( global ) - global variable
• ( njs ) - NodeJs related
• ( ui ) - user interface
• ( gui ) - graphical user interface
• ( tui ) - textual user interface
• ( cui ) - command user interface
• ( cui_parsing ) - tools to parse input of command user interface ( CUI )
• ( terminal ) - terminal, textual output
• ( cloud_api ) - remote APIs, mostly REST
• ( cross_compile ) - build from one platform to another one
• ( build ) - toolchains to build your project
• ( perf_benchmark ) - performance benchmarking
• ( wasm ) - WebAssembly-related
• ( windowing ) - windows creating, manipulating OS GUI
• ( dsa ) - data streams aggregation
• ( html ) - HTML generating / parsing / transformation
• ( dom ) - web DOM
• ( web_frontend ) - web frontend
• ( web_backend ) - web backend
• ( network ) - network
• ( db ) - database-related
• ( db_key_value ) - key-value
• ( db_document_oriented ) - document-oriented
• ( db_relational ) - relational
• ( db_graphs ) - graph
• ( data_science ) - data science, data mining, data minding, machine learning
• ( functional ) - functional programming
• ( virtualisation ) - virtualisation-related, docker-related
• ( concurrency ) - concurrency programming
• ( async ) - asynchronous programming
• ( async_runtime ) - asynchronous runtimes and executors
• ( persistence ) - persistence and delayed execution
• ( communication ) - either inter-process or inter-thread communication
• ( streams ) - read/write streams
• ( buffers ) - buffers for memory management
• ( mem ) - memory management
• ( serialization ) - serialization / deserialization
• ( stringification ) - converting to / from a string
• ( parser_generator ) - parser generators / combinators
• ( lexer_generator ) - lexer generator
• ( parser ) - parser of a specific language
• ( time ) - time
• ( statistics ) - random generators, distributions and statistics-related things
• ( character_encoding ) - character encoding
• ( adt ) - abstract data types
• ( algo ) - algorithms
• ( data_structure ) - data structures and algorithms
• ( primitive ) - primitives
• ( ds_collection ) - data structures which are collections
• ( string ) - either string or bytes slice based data structures and algorithms
• ( stack_based ) - stack-based data structures and algorithms
• ( graphs ) - graphs data structures and algorithms
• ( hashing ) - hashing algorithms
• ( cryptography ) - cryptographic
• ( compression ) - compression, archiving
• ( encoding ) - encoding / decoding
• ( gdf ) - general data format, genera-purpose formats to exchange data
• ( asset_image ) - reading / writing / manipulating various image formats
• ( fs ) - file system related
• ( os ) - operation systems, bootloaders and components of such, OS APIs
• ( kernel ) - kernel of operation system
• ( cargo ) - extension of cargo
• ( cargo_clean ) - clean artifacts
• 🎥 - video-processing, capturing
• ( asm ) - machine code, byte code, interpreters, assembler
• ( hardware ) - reading / writing hardware
• ( embed ) - embedded
• ( foreign ) - foreign functions, C / C++ binding, foreign function interface ( FFI )
• ( self_ref ) - self referential structures
• ( ownership_semantics ) - solutions of problems of owning/borrowing/lifetimes self referring
• ( multidimensional ) - multidimensional data structures and algorithms
• ( bindings ) - bindings to foreign library or service
• ( logger ) - tools for printing information
• ( config ) - config managing
• ( daignostics ) - tools for diagnostics
• ( mobile ) - tool or lib related to running rust code on mobile
• ( android ) - tools for running rust code on Android
• ( ios ) - tools for running rust code on iOS
• ( testing ) - for writing tests
• ( utility ) - utility to run in terminal
• ( example ) - example project
• ( templating ) - tools to generate text using template
• ( idea ) - it is rather proof of concept than production-ready implementation
• ( development ) - helps the developer to develop
• ( xml ) - XML parsers, readers/writers
• ( messaging ) - tools for messaging