What is Rustmax?

Rustmax is a collection of crates, tools, and documentation for the Rust programming language.

Rust is a modern systems programming language that is extremely fast and does not crash. It is suitable for development of high-performance, low-level software as in operating systems, databases, and distributed systems; as well as command-line, web, mobile, embedded, and application development.

Rustmax is a comprehensive guide to the Rust ecosystem for new and old Rust programmers, including a "batteries-included" supercrate of selected high-quality Rust libraries: rustmax.

Rust mastery awaits

Step 1: Install Rust with rustup.
Step 2: Learn Rust from The Rustmax Library.
Step 3: Build programs with Rust crates.
Step 4: Maintain programs with Rust tools.

Easy Mode Rust

Install Rust with `rustup`

Rust is installed with the rustup tool.

On Linux, Mac OS, and Unixes, run the following in your shell then follow the onscreen instructions:

curl -sSf https://sh.rustup.rs | sh

For Windows and other install see https://rustup.rs.

Rust workspace considerations

Start a new `rustmax` project with `cargo-generate`

This will create a cargo workspace with two crates, one a library, one a CLI, with a dependency on the rustmax crate.

$ cargo generate brson/rustmax
⚠️   Favorite `brson/rustmax` not found in config, using it as a git repository: https://github.com/brson/rustmax.git
🤷   Project Name: datalang
🔧   Destination: /home/brian/.homes/dev/megaspace/datalang ...
🔧   project-name: datalang ...
🔧   Generating template ...
[ 1/11]   Done: .gitignore
[ 2/11]   Done: Cargo.toml.liquid
[ 3/11]   Done: crates/datalang/Cargo.toml.liquid
[ 4/11]   Done: crates/datalang/src/lib.rs
[ 5/11]   Done: crates/datalang/src
[ 6/11]   Done: crates/datalang
[ 7/11]   Done: crates/datalang-cli/Cargo.toml.liquid
[ 8/11]   Done: crates/datalang-cli/src/main.rs
[ 9/11]   Done: crates/datalang-cli/src
[10/11]   Done: crates/datalang-cli
[11/11]   Done: crates
     Moving generated files into: `/home/brian/.homes/dev/megaspace/datalang`...
🔧   Initializing a fresh Git repository
✨   Done! New project created /home/brian/.homes/dev/megaspace/datalang

Updating dependencies in lockfile

cargo update

Updating dependencies in Cargo.toml

cargo upgrade

With no extra arguments cargo upgrade modifies Cargo.toml files such that the dependencies are set to their latest compatible versions. In this way it similar to cargo update but for manifests instead of lockfiles.

todo This command is from the cargo-edit package.

Upgrading dependencies across minor versions in Cargo.toml

cargo upgrade --incompatible

topics

anyhow, thiserror

Rustmax: Crates

Rustmax: Tools

Standard Rust tools: cargo rustc rustup rustdoc rustfmt clippy just mdbook bindgen miri
Cargo plugins: cargo-edit cargo-clean-all cargo-deny cargo-license cargo-audit cargo-generate
More Rust tools: clippy-control
Non-Rust tools for Rust: mold
More general developer tools: ripgrep tokei basic-http-server gist jaq jsonxf fd sd dust

Standard Rust tools

🌞 `cargo`

The Rust build and packaging tool. It is the central tool in most Rust development workflows. It is part of every Rust toolchain, usually managed by rustup.

🌞 `rustc`

The Rust compiler. It is usually invoked through cargo.

🌞 `rustup`

The Rust toolchain installer and version manager.

🌞 `rustfmt`

A tool for formatting Rust code. Included with Rust toolchains.

rustup component add rustfmt

🌞 `clippy`

A collection of lints to catch common mistakes and improve your Rust code.

rustup component add clippy

🌞 `rustdoc`

The Rust documentation generator. Usually invoked through cargo doc.

🌞 `mdbook`

A utility to create modern online books from Markdown files.

cargo install mdbook

🌞 `bindgen`

Automatically generates Rust FFI bindings to C libraries.

cargo install bindgen-cli

🌞 `miri`

