Cookin’ with Rust

This Rust Cookbook is a collection of simple recipes that demonstrate good practices to accomplish common programming tasks, using the crates of the Rust ecosystem.

Read more about Rust Cookbook, including tips for how to read the book, how to use the recipes, and notes on conventions.

Contributing

This project is intended to be easy for new Rust programmers to contribute to, and an easy way to get involved with the Rust community. It needs and welcomes help. For details see CONTRIBUTING.md.

Algorithms

Recipe	Crates	Categories
Generate random numbers	rand	Science
Generate random numbers within a range	rand rand_distr	Science
Generate random numbers with given distribution	rand rand_distr	Science
Generate random values of a custom type	rand	Science
Create random passwords from a set of alphanumeric characters	rand	OS
Create random passwords from a set of user-defined characters	rand	OS
Sort a Vector of Integers	std	Science
Sort a Vector of Floats	std	Science
Sort a Vector of Structs	std	Science

Asynchronous

Recipe	Crates	Categories
Tokio Runtime	tokio	Asynchronous
Tokio Runtime Builder	tokio	Asynchronous
Create Files Operations	tokio	Asynchronous
Read Files Operations	tokio	Asynchronous
Write Files Operations	tokio	Asynchronous
Remove Files Operations	tokio	Asynchronous
AsyncRead and AsyncWrite traits	tokio	Asynchronous
Bounded channels	tokio	Asynchronous
Unbounded channels	tokio	Asynchronous
First-to-complete	tokio	Asynchronous
Task Timeouts	tokio	Asynchronous
Join Sets	tokio	Asynchronous
Ctrl-C	tokio	Asynchronous
Macro	tokio	Asynchronous

Command Line

Recipe	Crates	Categories
Parse command line arguments	std	Command line
Clap Basic Argument Parsing	clap	Command line
Clap Derive	clap	Command line
Clap Subcommands	clap	Command line
Clap Arguments Validation	clap	Command line
ANSI Terminal	nu-ansi-term	Command line
Environment Variables	std	Command line
Load Config	std	Command line

Compression

Recipe	Crates	Categories
Decompress a tarball	flate2 tar	Compression
Compress a directory into a tarball	flate2 tar	Compression
Decompress a tarball while removing a prefix from the paths	flate2 tar	Compression
Decompress a gzip file	flate2	Compression
Compress a file with gzip	flate2	Compression
Decompress a bzip2 file	bzip2	Compression
Compress a file with bzip2	bzip2	Compression

Concurrency

Recipe	Crates	Categories
Spawn a short-lived thread	std	Concurrency
Create a parallel data pipeline	crossbeam	Concurrency
Pass data between two threads	crossbeam	Concurrency
Maintain global mutable state	std	Rust patterns
Calculate SHA256 sum of *.iso files concurrently	rayon walkdir ring	Concurrency Filesystem
Sum the size of every file in a directory	rayon walkdir	Concurrency Filesystem
Draw fractal dispatching work to a thread pool	rayon num image	Concurrency Science Rendering
Lock-free counter with `AtomicUsize`	std	Concurrency
Guard compound state with `Arc<Mutex<T>>`	std	Concurrency
Concurrent reads with `Arc<RwLock<T>>`	std	Concurrency
Communicate between threads with `mpsc` channels	std	Concurrency
Coordinate thread phases with `Barrier`	std	Concurrency
Signal a waiting thread with `Condvar`	std	Concurrency
Mutate the elements of an array in parallel	rayon	Concurrency
Test in parallel if any or all elements of a collection match a given predicate	rayon	Concurrency
Search items using given predicate in parallel	rayon	Concurrency
Sort a vector in parallel	rayon rand	Concurrency
Map-reduce in parallel	rayon	Concurrency
Generate jpg thumbnails in parallel	rayon glob image	Concurrency Filesystem
Actor Pattern with Tokio	tokio thiserror	Concurrency Rust patterns
Custom Future (Pin, Waker, Poll)	tokio	Concurrency Rust patterns

Configuration

Recipe	Crates	Categories
Layer defaults, a file, and environment variables	config serde	Config
Merge multiple providers with figment	figment serde	Config
Store per-user configuration with confy	confy serde	Config
Reload configuration when the file changes	config notify serde notify-debouncer-full	Config Filesystem

