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

cargo-generate-rpm

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

cargo-llvm-lines

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

cargo-edit

Cargo commands for modifying a Cargo.toml file

cargo-dist

Shippable application packaging for Rust

dylint

running Rust lints from dynamic libraries

flamegraph

cargo subcommand for generating flamegraphs, using inferno under the hood

cargo-c

Helper program to build and install c-like libraries

cargo-llvm-cov

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

bender

A dependency management tool for hardware projects

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-deny

Cargo plugin to help you manage large dependency graphs

cargo-generate

cargo, make me a project

cargo-sort-derives

Cargo subcommand to sort derive attributes

cargo-nextest

A next-generation test runner for Rust

cargo-zigbuild

Compile Cargo project with zig as linker

cargo-bundle

Wrap rust executables in OS-specific app bundles

cargo-get

Cargo plugin to easily query information from Cargo.toml files

cargo-rdme

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

cargo-outdated

Cargo subcommand for displaying when dependencies are out of date

cargo-husky

husky for cargo

cargo-release

Cargo subcommand for you to smooth your release process

cargo-temp

Create temporary Rust project with specified dependencies

cargo-leptos

Build tool for Leptos

cargo-ndk

Makes building Rust libraries for Android simpler

cargo-sweep

cleaning unused build files created by Cargo

picodata-pike

Cargo plugin for Picodata plugin development

cargo-xwin

Cross compile Cargo project to Windows MSVC target with ease

miho

Repository management tools

cargo-binutils

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

cargo-component

A cargo extension for authoring WebAssembly components

cargo-update

A cargo subcommand for checking and applying updates to installed executables

cargo-instruments

Profile binary targets on macOS using Xcode Instruments

cargo-semver-checks

Scan your Rust crate for semver violations

cargo-show-asm

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

cargo-workspaces

Cargo workspace manager

cargo-aoc

Cargo Advent of Code Helper

cargo-unmaintained

Find unmaintained packages in Rust projects

cargo-chef

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

cargo-quickinstall

Precompiled binary installs for cargo install

cargo-wix

Build Windows installers using the WiX Toolset

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-psp

cargo build wrapper for creating Sony PSP executables

cargo-msrv

Find your minimum supported Rust version (MSRV)!

cargo-mobile2

Rust on mobile made easy!

cargo-make

Rust task runner and build tool

cargo-shear

Detect and fix unused/misplaced dependencies from Cargo.toml

cargo-ferris-wheel

🎡 Detect workspace dependency cycles in Rust monorepos

cargo-appimage

Converts your crate into an AppImage

cargo-bloat

Find out what takes most of the space in your executable

cargo-all-features

A Cargo subcommand to build and test all feature flag combinations

cargo-espflash

Cargo subcommand for interacting with Espressif devices

cargo-supply-chain

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

cargo-commitlint

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

cargo-docs-rs

Imitate the documentation build that docs.rs would do

cargo-watch

Watches over your Cargo project’s source

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-dinghy

Cross-compilation made easier

cargo-dtc

Devicetree Compiler packaged for building with cargo

cargo-osdk

Accelerate OS development with Asterinas OSDK

kani-verifier

A bit-precise model checker for Rust

cargo-smart-release

Cargo subcommand for fearlessly releasing crates in workspaces

rzup

The RISC Zero version management library and CLI

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-udeps

Find unused dependencies in Cargo.toml

cargo-liner

Cargo subcommand to install and update binary packages listed in configuration

cargo-modules

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

cargo-machete

Find unused dependencies with this one weird trick!

cargo-ci-template

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

cargo-sonar

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

public-api

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

cargo-firstpage

Shows only the first page of rustc output

zepter

Analyze, Fix and Format features in your Rust workspace

cargo-manifest-check

Check the formatting of your manifest files

cargo-limit

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

cargo-prebuilt

Download prebuilt crate binaries for many different platforms

cargo-templated-examples

Cargo extension for templated running of example

cargo-packager

Executable packager and bundler distributed as a CLI and library

cargo-cross

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

libcnb-cargo

Cargo command for managing buildpacks written with libcnb.rs

yewi-cli

CLI tool for managing yewi-kit components in Yew projects

cargo-bisect-rustc

Bisects rustc toolchains with rustup

cargo-stale

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

hash-crate

generating deterministic hashes of local crates

cargo-vita

Cargo wrapper for developing Sony PlayStation Vita homebrew apps

cargo-files

List all source files in a cargo crate

cargo-credential-pass

Keep your cargo registry tokens encrypted in your pass store

cargo-detect-package

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

cargo-readme

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

cargo-insert-docs

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

cargo-spellcheck

Checks all doc comments for spelling mistakes

cargo-tes

A cargo subcommand to run cargo test and output filtered test failure messages as a JSON array

cargo-pgo

Cargo subcommand for optimizing Rust binaries with PGO and BOLT