An interpreter for Rust's mid-level intermediate representation. Useful for detecting undefined behavior.

rustup component add miri

Cargo plugins

🌞 `cargo-edit`

Extra cargo subcommands for editing Cargo.toml.

cargo install cargo-edit

Installing cargo-edit provides two cargo subcommands:

cargo add was once provided by cargo-edit but since Rust 1.62.0 is built into cargo itself.

🌞 `cargo-clean-all`

Recursively clean all Cargo projects in a directory tree.

cargo install cargo-clean-all

🌞 `cargo-deny`

Cargo plugin for linting your dependencies. Checks for security vulnerabilities, licenses, and more.

cargo install cargo-deny

🌞 `cargo-license`

Displays the license of dependencies.

cargo install cargo-license

🌞 `cargo-audit`

Audit Cargo.lock files for known security vulnerabilities.

cargo install cargo-audit

🌞 `cargo-generate`

Generate a new Rust project from a template.

cargo install cargo-generate

More Rust tools

🌞 `clippy-control`

Temporarily allow/deny clippy lints from the command line.

cargo install clippy-control

Non-Rust tools for Rust

🌞 `mold`

A high-performance linker that significantly speeds up Rust builds on Linux.

rustmax install-tool mold

Linking is one of the most time-consuming stages of a Rust build, and it has to be redone every time you test your program. On Linux the mold linker is faster than the default linker.

Setting up mold manually requires configuring .cargo/config.toml and ensuring the linker is properly installed, but the Rustmax CLI tool handles this setup automatically.

More general developer tools

🌞 `ripgrep`

A line-oriented search tool that recursively searches your current directory for a regex pattern. Faster than grep and respects gitignore.

Documented in the legendary blog post, "ripgrep is faster than ...".

cargo install ripgrep

🌞 `just`

A simple and suprisingly useful command runner with make-like syntax.

cargo install just

Almost every project has a handful of commands the developer(s) uses frequently. Put these in a justfile so the menu of commands for this project is always obvious, which can be extra helpful after years away from a project.

just runs commands listed in a file named justfile. The justfile lives your project's root directory, and is configured with a make-like syntax:

default:
    just --list

install-tools:
    cargo install mdbook
    cargo install mdbook-yapp

clean: doc-clean
    cargo clean

doc-clean:
    rm -rf out

It's a simple idea, but suprisingly useful. And don't worry that it looks like a Makefile — it is much more fun and sensible in use than make.

When you come back to a project and see there's a justfile you know to run just --list and you'll immediately see what was on the previous maintainer's mind.

$ just --list
Available recipes:
    build
    check
    clean
    default
    doc-book
    doc-build
    doc-clean
    doc-crates
    install-tools
    lint
    maint-audit
    maint-duplicates
    maint-lock-minimum-versions # useful prior to running `cargo audit`
    maint-outdated
    maint-upgrade
    prebuild
    publish
    publish-dry
    replace-version old new
    test
    test-min-version-build

$ just build
   Compiling rustmax-cli v0.0.5 (…/rustmax/crates/rustmax-cli)
   …

🌞 `tokei`

A program for counting lines of code quickly.

cargo install tokei

🌞 `basic-http-server`

A simple HTTP server for serving static files.

cargo install basic-http-server

🌞 `gist`

Upload code to GitHub Gist from the command line.

cargo install gist

🌞 `jaq`

A jq clone focused on correctness, speed, and simplicity.

cargo install jaq

🌞 `jsonxf`

A JSON transformer and formatter.

cargo install jsonxf

🌞 `fd`

Find files recursively. A simple, fast and user-friendly alternative to 'find'. Pair with sd to search and replace.

cargo install fd-find

🌞 `sd`

Intuitive find & replace CLI, sed alternative, pair with fd.

cargo install sd

🌞 `dust`

Show disk usage. A more intuitive version of du.

cargo install du-dust

The Rustmax Library

The Rust language and its ecosystem is documented in "books" (rendered with mdbook), and most of these links are to books.

Links with a bookmark icon, 🔖, are to particularly notable or useful chapters within a book.

The Rust language

