Lib.rs

cargo_metadata

structured access to the output of cargo metadata

cargo-hack

Cargo subcommand to provide various options useful for testing and continuous integration

clap-cargo

Re-usable CLI flags for cargo plugins

cargo-sort

Check if tables and items in a .toml file are lexically sorted

cargo-deb

Make Debian packages (.deb) easily with a Cargo subcommand

cargo-tarpaulin

determine code coverage achieved via tests

cargo-careful

Execute Rust code carefully, with extra checking along the way

flamegraph

cargo subcommand for generating flamegraphs, using inferno under the hood

cargo-llvm-lines

Count the number of lines of LLVM IR across all instantiations of a generic function

cargo-llvm-cov

Cargo subcommand to easily use LLVM source-based code coverage (-C instrument-coverage)

cargo-edit

Cargo commands for modifying a Cargo.toml file

cargo-public-api

List and diff the public API of Rust library crates between releases and commits. Detect breaking API changes and semver violations via CI or a CLI.

cargo-dist

Shippable application packaging for Rust

cargo-leptos

Build tool for Leptos

cargo-zigbuild

Compile Cargo project with zig as linker

dylint

running Rust lints from dynamic libraries

cargo-generate-rpm

Generate a binary RPM package (.rpm) from Cargo projects

cargo-generate

cargo, make me a project

cargo-liner

Cargo subcommand to install and update binary packages listed in configuration

cargo-nextest

A next-generation test runner for Rust

cargo-c

Helper program to build and install c-like libraries

cargo-husky

husky for cargo

cargo-bundle

Wrap rust executables in OS-specific app bundles

cargo-deny

Cargo plugin to help you manage large dependency graphs

cargo-get

Cargo plugin to easily query information from Cargo.toml files

cargo-outdated

Cargo subcommand for displaying when dependencies are out of date

cargo-xwin

Cross compile Cargo project to Windows MSVC target with ease

cargo-supply-chain

Gather author, contributor, publisher data on crates in your dependency graph

cargo-docs-rs

Imitate the documentation build that docs.rs would do

cargo-update

A cargo subcommand for checking and applying updates to installed executables

zepter

Analyze, Fix and Format features in your Rust workspace

cargo-sweep

cleaning unused build files created by Cargo

cargo-ndk

Makes building Rust libraries for Android simpler

cargo-workspaces

Cargo workspace manager

cargo-semver-checks

Scan your Rust crate for semver violations

cargo-component

A cargo extension for authoring WebAssembly components

bender

A dependency management tool for hardware projects

cargo-binutils

Proxy for LLVM tools like llvm-nm, llvm-objdump and llvm-size

cargo-chef

A cargo sub-command to build project dependencies for optimal Docker layer caching

cargo-wix

Build Windows installers using the WiX Toolset

cargo-aoc

Cargo Advent of Code Helper

cargo-sort-derives

Cargo subcommand to sort derive attributes

cargo-appimage

Converts your crate into an AppImage

cargo-all-features

A Cargo subcommand to build and test all feature flag combinations

cargo-instruments

Profile binary targets on macOS using Xcode Instruments

cargo-release

Cargo subcommand for you to smooth your release process

cargo-psp

cargo build wrapper for creating Sony PSP executables

cargo-rdme

Cargo command to create your README.md from your crate’s documentation

cargo-crate

A set of crate related cargo commands. You can for instance get the information about a crate, as text or json, including the owners of a crate and its versions.

cargo-msrv

Find your minimum supported Rust version (MSRV)!

kani-verifier

A bit-precise model checker for Rust

cargo-make

Rust task runner and build tool

cargo-quickinstall

Precompiled binary installs for cargo install

cargo-show-asm

A cargo subcommand that displays the generated assembly of Rust source code

cargo-shear

Detect and fix unused/misplaced dependencies from Cargo.toml

public-api

List and diff the public API of Rust library crates. Relies on rustdoc JSON output from the nightly toolchain.

cargo-run-bin

Build, cache, and run binaries scoped in Cargo.toml rather than installing globally. This acts similarly to npm run and gomodrun, and allows your teams to always be running the same tooling versions.

