rand[docs]
De facto standard random number generation library split out from the standard library

Unfortunately there is no clear answer as to which is best between time and chrono.
Evaluate for yourself between these two, but be resassured that both are trusted and well-maintained.

time[docs]
A smaller, simpler library. Preferrable if covers your needs, but it's quite limited in what it provides.

chrono[docs]
The most comprehensive and full-featured datetime library, but more complex because of it.

regex[docs]
De facto standard regex library. Very fast, but does not support fancier features such as backtracking.

fancy-regex[docs]
Use if need features such as backtracking which regex doesn't support

uuid[docs]
Implements generating and parsing UUIDs and a number of utility functions

tempfile[docs]
Supports both temporary files and temporary directories

flate2[docs]
Uses a pure-Rust implementation by default. Use feature flags to opt in to system zlib.

indexmap[docs]
A HashMap that seperately keeps track of insertion order and allows you to efficiently iterate over its elements in that order

arrayvec[docs]
Arrays that are ONLY stack-allocated with fixed capacity

smallvec[docs]
Arrays that are stack-allocated with fallback to the heap if the fixed stack capacity is exceeded

tinyvec[docs]
Stack allocated arrays in 100% safe Rust code but requires items to implement the Default trait.

See the HTTP section below for server-side libraries

reqwest[docs]
Full-fat HTTP client. Can be used in both synchronous and asynchronous code. Requires tokio runtime.

ureq[docs]
Minimal synchronous HTTP client focussed on simplicity and minimising dependencies.

anyhow[docs]
Provides a boxed error type that can hold any error, and helpers for generating an application-level stack trace.

color-eyre[docs]
A fork of anyhow that gives you more control over the format of the generated error messages. Recommended if you intend to present error messages to end users. Otherwise anyhow is simpler.

See also: Designing error types in Rust

thiserror[docs]
Helps with generating boilerplate for enum-style error types.

tracing[docs]
Tracing is now the go-to crate for logging.

log[docs]
An older and simpler crate if your needs are simple and you are not using any async code.

tracing[docs]
Tracing is now the go-to crate for logging.

slog[docs]
Structured logging

This functionality is now included in the standard library

once_cell[docs]
Newer crate with more ergonomic API. Has since been adopted into the std library

lazy_static[docs]
Older crate. API is less convenient, but crate is stable and maintained.

itertools[docs]
A bunch of useful methods on iterators that aren't in the stdlib

syn[docs]
Parse rust source code

quote[docs]
Quasi quoting rust (useful for interpolating generated code with literal code)

paste[docs]
Concatenating and manipulating identifiers

darling[docs]
Derive macro to easily parse derive macro inputs

bytemuck[docs]

zerocopy[docs]

bitflags[docs]
Strongly typed bitflag types

serde[docs]
De facto standard serialization library. Use in conjunction with sub-crates like `serde_json` for the specific format that you are using (JSON, YAML, etc). Supports a variety of both text and binary protocols, including self-describing ones.

prost[docs]
Protocol buffer library with strong ergonomics and wide industry adoption. Commonly used with gRPC / `tonic`. Use in conjunction with `protox` to avoid dependency on `protoc`.

capnp[docs]
Cap'n Proto library. Offers zero-copy usage mode that is optimal for large messages, along with other improvements over Protocol Buffers. Tradeoffs are less wide usage and less developer-friendly.

flatbuffers[docs]
Flatbuffers library. Also offers zero-copy usage and is more widely used than cap'n proto, with further cost to ergonomics.

postcard[docs]
no_std focused Serde serializer/deserializer, aimed at constrained environments.

rkyv[docs]
Fast zero-copy deserialization framework that allows arbitrary field types and safe zero-copy mutation.

memmap2[docs]
The older memmap crate is unmaintained.

libc[docs]
Bindings for directly calling libc functions.

windows[docs]
The official Microsoft-provided crate for interacting with windows APIs

winapi[docs]
Older binding to the windows APIs. Unofficial, but more complete than windows-rs

rustix[docs]
Efficient and safe POSIX / *nix / Winsock syscall-like APIs. It uses idiomatic Rust types: refs, slices, Results instead of raw pointers, safe wrappers around raw file descriptors, bitflags instead of bare integer flags, and several other conveniences.

nix[docs]
Bindings to the various *nix system functions. (Unix, Linux, MacOS, etc.)

rustup[docs]
Install, manage, and upgrade versions of rustc, cargo, clippy, rustfmt and more.

clippy[docs]
The official Rust linter.

cargo-semver-checks
Lint your crate releases for semantic versioning violations.

rustfmt[docs]
The official Rust code formatter.

cross[docs]
Seamless cross-compiling using Docker containers.

