# Rust Tool Index
A curated reference of Rust development tooling. Metrics are auto-refreshed from the source forge and crates.io.
Full data: https://tools.corrode.dev/api/v1/tools

## Toolchain
Installing, switching, and managing Rust toolchains and components.

- rustup [RECOMMENDED] — https://github.com/rust-lang/rustup
  6907 stars · last commit 2026-06-03 · Apache-2.0
  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-master, Nix (oxalica/rust-overlay)

- cargo-binstall — https://github.com/cargo-bins/cargo-binstall
  3345830 downloads · v1.19.1 · 2694 stars · last commit 2026-05-29 · GPL-3.0
  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-install, cargo-quickinstall

- cargo-quickinstall — https://github.com/cargo-bins/cargo-quickinstall
  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

## Build
Speeding up, caching, and customizing the build itself.

- cargo-chef [RECOMMENDED] — https://github.com/LukeMathWalker/cargo-chef
  3094121 downloads · v0.1.77 · 2612 stars · last commit 2026-04-13 · Apache-2.0
  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: sccache, Docker BuildKit cache mounts

- sccache — https://github.com/mozilla/sccache
  1179904 downloads · v0.15.0 · 7328 stars · last commit 2026-06-04 · Apache-2.0
  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 compilation, cargo-chef (Docker layer caching)

## Cargo Extensions
General-purpose cargo subcommands that smooth day-to-day workflows.

- cargo-edit — https://github.com/killercup/cargo-edit
  2991997 downloads · v0.13.11 · 3406 stars · last commit 2026-05-28 · MIT
  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-upgrades, cargo-set-version

- cargo-watch [DEPRECATED] — https://github.com/watchexec/cargo-watch
  1772028 downloads · v8.5.3 · 2862 stars · last commit 2025-01-14 · CC0-1.0
  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.
  alternatives: bacon, watchexec
  use instead: bacon, watchexec

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

- cargo-udeps [RECOMMENDED] — https://github.com/est31/cargo-udeps
  1309725 downloads · v0.1.61 · 2108 stars · last commit 2026-04-29
  Finds unused dependencies by inspecting actual compiler output, so it knows
  which crates were genuinely 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

- cargo-machete — https://github.com/bnjbvr/cargo-machete
  2281811 downloads · v0.9.2 · 1315 stars · last commit 2026-06-03 · MIT
  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

- cargo-outdated — https://github.com/kbknapp/cargo-outdated
  893994 downloads · v0.19.0 · 1401 stars · last commit 2026-06-01 · MIT
  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

- cargo-upgrades — https://gitlab.com/kornelski/cargo-upgrades
  79238 downloads · v3.1.0 · 17 stars · last commit 2026-05-11
  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

- cargo-tree [DEPRECATED] — https://github.com/sfackler/cargo-tree
  228767 downloads · v0.29.0 · 531 stars · last commit 2020-06-04 · Apache-2.0
  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)

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

- cargo-nextest [RECOMMENDED] — https://github.com/nextest-rs/nextest
  10629477 downloads · v0.9.137 · 3025 stars · last commit 2026-06-04 · Apache-2.0
  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)

- proptest — https://github.com/proptest-rs/proptest
  133037796 downloads · v1.11.0 · 2151 stars · last commit 2026-05-27 · Apache-2.0
  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

- insta — https://github.com/mitsuhiko/insta
  69152471 downloads · v1.47.2 · 2876 stars · last commit 2026-06-03 · Apache-2.0
  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.

- cargo-llvm-cov — https://github.com/taiki-e/cargo-llvm-cov
  5946143 downloads · v0.8.7 · 1389 stars · last commit 2026-06-03 · Apache-2.0
  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

- cargo-fuzz — https://github.com/rust-fuzz/cargo-fuzz
  3128206 downloads · v0.13.1 · 1820 stars · last commit 2026-05-26 · Apache-2.0
  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

- cargo-tarpaulin — https://github.com/xd009642/tarpaulin
  2653317 downloads · v0.35.4 · 2972 stars · last commit 2026-06-01 · Apache-2.0
  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

- cargo-afl — https://github.com/rust-fuzz/afl.rs
  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

- quickcheck — https://github.com/BurntSushi/quickcheck
  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

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

- clippy [RECOMMENDED] — https://github.com/rust-lang/rust-clippy
  13233 stars · last commit 2026-06-04 · Apache-2.0
  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

- cargo-semver-checks — https://github.com/obi1kenobi/cargo-semver-checks
  435681 downloads · v0.48.0 · 1631 stars · last commit 2026-05-31 · Apache-2.0
  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

## Formatting
Consistent, automatic code and config formatting.

- rustfmt [RECOMMENDED] — https://github.com/rust-lang/rustfmt
  6857 stars · last commit 2026-06-02 · Apache-2.0
  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

- taplo — https://github.com/tamasfe/taplo
  1975107 downloads · v0.10.0 · 2288 stars · last commit 2026-03-11 · MIT
  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

## Security
Vulnerability scanning, license/policy enforcement, and audits.

- cargo-audit [RECOMMENDED] — https://github.com/rustsec/rustsec
  8084997 downloads · v0.22.1 · 1896 stars · last commit 2026-06-04
  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

- cargo-deny [RECOMMENDED] — https://github.com/EmbarkStudios/cargo-deny
  3907597 downloads · v0.19.8 · 2324 stars · last commit 2026-05-28 · Apache-2.0
  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

- cargo-geiger [RECOMMENDED] — https://github.com/geiger-rs/cargo-geiger
  180175 downloads · v0.13.0 · 1584 stars · last commit 2026-01-11
  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

