Blessed

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.

See here for supported formats.

serde [docs]
De facto standard serialization library. Use in conjunction with sub-crates like serde_json for the specific format that you are using.

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 need 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

once_cell [docs]
Newer crate with more ergonomic API. On track to be incorporated into the standard library. Should be preferred for all new projects.

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

bytemuck [docs]

bitflags [docs]
Strongly typed bitflag types

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

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

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.

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

redis [docs]

mongodb [docs]

elasticsearch [docs]

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
High-performance globbing that allows multiple globs to be evaluated at once

walkdir
Basic recursive filesystem walking.

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

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

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

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

flurry [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 absolute fastest channel implementation available. Implements 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.

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.

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

slint [docs]
Possibly the most complete rust-native UI library. But note that it's dual GPL3/commercial licensed.

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.

glazier
A new competitor to winit based on the old druid-shell. Has a callback that may be better than the event loop architecture for some tasks. Doesn't yet have a stable release.

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

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

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

vello
Pure Rust, and uses cutting edge techniques to render using the GPU. Still somewhat immature and hasn't yet put out a stable release.

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
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

Both cli-clipboard and copypasta are forks of the original rust-clipboard that add support for wayland.

cli-clipboard [docs]

copypasta [docs]

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

Bevy is the clear winner for complex games (and especially 3D games). For those wanting something simpler, both ggez and macroquad are good options

bevy [docs]
By far the most developed Rust game engine. It's still early, but already impressive and very much useable.

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