cargo-upkeep

Unified Rust project maintenance CLI (cargo subcommand)

cargo-changeset

A cargo subcommand for managing changesets

cargo-dtc

Devicetree Compiler packaged for building with cargo

cargo-osdk

Accelerate OS development with Asterinas OSDK

cargo-mobile2

Rust on mobile made easy!

cargo-dinghy

Cross-compilation made easier

cargo-watch

Watches over your Cargo project’s source

rzup

The RISC Zero version management library and CLI

cargo-vita

Cargo wrapper for developing Sony PlayStation Vita homebrew apps

cargo-udeps

Find unused dependencies in Cargo.toml

cargo-temp

Create temporary Rust project with specified dependencies

detect-wasi

Detect if WASI can be run

cargo-hold

CI tool to ensure Cargo's incremental compilation is reliable by managing your caches intelligently

cargo-tomlfmt

Formatting Cargo.toml

cargo-bom

Bill of Materials for Rust Crates

cargo-sonar

Helper to transform reports from Rust tooling for code quality, into valid Sonar report

cargo-unmaintained

Find unmaintained packages in Rust projects

cargo-machete

Find unused dependencies with this one weird trick!

shiguredo_sysroot

cargo subcommand for generating cross compile sysroot

cargo-swift

A cargo plugin to easily build Swift packages from Rust code for use in iOS and macOS applications

cargo-spellcheck

Checks all doc comments for spelling mistakes

cargo-modules

A cargo plugin for showing a tree-like overview of a crate's modules

changepacks

A unified version management and changelog tool for multi-language projects

cargo-firstpage

Shows only the first page of rustc output

cargo-bloat

Find out what takes most of the space in your executable

miho

Repository management tools

cargo-ferris-wheel

🎡 Detect workspace dependency cycles in Rust monorepos

picodata-pike

Cargo plugin for Picodata plugin development

cargo-ci-template

The command line(s) for cargo-ci-template

cargo-dupes

A cargo subcommand that detects duplicate and near-duplicate code blocks in Rust codebases using AST normalization

libcnb-cargo

Cargo command for managing buildpacks written with libcnb.rs

cargo-smart-release

Cargo subcommand for fearlessly releasing crates in workspaces

cargo-prebuilt

Download prebuilt crate binaries for many different platforms

cargo-espflash

Cargo subcommand for interacting with Espressif devices

cargo-credential-pass

Keep your cargo registry tokens encrypted in your pass store

cargo-unused-allow

Detect unused #[allow(...)] attributes in Rust projects

ribir-bot

A CLI tool for managing Ribir releases and changelogs

cargo-packager

Executable packager and bundler distributed as a CLI and library

cargo-templated-examples

Cargo extension for templated running of example

cargo-bisect-rustc

Bisects rustc toolchains with rustup

cargo-delta

Detects which crates in a Cargo workspace are affected by changes in a Git feature branch

cargo-readme

A cargo subcommand to generate README.md content from doc comments

bootimage

create a bootable OS image from a kernel binary

cargo-valgrind

A cargo subcommand for running valgrind

cargo-pgo

Cargo subcommand for optimizing Rust binaries with PGO and BOLT

cargo-hyperlight

cargo subcommand to build hyperlight guest binaries

spotlight-find

Index-powered file search for macOS. Queries Spotlight instead of walking the filesystem.

cargo-cache

Manage cargo cache ($CARGO_HOME or ~/.cargo/), show sizes and remove directories selectively

cargo-hwhkit

cargo hwhkit init 命令

cargo-commitlint

A Rust-based commit message linter following Conventional Commits specification, compatible with commitlint

cargo-pants

cargo subcommand application that provides a bill of materials and a list of which dependencies have a vulnerability, powered by Sonatype OSSIndex

cargo-vendor-filterer

cargo vendor, but with filtering for platforms and more

cargo-bundle-licenses

Bundle licensing of dependencies

tauri-bundler

Wrap rust executables in OS-specific app bundles for Tauri