The Rust Programming Language (upstream)
Rust By Example
The Rust Reference (upstream)
- 🔖 Conditional compilation. Including which cfgs are set by rustc.
- 🔖 Behavior considered undefined
The Rustonomicon (upstream)
The Rust Edition Guide (upstream)
The Little Book of Rust Macros
Rust API Guidelines (upstream)
Rust Unsafe Code Guidelines (upstream)
Rust Error Codes Index
The Rust Unstable Book
The Rust Style Guide
Rust Release Notes

The Rust standard library

std
- 🔖 std::collections
- 🔖 std::error
- 🔖 std::ptr. Safety, undefined behavior, and "provenance".
- 🔖 std::sync
- 🔖 std::sync::atomic
core
alloc
proc_macro

Standard Rust tools

The Cargo Book (upstream)
- 🔖 The manifest format
- 🔖 Environment variables that affect the Cargo build process.
- 🔖 Configuration format. Cargo has many interesting configuration options.
- 🔖 SemVer compatibility. Guidelines for maintaining semver compatibility.
The rustc Book (upstream)
- 🔖 The lint system and built-in lints
- 🔖 Rust platform support tiers
The rustup Book
The rustdoc Book (upstream)
rustfmt (todo)
The clippy Book
The just Programmer's Manual
The mdBook Book (upstream)
The bindgen User Guide (upstream)
miri (todo)

The Rust crate ecosystem

Domain-specific Rust

The Embedded Rust Book (upstream)

The Rust Project internals

The Rustmax CLI

To install:

cargo install rustmax-cli --locked

The Rustmax CLI provides a number of small tools that help manage a Rust development environment, Rust tools, and Rust projects.

Print Rust sytem status
Install the mold linker
Install all Rustmax tools
Create a Rustmax project from template
Build the Rustmax documentation
Run all lint-style checks
Emit opinionated rustfmt.toml
Emit opinionated deny.toml
Emit opinionated clippy-control.toml

Print Rust system status

Rustmax understands your rustup toolchain status, Rustmax tools installed via cargo, and other tools like the mold linker.

$ rustmax status
... todo ...

Assert `Send` / `Sync`

struct DbPathGen(());

const _ASSERT_SEND_SYNC: () = assert_send_sync::<DbPathGen>();
const fn assert_send_sync<T: Send + Sync>() { }

Also in rustmax::extras::assert_send_sync.

Copy a directory recursively

There's no standard way to recursively copy a dir!

Here take this:

    pub fn copy_dir_recursive(
        src: &std::path::Path,
        dst: &std::path::Path,
    ) -> std::io::Result<()> {
        std::fs::create_dir_all(dst)?;

        for entry in std::fs::read_dir(src)? {
            let entry = entry?;
            let file_type = entry.file_type()?;
            let src_path = entry.path();
            let dst_path = dst.join(entry.file_name());

            if file_type.is_dir() {
                copy_dir_recursive(&src_path, &dst_path)?;
            } else {
                std::fs::copy(&src_path, &dst_path)?;
            }
        }

        Ok(())
    }

It's also at rustmax::extras::copy_dir_recursive.

Now doing it in a way that is mindful of the infinite curveballs different OSes will throw at you via the filesystem … well that's probably why std doesn't try.

There's an `Either` hiding in the `futures` crate!

The Either type, most known from Haskell, is a useful reusable abstraction for the common need to create a lightweight type that is a named union of two other types, typically looks like:

enum Either<A, B> {
  Left(A),
  Right(B),
}

Rust doesn't provide this type because it instead provides Result, which is the most common use-case for the pattern, and the remaining use-cases seem marginal for such a simple type - official guidelines encouraging writing your own Either type for specific uses, with more specific names.

Sometimes you want one though!

There's one in the futures crate: futures::future::Either.

Although Either is a Future and provided for awaiting pairs of futures, its definition is exactly as above.

Import traits with `as _`

Most of the time we need traits to call a method, and for this we need the trait to be in scope, but it doesn't need to be namable.

#![allow(unused)]
fn main() {
use std::io::{self, Seek as _};

let hash = read_hash(&mut reader)?;
reader.seek(io::SeekFrom::Start(0))?;
}