cargo-zbuild

cargo-valgrind

A cargo subcommand for running valgrind

changepacks

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

cargo-rail

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

cargo-bundle-licenses

Bundle licensing of dependencies

cargo-wash

clean up your Cargo caches

cargo-px

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

cargo-cache

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

cargo-skyline

A cargo subcommand for working with Skyline plugins written in Rust

cargo-goose

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

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-onedoc

Generate your README.md from Rust doc comments

tauri-bundler

Wrap rust executables in OS-specific app bundles for Tauri

cargo-vendor-filterer

cargo vendor, but with filtering for platforms and more

cargo-perf

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

cargo-nav

Navigate directly to crate links from your terminal

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

cargo-features

Power tools for working with (conditional) features

tazui

terminal calculator

cargo-gc-bin

Garbage collect outdated cargo build artifacts

cargo-clean-all

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

cargo-wgsl

Validate wgsl in rust projects

cargo-duckdb-ext-tools

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

cargo-auto

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

cargo-archtest-cli

CLI of arch_test_core for rule based architecture tests

cargo-duplicates

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

cargo-license

Cargo subcommand to see license of dependencies

crates-io-cli

Interact with crates.io from the command-line

cargo-clean-recursive

A cargo subcommand cleans all projects under specified directory

cargo-alias-exec

Extend cargo aliases to arbitrary commands

cargo-hyperlight

cargo subcommand to build hyperlight guest binaries

cargo-advrunner

An advanced configurable cargo runner

cargo-3ds

Cargo wrapper for developing Nintendo 3DS homebrew apps

fli

The commander.js like CLI Parser for rust

cargo-featalign

Cargo features alignment tool

cargo-sync-rdme

Cargo subcommand to synchronize README with crate documentation

boots

Rust template generator for modular architectures(monorepo)

cargo-mcp

mcp server for cargo commands

detect-targets

Detect the target of the env at runtime

cargo-wasix

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

cargo-about

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

cargo-subunit

Cargo extension to run tests and output results in subunit format

tracel-xtask-cli

CLI entrypoint for Tracel xtask

sheepit

releasing projects 🚀

cargo-msrv-prep

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

cargo-resources

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

cargo-ibuild

cargo-simplebench

minimalist microbenchmarking framework with clear regression detection

cargo-rerun

that runs cargo run and automatically restarts when watched files change

cargo-depcription

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

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

cargo-dylint

running Rust lints from dynamic libraries

cargo-ecos

ECOS embedded project cargo plugin

cargo-codspeed

Cargo extension to build & run your codspeed benchmarks

cargo-regression

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

cargo-feature-combinations

run cargo commands for all feature combinations

libbpf-cargo

Cargo plugin to build bpf programs

cargo-override

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

cargo-compat

Cargo subcommand to resolve and validate dependency versions (SemVer) for Rust projects and workspaces

cargo-afl

Fuzzing Rust code with american-fuzzy-lop

cargo-resolvediff

diffing cargo dependency resolutions between updates

cargo-info

Extends cargo to query crates.io registry for crates details

cargo-piston

streamlining the configuration of rust binaries for various operating systems

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-local-registry

A Cargo subcommand for managing local registries

cvefixer

Fix all vulnerabilities that are fixed

cargo-safe-publish

A safer version of cargo publish

cargo-sponsor

Find sponsorship links for your Rust project's dependencies

cargoe

Advanced Cargo.toml management CLI tool

cargo-compete

A Cargo subcommand for competitive programming

cargo-workspace-deps

A Cargo subcommand that consolidates shared dependencies to workspace.dependencies

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

ddt

Useful cli tools

cargo-copter

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

cargo-swift

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

cargo-wdk

A Cargo extension for developing Windows drivers in Rust

cargo-doc2readme

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

cargo-winapp

Cargo subcommand for Windows app development with winapp CLI

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

cargo-autoinherit

A cargo sub-command to leverage dependency inheritance wherever possible

cargo-subspace

rust-analyzer work better with very large cargo workspaces

cargo-fetch-source

Declare and fetch external sources programmatically

cargo-samply

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

chronsync

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

cargo-sort-fix

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

lmrc-cargo-workspace

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

cargo-quality

Professional Rust code quality analysis tool with hardcoded standards

cargo-omnibus

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

cargo-coupling

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

cargo-verison

Bump a package version

cargo-lipo

cargo lipo subcommand to automatically create universal libraries for iOS

cargo-env-run

Like dotenv but with .cargo/config.toml files

evcxr

An Evaluation Context for Rust

cargo-open

Cargo command to open an installed crate in your editor

redpen-linter

Rust linter

cargo-list

List and update installed crates

rustmerge

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

cargo-goggles

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

cargo-playdate

Build tool for neat yellow console

cargo-buckal

Seamlessly build Cargo projects with Buck2