cargo-onedoc

Generate your README.md from Rust doc comments

cargo-insert-docs

Inserts feature docs into crate docs, and crate docs into README

cargo-chec

A cargo subcommand to run cargo check and output filtered error messages as a JSON array

cargo-easy-dep

Simplifies dependency management in Rust workspaces by unifying common workspace members' dependencies in workspace

cargo-wgsl

Validate wgsl in rust projects

semwave

Static analysis tool for semver bump propagation in Cargo workspaces

cargo-skyline

A cargo subcommand for working with Skyline plugins written in Rust

cargo-rail

Graph-aware testing, dependency unification, and crate extraction for Rust monorepos

crm

crm can help you easy and fast switch between different cargo registries, now include: sjtu, tuna, ustc, rsproxy, bfsu, nju, hit, cqu, zju, CERNET

libbpf-cargo

Cargo plugin to build bpf programs

cargo-archtest-cli

CLI of arch_test_core for rule based architecture tests

cargo-clean-all

Recursively clean all cargo projects in a given directory that match the specified criteria

cargo-info

Extends cargo to query crates.io registry for crates details

cargo-limit

Cargo with less noise: warnings are skipped until errors are fixed, Neovim integration, etc

cargo-features

Power tools for working with (conditional) features

hash-crate

generating deterministic hashes of local crates

cargo-gc-bin

Garbage collect outdated cargo build artifacts

hddsgen

IDL 4.2 parser and code generator for HDDS

detect-targets

Detect the target of the env at runtime

cargo-cross

A cargo subcommand for cross-compilation, no need docker!

cargo-buckal

Seamlessly build Cargo projects with Buck2

cargo-nav

Navigate directly to crate links from your terminal

cargo-files

List all source files in a cargo crate

cargo-duckdb-ext-tools

A cargo subcommand that packages DuckDB extensions by appending the required extension metadata to a compiled dynamic library

cargo-duplicates

Cargo subcommand for displaying when different versions of a same dependency are pulled in

cargo-clean-recursive

A cargo subcommand cleans all projects under specified directory

cargo-dylint

running Rust lints from dynamic libraries

cargo-3ds

Cargo wrapper for developing Nintendo 3DS homebrew apps

cargo-subunit

Cargo extension to run tests and output results in subunit format

cargo-local-registry

A Cargo subcommand for managing local registries

cargo-alias-exec

Extend cargo aliases to arbitrary commands

fli

The commander.js like CLI Parser for rust

cargo-px

A cargo sub-command to overcome some of the limitations of build scripts for code generation

cargo-license

Cargo subcommand to see license of dependencies

cargo-sync-rdme

Cargo subcommand to synchronize README with crate documentation

cargo-upgrades

Checks if dependencies in Cargo.toml are up to date. Compatible with workspaces and path dependencies.

tazui

terminal calculator

cargo-wasix

Subcommand for Cargo to easily build code for wasm32-wasmer-wasi and wasm64-wasmer-wasi targets; aka. WASIX targets.

cargo-detect-package

A Cargo tool to detect the package that a file belongs to, passing the package name to a subcommand

boots

Rust template generator for modular architectures(monorepo)

cargo-rerun

that runs cargo run and automatically restarts when watched files change

cargo-featalign

Cargo features alignment tool

crates-io-cli

Interact with crates.io from the command-line

cargo-resources

Cargo Resources provides a cargo command line tool and library, to help declare and collate resources within Cargo Crates

cargo-ibuild

cargo-auto

Automation tasks coded in Rust language for the workflow of Rust projects

cargo-piston

streamlining the configuration of rust binaries for various operating systems

cargo-afl

Fuzzing Rust code with american-fuzzy-lop

cargo-msrv-prep

Cargo subcommand useful to prepare for determining/verifying a crate's MSRV

cargo-simplebench

minimalist microbenchmarking framework with clear regression detection

cargo-feature-combinations

run cargo commands for all feature combinations

cargo-mcp

mcp server for cargo commands

cargo-codspeed

Cargo extension to build & run your codspeed benchmarks