cargo-zigbuild
Easily cross-compile using Zig as the linker.

cargo-edit
Adds 'cargo upgrade' and 'cargo set-version' commands to cargo

cargo-outdated
Finds dependencies that have available updates

cargo-audit
Check dependencies for reported security vulnerabilities

cargo-license
Lists licenses of all dependencies

cargo-deny[docs]
Enforce policies on your code and dependencies.

cargo-nextest
Faster, better test runner

insta[docs]
Snapshot testing with inline snapshot support

criterion[docs]
Statistically accurate benchmarking tool for benchmarking libraries

divan[docs]
Simple yet powerful benchmarking library with allocation profiling

hyperfine
Tool for benchmarking compiled binaries (similar to unix time command but better)

cargo-flamegraph
Execution flamegraph generation

dhat[docs]
Heap memory profiling

cargo-show-asm[docs]
Print the generated assembly for a Rust function

Rust Analyzer also allows you to expand macros directly in your editor

cargo-expand
Allows you to inspect the code that macros expand to

cargo-release[docs]
Helper for publishing new crate versions.

Release-plz[docs]
Release Rust crates from CI with a Release PR.

rust-toolchain (github action)
Github action to install Rust components via rustup

rust-cache (github action)
Github action to cache compilation artifacts and speed up subsequent runs.

install-action (github action)
GitHub Action for installing development tools (mainly from GitHub Releases).

tokio[docs]
The oldest async runtime in the Rust ecosystem and still the most widely supported. Recommended for new projects.

futures-executor[docs]
A minimal executor. In particular, the block_on function is useful if you want to run an async function synchronously in codebase that is mostly synchronous.

smol[docs]
A small and modular async runtime. Since the implementation is modularized in smaller crates, you can directly use only the required crates instead of depending on the entire runtime.

futures[docs]
Utility functions for working with Futures and Streams

async-trait[docs]
Provides a workaround for the lack of language support for async functions in traits

glommio[docs]
Use if you need io_uring support. Still somewhat experimental but rapidly maturing.

http[docs]
The `http` crate doesn't actually contain an HTTP implementation. Just types and interfaces to help interoperability.

hyper[docs]
A low-level HTTP implementation (both client and server). Implements HTTP/1, and HTTP/2. Works best with the tokio async runtime, but can support other runtimes.

reqwest[docs]
Full-fat HTTP client. Can be used in both synchronous and asynchronous code. Requires tokio runtime.

ureq[docs]
Minimal synchronous HTTP client focussed on simplicity and minimising dependencies.

axum[docs]
A minimal and ergonomic framework. An official part of the tokio project. Recommend for most new projects.

actix-web[docs]
A performance focussed framework. All Rust frameworks are fast, but choose actix-web if you need the absolutely maximum performance.

async-graphql[docs]
A high-performance graphql server library that's fully specification compliant. Integrates with actix-web, axum, poem, rocket, tide, warp.

tungstenite[docs]
Low-level crate that others build on

tokio-tungstenite[docs]
If you are using the tokio executor

async-tungstenite[docs]
If you are using the async-std executor

tonic[docs]
gRPC over HTTP/2 with full support for asynchronous code. Works with tokio

sqlx[docs]
Works with Postgres, MySQL, SQLite, and MS SQL.
Supports compile time checking of queries. Async: supports both tokio and async-std.

diesel[docs]
Has excellent performance and takes an approach of strict compile time guarantees. The main crate is Sync only, but diesel-async provides an async connection implementation.

sea-orm[docs]
Built on top of sqlx (see above). There is also a related sea-query crate that provides a query builder without full ORM functionality.

tokio-postgres[docs]
Postgres-specific library. Performs better than SQLx

mysql_async[docs]
Has a poorly designed API. Prefer SQLx or Diesel for MySQL

rusqlite[docs]
Provides a sync API to SQLite + provides access to advanced sqlite features.

tiberius[docs]
MS SQL specific library. Has better support for advanced column types than SQLx.

diesel-oci[docs]
Diesel backend and connection implementation for oracle databases

oracle[docs]
Rust bindings to ODPI-C

sibyl[docs]
An OCI-based interface supporting both blocking (threads) and nonblocking (async) AP

redis[docs]

mongodb[docs]

elasticsearch[docs]

The rkv crate depends on the lmdb-rkv dependency which is archived and is inactive.

heed[docs]
A fully typed LMDB wrapper with minimum overhead.

rocksdb[docs]

cassandra-protocol[docs]
Low-level Cassandra protocol implementation.

cdrs-tokio[docs]
High-level async Cassandra driver.

deadpool[docs]
A dead simple async pool for connections and objects of any type.

clap[docs]
Ergonomic, battle-tested, includes the kitchen sink, and is fast at runtime. However compile times can be slow