Cryptography

Recipe	Crates	Categories
Calculate the SHA-256 digest of a file	ring data-encoding	Cryptography
Sign and verify a message with an HMAC digest	ring	Cryptography
Salt and hash a password with PBKDF2	ring data-encoding	Cryptography

Data Structures

Recipe	Crates	Categories
Define and operate on a type represented as a bitfield	bitflags	no_std
Count word frequency in a document	std	Data structures
Group records by key	std	Data structures
Look up records within a time range	std	Data structures
Set operations with HashSet	std	Data structures
Use a custom type as a HashMap key	std	Data structures
Look up a tuple key without cloning	std	Data structures
Process tasks in priority order	std	Data structures
Sliding-window buffer with VecDeque	std	Data structures

Database

Recipe	Crates	Categories
Create a SQLite database	rusqlite	Database
Insert and Query data	rusqlite	Database
Create tables in a Postgres database	postgres	Database
Insert and Query data	postgres	Database
Aggregate data	postgres	Database
Connect to SQLite pool and simple query	sqlx tokio	Database
Connect to Pg Pool and query typed rows	sqlx tokio	Database
Compile-time checked queries	sqlx tokio	Database
Transactions in SQLx	sqlx tokio	Database
Simple ORM pattern	sea_orm tokio	Database
Using transactions	rusqlite	Database

Date and Time

Not sure which crate to use? See Choosing between chrono, time and jiff.

Recipe	Crates	Categories
Measure elapsed time	std	Time
Deadline arithmetic with Duration	std	Time
Convert SystemTime to UNIX timestamp	std	Time
Benchmark a closure with Instant	std	Time
Perform checked date and time calculations	chrono	Date and time
Convert a local time to another timezone	chrono	Date and time
Examine the date and time	chrono	Date and time
Convert date to UNIX timestamp and vice versa	chrono	Date and time
Display formatted date and time	chrono	Date and time
Parse string into DateTime struct	chrono	Date and time
Examine the current time with a time zone	jiff	Date and time
Parse and format a datetime with a time zone	jiff	Date and time
Perform calendar arithmetic with Span	jiff	Date and time
Examine the current time with a UTC offset	time	Date and time
Parse and format a datetime with format descriptions	time	Date and time
Perform checked date and time calculations with Duration	time	Date and time

Development Tools

Debugging

Recipe	Crates	Categories
Log a debug message to the console	log env_logger	Debugging
Log an error message to the console	log env_logger	Debugging
Log to stdout instead of stderr	log env_logger	Debugging
Log messages with a custom logger	log	Debugging
Log to the Unix syslog	log syslog	Debugging
Enable log levels per module	log env_logger	Debugging
Use a custom environment variable to set up logging	log env_logger	Debugging
Include timestamp in log messages	log env_logger chrono	Debugging
Log messages to a custom location	log log4rs	Debugging

Versioning

Recipe	Crates	Categories
Parse and increment a version string	semver	Config
Parse a complex version string	semver	Config
Check if given version is pre-release	semver	Config
Find the latest version satisfying given range	semver	Config
Check external command version for compatibility	semver	Text processing OS

Build Time

Recipe	Crates	Categories
Compile and link statically to a bundled C library	cc	Development tools
Compile and link statically to a bundled C++ library	cc	Development tools
Compile a C library while setting custom defines	cc	Development tools
Compile and link dynamically to a C++ shared library	std	Development tools
Compile and link statically to an external C library	cc	Development tools
Log messages to the console	tracing tracing-subscriber	Debugging

Encoding

Recipe	Crates	Categories
Percent-encode a string	percent-encoding	Encoding
Encode a string as application/x-www-form-urlencoded	url	Encoding
Encode and decode hex	data-encoding	Encoding
Generate OTP with a Base32 set	data-encoding rand	Encoding
Encode and decode base64	base64	Encoding
Read CSV records	csv serde	Encoding
Read CSV records with different delimiter	csv serde	Encoding
Filter CSV records matching a predicate	csv	Encoding
Handle invalid CSV data with Serde	csv serde	Encoding
Serialize records to CSV	csv	Encoding
Serialize records to CSV using Serde	csv serde	Encoding
Transform one column of a CSV file	csv serde	Encoding
Serialize and deserialize unstructured JSON	serde_json	Encoding
Deserialize a TOML configuration file	toml serde	Encoding
Read and write integers in little-endian byte order	std	Encoding
Access serialized data without deserializing it	rkyv	Encoding
Read an archive from a file	rkyv	Encoding

