Curated stacks

What are you building?

Pick a use case to show the tools that matter most, on top of a practical baseline for every Rust project.

Choose a stack Browse curated tool sets for your use case

Jump to Sort License MSRV

Hide deprecated Staff picks only Staff picks are hand-selected by corrode.dev, an independent Rust consultancy.

3

Installing, switching, and managing Rust toolchains and components.

Tool	Notes	Metrics
rustup rust-lang/rustup Apache-2.0 Staff pickEssentials	The official Rust toolchain installer and version manager. Installs and switches between stable, beta, and nightly toolchains, manages components (clippy, rustfmt, rust-src) and cross-compilation targets, and pins a per-project toolchain via `rust-toolchain.toml`. Effectively mandatory: almost every other tool here assumes a rustup-managed toolchain. The only time you'd skip it is a fully pinned distro/Nix or CI image that provisions toolchains some other way. alternatives rustup-toolchain-install-masterNix (oxalica/rust-overlay)	7.0k stars 1d ago updated Maintained
cargo-binstall cargo-bins/cargo-binstall v1.21.1GPL-3.0-onlyRust 1.79.0+ by Félix Saparelli, ryan, Jiahao XU, Binstall Essentials	Installs Rust binaries from pre-built GitHub release artifacts instead of compiling from source, turning a multi-minute `cargo install` into a download. Falls back to building from source when no prebuilt binary is published. Reach for it in CI and on dev machines to install tools fast. Skip it if you need a build from source for provenance/audit reasons, or for crates that ship no release binaries (where it gains you nothing over `cargo install`). alternatives cargo-installcargo-quickinstall	119.0k downloads 2.8k stars 1d ago updated Maintained
cargo-quickinstall cargo-bins/cargo-quickinstall v0.3.53MIT OR Apache-2.0 by David Laban, Jiahao XU	Installs Rust binaries from precompiled artifacts instead of building from source. It fetches prebuilt packages from a community build service, falling back to `cargo install` when no prebuilt binary exists for your target. Useful for skipping long compile times in CI and local setup. It is also used as a backend by `cargo-binstall`, which adds discovery of binaries published directly on a project's own releases. alternatives cargo-binstall	9.6k downloads 312 stars 1d ago updated Maintained

3

Speeding up, caching, and customizing the build itself.

Tool Notes Metrics

Tool	Notes	Metrics
cargo-chef LukeMathWalker/cargo-chef v0.1.78Apache-2.0 OR MIT by Luca Palmieri Staff pickIn Backend Services	Speeds up Docker builds by caching your dependency compilation as a separate, stable image layer. It computes a `recipe.json` from your manifests, cooks the dependencies once, and only rebuilds them when `Cargo.toml`/`Cargo.lock` change, so editing application code no longer recompiles the whole tree. Specifically a Docker/CI optimization. It does nothing for local `cargo build`, and outside containerized builds you want `sccache` or plain incremental builds instead. alternatives sccacheDocker BuildKit cache mounts	852.1k downloads 2.7k stars 6d ago updated Maintained
sccache mozilla/sccache v0.17.0Apache-2.0Rust 1.85.0+ by Ted Mielczarek, Bernhard Schuster, Igor Matuszewski, Mike Hommey, Sylvestre Ledru In Backend Services Continuous Integration	A compiler cache (think `ccache` for Rust) that caches compilation artifacts locally or in shared storage (S3, GCS, Redis, memcached). Set it as your `RUSTC_WRAPPER` to share build outputs across branches, machines, and CI runs. Big wins on CI and large teams. Less useful for a single dev with a warm local `target/` (incremental compilation already covers you), and shared caches add network/storage setup you may not want for small projects. alternatives Cargo incremental compilationcargo-chef (Docker layer caching) related cargo-wizard	134.4k downloads 7.6k stars 5d ago updated Maintained
cargo-wizard Kobzol/cargo-wizard v0.2.3MIT by Jakub Beránek	An interactive assistant for Cargo build configuration. Pick a goal (fast compiles, fast runtime, or small binaries) and it writes the matching `[profile]` settings (and relevant `.cargo/config.toml` entries), including the less-obvious knobs like `codegen-units`, `lto`, `panic`, and `opt-level`. A TUI lets you inspect and adjust each choice before it's applied. It's a one-shot setup helper, not something you run continuously: useful for learning which profile settings matter and getting a sensible baseline, after which the output is ordinary TOML you own and tune by hand. It changes how you build, not how well the build is cached; pair it with `sccache` for the latter. related sccache	324 downloads 1.1k stars 3w ago updated Maintained

cargo-chef LukeMathWalker/cargo-chef v0.1.78Apache-2.0 OR MIT by Luca Palmieri Staff pickIn Backend Services

Speeds up Docker builds by caching your dependency compilation as a separate, stable image layer. It computes a recipe.json from your manifests, cooks the dependencies once, and only rebuilds them when Cargo.toml/Cargo.lock change, so editing application code no longer recompiles the whole tree.

Specifically a Docker/CI optimization. It does nothing for local cargo build, and outside containerized builds you want sccache or plain incremental builds instead.

alternatives sccacheDocker BuildKit cache mounts

852.1k downloads

2.7k stars

6d ago updated

Maintained

sccache mozilla/sccache v0.17.0Apache-2.0Rust 1.85.0+ by Ted Mielczarek, Bernhard Schuster, Igor Matuszewski, Mike Hommey, Sylvestre Ledru In Backend Services Continuous Integration

A compiler cache (think ccache for Rust) that caches compilation artifacts locally or in shared storage (S3, GCS, Redis, memcached). Set it as your RUSTC_WRAPPER to share build outputs across branches, machines, and CI runs.

Big wins on CI and large teams. Less useful for a single dev with a warm local target/ (incremental compilation already covers you), and shared caches add network/storage setup you may not want for small projects.

alternatives Cargo incremental compilationcargo-chef (Docker layer caching)

related cargo-wizard

134.4k downloads

7.6k stars

5d ago updated

Maintained

cargo-wizard Kobzol/cargo-wizard v0.2.3MIT by Jakub Beránek

