What are you building?

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.