Error Handling

Recipe	Crates	Categories
Handle errors correctly in main	anyhow thiserror	Rust patterns
Transform an Option value	std	Rust patterns
Provide fallbacks for missing values	std	Rust patterns
Convert an Option to a Result	std	Rust patterns
Chain fallible operations with Result	std	Rust patterns
Collect an iterator of Results	std	Rust patterns

File System

Recipe	Crates	Categories
Read a whole file into a string	tempfile	Filesystem
Write a string to a file	tempfile	Filesystem
Read lines of strings from a file	std	Filesystem
Rename or atomically replace a file	tempfile	Filesystem
Create a temporary file	tempfile	Filesystem
Atomically replace a file with a temporary file	tempfile	Filesystem
Avoid writing and reading from a same file	same_file	Filesystem
Access a file randomly using a memory map	memmap2	Filesystem
Read a file line by line with BufReader	tempfile	Filesystem
Write to a file with BufWriter	tempfile	Filesystem
Read a line from stdin	std	Filesystem
Use Cursor as an in-memory buffer	std	Filesystem
Format text into a String with write!	std	Filesystem
Construct and inspect a path	std	Filesystem
Create a nested directory tree	tempfile	Filesystem
File names that have been modified in the last 24 hours	walkdir	Filesystem OS
Find loops for a given path	same_file walkdir	Filesystem
Recursively find duplicate file names	walkdir	Filesystem
Recursively find all files with given predicate	walkdir	Filesystem
Traverse directories while skipping dotfiles	walkdir	Filesystem
Recursively calculate file sizes at given depth	walkdir	Filesystem
Find all png files recursively	glob	Filesystem
Find all files with given pattern ignoring filename case	glob walkdir	Filesystem
Watch a directory for changes	notify	Filesystem
Debounce a burst of file events	notify-debouncer-full notify	Filesystem
Find a binary on the PATH	which	Filesystem

Hardware Support

Recipe	Crates	Categories
Check available parallelism	std	Hardware support
Check number of logical cpu cores	num_cpus	Hardware support

Memory Management

Recipe	Crates	Categories
Declare lazily evaluated constant	std	Caching Rust patterns
Std::cell	std	Caching Rust patterns
`std::cell:LazyCell`	std	Caching Rust patterns
`std::sync::LazyLock`	std	Caching Rust patterns
Store different types in one vector with `Box<dyn Trait>`	std	Rust patterns
Share mutable structure between owners with `Rc<RefCell<T>>`	std	Rust patterns
Return borrowed or owned text with `Cow<str>`	std	Rust patterns
Update text using `mem::swap`, `mem::take` and `mem::replace`	std	Rust patterns

Multimedia

Recipe	Crates	Categories
Resize and re-encode an image	image	Multimedia
Detect an image format from its bytes	image	Multimedia
Inspect image EXIF metadata	kamadak-exif	Multimedia
Decode audio samples from a file	symphonia	Multimedia
Play an audio file	rodio	Multimedia

Networking

Recipe	Crates	Categories
Listen on unused port TCP/IP	std	Net
TCP echo server	std	Net
TCP client	std	Net
TCP connect with a timeout	std	Net
Set a read timeout on a TCP stream	std	Net
Disable Nagle’s algorithm	std	Net
Half-close a TCP connection	std	Net
Non-blocking TCP accept	std	Net
Send and receive a UDP datagram	std	Net
Join a UDP multicast group	std	Net
Resolve a hostname to socket addresses	std	Net
Classify an IP address	std	Net
Bind for both IPv4 and IPv6	std	Net

Operating System

Recipe	Crates	Categories
Run an external command and process stdout	std	OS Text processing
Run an external command passing it stdin and check for an error code	std	OS Text processing
Run piped external commands	std	OS
Redirect both stdout and stderr of child process to the same file	std	OS
Continuously process child process’ outputs	std	OS Text processing
Read environment variable	std	OS

