Crate List - Blessed.rs

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

uuid
Implements generating and parsing UUIDs and a number of utility functions

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

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

fancy_regex
Use if need features such as backtracking which regex doesn't support

tempfile
Supports both temporary files and temporary directories

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

time
The original datetime crate which was split out of std pre-rust-1.0. Preferrable if covers your needs, but it's quite limited in what it provides.

chrono
The most comphrehensive and full-featured datetime library, but more complex because of it.

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

arrayvec
Arrays that are ONLY stack-allocated with fixed capacity

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

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

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

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

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

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

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

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

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

slog
Structured logging

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

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

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

num
Traits like Number, Add, etc that allow you write functions that are generic over the specific numeric type

byteorder
Utility functions to convert between different endianness or read/write data with a specific endianness

bitflags
Strongly typed bitflag types

memmap2
The older memmap crate is unmaintained.

libc
Bindings for directly calling libc functions.

windows
The official Microsoft-provided crate for interacting with windows APIs

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

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

async-std
A newer option that is very similar to tokio. Its API more closely mirrors the std library, but it doesn't have as much traction as Tokio.

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

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

hyper
A low-level HTTP implementation (both client and server). Implements HTTP 1, 2, and 3. Requires the tokio async runtime.

rustls
A portable pure-rust implementation of TLS

rust-native-tls
Delegates to the system TLS implementations on windows and macOS, and uses OpenSSL on linux.

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

surf
Client that uses the async-std runtime rather than the tokio runtime.

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

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

tide
Similar to Axum, but based on async-std rather than tokio

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

poem
Automatically generates OpenAPI defintions.

warp
Very similar to axum but with a quirkier API. This is a solid framework, but you should probably prefer Axum unless you particular like the API

rocket
Focussed on ergonomics. This is a solid framework, however development has stalled. Avoid for new projects.

tungstenite-rs
Low-level crate that others build on

tokio-tungstenite
If you are using the tokio executor

async-tungstenite
If you are using the async-std executor

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

clap
Ergonomic, supports everything, and is fast at runtime. However compile times can be slow

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

pico-args
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)

watchexec
Watch files or directories and execute a function when they change

termcolor
Cross-platform terminal colour output

crossterm
Cross-platform terminal rendering and event handling

parking_lot
std::mutex also works fine. But Parking Lot is faster.

arc_swap
Useful for sharing data that has many readers but few writers

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

dashmap
The fastest for general purpose workloads

flurry
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
The absolute fastest channel implementation available. Implements Go-like 'select' feature.

flume
Smaller and simpler than crossbeam_channel and almost as fast

postage
Channels that integrate nicely with async code

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