cargo-selector

Cargo subcommand to select and execute binary/example targets

cvefixer

Fix all vulnerabilities that are fixed

cargo-governor

Machine-First, LLM-Ready, CI/CD-Native release automation tool for Rust crates

releasor2000

Release your bin everywhere*

cargo-usage-rules

A cargo subcommand to aggregate usage-rules.md files from Rust dependencies for AI agent consumption. Inspired by https://github.com/ash-project/usage_rules

rustdoc-json

working with rustdoc JSON

cargo-about

Cargo plugin for generating a listing of all of the crates and the the terms under which they are licensed

cargo-progenitor

A cargo command to generate a Rust client SDK from OpenAPI

cargo-wash

clean up your Cargo caches

cargo-workspace-deps

A Cargo subcommand that consolidates shared dependencies to workspace.dependencies

cargo-manifest-check

Check the formatting of your manifest files

cargo-focus

A Cargo subcommand for managing workspace.default-members

cargo-quality

Professional Rust code quality analysis tool with hardcoded standards

cargo-lockdiff

See what crates have changed after you run cargo update by comparing Cargo.lock to the vcs ref or file of your choice

cargo-wdk

A Cargo extension for developing Windows drivers in Rust

cargo-copter

Test dependents against multiple versions of your crate (or your local WIP before publishing). Inspired by the cargo-crusader

cargo-compete

A Cargo subcommand for competitive programming

cargo-verison

Bump a package version

cargo-regression

Collect test task from input files, execute them and compare results with golden

cargo-autoinherit

A cargo sub-command to leverage dependency inheritance wherever possible

cargo-culting

Cargo subcommand that adds mass-downloaded dependencies without understanding why

cargo-doc2readme

cargo subcommand to create a readme file containing the rustdoc comments from your code

cargo-subspace

rust-analyzer work better with very large cargo workspaces

ddt

Useful cli tools

cargo-hakari

Manage workspace-hack packages to speed up builds in large workspaces

lmrc-cargo-workspace

Cargo workspace management library for the LMRC Stack - comprehensive library for managing Cargo workspaces programmatically

cargo-safe-publish

A safer version of cargo publish

cargo-coupling

A coupling analysis tool for Rust projects - measuring the 'right distance' in your code

chronsync

Lightweight, real-time reloading cron-like task scheduler daemon

evcxr

An Evaluation Context for Rust

cargo-reedme

Generate README.md from doc comments in lib.rs

cargo-zbuild

redpen-linter

Rust linter

cargo-list

List and update installed crates

cargo-cyclonedx

CycloneDX Software Bill of Materials (SBOM) for Rust Crates

cargo-stale

A fast, concurrent tool to check for outdated dependencies in your Rust Cargo.toml file

cargo_pup

architectural linting tool that integrates with rustc to enforce architectural patterns and boundaries

cargo-playdate

Build tool for neat yellow console

cargo-perf

Preventive performance analysis for Rust - catch anti-patterns before production

cargo-multivers

Cargo subcommand to build multiple versions of the same binary, each with a different CPU features set, merged into a single portable optimized binary

prevail

eBPF Verifier using Abstract Interpretation

battery-pack

Curated crate bundles with docs, templates, and agentic skills

cargo-omnibus

A thin wrapper around Cargo that generates an omnibus crate bundling multiple Rust libraries

cargo-newcpp

A cargo plugin for creating new C++ projects

cargo-samply

A cargo subcommand to automate the process of running samply for project binaries

cargo-xfmt

Safely use nightly fmt options without using unstable Rust

cargo-examples

Run all examples for any locally cloned crate

e_obs

control OBS via websocket. Open Broadcaster Software control for use with cargo-e

cargo-doc-docusaurus

Cargo subcommand to generate Docusaurus-compatible documentation for Rust crates and dependencies

cargo-sponsor

Find sponsorship links for your Rust project's dependencies

cargo-test-r

Test framework for Rust - cargo extensions

cnp

written in Rust to check unused node packages

rustmerge

A Cargo subcommand that merges all Rust source files in a package into a single file