Parsing

Recipe	Crates	Categories
Parse tagged fields from a log line	nom	Parser implementations
Decode a hex color	nom	Parser implementations
Parse an unstructured string into key value pairs	winnow	Parser implementations
Read CSV data with a parsing expression grammar	pest pest_derive	Parser implementations

Science

science/mathematics

Recipe	Crates	Categories
Vector Norm	ndarray	Science
Adding matrices	ndarray	Science
Multiplying matrices	ndarray	Science
Multiply a scalar with a vector with a matrix	ndarray	Science
Invert matrix	nalgebra	Science
Calculating the side length of a triangle	std	Science
Verifying tan is equal to sin divided by cos	std	Science
Distance between two points on the Earth	std	Science
Creating complex numbers	num	Science
Adding complex numbers	num	Science
Mathematical functions on complex numbers	num	Science
Measures of central tendency	std	Science
Computing standard deviation	std	Science
Big integers	num	Science
(De)-Serialize a Matrix	nalgebra serde_json	Science
Vector comparison	ndarray	Science

Text Processing

Recipe	Crates	Categories
Collect Unicode Graphemes	unicode-segmentation	Encoding
Verify and extract login from an email address	regex	Text processing
Extract a list of unique #Hashtags from a text	regex	Text processing
Extract phone numbers from text	regex	Text processing
Filter a log file by matching multiple regular expressions	regex	Text processing
Replace all occurrences of one text pattern with another pattern.	regex	Text processing
Implement the `FromStr` trait for a custom `struct`	std	Text processing
Implement Debug, Display, and Hash for a custom type	std	Text processing

WebAssembly

wasmtime is an embeddable WebAssembly runtime. These recipes cover the host embedding API — loading modules, calling exports, sharing linear memory, and wiring up host-defined functions that guests can call back into.

The recipes live outside the main workspace because wasmtime is a large dependency not used elsewhere. Run them with cargo run --manifest-path crates/wasm/Cargo.toml --bin <name>.

Embedding wasmtime

Recipe	Crates	Categories
Call an exported WebAssembly function	wasmtime	WebAssembly
Exchange data via WebAssembly linear memory	wasmtime	WebAssembly
Define host functions for WebAssembly	wasmtime	WebAssembly
Component Model — typed strings and structs	wasmtime wasmtime-wasi wit-bindgen	WebAssembly

Web Programming

Scraping Web Pages

Recipe	Crates	Categories
Extract all links from a webpage HTML	reqwest scraper tokio thiserror	Net
Check webpage for broken links	reqwest scraper url tokio thiserror	Net
Extract all unique links from a MediaWiki markup	reqwest regex tokio	Net

Uniform Resource Locations (URL)

Recipe	Crates	Categories
Parse a URL from a string to a `Url` type	url	Net
Create a base URL by removing path segments	url	Net
Create new URLs from a base URL	url	Net
Extract the URL origin (scheme / host / port)	url	Net
Remove fragment identifiers and query pairs from a URL	url	Net

Media Types (MIME)

Recipe	Crates	Categories
Get MIME type from string	mime	Encoding
Get MIME type from filename	mime	Encoding
Parse the MIME type of a HTTP response	mime reqwest tokio	Net Encoding

Clients

Recipe	Crates	Categories
Make a HTTP GET request	reqwest	Net
Set custom headers and URL parameters for a REST request	reqwest serde	Net
Query the GitHub API	reqwest serde	Net Encoding
Check if an API resource exists	reqwest	Net
Create and delete Gist with GitHub API	reqwest serde serde_json	Net Encoding
Consume a paginated RESTful API	reqwest serde	Net Encoding
Download a file to a temporary directory	reqwest tempfile	Net Filesystem
Make a partial download with HTTP range headers	reqwest	Net
POST a file to paste-rs	reqwest	Net

Web Authentication

Recipe	Crates	Categories
Basic Authentication	reqwest	Net

Full Stack Web

Recipe	Crates	Categories
Return filtered results as HTML	leptos leptos_router leptos_axum axum tokio	Net
Synchronize component state with the server	leptos leptos_axum axum tokio wasm-bindgen tower-http console_error_panic_hook	Net

Keyboard shortcuts

Rust Cookbook