100 Best Apps for Rust Developers
Rust development spans far more than a compiler. These first 25 tools cover the core workflow, from toolchain setup and editing to testing, security, documentation, and performance analysis.
Rustup
Rustup installs, updates, and switches Rust toolchains, targets, and components from a command-line interface. It reduces friction when projects require different compiler versions, targets, or optional tooling.
Cargo
Cargo builds, tests, runs, packages, and manages dependencies for Rust crates and workspaces. It centralizes routine project commands, preventing developers from manually coordinating builds and dependency versions.
rustc
rustc is Rust's compiler, transforming Rust source code into executable binaries or library artifacts. It catches type, ownership, lifetime, and safety errors before code reaches production environments.
rust-analyzer
rust-analyzer provides language-server features including completion, diagnostics, navigation, refactoring, and inline type information. It makes large Rust codebases easier to understand by bringing compiler-aware assistance directly into editors.
Visual Studio Code
Visual Studio Code is an extensible editor commonly paired with rust-analyzer for Rust development. It gives developers a flexible cross-platform workspace for coding, debugging, terminals, and source control.
IntelliJ Rust
IntelliJ Rust is a Rust plugin for JetBrains IDEs that adds coding assistance and project tooling. It helps teams already using JetBrains workflows work with Rust without changing their familiar environment.
RustRover
RustRover is JetBrains' dedicated Rust IDE with code analysis, debugging, testing, and Cargo integration. It bundles Rust-focused development features into one environment for developers preferring a full IDE.
CLion
CLion is a JetBrains C and C++ IDE that can support Rust through the IntelliJ Rust plugin. It supports mixed native-code projects where developers need to navigate Rust alongside C or C++.
Neovim
Neovim is a highly configurable terminal editor that supports Rust through language-server integrations and plugins. It serves developers seeking a keyboard-driven, lightweight editing environment tailored to their workflow.
Helix
Helix is a terminal-based editor with built-in language-server support and Rust-aware editing features. It offers modern code navigation and diagnostics without requiring extensive editor plugin configuration.
Zed
Zed is a collaborative code editor supporting Rust language features through language-server integrations. It helps distributed developers edit and discuss code together in a responsive shared workspace.
cargo-edit
cargo-edit adds Cargo subcommands for adding, removing, upgrading, and managing dependency declarations. It avoids error-prone manual edits to Cargo.toml when changing a project's crate dependencies.
cargo-watch
cargo-watch monitors file changes and automatically runs chosen Cargo commands during development. It eliminates repeated manual test or build commands while developers iterate on source files.
cargo-nextest
cargo-nextest is a Rust test runner designed to execute Cargo test suites efficiently. It helps projects with extensive tests reduce feedback delays and better manage test execution.
Clippy
Clippy is Rust's linter, offering additional diagnostics and suggestions beyond standard compiler warnings. It identifies common mistakes and non-idiomatic patterns before they become costly review comments.
rustfmt
rustfmt automatically formats Rust source files according to consistent community formatting conventions. It ends formatting debates and reduces noisy diffs caused by inconsistent code style.
cargo-audit
cargo-audit checks Rust dependency lockfiles against the RustSec advisory database for known vulnerabilities. It gives teams a repeatable way to spot publicly disclosed security issues in dependencies.
cargo-deny
cargo-deny checks dependency graphs for advisories, licenses, source restrictions, and duplicate crate versions. It helps teams enforce dependency policies before problematic packages enter production software.
Trunk
Trunk builds, bundles, and serves Rust WebAssembly applications for browser-based development and deployment. It simplifies the multi-step frontend workflow of compiling Rust, handling assets, and refreshing browser builds.
wasm-pack
wasm-pack builds Rust-generated WebAssembly packages and prepares them for use with JavaScript tooling. It reduces the complexity of packaging Rust code for JavaScript and browser ecosystems.
mdBook
mdBook builds searchable online books from Markdown files, including Rust code examples and chapters. It lets teams publish maintainable technical documentation without assembling a custom documentation website.
rustdoc
rustdoc generates API documentation from Rust source comments and can test documented code examples. It keeps public API documentation close to implementation and catches outdated examples through testing.
tokio-console
tokio-console visualizes runtime activity for Tokio applications, including tasks, resources, and scheduling behavior. It helps developers investigate asynchronous slowdowns and stuck tasks that ordinary logs can obscure.
cargo-flamegraph
cargo-flamegraph records profiling data and produces flame graphs for Rust program performance analysis. It reveals where programs spend CPU time, guiding optimization work toward meaningful bottlenecks.
Criterion.rs
Criterion.rs is a statistics-driven benchmarking library for measuring and comparing Rust code performance. It helps developers detect performance regressions with repeatable benchmarks instead of unreliable timing guesses.
Bacon
Bacon continuously checks Rust projects and presents compiler diagnostics in a terminal interface. It reduces manual check reruns by automatically refreshing actionable build feedback during development.
cargo-expand
cargo-expand prints Rust source code after macro expansion for inspection and debugging. It helps developers understand generated code when macro errors obscure the original source.
cargo-udeps
cargo-udeps identifies declared Rust dependencies that are not used by a project. It helps teams remove unnecessary crates that complicate manifests, builds, and maintenance.
cargo-machete
cargo-machete scans Cargo manifests for dependencies that appear unused in project code. It reduces dependency clutter by highlighting crates developers may safely investigate removing.
cargo-geiger
cargo-geiger reports unsafe Rust usage across a project's dependency graph. It gives security-conscious teams visibility into unsafe code before reviewing dependency risks.
cargo-mutants
cargo-mutants performs mutation testing by altering code and running a Rust project's tests. It exposes weak test suites when tests still pass after meaningful code changes.
cargo-tarpaulin
cargo-tarpaulin runs Rust tests and produces code coverage measurements on supported platforms. It helps developers find untested code paths before relying too heavily on passing tests.
cargo-llvm-cov
cargo-llvm-cov generates Rust code coverage reports using LLVM's coverage instrumentation. It simplifies coverage collection for teams needing readable reports from their existing test commands.
cargo-semver-checks
cargo-semver-checks compares Rust crate APIs to detect potential semantic-versioning violations. It helps library maintainers catch breaking public API changes before publishing releases.
cargo-release
cargo-release automates common Rust crate release tasks, including versioning, tagging, and publishing. It reduces error-prone release checklists for maintainers publishing crates through Cargo workflows.
cargo-dist
cargo-dist builds and packages release artifacts for Rust applications across supported targets. It streamlines distribution work when developers need consistent binaries for multiple platforms.
cross
cross provides Docker-based cross-compilation workflows for building Rust projects on other targets. It helps developers avoid manually configuring toolchains and system libraries for target platforms.
cargo-zigbuild
cargo-zigbuild uses Zig as a linker to cross-compile Rust projects for multiple targets. It eases cross-platform builds when native linker setup is difficult or inconsistent.
sccache
sccache caches compilation outputs to speed up repeated builds across supported compilers. It reduces waiting on unchanged compilation work during local development and continuous integration.
mold
mold is a high-performance linker that can link compatible Rust build outputs quickly. It shortens linking delays that can make iterative compilation feel sluggish on large projects.
just
just is a command runner that defines repeatable project tasks in a Justfile. It replaces forgotten shell commands with shared, readable shortcuts for routine development tasks.
cargo-make
cargo-make defines and runs Rust project tasks through configurable Makefile-style task files. It organizes build, test, and automation commands that otherwise drift across individual developer scripts.
cargo-generate
cargo-generate creates new Rust projects from reusable Git repository templates. It saves setup time when teams repeatedly create projects with similar structure and configuration.
cargo-binstall
cargo-binstall installs Rust command-line tools from available prebuilt binary releases. It avoids lengthy local compilation when developers need a supported Rust tool quickly.
cargo-outdated
cargo-outdated checks Rust dependencies and reports newer compatible crate versions. It helps maintainers spot aging dependencies without manually comparing registry versions and constraints.
cargo-tree
cargo-tree displays a Rust project's dependency graph in a navigable textual tree. It clarifies transitive dependency relationships when unexpected crates or version conflicts appear.
cargo-bloat
cargo-bloat analyzes Rust binaries to show which functions and crates consume space. It helps developers target size reductions when compiled applications or libraries become unexpectedly large.
cargo-fuzz
cargo-fuzz integrates libFuzzer with Rust projects for automated fuzz testing. It finds crash-inducing edge cases that conventional example-based tests often fail to cover.
cargo-hack
cargo-hack tests Rust crates across feature combinations and package workspace configurations. It catches feature-flag incompatibilities before users encounter untested dependency or build combinations.
Cucumber-rs
Cucumber-rs runs behavior-driven Rust tests written with Gherkin feature specifications. It connects product scenarios to executable tests when stakeholders need clearer acceptance criteria.
proptest
proptest generates randomized, shrinking test cases from property definitions for Rust code. It helps developers uncover edge cases without manually enumerating large sets of test inputs.
QuickCheck
QuickCheck performs property-based testing by generating inputs and checking declared behavioral properties. It reduces the risk that handpicked tests miss unexpected inputs and boundary conditions.
Insta
Insta provides snapshot testing for Rust, comparing structured outputs against committed reference files. It makes reviewing changes to complex output easier than maintaining many verbose assertions.
trybuild
trybuild runs compile-fail and compiler-diagnostic tests for Rust crates and macros. It helps library authors verify that invalid code produces intended compiler errors.
Loom
Loom systematically tests concurrent Rust code by exploring possible thread scheduling interleavings. It helps identify race conditions that ordinary tests may fail to reproduce reliably.
Miri
Miri interprets Rust programs to detect undefined behavior and memory-model violations. It helps developers find unsafe-code defects before they become difficult runtime failures.
cargo-vet
cargo-vet manages dependency audit records and policy criteria within Rust projects. It gives teams a structured way to assess third-party crate trust and review status.
cargo-crev
cargo-crev supports distributed code reviews and trust assessments for Rust package dependencies. It helps developers evaluate unfamiliar crates when centralized security reviews are unavailable.
cargo-msrv
cargo-msrv finds and verifies the minimum supported Rust version for a crate. It removes guesswork when maintaining compatibility with users on older Rust toolchains.
cargo-minimal-versions
cargo-minimal-versions tests dependency resolution using the lowest versions allowed by Cargo manifests. It exposes overly broad dependency version requirements before downstream builds unexpectedly fail.
cargo-llvm-lines
cargo-llvm-lines reports generated LLVM IR line counts for functions and generic instantiations. It helps pinpoint monomorphization and inlining sources behind unexpectedly large compiled binaries.
cargo-depgraph
cargo-depgraph generates Graphviz dependency graphs for Rust crates and workspace packages. It makes complex dependency relationships easier to inspect than reading manifests individually.
cargo-modules
cargo-modules displays a Rust crate's module structure from the command line. It helps contributors orient themselves quickly in unfamiliar codebases with deep module trees.
cargo-sort
cargo-sort organizes Cargo.toml dependencies, features, and package metadata into consistent order. It prevents noisy manifest diffs caused by inconsistent ordering across contributors.
cargo-feature
cargo-feature provides commands for managing feature declarations and configurations in Cargo projects. It reduces manual manifest editing when crates expose numerous optional compilation features.
cargo-whatfeatures
cargo-whatfeatures identifies which dependencies activate particular features in a Cargo dependency graph. It helps explain unexpected transitive features that increase build times or binary capabilities.
cargo-workspaces
cargo-workspaces automates versioning, changelog, publishing, and dependency updates across Rust workspaces. It reduces repetitive release coordination for repositories containing several interdependent crates.
cargo-lambda
cargo-lambda builds, tests, and deploys Rust functions for AWS Lambda environments. It streamlines Lambda packaging challenges that otherwise require platform-specific build configuration.
cargo-leptos
cargo-leptos builds, serves, and deploys full-stack applications created with the Leptos framework. It simplifies coordinating client and server builds for Rust web application projects.
cargo-tauri
cargo-tauri provides development, build, bundling, and signing commands for Tauri applications. It reduces the tooling friction of packaging Rust-backed desktop and mobile applications.
diesel_cli
diesel_cli creates, runs, reverts, and manages database migrations for Diesel applications. It gives database schema changes a repeatable workflow instead of relying on ad hoc SQL.
sqlx-cli
sqlx-cli manages SQLx database migrations and prepares metadata for offline query checking. It helps teams keep database migrations and compile-time SQL validation workflows consistent.
SeaORM CLI
SeaORM CLI generates entity code and manages database migrations for SeaORM projects. It saves developers from manually translating database schemas into repetitive Rust entity definitions.
bindgen
bindgen generates Rust foreign-function interface bindings from C and C++ header files. It avoids error-prone hand-written bindings when integrating Rust with native libraries.
cbindgen
cbindgen generates C and C++ header files from Rust library public interfaces. It helps library maintainers expose stable native interfaces without manually synchronizing header declarations.
wasm-bindgen
wasm-bindgen generates bindings that let Rust-compiled WebAssembly communicate with JavaScript and browser APIs. It reduces the tedious manual glue code needed when connecting Rust WebAssembly modules to web interfaces.
wasm-opt
wasm-opt optimizes WebAssembly binaries using Binaryen passes to reduce size and improve generated code. It helps developers address slow-loading or oversized WebAssembly artifacts without hand-tuning compiled output.
wasm-tools
wasm-tools provides command-line utilities for inspecting, validating, composing, and manipulating WebAssembly components. It helps teams diagnose unfamiliar WebAssembly binaries and component metadata through focused inspection commands.
cargo-component
cargo-component adds Cargo workflows for building Rust libraries that target the WebAssembly Component Model. It simplifies packaging component-based WebAssembly projects that otherwise require several specialized build steps.
wit-bindgen
wit-bindgen generates language bindings from WebAssembly Interface Types definitions for component-based application interfaces. It removes repetitive interoperability code when Rust components must implement or consume standardized WIT interfaces.
Dioxus CLI
Dioxus CLI provides commands for creating, serving, and building applications made with the Dioxus framework. It streamlines local development workflows for Dioxus projects by centralizing common framework commands.
Evcxr
Evcxr is an interactive Rust evaluation environment that runs code snippets in a notebook-like session. It helps developers quickly test language ideas without creating, compiling, and maintaining a full project.
Rust Playground
Rust Playground is a browser-based environment for writing, compiling, running, and sharing Rust code. It eliminates setup friction when developers need to reproduce examples or share small Rust experiments.
Compiler Explorer
Compiler Explorer compiles Rust code online and displays generated assembly alongside source code and compiler output. It helps performance-minded developers inspect how source changes affect machine code without local tooling.
GitHub Actions
GitHub Actions automates repository workflows, including Rust builds, tests, releases, and pull-request checks. It reduces manual validation work by running consistent checks whenever code changes enter a repository.
GitLab CI/CD
GitLab CI/CD runs configurable pipelines for building, testing, and deploying Rust projects from GitLab repositories. It helps teams standardize delivery steps and catch integration failures before changes reach production.
Buildkite
Buildkite orchestrates continuous integration pipelines using agents that execute jobs in your chosen infrastructure. It helps teams run customized Rust build pipelines while retaining control over execution environments.
CircleCI
CircleCI provides hosted continuous integration pipelines for automatically building, testing, and delivering software. It reduces the burden of maintaining repetitive build automation for Rust repositories and release branches.
Sentry
Sentry collects application errors and performance data, helping teams investigate failures in deployed Rust services. It helps developers find production failures faster by grouping error events with diagnostic context.
Datadog
Datadog provides infrastructure monitoring, logs, traces, and dashboards for observing deployed Rust applications. It centralizes operational signals when developers struggle to connect service behavior with infrastructure conditions.
Grafana
Grafana creates dashboards and visualizations from observability data sources such as metrics, logs, and traces. It helps teams understand changing service health by presenting operational data in configurable visual dashboards.
Prometheus
Prometheus collects time-series metrics and evaluates alerting rules for monitoring services and infrastructure. It helps developers detect reliability regressions by recording measurable application and system behavior over time.
OpenTelemetry
OpenTelemetry provides standards and tooling for generating, collecting, and exporting traces, metrics, and logs. It reduces fragmented observability instrumentation by giving Rust services a common telemetry data model.
Docker
Docker packages applications and dependencies into containers that run consistently across development and deployment environments. It helps prevent environment-specific failures by giving Rust services reproducible runtime packaging and configuration.
Podman
Podman builds, runs, and manages containers through a daemonless command-line container engine. It offers a container workflow for developers who need rootless operation or daemonless local tooling.
Postman
Postman lets developers send, organize, test, and document HTTP requests against APIs. It makes API debugging faster when Rust backend endpoints need repeatable manual request testing.
HTTPie
HTTPie is a command-line HTTP client with readable syntax for sending and inspecting web requests. It reduces friction when developers need quick API checks directly from a terminal session.
DBeaver
DBeaver is a database client for browsing, querying, and managing many relational and nonrelational databases. It helps developers inspect application data without writing one-off database commands for every investigation.
pgAdmin
pgAdmin is an administration and query tool for managing PostgreSQL databases through graphical interfaces. It simplifies PostgreSQL inspection and maintenance when Rust services use complex schemas or migrations.
Redis Insight
Redis Insight provides a graphical interface for browsing, querying, and monitoring Redis data and connections. It helps developers troubleshoot cached values and Redis structures without relying solely on command-line queries.
Together, these tools establish a productive Rust foundation; the remaining entries expand into deployment, observability, databases, APIs, and collaboration.