Set up the `mold` linker

Linking is one of the most time-consuming stages of a Rust build, and it has to be redone every time you test your program.

On Linux the mold linker is faster than the the default linker. Setting it up manually is not difficult, but just hard enough that I have to look it up every time.

The Rustmax CLI tool can do it instead:

rustmax install-tool mold

Use `rustfmt::skip`

Sometimes exact formatting is important to make code beautiful. Don't be afraid annotate with #[rustfmt::skip].

Use `Option` with `?`

The ? operator works with Option to early-return on None, making option-heavy code much cleaner.

#![allow(unused)]
fn main() {
fn find_user_email(id: u32) -> Option<String> {
    let user = database.find_user(id)?;  // Return None if user not found
    let profile = user.get_profile()?;   // Return None if no profile
    let email = profile.email?;          // Return None if no email
    Some(email)
}
}

An alternative to match or if let statements, ? lets you chain operations that might fail, automatically propagating None up the call stack.

Put common development commands in a `justfile`

just runs commands listed in a file named justfile. The justfile lives your project's root directory, and is configured with a make-like syntax:

default:
    just --list

install-tools:
    cargo install mdbook
    cargo install mdbook-yapp

clean: doc-clean
    cargo clean

doc-clean:
    rm -rf out

It's a simple idea, but suprisingly useful. And don't worry that it looks like a Makefile — it is much more fun and sensible in use than make.

When you come back to a project and see there's a justfile you know to run just --list and you'll immediately see what was on the previous maintainer's mind.

$ just --list
Available recipes:
    build
    check
    clean
    default
    doc-book
    doc-build
    doc-clean
    doc-crates
    install-tools
    lint
    maint-audit
    maint-duplicates
    maint-lock-minimum-versions # useful prior to running `cargo audit`
    maint-outdated
    maint-upgrade
    prebuild
    publish
    publish-dry
    replace-version old new
    test
    test-min-version-build

Merge message streams with `futures::stream::select`

An async event loop often needs to receive messages from multiple sources. Use futures::stream::select to merge two streams of the same type into one.

A common pattern: an event loop that handles both external messages and internally-generated events (like async task completions):

#![allow(unused)]
fn main() {
use futures::channel::mpsc;
use futures::stream::StreamExt;

async fn run_event_loop(
    mut rx_external: mpsc::Receiver<Msg>,
) {
    // Create channel for loop to send messages to itself.
    let (tx_self, rx_self) = mpsc::channel::<Msg>(10);

    // Merge both streams.
    let mut rx_combined = futures::stream::select(rx_external, rx_self);

    while let Some(msg) = rx_combined.next().await {
        match msg {
            Msg::StartTask => {
                // Spawn async task that reports completion.
                let mut tx_self = tx_self.clone();
                tokio::spawn(async move {
                    do_work().await;
                    tx_self.send(Msg::TaskComplete).await.ok();
                });
            }
            Msg::TaskComplete => {
                // Handle completion sent from spawned task.
            }
        }
    }
}
}

Rust CLI One Liners

Find all Rust files

fd -e rs

Replace text in all Rust files

fd -e rs -x sd "before_regex" "after"

Delete trailing newlines in all Python and Rust files

fd -e py -e rs . src/testing/python_driver/ -x sd "\s+$" "\n"

The Rust Standard Library Revisited

The Rust Standard Library contains many important tools. Much of its documentation is excellent, but some, including the Tour of the Rust Standard Library, has bitrotted.

API docs

Rust standard library classics

Some of the Rust standard library documentation is excellent, with good overviews of systems programming topics generally.

A (New) Tour of the Rust standard library

todo

The Rust Ecosystem

Rust resources

Error handling - `anyhow` and `thiserror`

Serialization - `serde`

Command line handling - `clap`

Derive all the things

Logging - `log` and `env_logger`

crate::env_logger::Builder::new()
    .filter_level(log::LevelFilter::Info)
    .parse_default_env()
    .init();

Async I/O - `tokio`

Managing Rust toolchains

Procedural macros

Rust build scripts

todo topics

cargo add
cargo update
cargo upgrade
lockfiles