lexopt[docs]
Fast compile times, fast runtime, pedantic about correctness. API is less ergonomic

pico-args[docs]
Fast compile times, fast runtime, more lax about correctness. API is more ergonomic

globset[docs]
High-performance globbing that allows multiple globs to be evaluated at once

walkdir[docs]
Basic recursive filesystem walking.

ignore[docs]
Recursive filesystem walking that respects ignore files (like .gitignore)

notify[docs]
Watch files or directories and execute a function when they change

dirs[docs]
Provide platform-specific locations for configuration, cache, and other data

directories[docs]
A higher-level library that can also compute paths for applications

termcolor[docs]
Cross-platform terminal colour output

indicatif[docs]
Progress bars and spinners

ratatui[docs]
A high-level TUI library with widgets, layout, etc.

crossterm[docs]
Low-level cross-platform terminal rendering and event handling

inquire[docs]
Ask for confirmation, selection, text input and more

parking_lot[docs]
std::sync::Mutex also works fine. But Parking Lot is faster.

arc-swap[docs]
Useful for sharing data that has many readers but few writers

See conc-map-bench for comparative benchmarks of concurrent HashMaps.

dashmap[docs]
The fastest for general purpose workloads

papaya[docs]
Particularly good for read-heavy workloads.

See communicating-between-sync-and-async-code for notes on when to use async-specific channels vs general purpose channels.

crossbeam-channel[docs]
The same channel algorithm as in the standard library but with a more powerful API, offering a Go-like 'select' feature.

flume[docs]
Smaller and simpler than crossbeam-channel and almost as fast

tokio[docs]
Tokio's sync module provides channels for using in async code

postage[docs]
Channels that integrate nicely with async code, with different options than Tokio

rayon[docs]
Convert sequential computation into parallel computation with one call - `par_iter` instead of `iter`

gtk4[docs]
Rust bindings to GTK4. These are quite well supported, although you'll often need to use the C documentation.

relm4[docs]
A higher-level library that sits on top of gtk4-rs

tauri[docs]
Electron-like web-based UI. Except it uses system webviews rather than shipping chromium, and non-UI code is written in Rust rather than node.js

dioxus[docs]
A very nice API layer that has Tauri, Web, and TUI renderers. A native renderer is coming soon.

egui[docs]
Immediate-mode UI. Lots of widgets. The most useable out of the box if your needs are simple and you don't need to customise of the look and feel

iced[docs]
Retained mode UI with a nice API. It's useable for basic apps, but has a number of missing features including multiple windows, layers, and proper text rendering.

floem[docs]
Inspired by Xilem, Leptos and rui, floem is currently more complete than any of them for native UI. Used by the Lapce text editor.

vizia[docs]
Fairly complete with sophisticated layout and text layout, but has yet to make a stable release.

winit[docs]
The defacto standard option. Uses an event loop based architecture. Widely used and should probably be the default choice.

tao[docs]
A fork of winit by the Tauri project which adds support for things like system menus that desktop apps need.

baseview
Specialized window creation library targetting windows to be embedded in other applications (e.g. DAW plugins)

femtovg[docs]
OpenGL based. Offers a simple API. Probably the easiest to get started with.

skia-safe[docs]
Bindings to the Skia C++ library. The most complete option with excellent performance. However, it can be difficult to get it to compile.

vello[docs]
WGPU based and uses cutting edge techniques to render vector paths using the GPU. Still somewhat immature and hasn't yet put out a stable release.

vger[docs]
A simpler WGPU based option which is less innovative but currently more stable than vello.

webrender[docs]
OpenGL based. Mature with production usage in Firefox but documentation and OSS maintenance are lacking.

taffy[docs]
Supports Flexbox and CSS Grid algorithms.

morphorm[docs]
Implements it's own layout algorithm based on Subform layout

cosmic-text[docs]
Full text layout including rich text and support for BiDi and non-latin scripts. The best option for now.

parley[docs]
Another very accomplished text layout library used by Druid/Xilem.

accesskit[docs]
Allows you to export a semantic tree representing your UI to make accessible to screen readers and other assistive technologies

arboard[docs]
A fork of rust-clipboard that supports copy and pasting of both text and images on Linux (X11/Wayland), MacOS and Windows.

rfd[docs]
Platform-native open/save file dialogs. Can be used in conjunction with other UI libraries.

bevy[docs]
An ECS based game engine, good for 3D but also capable of 2D.

fyrox[docs]
An OOP-focused game engine with 3D and 2D support and a full GUI scene editor.

ggez[docs]
A simpler option for 2d games only.

macroquad[docs]
A simple and easy to use 2d game library, great for beginners.

glam[docs]
Fast math library optimised for game development use cases