- cargo-auditable — https://github.com/rust-secure-code/cargo-auditable
  728480 downloads · v0.7.4 · 827 stars · last commit 2026-05-28 · Apache-2.0
  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 for distributing binaries whose provenance must remain
  verifiable. It records dependencies; it does not itself detect vulnerabilities.
  related: cargo-audit

- cargo-vet — https://github.com/mozilla/cargo-vet
  514629 downloads · v0.10.2 · 950 stars · last commit 2026-04-19 · Apache-2.0
  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

## Performance
Benchmarking, profiling, and finding what's slow.

- criterion [RECOMMENDED] — https://github.com/bheisler/criterion.rs
  214066660 downloads · v0.8.2 · 5481 stars · last commit 2026-04-23 · Apache-2.0
  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

- cargo-flamegraph — https://github.com/flamegraph-rs/flamegraph
  694794 downloads · v0.6.12 · 5948 stars · last commit 2026-06-03 · Apache-2.0
  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: samply, perf

- hyperfine — https://github.com/sharkdp/hyperfine
  555239 downloads · v1.20.0 · 28225 stars · last commit 2026-04-30 · Apache-2.0
  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

- samply — https://github.com/mstange/samply
  120741 downloads · v0.13.1 · 4233 stars · last commit 2026-05-25 · Apache-2.0
  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-flamegraph, perf

- divan — https://github.com/nvzqz/divan
  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

## Debugging
Debuggers, expansion, and understanding what the compiler sees.

- cargo-expand [RECOMMENDED] — https://github.com/dtolnay/cargo-expand
  2829657 downloads · v1.0.122 · 3086 stars · last commit 2026-05-18 · Apache-2.0
  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

- tokio-console [RECOMMENDED] — https://github.com/tokio-rs/console
  481010 downloads · v0.1.14 · 4536 stars · last commit 2026-04-09 · MIT
  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

- cargo-show-asm — https://github.com/pacak/cargo-show-asm
  179178 downloads · v0.2.60 · 943 stars · last commit 2026-05-29 · Apache-2.0
  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

## Documentation
Writing, testing, and publishing documentation.

- mdbook [RECOMMENDED] — https://github.com/rust-lang/mdBook
  9231806 downloads · v0.5.3 · 21739 stars · last commit 2026-06-01 · MPL-2.0
  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`.

## Release
Versioning, changelogs, and shipping crates and binaries.

- release-plz [RECOMMENDED] — https://github.com/release-plz/release-plz
  283550 downloads · v0.3.158 · 1383 stars · last commit 2026-06-01 · Apache-2.0
  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

- git-cliff — https://github.com/orhun/git-cliff
  285410 downloads · v2.13.1 · 11919 stars · last commit 2026-06-03 · Apache-2.0
  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

- cargo-dist — https://github.com/axodotdev/cargo-dist
  154238 downloads · v0.32.0 · 2047 stars · last commit 2026-06-04 · Apache-2.0
  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

- cargo-release — https://github.com/crate-ci/cargo-release
  522560 downloads · v1.1.2 · 1563 stars · last commit 2026-06-04 · Apache-2.0
  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

## Cross-Compilation
Building for other platforms, embedded, and WebAssembly.

- cross [RECOMMENDED] — https://github.com/cross-rs/cross
  5929561 downloads · v0.2.5 · 8195 stars · last commit 2026-04-23 · Apache-2.0
  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

- probe-rs [RECOMMENDED] — https://github.com/probe-rs/probe-rs
  490303 downloads · v0.31.0 · 2772 stars · last commit 2026-06-02 · Apache-2.0
  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.
  
  Reach for it whenever you develop firmware for microcontrollers. It's irrelevant
  for hosted (non-embedded) targets, and very capable probes with vendor-specific
  features may still need their proprietary tooling.
  alternatives: OpenOCD, cargo-flash, cargo-embed

- wasm-pack — https://github.com/rustwasm/wasm-pack
  4616928 downloads · v0.15.0 · 7197 stars · last commit 2026-05-29 · Apache-2.0
  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

- cargo-zigbuild — https://github.com/rust-cross/cargo-zigbuild
  5341726 downloads · v0.22.3 · 2513 stars · last commit 2026-06-02 · MIT
  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

- trunk — https://github.com/trunk-rs/trunk
  1031671 downloads · v0.22.0-beta.1 · 4305 stars · last commit 2026-03-13 · Apache-2.0
  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

- wasm-bindgen — https://github.com/rustwasm/wasm-bindgen
  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

## Productivity
Language servers, watchers, and general developer ergonomics.

- bacon [RECOMMENDED] — https://github.com/Canop/bacon
  304515 downloads · v3.23.0 · 3289 stars · last commit 2026-05-19 · AGPL-3.0
  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)

- rust-analyzer [RECOMMENDED] — https://github.com/rust-lang/rust-analyzer
  16505 stars · last commit 2026-06-04 · Apache-2.0
  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

- just — https://github.com/casey/just
  1985439 downloads · v1.51.0 · 34098 stars · last commit 2026-05-29 · CC0-1.0
  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: make, cargo-make

- evcxr — https://github.com/evcxr/evcxr
  750023 downloads · v0.21.1 · 6432 stars · last commit 2026-06-02
  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

- watchexec — https://github.com/watchexec/watchexec
  650220 downloads · v2.5.1 · 7010 stars · last commit 2026-05-05 · Apache-2.0
  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)

- IRust — https://github.com/sigmaSd/IRust
  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

- cargo-make — https://github.com/sagiegurari/cargo-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.
  alternatives: just, make