cargo-open

Cargo command to open an installed crate in your editor

cargo-goggles

Verify that registry crates in your Cargo.lock are reproducible from the git repository

cargo-lipo

cargo lipo subcommand to automatically create universal libraries for iOS

cargo-no-dev-deps

Cargo subcommand for running cargo without dev-dependencies

sheepit

releasing projects 🚀

brewery

A fast, friendly TUI for Homebrew

cargo-winapp

Cargo subcommand for Windows app development with winapp CLI

contrail-cli

Contrail CLI: service lifecycle plus history import and cross-machine export/merge

tracel-xtask-cli

CLI entrypoint for Tracel xtask

cargo-outdir

A cargo subcommand to get the $OUT_DIR environment variable from build scripts

cargo-sort-fix

Check if tables and items in a .toml file are lexically sorted

cargo-bolero

cargo command for running bolero fuzz tests

cargo-mkrs

Cargo subcommand for generating Rust files

xtask-watch

A customizable helper to watch for changes in your projects using xtask

cargo-steady-state

Code generator for steady_state projects based on a structured dot file

stack-assembly

minimalist, stack-based, assembly-like programming language

cargoe

Advanced Cargo.toml management CLI tool

cargo-tally

Cargo subcommand for drawing graphs of the number of dependencies on a crate over time

cargo-rename

Perform a coordinated, all-or-nothing rename of a Cargo package

cargo-generate-type

Cargo subcommand to generate Rust code from and for input data

xcframework

A Cargo plugin and library for building Apple XCFrameworks

mdbook-tailor

mdbook preprocessor for image-tailor

core-grep

core grep project

cargo-stitch

A Cargo subcommand that applies source-level patches and ast-grep rules to workspace crates before compilation

cargo-cargo

Literally, cargo cargo cargo cargo cargo

cargo-preflight

A custom Cargo subcommand to run local 'CI' on certain Git actions

cargo-anatomy

Analyze Rust workspaces and report package metrics

cargo-binlist

List all installed binaries with cargo and their versions

cargo-test-filter

A cargo subcommand for intelligent test filtering and compilation

eqlog

Datalog with equality

cargo-v5

Cargo tool for working with VEX V5 Rust projects

cargo-uv

Cargo tool for updating the version in your project

cargo-clone

A cargo subcommand to fetch the source code of a Rust crate

cargo-countlines

count SLOC

cargo-resolvediff

diffing cargo dependency resolutions between updates

cargo-qtest

an interactive test runner for rust projects

cargo-warp

Build then copy your project binary to a remote host

dockpack

Command line tool for unpacking files from Docker images

cargo-new-workspace

A tiny binary that creates a minimal Cargo.toml file that a workspace requires

cargo-unlock

Remove Cargo.lock lockfile

tinyrick_extras

common tasks for tinyrick projects

cargo-authors

A subcommand for cargo that lists all the authors of all the dependencies of the crate in your current working directory. Simply install, then navigate to the directory of a crate and run cargo authors

cargo-index

Cargo subcommand to manage a registry index

cargo-rootfs

Install or release a package in the rootfs, including extra files or directories

cargo-show

Prints package metadata like pip show, apt-cache show, npm view, gem query, etc

cargo-prompt

Recursively minify and concatenate source code into a markdown document for llm prompting

rustidy-ast-tokens

Rustidy formatter

kovi-cli

kovi cli

cargo-risczero

RISC Zero CLI tools

cargo-shuttle

CLI for the Shuttle platform (shuttle.dev)

xtest-data

Fetch auxiliary test data when testing published crates

cargo-atomic

A CLI tool to help make local git commits easier

cargo-advrunner

An advanced configurable cargo runner

axotag

share tag-parsing code between axodotdev projects

cargo-kit

Cargo subcommand to apply performance, compile-time, or size-optimized profiles and configs to your Rust project for enhanced build efficiency

cargo-flaky

A cargo sub-command to helps you find flaky tests

for-all-projects

run cargo commands for all projects in a directory, recursively

mtoc

Generate a table of contents for markdown files