cargo-xfmt

Safely use nightly fmt options without using unstable Rust

cargo-newcpp

A cargo plugin for creating new C++ projects

cargo-rename

Safely rename Cargo packages and update all workspace references

cnp

written in Rust to check unused node packages

cargo-thanku

Generate acknowledgments for your Rust project dependencies

whitaker-installer

Installer CLI for Whitaker Dylint lint libraries

cargo-doc-docusaurus

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

stack-assembly

minimalist, stack-based, assembly-like programming language

e_obs

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

cargo-cargo

Literally, cargo cargo cargo cargo cargo

cargo-no-dev-deps

Cargo subcommand for running cargo without dev-dependencies

cargo-neat

complement cargo-machete and remove unused workspace dependencies

core-grep

core grep project

cargo-generate-type

Cargo subcommand to generate Rust code from and for input data

mtoc

Generate a table of contents for markdown files

cargo-preflight

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

cargo-no-std

Validate no_std compliance

cargo-countlines

count SLOC

ribir-bot

A CLI tool for managing Ribir releases and changelogs

cargo-zoo

OS development

cargo-cyclonedx

CycloneDX Software Bill of Materials (SBOM) for Rust Crates

cargo-bolero

cargo command for running bolero fuzz tests

cargo-hakari

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

cargo-tally

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

xtask-watch

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

mdbook-tailor

mdbook preprocessor for image-tailor

cargo-steady-state

Code generator for steady_state projects based on a structured dot file

cargo-examples

Run all examples for any locally cloned crate

cargo-assemble

Cargo plugin to automate creating missing packages defined in a Rust workspace

battery-pack

Curated crate bundles with docs, templates, and agentic skills

cargo-owi

Cargo wrapper for the owi bug finding tool

cargo-new-workspace

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

dockpack

Command line tool for unpacking files from Docker images

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

cargo-uv

Cargo tool for updating the version in your project

cargo-outdir

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

eqlog

Datalog with equality

cargo-v5

Cargo tool for working with VEX V5 Rust projects

igor

Generic text-based vendoring

cargo-operi

Cargo subcommand for Operi SDK development

cargo-chec

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

crunch-app

Turbocharge your Rust workflow with crunch

cargo-qtest

an interactive test runner for rust projects

xtest-data

Fetch auxiliary test data when testing published crates

cargo-upgrades

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

cargo-warp

Build then copy your project binary to a remote host

cargo_pup

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

cargo-clone

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

cargo-extract-test

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

cargo-unlock

Remove Cargo.lock lockfile

tinyrick_extras

common tasks for tinyrick projects

cargo-show

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

axotag

share tag-parsing code between axodotdev projects

badgeland

Fast badge generator for any purpose

rustdoc-json

working with rustdoc JSON

antislop

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

cargo-prompt

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

cargo-shuttle

CLI for the Shuttle platform (shuttle.dev)

cargo-test-json-2-html

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

cargo-index

Cargo subcommand to manage a registry index

licenses

Cargo subcommand for collecting licenses

cargo-flaky

A cargo sub-command to helps you find flaky tests

cargo-atomic

A CLI tool to help make local git commits easier

group-runner

Group Rust executable output in GitHub logs

cargo-selector

Cargo subcommand to select and execute binary/example targets

for-all-projects

run cargo commands for all projects in a directory, recursively

cargo-single-line

A cargo plugin to shrink cargo's output

cargo-kit

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

cargo-oxur

Cargo subcommand for building Oxur Lisp projects

cargo-ovft

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

cargo-feature-scope

A helper library that enables workspace crates to independently control their required features without cross-package interference

zerus

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

cargo-tighterror

The cargo plugin of the tighterror framework

cargo-execute

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

cargo-geiger

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

cargo-ensure-no-cyclic-deps

A cargo subcommand to detect cyclic dependencies in workspace crates

kovi-cli

kovi cli

cargo-xbuild

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

cargo-local

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

cargo-ament-build

Cargo plugin for use with colcon workspaces

deepclean

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

typestorm

A cool terminal typing test CLI written in rust

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

cargo-risczero

RISC Zero CLI tools

cargo-ledger

Build and sideload Ledger apps

cargo-plugin-utils

Shared utilities for cargo plugins (logger, subprocess handling, common functions)

cargo-rootfs

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

cargo-xcode

Make Xcode project files from Cargo projects

cargo-jet

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

cargo-hammerwork

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

cargo-bazel

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

cargo-nvim

A Neovim plugin for Rust Cargo commands

greentic-dev

Developer CLI and local tooling for Greentic flows, packs, and components

cargo-nfpm

lightweight Cargo plugin for using nFPM from Any Rust project

cargo-prosa

ProSA utility to package and deliver a builded ProSA

cargo-anaxa

A modern native Rust configuration management system

cargo-install-describe

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

copilot