How Do I … in Rust?

Discovery

… find a crate for a given purpose?

… find the latest version of a crate?

Project organization

… init a Rustmax project from template?

cargo generate brson/rustmax

… organize a Rust workspace?

Conveniences

… define "extension" methods on a type in another crate?

… guarantee a trait is object-safe?

static_assertions::assert_obj_safe!(MyTrait);

Error handling and debugging

… handle errors simply and correctly?

… structure errors in a public API?

… set up basic logging?

Collections

… create a fast `HashMap`?

… convert from slices to fixed-length arrays?

… Implement an `impl Iterator` with `todo!`?

  fn merge_create_accounts_results(                      
      accounts: &[tb::Account],
      results: Vec<tb::CreateAccountsResult>,
  ) -> impl Iterator<Item = (u128, Option<tb::Account>)> + use<'_> {
      todo!(); // optional
      std::iter::empty() // satisfies the type checker
  }

Numerics

… convert between numeric types ideomatically?

… perform math ideomatically?

… convert between ints and bytes?

… perform typical byte order conversions?

Since Rust 1.32, all integer types have built-in methods for byte order conversion:

#![allow(unused)]
fn main() {
// Convert integers to bytes
let x: u32 = 0x12345678;
let be_bytes = x.to_be_bytes(); // big-endian: [0x12, 0x34, 0x56, 0x78]
let le_bytes = x.to_le_bytes(); // little-endian: [0x78, 0x56, 0x34, 0x12]
let ne_bytes = x.to_ne_bytes(); // native-endian (platform-dependent)

// Convert bytes back to integers
let y = u32::from_be_bytes([0x12, 0x34, 0x56, 0x78]); // 0x12345678
let z = u32::from_le_bytes([0x78, 0x56, 0x34, 0x12]); // 0x12345678
}

These methods work on all integer types: u8, u16, u32, u64, u128, usize, and their signed equivalents.

Encoding, serialization, parsing

… serialize to and from JSON?

… decide what format to use with `serde`?

Time

… parse and render standard time formats?

Random numbers

… generate a strong random anything?

Use rand::random for convenience when you need cryptographically secure randomness without managing state.

#![allow(unused)]
fn main() {
let x: u32 = rand::random();
let y: f64 = rand::random(); // 0.0..1.0
}

… generate a strong random number from a seed?

Use rand::rngs::StdRng when you need reproducible cryptographically secure randomness. This uses the platform's secure RNG algorithm.

#![allow(unused)]
fn main() {
use rand::{Rng, SeedableRng};
let mut rng = rand::rngs::StdRng::seed_from_u64(42);
let x: u32 = rng.gen();
}

… generate a fast random number from a seed?

Use rand::rngs::SmallRng for performance-critical code where cryptographic security isn't required. This automatically selects a fast algorithm.

#![allow(unused)]
fn main() {
use rand::{Rng, SeedableRng};
let mut rng = rand::rngs::SmallRng::seed_from_u64(42);
let x: u32 = rng.gen();
}

… generate a strong random number from a seed with stable algorithm?

Use rand_chacha::ChaCha12Rng when you need reproducible results across Rust versions and platforms with cryptographic security.

#![allow(unused)]
fn main() {
use rand::{Rng, SeedableRng};
let mut rng = rand_chacha::ChaCha12Rng::seed_from_u64(42);
let x: u32 = rng.gen();
}

… generate a fast random number from a seed with stable algorithm?

Use rand_pcg::Pcg64 for deterministic, fast random numbers that remain consistent across platforms and Rust versions.

#![allow(unused)]
fn main() {
use rand::{Rng, SeedableRng};
let mut rng = rand_pcg::Pcg64::seed_from_u64(42);
let x: u32 = rng.gen();
}

Cryptography

… calculate a cryptographic content hash?

Parallelism and Concurrency

… initialize a global value?

todo LazyLock, OnceLock, and Once.

… send messages to/from async code?

todo futures::channels

… use a thread pool?

Use rayon::ThreadPool.

Although it has additional rayon features, it can be used as a basic thread pool.

todo example