badgeland

Fast badge generator for any purpose

cargo-owi

Cargo wrapper for the owi bug finding tool

cargo-thanku

Generate acknowledgments for your Rust project dependencies

licenses

Cargo subcommand for collecting licenses

cargo-ensure-no-cyclic-deps

A cargo subcommand to detect cyclic dependencies in workspace crates

cargo-neat

complement cargo-machete and remove unused workspace dependencies

crunch-app

Turbocharge your Rust workflow with crunch

cargo-ledger

Build and sideload Ledger apps

cargo-ament-build

Cargo plugin for use with colcon workspaces

cargo-xbuild

Automatically cross-compiles the sysroot crates core, compiler_builtins, and alloc

cargo-extract-test

A Cargo subcommand to extract and run a single test function in isolation

cargo-test-json-2-html

Convert cargo test JSON output to beautiful, self-contained HTML reports

cargo-single-line

A cargo plugin to shrink cargo's output

cargo-vcpkg

A cargo subcommand to build a vcpkg tree from metadata entries in Cargo.toml for a top level crate and the crates that it depends on

group-runner

Group Rust executable output in GitHub logs

typestorm

A cool terminal typing test CLI written in rust

cargo-avail

Check whether crate names are truly available on crates.io

cargo-depgraph

Creates dependency graphs for cargo projects using cargo metadata and graphviz

cargo-jet

Build and run your Rust projects effortlessly on a remote machine! 🦀⚡

cargo-nvim

A Neovim plugin for Rust Cargo commands

symposium-cargo

Symposium Cargo proxy - an MCP server connecting to Cargo and a ACP Proxy managing it

cargo-hammerwork

A comprehensive cargo subcommand for managing Hammerwork job queues with webhook management, event streaming, database operations, and advanced monitoring capabilities

cargo-nfpm

lightweight Cargo plugin for using nFPM from Any Rust project

cargo-arc

Visualize crate and module dependencies in Cargo workspaces

cargo-prosa

ProSA utility to package and deliver a builded ProSA

cargo-anaxa

A modern native Rust configuration management system

cargo-geiger

Detects usage of unsafe Rust in a Rust crate and its dependencies

zerus

Lightweight binary to download only project required crates for offline crates.io mirror

cargo-ovft

A Cargo plugin for Open Very Fast Trace - requirements traceability for Rust projects

rust-cargo-test2

rust cargo test

ros_new

Cargo plugin to create new ROS2 Rust packages with package.xml

antislop

A blazing-fast, multi-language linter for detecting AI-generated code slop

cargo-ruin

Ruins your project with different options

copilot

MCP Server for Cargo

cargo-local

A third-party cargo extension that lists local source locations of dependencies

rerast

An AST (abstract syntax tree) based search replace tool for code written in Rust

udonsharp-cli

Command-line interface for Rust UdonSharp development

cargo-whatfeatures

display features, versions and dependencies of crates

lockdiff

Display more readable diffs for lock files

cargo-env-run

Like dotenv but with .cargo/config.toml files

cargo-xcode

Make Xcode project files from Cargo projects

cargo-commander

Like npm scripts, but better

cargo-execute

A Cargo subcommand to execute a command in the context of a Cargo project

cargo-bazel

A collection of tools which use Cargo to generate build targets for Bazel

handling

Cargo extensions for binary management

cargo-goose

A strict, explicit SemVer CLI with first-class prerelease support

cargo-depcription

Transforms your rust project dependencies into an explicative dependency choice markdown table!

cargo-hackerman

Workspace hack management and package/feature query

exporter

Contrail exporter for filtered JSONL datasets

cargo-unload

A command for handling cargo unload operations

cargo-oxur

Cargo subcommand for building Oxur Lisp projects

cargo-task

Ultra-Lightweight Zero-Dependency Rust Cargo Task Runner

cargo-ecos

ECOS embedded project cargo plugin

cargo-tighterror

The cargo plugin of the tighterror framework

cargo-set-version

A Cargo subcommand to set versions for crates in a workspace

cargo-release-oxc