MCP Server for Cargo

rust-cargo-test2

rust cargo test

cargo-depgraph

Creates dependency graphs for cargo projects using cargo metadata and graphviz

cargo-groups

Run cargo commands on a groups of crates in a workspace

cargo-qemu-runner

A cargo subcommand that allows running Limine kernels using cargo run

cargo-hackerman

Workspace hack management and package/feature query

cargo-ruin

Ruins your project with different options

cargo-deltabuild

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

rerast

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

bootimage

create a bootable OS image from a kernel binary

udonsharp-cli

Command-line interface for Rust UdonSharp development

symposium-cargo

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

lockdiff

Display more readable diffs for lock files

cargo_tsgen

Additional code generation tools for tree-sitter

cargo-doc-viewer

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

cargo-commander

Like npm scripts, but better

cargo-load

A command for handling cargo load operations

handling

Cargo extensions for binary management

cargo-cycles

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

cargo-whatfeatures

display features, versions and dependencies of crates

cargo-progenitor

A cargo command to generate a Rust client SDK from OpenAPI

cargo-task

Ultra-Lightweight Zero-Dependency Rust Cargo Task Runner

cargo-lpatch

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

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

safe-cargo

Build and runs code in a sandboxed environment

cargo-fill

An interactive CLI tool for filling the fields of Cargo.toml quickly

cargo-cooldown

Cargo wrapper that enforces a cooldown window for freshly published crates on crates.io for improved supply chain security

cargo-altvup

Rust module + alt:V server installer

cargo-extensions

cargo extensions

cargo-llms-txt

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

nj-cli

build tool for node-bindgen

cargo-polkajam

A cargo subcommand for generating JAM service projects for Polkadot

cargo-deps

Cargo subcommand for building dependency graphs of Rust projects

cargo-nixpackage

A small utility to scaffold Rust projects with Nix Flake support

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-wef

command line tool for wef

cargo-local-install

Wraps cargo install for better local, non-conflicting installation

httpdiff

comparing the differences between 2 HTTP GET requests

disperse

automation for creation of releases

cargox-cli

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

cargo-nnd

Cargo subcommand for easily starting nnd

cargo-screeps

Build tool for deploying Rust WASM code to Screeps game servers

cargo-pak

Generate manifest and desktop files for flatpak

cargo-i18n

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

ros_new

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

cargo-census

Analyze Rust crate module structure and item counts

cargo-doc-md

Cargo subcommand to generate markdown documentation for Rust crates and dependencies

cargo-delayedclippy

Delay clippy to improve compile times by a minuscule amount

rust_project_reader

program that reads all the fiels of a rust project and copies them to the clipboard. This is useful for using with chatgpt/gpt-4.

cargo-csc

Code spell checking

cargo-dependabot-if-necessary

Cargo dependabot config generator with increase-if-necessary strategy

cargo-verset

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

cargo-indicate

running GraphQL queries on Rust dependency trees

cargo-dl

Cargo subcommand for downloading crate sources

cargo-jump

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

cargo-deadlinks

Cargo subcommand for checking your documentation for broken links

dep-insight

Dependency analysis, auditing, and visualization tool for Rust projects

cargo-bins

Lists all installed cargo binaries

cargo-q

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

cargo-axplat

Manages hardware platform packages using axplat

cargo-setup

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

cargo_atelier

Cargo integration for the AWS Smithy IDL

prox

development process manager like foreman, but better!

semver-cli-check

cli util to validate semver

cargo-featurex

cargo plugin to run tasks against feature powersets

cargo-publish-crates

Publish rust crates with support for cargo workspaces

cargo-npk

Northstar is an container runtime for Linux targetting embedded systems

cargo-subcommand

creating cargo subcommands

cargo-diet

Make your crate lean by computing size-optimal include directives for Cargo manifests

cargo-spiel

Run a playground connected to a Cargo project locally

tool42

MCP Server - AI assisted Rust development made easy

cargo-web

A Cargo subcommand for the client-side Web

cargo-mono

Cargo subcommand to manage mono repository

cargo-information

A cargo subcommand to show information about crates

cargo-hilly

projects that helps migrate flat module files (e.g., "foo.rs") into the more idiomatic Rust module layout

cargo-oj

package a crate into single file, minimized and formatted

cargo-aur

Prepare Rust projects to be released on the Arch Linux User Repository

cargo-sync-readme

Generate a Markdown section in your README based on your Rust documentation

cargo-whichp

Cli for debugging executable lookup

xcframework

A Cargo plugin and library for building Apple XCFrameworks

cargo-minimal-versions

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

cargo-reaper

A Cargo plugin for developing REAPER extension and VST plugins with Rust

braise

Run your tasks like a chef !

cargo-ws

cargo plugin, generate vscode workspace file

cargo-stm32bs

STM32bs, to create a stm32 project!