Asynchronous I/O

… set up the `tokio` event loop?

… stub an unwritten `async fn`?

Networking and web

… make a synchronous HTTP request?

… configure a basic HTTP server?

Text / unicode

Terminal / CLI

… set up a simple CLI parser with subcommands?

… display colors in the terminal?

… read line-based input from the terminal?

… handle ctrl-?

Either use the [ctrl] crate or [tokio::signal::ctrlc].

todo say more w/ example

System / OS

… read environment variables?

… work with a temporary file?

… work with multiple files in a temporary directory?

Testing

… create a custom test harness?

… create a custom table-based test harness?

Build scripts

… write build scripts ideomatically?

… link to a native static library?

… compile and link a C source file?

FFI / interop

… create Rust bindings to a C/C++ program?

Procedural macros

`let else`

topics

justfiles
time - jiff vs chrono vs time
xtask and xshell
project organization
extension_trait
global initialization - lazy_static vs once_cell vs std
- lazy_static -> LazyLock
- lazy_static can be used with a spin lock
- OnceLock is in std
error handling
ideomatic casting
ideomatic math

The Rustmax Radar

This is where we collect crates and tools of interest, but that are not yet part of Rustmax.

Crates

backtrace-on-stack-overflow. Nice missing feature, but code looks underdeveloped.
bitvec. Operate directly on bits.
borsh. Fast and stable binary serialization.
boringtun. WireGuard.
comrak. Markdown parser.
cpal. Cross-platform audio I/O.
console, dialoguer, and indicatif. Pretty terminals.
criterion. Advanced benchmarking.
dashmap. Concurrent hash map.
datatest-stable Data-driven tests.
dotenv.
derive-new Derive the new function.
ena. The union find algorithm.
encoding, charset, codepage, oem_cp, icu_normalizer, detone. Text encoding.
enum-iterator. Iterate over variants.
eyre. Sophisticated error handling.
flate2.
fnv or some other non-ahash fast hash
hashbrown. Hash maps with no-std.
home
ignore. Like walkdir but obeys .gitignore.
include_dir.
indexmap
libm. Useful for no-std.
memchr
memmap
ndarray
nix
notify. File system notification.
num.
num-traits
ordered-float
parking_lot Non-poisoning mutexes, etc.
petgraph
ratatui. Seriously cool CLIs.
rangetools
rodio. Cross-platform audio playback.
rustls. TLS.
rustversion
rust-embed. Embedding of file system resources into binaries, with hot-reloading during development.
scopeguard. Like defer.
smallvec. The "small vector" optimization. There may be better / newer options.
sqlx.
tar.
tungstenite. WebSockets.
stacker. Manually-growable call stacks.
time. Another time crate.
tracing.
tracing-subscriber.
tracing-tracy.
unicode-xid.
xdg

Tools

Wanted

SHA3
gRPC
wasm crates and tools, wasm-bindgen, stdweb
threadpool
zip, gzip
parser generator (pest?)
alternative to bitflags
gui stuff
- winit, wgpu vs glow, morphorm, css, iced vs egui
i18n
QUIC - either quinn or quiche
HTTP3
markdown
csv
small string, smartstring
rational numbers
fixed-point, decimal numbers, rust-decimal

Replacements

num_cpu -> std::thread::available_parallelism

Graveyard

These projects were once useful or notable, but are now deprecated by others.

lazy_static. Use std::sync::LazyLock.
once_cell. Use std::sync::OnceLock.

Trusted Maintainers

The Rust ecosystem is built by thousands of contributors, but certain individuals and organizations have established exceptional reputations for creating and maintaining high-quality, widely-trusted libraries.

For new Rustaceans, understanding who maintains the crates you depend on can help you make informed decisions about which libraries to use in your projects.

David Tolnay

GitHub: dtolnay

Prolific Rust library author and maintainer. Core contributor to the Rust compiler and tooling.

Notable crates:

serde — The standard serialization framework
syn — Parser for Rust source code, essential for proc macros
quote — Code generation for proc macros
thiserror — Derive macro for error types
anyhow — Flexible error handling for applications
proc-macro2 — Wrapper around proc_macro for better ergonomics