Oxc release management

e_crate_version_checker

check for newer versions of Rust crates on crates.io and interactively update them

cargo-testdox

A Cargo subcommand to print your test names as sentences

igor

Generic text-based vendoring

cargo-qemu-runner

A cargo subcommand that allows running Limine kernels using cargo run

cargo-override

Quickly override dependencies using the [patch] section of Cargo.tomls

cargo-extract

Cargo subcommand to extract information from Cargo.toml files

cargo-setup

Cargo subcommand to scaffold projects with README, LICENSE, tests/, benches/, using your cargo-me profile

cargo-altvup

Rust module + alt:V server installer

safe-cargo

Build and runs code in a sandboxed environment

cargo-llms-txt

Cargo subcommand to generate llms.txt and llms-full.txt from Rust projects

cargo-polkajam

A cargo subcommand for generating JAM service projects for Polkadot

cargo-nixpackage

A small utility to scaffold Rust projects with Nix Flake support

cargo-pak

Generate manifest and desktop files for flatpak

struct_iterable

providing a proc macro to make a struct iterable

cargo-swell

cargo expand without automatically derived items

cargo-fixup

A Cargo helper that installs a rustc-wrapper to dynamically patch crate source code at build time — no need to modify Cargo.toml or maintain forks

cargo-terse

Concise cargo output for AI-assisted workflows

httpdiff

comparing the differences between 2 HTTP GET requests

cargo-nnd

Cargo subcommand for easily starting nnd

cargo-local-install

Wraps cargo install for better local, non-conflicting installation

disperse

automation for creation of releases

cargo-verset

A cargo plugin to change the version of a package in the Cargo.toml file

cargox-cli

Run Cargo binaries on demand, installing them via cargo-binstall when missing

deepclean

A fast, parallel tool to clean Rust projects and remove unused dependencies

cargo-doc-viewer

Enhance rustdoc HTML with a richer UI and AI-assisted chat via cargo doc-enhance

cargo-install-describe

A cargo subcommand to list installed cargo binaries with descriptions and metadata

nj-cli

build tool for node-bindgen

cargo-wef

command line tool for wef

cargo-i18n

Cargo sub-command to extract and build localization resources to embed in your application/library

cargo-jump

A single command to bump versions in a Cargo workspace based on changed files

cargo-lpatch

A cargo plugin to locally patch dependencies by cloning them and setting up local patches

cargo-cycles

A cargo extension for detecting dependency cycles between crates and within modules for a workspace

ros_add

The Purpose of the Package is to provide the cargo ros_add command to add dependencies to Cargo.toml and the package.xml

cargo-doc-md

Cargo subcommand to generate markdown documentation for Rust crates and dependencies

cargo-zoo

OS development

cargo-fetch-source

Declare and fetch external sources programmatically

cargo-minimal-versions

Cargo subcommand for proper use of -Z minimal-versions and -Z direct-minimal-versions

cargo-csc

Code spell checking

cargo-extensions

cargo extensions

cargo-indicate

running GraphQL queries on Rust dependency trees

cargo-groups

Run cargo commands on a groups of crates in a workspace

cargo-deadlinks

Cargo subcommand for checking your documentation for broken links

cargo-screeps

Build tool for deploying Rust WASM code to Screeps game servers

cargo-q

A Cargo subcommand for running multiple Cargo commands sequentially or in parallel

cargo-ws

cargo plugin, generate vscode workspace file

prox

development process manager like foreman, but better!

cargo-subcommand

creating cargo subcommands

cargo-featurex

cargo plugin to run tasks against feature powersets

cargo-publish-crates

Publish rust crates with support for cargo workspaces

cargo-deps

Cargo subcommand for building dependency graphs of Rust projects

cargo-mono

Cargo subcommand to manage mono repository

cargo-information

A cargo subcommand to show information about crates

cargo-oj

package a crate into single file, minimized and formatted

cargo-operi

Cargo subcommand for Operi SDK development

cargo-feature-matrix

run cargo commands on a matrix of feature sets

braise

Run your tasks like a chef !