An interactive assistant for Cargo build configuration. Pick a goal (fast compiles, fast runtime, or small binaries) and it writes the matching [profile] settings (and relevant .cargo/config.toml entries), including the less-obvious knobs like codegen-units, lto, panic, and opt-level. A TUI lets you inspect and adjust each choice before it's applied.

It's a one-shot setup helper, not something you run continuously: useful for learning which profile settings matter and getting a sensible baseline, after which the output is ordinary TOML you own and tune by hand. It changes how you build, not how well the build is cached; pair it with sccache for the latter.

related sccache

324 downloads

1.1k stars

3w ago updated

Maintained

3

General-purpose cargo subcommands that smooth day-to-day workflows.

Tool	Notes	Metrics
cargo-generate cargo-generate/cargo-generate v0.23.14MIT OR Apache-2.0 by ashley williams Staff pick	Scaffolds a new project from a Git template, filling in the crate name and other placeholders via Liquid templating and interactive prompts. It's the practical answer to "`cargo new`, but with my CI, lints, license, and module layout already wired up", and because templates are just ordinary repositories, teams can maintain their own. Reach for it when you spin up similar crates often or want to standardize a house style; for a true one-off, plain `cargo new` is still simpler. A template is third-party code that runs on your machine, so treat an unfamiliar one with the same caution as any dependency.	290.7k downloads 2.5k stars 1w ago updated Maintained
cargo-edit killercup/cargo-edit v0.13.13Apache-2.0 OR MITRust 1.92+ by Pascal Hertleif, Ed Page, Benjamin Gill, ordian	Adds dependency-editing subcommands to Cargo. `cargo add` and `cargo rm` are now built into Cargo itself, but cargo-edit still provides `cargo upgrade` (bump dependencies in `Cargo.toml` to the latest compatible, or `--incompatible`, versions) and `cargo set-version`. Mostly you only need it today for `cargo upgrade`. If you just want to add or remove a dependency, use the built-in `cargo add`/`cargo remove` and skip this. alternatives cargo add (built-in)cargo-upgradescargo-set-version	549.7k downloads 3.4k stars 1mo ago updated Maintained
cargo-watch watchexec/cargo-watch v8.5.3CC0-1.0Rust 1.75.0+ by Félix Saparelli, maintainers	Watches your source tree and re-runs a cargo command (`check`, `test`, `run`) on every change. It was the de-facto Rust file-watcher for years. Deprecated: the project is archived and no longer maintained. For a Rust-aware watch loop with a clean rendered TUI use bacon; for a general-purpose, language-agnostic watcher use watchexec (which now absorbs cargo-watch's maintainers). Don't start new projects on cargo-watch. use instead bacon watchexec	172.6k downloads 2.9k stars 1y ago updated Deprecated

5

Inspecting, updating, auditing, and pruning your dependency tree.

Tool	Notes	Metrics
cargo-udeps est31/cargo-udeps v0.1.61MIT OR Apache-2.0 by est31 Staff pick	Finds unused dependencies by inspecting actual compiler output, so it knows which crates were actually linked rather than guessing from source text. This makes it more accurate than heuristic scanners, catching cases that pure text analysis misses and avoiding some false positives. The tradeoff is that it requires a nightly toolchain and a full build, so it is slower. If you want a stable, fast check for everyday CI, prefer `cargo-machete` and keep `cargo-udeps` for periodic deep audits. alternatives cargo-machete	134.8k downloads 2.1k stars 3mo ago updated Maintained
cargo-machete bnjbvr/cargo-machete v0.9.2MIT by Benjamin Bouvier In Publishing a Library Security & Supply Chain	Finds dependencies declared in `Cargo.toml` that are never used, by scanning source files for references to each crate. It runs on stable Rust without compiling the project, which makes it fast enough for CI gates and large workspaces. Because the analysis is heuristic (text-based), it can produce false positives for crates used only via macros or re-exports; mark those with `ignored = [...]` under `[package.metadata.cargo-machete]`. For a precise but slower, nightly-only check, use `cargo-udeps`. alternatives cargo-udeps	461.8k downloads 1.4k stars 1w ago updated Maintained
cargo-outdated kbknapp/cargo-outdated v0.19.0MITRust 1.88.0+ by Kevin K.	Displays a table of dependencies that have newer versions available, comparing what is resolved in `Cargo.lock` against the latest releases on crates.io. It distinguishes between updates allowed by your current version requirements and those that need a manual `Cargo.toml` bump (SemVer-incompatible). Run `cargo outdated -R` to limit the report to root dependencies. It only reports and never edits your manifest, so reach for `cargo upgrade` (from cargo-edit) when you actually want to apply the bumps. alternatives cargo-upgrades cargo-edit	70.2k downloads 1.4k stars 2mo ago updated Maintained
cargo-upgrades gitlab.com/kornelski/cargo-upgrades v3.1.0GPL-3.0+Rust 1.92+ by Kornel	Checks which dependencies can be upgraded to newer SemVer-incompatible versions, accounting for the whole dependency graph so it only suggests upgrades that can actually resolve. This avoids the false positives you get from naively comparing against the latest crates.io release. Use it as a sanity check before bumping version requirements. It reports only; pair it with `cargo upgrade` from cargo-edit to apply changes. Overlaps heavily with `cargo-outdated`, so most projects need just one. alternatives cargo-outdated cargo-edit	4.1k downloads 17 stars 1mo ago updated Maintained
cargo-tree sfackler/cargo-tree v0.29.0MIT OR Apache-2.0 by Steven Fackler	ARCHIVED. This standalone subcommand visualized the dependency graph as a tree and helped track down where a transitive crate or duplicate version came from. Its functionality was upstreamed into Cargo itself starting with Rust 1.44. Do not install this crate anymore: run the built-in `cargo tree` instead, which is maintained, supports `-i`/`--invert` to find who pulls in a package, and `-d` to show duplicate versions. The external repository is no longer developed. use instead cargo tree (built-in)	9.5k downloads 531 stars 6y ago updated Deprecated

13

Test runners, coverage, property testing, fuzzing, and snapshots.

Tool	Notes	Metrics
mockall asomers/mockall v0.15.0MIT OR Apache-2.0Rust 1.77.0+ by Alan Somers Staff pickIn Testing & Correctness	A powerful mocking library: generate mock implementations of your traits, then set expectations on which methods are called, with what arguments, how often, and what they return. It earns its place at the seams of a system (network, clock, filesystem) where you want to exercise logic without the real dependency. Mockall works best when your code already abstracts over traits rather than concrete types; retrofitting it can mean introducing traits purely for testing, which not every codebase wants. For simple cases a hand-written fake or a small trait impl is often clearer than the macro machinery. Added as a `dev-dependency`, not installed.	28.0M downloads 1.8k stars 1mo ago updated Maintained
rstest la10736/rstest v0.26.1MIT OR Apache-2.0Rust 1.70.0+ by Michele d'Amico Staff pickIn Testing & Correctness	Adds fixtures and parameterized cases to ordinary `#[test]` functions. Declare a reusable `#[fixture]` and request it as an argument, or attach `#[case(...)]` rows (and `#[values(...)]` matrices) to run the same body across many inputs. Each case reports as its own named test. It removes most of the copy-paste from table-driven tests while staying close to the built-in harness, so it composes with `cargo-nextest`, `insta`, and the rest rather than replacing them. For exhaustively generated inputs rather than a hand-written table, reach for property testing with `proptest`. Added as a `dev-dependency`, not installed. related proptest insta	25.5M downloads 1.6k stars 4mo ago updated Maintained
loom tokio-rs/loom v0.7.2MITRust 1.65+ by Carl Lerche, Core Staff pickIn Testing & Correctness	A model checker for concurrent Rust. Write a test against loom's drop-in replacements for `Atomic*`, `Mutex`, `UnsafeCell`, and friends, and it exhaustively explores the interleavings and memory orderings the C11 model permits, surfacing races and ordering bugs that may never appear on the hardware you happen to test on. It's how Tokio validates its own lock-free code. This is a tool for `unsafe`, lock-free, or hand-rolled synchronization, not for everyday application logic built on channels and `async`. The state space grows quickly, so loom tests must be kept small and gated behind a `cfg`. If you aren't writing your own concurrency primitives, you probably don't need it. Added as a `dev-dependency`, not installed. related miri tokio-console	10.8M downloads 2.8k stars 5mo ago updated Maintained
cargo-nextest nextest-rs/nextest v0.9.143Apache-2.0 OR MITRust 1.91+ by Rain, Nextest Bot Staff pickEssentials	A next-generation test runner that executes each test in its own process for isolation, runs them in parallel with a clean summary output, and is typically faster than `cargo test` on larger suites. It adds practical features like automatic retries for flaky tests, per-test timeouts, and JUnit output for CI. Run it with `cargo nextest run`. Note it does not run doctests, so you still need `cargo test --doc` for those. Tests that assume they share a process (for example relying on global state set by another test) may need adjustment under its process-per-test model. alternatives cargo test (built-in) related cargo-mutants	1.7M downloads 3.2k stars 1d ago updated Maintained
cargo-mutants sourcefrog/cargo-mutants v27.1.0MITRust 1.88+ by Martin Pool Staff pickIn Testing & Correctness	Mutation testing for Rust: it injects small changes (a `>` becomes `>=`, a function returns `Default::default()`) and reruns your tests, reporting any mutant that survives as a gap in your suite. Where line coverage only proves code was executed, surviving mutants show where your assertions don't actually pin down behavior. It's CPU-hungry: every mutant is a fresh build-and-test cycle, so scope it to changed files or specific modules in CI rather than re-running the whole tree. It pairs naturally with `cargo-nextest` as the runner and complements `cargo-llvm-cov`: use coverage to find untested lines, mutants to find under-tested ones. related cargo-nextest cargo-llvm-cov	169.2k downloads 1.3k stars 1d ago updated Maintained
miri rust-lang/miri Apache-2.0 Staff pick	An interpreter for Rust's mid-level IR that runs your test suite and flags undefined behavior in `unsafe` code: out-of-bounds accesses, use-after-free, invalid alignment, data races, and leaks that compile cleanly and pass under a normal build. Installed as a rustup component with `rustup +nightly component add miri`, then run via `cargo +nightly miri test`. It is nightly-only and interprets rather than compiles, so runs are many times slower than native and most FFI and raw syscalls are unsupported. Reach for it to vet `unsafe` blocks, not as a general test runner. related cargo-fuzz loom	6.5k stars 2d ago updated Maintained
proptest proptest-rs/proptest v1.11.0MIT OR Apache-2.0Rust 1.85+ by Mazdak Farrokhzad, Jason Lingle, publish In Publishing a Library Testing & Correctness	A property-based testing library: instead of hand-writing example inputs, you describe properties that should hold for all inputs and let `proptest` generate many cases. When a case fails it automatically shrinks the input to a minimal failing example and persists it to a regression file so failures stay reproducible. Its `Strategy`-based generators compose well for structured and constrained data, going beyond simple type-driven generation. Compared to `quickcheck`, it is more flexible but more verbose; reach for `quickcheck` when you want a lighter, type-directed approach. alternatives quickcheck related rstest	43.2M downloads 2.2k stars 3w ago updated Maintained
insta mitsuhiko/insta v1.48.0Apache-2.0Rust 1.66.0+ by Armin Ronacher, Maximilian Roos In Command-Line Apps Testing & Correctness	A snapshot testing library that records the output of a value (debug, JSON, YAML, RON, or plain strings) to a file and fails when it later changes. This is ideal for asserting on large or structured outputs where writing explicit expected values by hand is tedious. Its companion `cargo-insta` adds `cargo insta review` for interactively accepting or rejecting diffs, plus inline snapshots embedded in source. Use it for serialization, parser, and rendering output; for small scalar assertions a plain `assert_eq!` is clearer and avoids a separate review step. related rstest	23.4M downloads 2.9k stars 3w ago updated Maintained
quickcheck BurntSushi/quickcheck v1.1.0Unlicense OR MITRust 1.85.0+ by Andrew Gallant	A property-based testing library in the classic Haskell QuickCheck style: you assert properties that should hold for all inputs, and it generates random values to try to falsify them, shrinking any counterexample to a minimal case. Good for a lightweight, low-ceremony way to add property tests. For richer strategies, struct-aware generation, and a persistent failure database, reach for `proptest` instead. alternatives proptest	9.3M downloads 2.8k stars 4mo ago updated Maintained
cargo-llvm-cov taiki-e/cargo-llvm-cov v0.9.0Apache-2.0 OR MITRust 1.87+ by Taiki Endo In Continuous Integration Testing & Correctness	Collects source-based code coverage using LLVM's instrumentation (`-C instrument-coverage`), giving accurate line and region coverage that maps back to your source. It handles the gcov/profdata plumbing for you and can emit lcov, HTML, or Cobertura reports, and integrates with `cargo nextest`. It works across the major platforms Rust's LLVM coverage supports and is the current go-to for accurate coverage. It needs the `llvm-tools-preview` rustup component; the older `cargo-tarpaulin` is an alternative with different platform tradeoffs. alternatives cargo-tarpaulin related cargo-mutants	1.5M downloads 1.4k stars 2d ago updated Maintained
cargo-fuzz rust-fuzz/cargo-fuzz v0.13.2MIT OR Apache-2.0 by Corey Farwell, Nick Fitzgerald, Simonas Kazlauskas, Manish Goregaokar, Publishers	Scaffolds and drives coverage-guided fuzzing targets backed by libFuzzer. You write a `fuzz_target!` that feeds arbitrary bytes into your code, and `cargo fuzz run` mutates inputs to maximize coverage and surface panics, memory errors, and crashes, saving any reproducer it finds. It links libFuzzer through the compiler's sanitizer support and therefore requires a nightly toolchain. For an AFL-style engine instead, see the `afl` crate (cargo-afl). Fuzzing complements, rather than replaces, unit and property tests. alternatives cargo-afl	1.1M downloads 1.9k stars 4w ago updated Maintained
cargo-tarpaulin xd009642/tarpaulin v0.37.2MIT OR Apache-2.0 by xd009642	A code coverage tool for Rust that reports line coverage and uploads cleanly to services like Codecov and Coveralls. It was the long-standing default for CI coverage and remains widely used and simple to invoke with `cargo tarpaulin`. Its mature Ptrace-based engine is Linux/x86_64-focused, though it now also offers an LLVM-based backend. If you need accurate source-based coverage across more platforms, `cargo-llvm-cov` is generally the better fit today. alternatives cargo-llvm-cov	316.6k downloads 3.0k stars 3d ago updated Maintained
cargo-afl rust-fuzz/afl.rs v0.18.2Apache-2.0 by Samuel Moelius, anishnaik, Publishers	Coverage-guided fuzzing for Rust built on AFL++. The `afl.rs` project ships the `cargo afl` subcommand, which instruments your target and runs the AFL++ engine to discover inputs that trigger panics, assertion failures, or crashes. Pick it when you want AFL++'s mature mutation engine and tooling. For the LLVM/libFuzzer ecosystem with first-class `#[no_main]` fuzz targets and structured corpora, `cargo-fuzz` is the more common starting point. alternatives cargo-fuzz	27.4k downloads 1.8k stars 1w ago updated Maintained

2

Catching bugs, anti-patterns, and style issues before review.

Tool	Notes	Metrics
clippy rust-lang/rust-clippy Apache-2.0 Staff pickEssentials	The official Rust linter, providing 700+ lints that catch correctness issues, performance pitfalls, and unidiomatic code beyond what `rustc` reports. Installed as a rustup component with `rustup component add clippy` and run via `cargo clippy`. Effectively mandatory in CI as `cargo clippy -- -D warnings` to fail the build on any lint. Not a formatter; pair it with `rustfmt` for style. related cargo-semver-checks	13.4k stars 2d ago updated Maintained
cargo-semver-checks obi1kenobi/cargo-semver-checks v0.50.0Apache-2.0 OR MITRust 1.93+ by Predrag Gruevski In Publishing a Library	Lints a crate's public API for SemVer-violating changes between releases, catching breaking changes that would require a major version bump. Run `cargo semver-checks` before publishing to verify your version bump matches the actual API surface. It analyzes the API for breakage but cannot detect behavioral or semantic changes, so it complements rather than replaces tests. related clippy	145.6k downloads 1.7k stars 3d ago updated Maintained

2

Consistent, automatic code and config formatting.

Tool	Notes	Metrics
rustfmt rust-lang/rustfmt Apache-2.0 Staff pickEssentials	The official Rust code formatter, applying a consistent style across a codebase so diffs stay focused on real changes rather than whitespace. Installed as a rustup component with `rustup component add rustfmt` and run via `cargo fmt`. Use `cargo fmt --check` in CI to enforce formatting without writing files. It formats Rust source only; use `taplo` for `Cargo.toml` and other TOML. alternatives taplo	6.9k stars 3d ago updated Maintained
taplo tamasfe/taplo v0.10.0MITRust 1.74+ by Ferenc Tamás, JounQin In Continuous Integration	A TOML toolkit providing a formatter, linter, and language server for TOML files such as `Cargo.toml` and `rustfmt.toml`. Install with the `taplo-cli` crate and run `taplo fmt` or `taplo lint`; use `taplo fmt --check` in CI. Reach for it to keep config files tidy and validated against schemas. It handles TOML only, so pair it with `rustfmt` for Rust source. alternatives rustfmt	183.7k downloads 2.4k stars 3w ago updated Maintained

5

Vulnerability scanning, license/policy enforcement, and audits.

Tool	Notes	Metrics
cargo-audit rustsec/rustsec v0.22.2Apache-2.0 OR MITRust 1.88+ by Alex Gaynor, Tony Arcieri, Dirkjan Ochtman, Sergey "Shnatsel" Davidoff, Working Group Staff pickIn Security & Supply Chain	Scans `Cargo.lock` for dependencies with known vulnerabilities reported in the RustSec advisory database. Run `cargo audit` in CI to fail builds when a vulnerable or yanked crate enters the dependency tree. It checks advisories only; for license, source, and duplicate-crate policy use `cargo-deny`, which subsumes this functionality. alternatives cargo-deny cargo-vet related cargo-auditable	2.9M downloads 1.9k stars 5d ago updated Maintained
cargo-deny EmbarkStudios/cargo-deny v0.20.2MIT OR Apache-2.0Rust 1.88.0+ by embark-studios Staff pickIn Backend Services Continuous Integration Publishing a Library Security & Supply Chain	A policy linter for your dependency graph, checking security advisories, license compliance, banned or duplicate crates, and allowed source registries. Configure rules in `deny.toml` and run `cargo deny check` in CI. Broader than `cargo-audit`, which covers only advisories. Reach for it when you need to enforce organizational policy across all four areas in one pass. alternatives cargo-audit cargo-vet	1.4M downloads 2.4k stars 1w ago updated Maintained
cargo-geiger geiger-rs/cargo-geiger v0.13.0Apache-2.0 OR MITRust 1.85+ by Tony Arcieri, anderejd, pinkforest(she/her), publish-rs, publish Staff pickIn Security & Supply Chain	Audits your dependency tree for `unsafe` code, reporting how many unsafe expressions each crate contains so you can gauge how much of your supply chain relies on it. Useful for security reviews and for projects that aim to minimize unsafe surface area. Treat the counts as a heuristic, not a verdict: `unsafe` is not inherently a bug, and the tool can struggle with some macro-heavy crates. Note its maintenance has been intermittent. Verify it builds against current toolchains before relying on it in CI. alternatives cargo-audit cargo-deny	46.4k downloads 1.6k stars 2mo ago updated Maintained
cargo-auditable rust-secure-code/cargo-auditable v0.7.5MIT OR Apache-2.0 by Tony Arcieri, Sergey "Shnatsel" Davidoff In Backend Services Security & Supply Chain	Embeds the exact dependency list into compiled binaries so they can be audited after the fact, even without the original source or `Cargo.lock`. Build with `cargo auditable build --release`, then scan the artifact later with `cargo audit bin`. Useful when a software bill of materials (SBOM) or later vulnerability scan must be tied to the binary you actually shipped. It records dependencies; it does not itself detect vulnerabilities. related cargo-audit	229.0k downloads 841 stars 3w ago updated Maintained
cargo-vet mozilla/cargo-vet v0.10.2Apache-2.0/MITRust 1.82+ by Nika Layzell, Bobby Holley In Security & Supply Chain	A supply-chain tool to record and enforce that each dependency has been human-reviewed, storing audit records that can be shared across an organization. Run `cargo vet` in CI to require that new or updated crates have a recorded audit before they are accepted. Designed for teams that perform source review; it tracks human judgment rather than scanning for known vulnerabilities like `cargo-audit`. Overkill for a small solo project. alternatives cargo-audit cargo-deny	94.7k downloads 971 stars 4mo ago updated Maintained

7

Benchmarking, profiling, and finding what's slow.

Tool	Notes	Metrics
criterion bheisler/criterion.rs v0.8.2Apache-2.0 OR MITRust 1.86+ by Berkus Decker, Brook Heisler, David Himmelstrup, maintainers Staff pickIn Profiling & Optimization	A statistics-driven microbenchmarking library for in-process Rust functions. It collects many samples, estimates confidence intervals, and detects performance regressions between runs, all on stable Rust. Prefer it over the unstable built-in `#[bench]` harness when you need reliable numbers without nightly. If you want a lighter, faster-to-compile alternative look at `divan`; to benchmark whole commands rather than functions use `hyperfine`. alternatives divan hyperfine	54.0M downloads 5.5k stars 3mo ago updated Maintained
cargo-bloat RazrFalcon/cargo-bloat v0.12.1MIT by Yevhenii Reizner Staff pickIn Embedded & no_std Profiling & Optimization	Breaks down what's taking up space in a release binary, listing the largest functions and the per-crate contribution to the `.text` section. Run `cargo bloat --release` for the function view or `--crates` to see which dependencies pull their weight: the natural first step before reaching for linker flags, `opt-level = "z"`, or `panic = "abort"`. It measures machine-code size, not runtime cost, so the biggest function is not necessarily a slow one. Generic-heavy code is attributed to the crate that instantiates it, which can blur where size really comes from. For the matching instruction-level view of a single function, use `cargo-show-asm`. related cargo-show-asm	27.1k downloads 2.8k stars 2y ago updated Maintained
divan nvzqz/divan v0.1.21MIT OR Apache-2.0Rust 1.80.0+ by Nikolai Vazquez, Thom Chiovoloni In Profiling & Optimization	A fast, low-boilerplate microbenchmarking harness. Benchmarks are plain functions annotated with `#[divan::bench]`, and results print as a compact tree grouped by module, with support for generic and parameterized cases. Reach for it when you want quick, readable benchmarks that compile fast on stable Rust. It does less statistical analysis than `criterion` (no regression detection across runs), so prefer `criterion` when you need rigorous confidence intervals, or `hyperfine` to time whole commands. alternatives criterion hyperfine	2.6M downloads 1.4k stars 1mo ago updated Maintained
cargo-flamegraph flamegraph-rs/flamegraph v0.6.14MIT OR Apache-2.0Rust 1.86+ by Tyler Neely, Dirkjan Ochtman, maintainers In Backend Services Profiling & Optimization	Generates flamegraphs from a single `cargo flamegraph` invocation, wrapping `perf` on Linux and `dtrace` on macOS/Windows to sample stacks and render an interactive SVG. Reach for it when you need a quick visual of where wall-clock time goes across a whole binary. It profiles a complete run, so for fine-grained, statistically sound timing of individual functions use `criterion` instead, and for an interactive UI consider `samply`. alternatives samplyperf	333.7k downloads 6.0k stars 6d ago updated Maintained
hotpath pawurb/hotpath-rs v0.23.3MIT by Paweł Urbanek	An instrumentation-based profiler: annotate hot functions with `#[hotpath::measure]`, add `#[hotpath::main]` to your entry point, and run with the `hotpath` feature to get a per-function table of timing, memory allocations, and CPU usage. Everything is gated behind a feature flag, so it compiles to a no-op when disabled. A live TUI dashboard, async channel/stream/future instrumentation, and an MCP server for querying results from an LLM round out the package. Reach for it when you want low-overhead, targeted numbers on functions you already suspect, especially in async code where it separates time spent waiting on I/O from time burning CPU. Because it only measures what you annotate, it won't reveal hot spots in code you didn't mark; for unguided, whole-process sampling reach for `samply` or `cargo-flamegraph`, and for rigorous statistical benchmarking of a single function use `criterion`. alternatives samply cargo-flamegraph related tokio-console	295.8k downloads 1.7k stars 3d ago updated Maintained
hyperfine sharkdp/hyperfine v1.20.0MIT OR Apache-2.0Rust 1.88.0+ by David Peter In Profiling & Optimization	A command-line benchmarking tool that runs a program many times, performs warmup runs, and reports mean/stddev with statistical analysis and outlier detection. Supports parameterized runs and exporting results to JSON/CSV/Markdown. Use it to compare whole programs or shell commands (e.g. two CLI builds) under realistic conditions. It measures process start-to-finish time, so it cannot profile in-process functions; for that use `criterion` or `divan`. alternatives criterion divan	113.4k downloads 28.7k stars 3mo ago updated Maintained
samply mstange/samply v0.13.1MIT OR Apache-2.0Rust 1.77+ by Markus Stange In Profiling & Optimization	A cross-platform sampling profiler: `samply record <cmd>` captures a profile and opens it in the Firefox Profiler web UI, giving you a call tree, stack charts, and timeline without leaving the browser. Good when you want interactive exploration of where time is spent across a whole process. For a static, shareable SVG instead use `cargo-flamegraph`, and for precise per-function timing use `criterion`. alternatives cargo-flamegraphperf	12.0k downloads 4.4k stars 4d ago updated Maintained

3

Debuggers, expansion, and understanding what the compiler sees.

Tool Notes Metrics

Tool	Notes	Metrics
cargo-expand dtolnay/cargo-expand v1.0.124MIT OR Apache-2.0Rust 1.88+ by David Tolnay Staff pick	Prints the source of your crate after macro expansion, so you can see exactly what `derive`, `macro_rules!`, and proc-macros generate. Invaluable for debugging macros and understanding surprising compiler errors. It shells out to the compiler's expansion mode, which requires a nightly `rustc` to run (`rustup toolchain install nightly`), even if your project otherwise uses stable. Not a code generator: it only shows expansion, it does not modify your sources. alternatives cargo-show-asm	593.1k downloads 3.1k stars 1mo ago updated Maintained
tokio-console tokio-rs/console v0.1.14MITRust 1.74.0+ by Carl Lerche, Eliza Weisman, Console Staff pickIn Backend Services Profiling & Optimization	A diagnostics and debugging TUI for async Rust. It connects to a running `tokio` app (via the `console-subscriber` instrumentation) and shows live per-task state, poll times, wakers, and resource usage, making it possible to spot tasks that are stuck, busy-looping, or never waking. Indispensable for diagnosing async stalls and runaway tasks. It requires adding the subscriber and building with `tokio_unstable`, so it's a development-time tool, not something you ship. For CPU/wall-clock hotspots in sync code, reach for a sampling profiler like `samply` instead. alternatives samply cargo-flamegraph related loom	35.6k downloads 4.6k stars 1w ago updated Maintained
cargo-show-asm pacak/cargo-show-asm v0.2.62MIT OR Apache-2.0Rust 1.86+ by pacak In Embedded & no_std Profiling & Optimization	Shows the assembly, LLVM IR, MIR, or WASM the compiler generates for a chosen function via `cargo asm`. Lets you confirm that optimizations (inlining, vectorization, bounds-check elimination) actually happened. Use it when you need to inspect codegen at the instruction level for a specific function. To see source after macro expansion instead use `cargo-expand`, and to profile real runtime behavior use `samply` or `cargo-flamegraph`. alternatives cargo-expand related cargo-bloat	12.4k downloads 971 stars 1w ago updated Maintained

cargo-expand dtolnay/cargo-expand v1.0.124MIT OR Apache-2.0Rust 1.88+ by David Tolnay Staff pick

Prints the source of your crate after macro expansion, so you can see exactly what derive, macro_rules!, and proc-macros generate. Invaluable for debugging macros and understanding surprising compiler errors.

It shells out to the compiler's expansion mode, which requires a nightly rustc to run (rustup toolchain install nightly), even if your project otherwise uses stable. Not a code generator: it only shows expansion, it does not modify your sources.

alternatives cargo-show-asm

593.1k downloads

3.1k stars

1mo ago updated

Maintained

tokio-console tokio-rs/console v0.1.14MITRust 1.74.0+ by Carl Lerche, Eliza Weisman, Console Staff pickIn Backend Services Profiling & Optimization

A diagnostics and debugging TUI for async Rust. It connects to a running tokio app (via the console-subscriber instrumentation) and shows live per-task state, poll times, wakers, and resource usage, making it possible to spot tasks that are stuck, busy-looping, or never waking.

Indispensable for diagnosing async stalls and runaway tasks. It requires adding the subscriber and building with tokio_unstable, so it's a development-time tool, not something you ship. For CPU/wall-clock hotspots in sync code, reach for a sampling profiler like samply instead.

alternatives samply cargo-flamegraph

related loom

35.6k downloads

4.6k stars

1w ago updated

Maintained

cargo-show-asm pacak/cargo-show-asm v0.2.62MIT OR Apache-2.0Rust 1.86+ by pacak In Embedded & no_std Profiling & Optimization

Shows the assembly, LLVM IR, MIR, or WASM the compiler generates for a chosen function via cargo asm. Lets you confirm that optimizations (inlining, vectorization, bounds-check elimination) actually happened.

Use it when you need to inspect codegen at the instruction level for a specific function. To see source after macro expansion instead use cargo-expand, and to profile real runtime behavior use samply or cargo-flamegraph.

alternatives cargo-expand

related cargo-bloat

12.4k downloads

971 stars

1w ago updated

Maintained

1

Writing, testing, and publishing documentation.

Tool	Notes	Metrics
mdbook rust-lang/mdBook v0.5.4MPL-2.0Rust 1.88.0+ by Eric Huss, Dylan DPC, rust-lang-owner Staff pickIn Publishing a Library	Builds searchable online books from a set of Markdown files; it powers The Rust Book and most official Rust documentation. Run `mdbook build` to generate a static site or `mdbook serve` for live preview. Reach for it to write guides, tutorials, and prose documentation. It is not for API reference docs generated from code comments; use `rustdoc` / `cargo doc`.	819.5k downloads 22.1k stars 3d ago updated Maintained

4

Versioning, changelogs, and shipping crates and binaries.

Tool	Notes	Metrics
release-plz release-plz/release-plz v0.3.160MIT OR Apache-2.0 by Marco Ieni Staff pickIn Publishing a Library	Automates releases for cargo workspaces through pull requests: it derives version bumps and changelog entries from conventional commits, opens a release PR, and publishes to crates.io once merged. Designed to run in CI. Use it for a hands-off, git-driven release flow across many crates. If you want manual, step-by-step control from your terminal instead, use the lower-level `cargo-release`; it internally relies on `git-cliff`-style changelog generation. alternatives cargo-release git-cliff	53.0k downloads 1.5k stars 1d ago updated Maintained
git-cliff orhun/git-cliff v2.13.1MIT OR Apache-2.0Rust 1.87.0+ by Orhun Parmaksız	A highly customizable changelog generator that builds release notes from git history, with first-class support for conventional commits and fully templated output (via Tera) and regex-based commit grouping. Use it when you want full control over changelog formatting independent of your release tooling. It only produces the changelog; to drive the actual version bump, tag, and publish use `cargo-release` or `release-plz`. alternatives release-plz cargo-release	32.3k downloads 12.1k stars 2w ago updated Maintained
cargo-dist axodotdev/cargo-dist v0.32.0MIT OR Apache-2.0Rust 1.74+ by Aria Desires, ashley williams, Misty De Méo, axoadmin, eng In Command-Line Apps	Builds and packages cross-platform binary artifacts and installers (shell/PowerShell installers, archives, npm/Homebrew formulae) and wires up the CI to produce them on a tagged release. Use it when you ship prebuilt binaries rather than just publishing a crate. Note the project has been renamed to `dist`; newer releases and docs live under that name. It handles distribution, not version bumping, so pair it with `cargo-release` or `release-plz`. alternatives release-plz cargo-release	22.0k downloads 2.1k stars 1d ago updated Maintained
cargo-release crate-ci/cargo-release v1.1.5MIT OR Apache-2.0Rust 1.92+ by Ning Sun, Ed Page In Publishing a Library	Automates the mechanics of cutting a release: bumps the version, commits, creates a git tag, runs `cargo publish`, and applies a post-release dev-version bump, with workspace support. Reach for it when you want explicit, command-driven control over each release step. If you prefer a fully automated, PR-based flow that derives versions from conventional commits, use `release-plz` instead; for changelog generation pair it with `git-cliff`. alternatives release-plz cargo-dist	15.1k downloads 1.6k stars 1w ago updated Maintained

2

Building binaries for a platform other than the host system.

Tool	Notes	Metrics
cross cross-rs/cross v0.2.5MIT OR Apache-2.0 by Adam Greig, publishers Staff pick	Zero-setup cross compilation: `cross build --target ...` runs the build inside prebuilt Docker/Podman images that already contain the right toolchain, linker, and system libraries for the target. Use it to target architectures and platforms without manually installing cross linkers. It requires a running container engine (Docker or Podman), which can be a dealbreaker in restricted CI; if you only need different glibc versions or want to avoid containers, consider `cargo-zigbuild`. alternatives cargo-zigbuild	299.0k downloads 8.3k stars 4d ago updated Maintained
cargo-zigbuild rust-cross/cargo-zigbuild v0.23.0MITRust 1.88+ by messense	Cross compiles by using `zig cc` as the linker, which makes it easy to target a specific older glibc version (e.g. `--target x86_64-unknown-linux-gnu.2.17`) for broad binary compatibility, all without containers. Use it for lightweight, container-free cross builds, especially for glibc version targeting. It requires Zig to be installed and does not cover every exotic target or runtime; for those, `cross` with its prebuilt images may be more reliable. alternatives cross	1.4M downloads 2.6k stars 1w ago updated Maintained

1

Flashing, debugging, and inspecting firmware on microcontrollers.

Tool	Notes	Metrics
probe-rs probe-rs/probe-rs v0.32.0MIT OR Apache-2.0Rust 1.89+ by Noah Hüsser, Dominik Boehi, crate-owners Staff pickIn Embedded & no_std	A toolkit for debugging and flashing embedded Rust on real hardware. It talks to debug probes (CMSIS-DAP, J-Link, ST-Link) to flash firmware, reset targets, and run an in-app log/RTT console, and ships `cargo embed` plus a GDB/DAP server for editor debugging. It's the modern replacement for OpenOCD-based workflows in the embedded Rust ecosystem. This is not a cross-compilation tool: you still need to install the appropriate Rust target (for example with `rustup target add`) and configure the target and linker for your microcontroller. Reach for probe-rs once you need to put that firmware onto a device or inspect it while it runs. It's irrelevant for hosted (non-embedded) targets, and very capable probes with vendor-specific features may still need their proprietary tooling. alternatives OpenOCDcargo-flashcargo-embed	152.6k downloads 2.9k stars 1d ago updated Maintained

3

Building, binding, and packaging Rust for browsers and JavaScript.

Tool	Notes	Metrics
wasm-pack rustwasm/wasm-pack v0.15.0MIT OR Apache-2.0 by Jesper Håkansson In Web Frontend (WASM)	Builds Rust-generated WebAssembly for consumption from JavaScript, producing an npm-ready package with the `wasm-bindgen` glue, TypeScript types, and a `package.json`. Use it when you publish a Rust library to npm or integrate WASM into a JS toolchain. Note its maintenance activity has slowed; for a full Rust frontend app prefer `trunk`, and for a thinner build step you can invoke `wasm-bindgen-cli` directly. alternatives trunk wasm-bindgen-cli	1.4M downloads 7.3k stars 6d ago updated Maintained
wasm-bindgen rustwasm/wasm-bindgen v0.2.127MIT OR Apache-2.0Rust 1.86+ by Ingvar Stepanyan, daxpedda, Guy Bedford, wasm-bindgen-publish In Web Frontend (WASM)	The foundational toolchain for high-level interaction between Rust-compiled WebAssembly and JavaScript. The `wasm-bindgen` CLI post-processes a `.wasm` artifact to emit the JS bindings, TypeScript types, and glue that make exported Rust functions and imported JS APIs usable from the web. You rarely invoke it directly: `trunk` and `wasm-pack` both drive it for you. Reach for the raw CLI when you need fine-grained control over the output or are wiring wasm-bindgen into a custom build pipeline. related trunk wasm-pack	828.8k downloads 9.1k stars 1d ago updated Maintained
trunk trunk-rs/trunk v0.22.0-beta.2MIT/Apache-2.0Rust 1.96.1+ by Anthony Dodd In Web Frontend (WASM)	A WASM web application bundler for Rust frontend frameworks like Yew and Leptos. Driven by a `Trunk.toml` and `index.html`, it runs the asset pipeline (SCSS, images, JS snippets), builds the WASM, and serves a hot-reloading dev server. Reach for it to build and ship a Rust single-page app to the browser. If your goal is instead to produce a WASM package consumed from JavaScript/npm, use `wasm-pack` or `wasm-bindgen-cli` directly. alternatives wasm-pack wasm-bindgen-cli	102.6k downloads 4.4k stars 2w ago updated Maintained

8

Language servers, watchers, and general developer ergonomics.

Tool	Notes	Metrics
bacon Canop/bacon v3.24.0AGPL-3.0Rust 1.85+ by Denys Séguret Staff pickEssentials	A background Rust code checker that re-runs `cargo check`, `clippy`, `test`, or `doc` whenever you save and shows warnings and errors in a compact, navigable TUI, jumping straight to the first problem. Use it for a fast, terminal-based feedback loop without a full IDE. It is Rust/cargo-focused; if you need a language-agnostic runner that executes arbitrary commands on file change, use `watchexec` instead. alternatives watchexec cargo-watch (deprecated)	20.7k downloads 3.4k stars 1w ago updated Maintained
rust-analyzer rust-lang/rust-analyzer Apache-2.0 Staff pickEssentials	The official Language Server Protocol implementation for Rust, powering IDE features like completion, go-to-definition, inline type hints, refactorings, and on-the-fly diagnostics in editors such as VS Code, Zed, and Neovim. It is the default choice for editor integration and is distributed as a `rustup` component or an editor extension rather than an installable crate. It is an interactive analysis server, not a CI checker; for command-line checks use `cargo check`/`clippy`, and for an automated check loop use `bacon`. alternatives bacon	16.8k stars 1d ago updated Maintained
cargo-xtask matklad/cargo-xtask Staff pick	A convention rather than a binary: you add an `xtask` package to the workspace and alias `cargo xtask` (in `.cargo/config.toml`) to `cargo run --package xtask`, so build automation, codegen, and release chores are written in plain Rust with no extra tool to install. Reach for it when you want dev and CI tasks that are cross-platform and can share your crates' own types instead of drifting shell or `make` scripts. The cost is boilerplate and compile time, so for a handful of simple commands `just` or `cargo-make` stay lighter; there is nothing to install here, only a pattern to copy. alternatives just cargo-make	1.3k stars 9mo ago updated Maintained
just casey/just v1.58.0CC0-1.0Rust 1.89.0+ by Casey Rodarmor, maintainers In Command-Line Apps	A command runner that saves project-specific commands as recipes in a `justfile` and runs them with `just <recipe>`. Think of it as a saner `make`: recipes, parameters, and dependencies without make's reliance on file timestamps and tab-sensitive syntax. Use it to standardize common project tasks (build, test, lint, deploy) for a team. It is a task runner, not a build system, so it does not do incremental builds based on file changes; for that keep using `cargo` or `make`. alternatives makecargo-make	472.7k downloads 35.3k stars 6d ago updated Maintained
cargo-make sagiegurari/cargo-make v0.37.24Apache-2.0 by Sagie Gur-Ari	A task runner and build tool configured through a `Makefile.toml`, with cross-platform tasks, dependencies between tasks, conditions, and a large set of predefined tasks for common cargo workflows. Choose it when you want a batteries-included, cargo-native task system that encodes complex pipelines in one file. If you only need a simple, language agnostic command launcher, `just` is lighter and quicker to learn. alternatives justmake	249.6k downloads 2.9k stars 6mo ago updated Maintained
evcxr evcxr/evcxr v0.21.1MIT OR Apache-2.0 by David Lattimore	Provides interactive Rust evaluation: `evcxr_repl` is a REPL where you can define items, add dependencies with `:dep`, and evaluate expressions incrementally, and the same engine backs a Jupyter kernel for notebooks. Use it for experimentation, learning, and prototyping snippets without a full crate. It recompiles behind the scenes so it is not a performance-measurement tool; for benchmarking use `criterion` or `hyperfine`. alternatives irust	109.8k downloads 6.5k stars 2d ago updated Maintained
watchexec watchexec/watchexec v2.5.1Apache-2.0 by Félix Saparelli	A general-purpose, language-agnostic file watcher that runs an arbitrary command whenever matching files change, with debouncing, glob filters, and process restart handling. Installed via the `watchexec-cli` crate. Use it to drive any tool on change (tests, builds, codegen, server reloads), regardless of language. For a Rust-specific experience with a results TUI and ready-made `cargo` jobs, `bacon` is more convenient. alternatives bacon cargo-watch (deprecated)	7.8k downloads 7.1k stars 1d ago updated Maintained
IRust sigmaSd/IRust v1.77.0MIT by Bedis Nbiba	A standalone Rust REPL for the terminal, with code completion, syntax highlighting, and the ability to pull in crates on the fly to experiment interactively. Reach for it when you want a quick scratchpad for Rust without setting up a project. If you'd rather work in notebooks or need a Jupyter kernel, `evcxr` covers that ground instead. alternatives evcxr	1.3k downloads 714 stars 3w ago updated Maintained