David's crates are characterized by exceptional documentation, thoughtful API design, and comprehensive testing.

Andrew Gallant (BurntSushi)

GitHub: BurntSushi

Creator of ripgrep and author of numerous widely-used libraries.

Notable crates:

regex — Fast, Unicode-aware regular expressions
walkdir — Recursive directory traversal
jiff — Modern date and time library
csv — Fast CSV parser

Andrew's libraries are known for their performance, correctness, and extensive documentation. His blog posts often provide deep insights into Rust performance optimization.

Alex Crichton

GitHub: alexcrichton

Former Rust core team member and prolific contributor to foundational crates.

Notable crates:

toml — TOML parser
wasm-bindgen — Facilitating WebAssembly and JavaScript interop
Many foundational async and FFI crates in the ecosystem

Alex's contributions span compiler internals, tooling, and critical ecosystem infrastructure.

Sean McArthur

GitHub: seanmonstar

Creator and maintainer of core HTTP ecosystem libraries. Member of the Tokio team.

Notable crates:

hyper — Low-level HTTP library
reqwest — High-level HTTP client
tower — Service abstractions for building robust clients and servers

Sean's HTTP libraries form the foundation of most HTTP and web applications in Rust.

Ulrik Sverdrup (bluss)

GitHub: bluss

Author and maintainer of itertools and other iterator-focused utility crates.

Notable crates:

itertools — Extra iterator adaptors and methods

Servo Project

GitHub: servo

The Servo browser engine project, maintaining web-platform crates.

Notable crates:

url — URL parser
Many other web platform implementation crates

Aleksey Kladov

GitHub: matklad

Creator of rust-analyzer. Former Rust core team member.

Notable crates:

xshell — Ergonomic shell scripting in Rust

The Rust Project

GitHub: rust-lang

The official Rust project organization.

Maintains the Rust compiler, standard library, and core tooling:

rustc — The Rust compiler
cargo — Rust's package manager and build system
rustup — Rust toolchain installer
rustfmt — Code formatter
clippy — Linting tool
futures — Fundamental async primitives

All official Rust tooling is developed under this organization.

Tokio Project

GitHub: tokio-rs

Organization maintaining the async runtime ecosystem.

Notable crates:

tokio — Async runtime for writing reliable network applications
axum — Web application framework
tower — Library of modular and reusable components for networking
bytes — Utilities for working with bytes

The Tokio project provides the foundation for async programming in Rust, including runtime, I/O, and HTTP abstractions.

RustCrypto

GitHub: RustCrypto

Organization maintaining pure Rust implementations of cryptographic algorithms and protocols.

Notable crates:

sha2 — SHA-2 hash functions
Many other cryptographic primitives following uniform APIs

RustCrypto crates are characterized by rigorous security practices, constant-time implementations where appropriate, and comprehensive cryptographic algorithm coverage.

RustSec

GitHub: rustsec

Organization maintaining the Rust security advisory database and related security tooling.

Notable projects:

cargo-audit — Audits Cargo.lock for crates with security vulnerabilities
Rust Security Advisory Database

RustSec provides essential security infrastructure for the Rust ecosystem.

Recognition Criteria

Trusted maintainers are recognized based on:

Quality — Crates are well-designed, performant, and reliable
Documentation — Comprehensive docs and examples
Maintenance — Active development and responsive to issues
Community standing — Positive reputation in the Rust community
Impact — Widespread use and foundational importance

This is not an exhaustive list. Many other excellent maintainers contribute to the Rust ecosystem.

External Rust Resources

These are not part of Rustmax.

Must know URLS 🤯

Tier 1 - looks good 👍

Rust Language Cheat Sheet. This looks awesome.
Rust Component History. rustup toolchain status. Look here to figure out if your nightly toolchain had component build failures.
The Little Book of Rust Books
"Can I Use _?"
releases.rs. Rust release history.

Tier 2 - unvetted 😒

todo

rust-lang.org
play.rust-lang.org
rustup.org
crates.io
std.rs
docs.rs
query.rs
social and forums
releases.rs

Rustmax: The Book