Lib.rs

cargo-cache

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

cargo-outdated

Cargo subcommand for displaying when dependencies are out of date

cargo-deb

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

cargo-hack

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

cargo-ndk

Makes building Rust libraries for Android simpler

cargo-make

Rust task runner and build tool

cargo-watch

Watches over your Cargo project’s source

cargo-audit

Audit Cargo.lock for crates with security vulnerabilities

tauri-bundler

Wrap rust executables in OS-specific app bundles for Tauri

cargo-sort

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

cargo-edit

This extends Cargo to allow you to add and remove dependencies by modifying your Cargo.toml file from the command line. It contains cargo add, cargo rm, and cargo upgrade.

cargo-espflash

Cargo subcommand for flashing Espressif devices over serial

cargo-pgx

Cargo subcommand for ‘pgx’ to make Postgres extension development easy

cargo-geiger

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

cargo-wasi

Subcommand for Cargo to easily build code for wasm32-wasi

flamegraph

A simple cargo subcommand for generating flamegraphs, using inferno under the hood

cargo-c

Helper program to build and install c-like libraries

cargo-llvm-lines

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

cargo-tarpaulin

Cargo-Tarpaulin is a tool to determine code coverage achieved via tests

cargo-bloat

Find out what takes most of the space in your executable

cargo-lambda

Cargo subcommand to work with AWS Lambda

cargo-bpf

Cargo plugin to manage eBPF probes using redbpf

cargo-deny

Cargo plugin to help you manage large dependency graphs

cargo-udeps

Find unused dependencies in Cargo.toml

cargo-update

A cargo subcommand for checking and applying updates to installed executables

cargo-test-fuzz

cargo-chef

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

cargo-ui

GUI for cargo

semverver

Automatic verification of SemVer adherence in Rust library crates

cargo-msrv

Find your minimum supported Rust version (MSRV)!

cargo-depgraph

Creates dependency graphs for cargo projects using cargo metadata and graphviz

cargo-coverage-annotations

Ensure annotations in code match actual coverage

cargo-lipo

cargo lipo subcommand to automatically create universal libraries for iOS

cargo-generate-rpm

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

cargo-commander

Like npm scripts, but better

cargo-aur

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

cargo-pants

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

cargo-llvm-cov

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

cargo-i18n

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

cargo-compete

A Cargo subcommand for competitive programming

cargo-arch

Rust Arch Linux package packer

cargo-tally

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

cargo-play

Run your Rust code without setting up Cargo

dinghy-build

Cross-compilation made easier - helpers for build.rs scripts

cargo-feature

Cargo plugin to manage dependency features

cargo-fetcher

🎁 Alternative to cargo fetch

cargo-license

Cargo subcommand to see license of dependencies

cargo-instruments

Profile binary targets on macOS using Xcode Instruments

cargo-all-features

A Cargo subcommand to build and test all feature flag combinations

cargo-smart-release

Cargo subcommand for fearlessly releasing crates in workspaces

cargo-local-install

Wraps cargo install for better local, non-conflicting installation

cargo-bundle

Wrap rust executables in OS-specific app bundles

cargo-criterion

Cargo extension for running Criterion.rs benchmarks and reporting the results

cargo-pkg

A simple subcommand for the Cargo package manager for building GTK packages from Rust projects

cargo-espmonitor

Cargo subcommand for monitoring ESP8266 and ESP32 execution over serial

crm

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

cargo-valgrind

A cargo subcommand for running valgrind

cargo-deps

Cargo subcommand for building dependency graphs of Rust projects

clap-cargo

Re-usable CLI flags for cargo plugins

cargo-zigbuild

Compile Cargo project with zig as linker

cargo-temp

A CLI tool that allow you to create a temporary new rust project using cargo with already installed dependencies

cargo-pipe

A command-line tool to generate and build data integration app using pipebase framework

cargo-task

Ultra-Lightweight Zero-Dependency Rust Cargo Task Runner

cargo-modules

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

cargo-spellcheck

Checks all doc comments for spelling mistakes

cargo-apk

Helps cargo build APKs

cargo-hakari

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

cargo-crev

Distibuted Code REView system for verifying security and quality of Cargo dependencies

cargo-sysroot

Simply and Easily cross-compile the Rust sysroot crates

cargo-wix

Build Windows installers using the WiX Toolset

cargo-machete

Find unused dependencies with this one weird trick!

cargo-rls-install

Rust Language Server easy install

cargo-dylint

A tool for running Rust lints from dynamic libraries

cargo-bitbake

Generates a BitBake recipe for a package utilizing meta-rust’s classes

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

Makes building Rust libraries for Android simpler

cargo-wgsl

Validate wgsl in rust projects

rhdxmr-publish-test

Cargo plugin to manage eBPF probes using redbpf

cargo-info

Extends cargo to query crates.io registry for crates details

cargo-sweep

A tool for cleaning unused build files created by Cargo

cargo-subcommand

Library for creating cargo subcommands

cargo-benchcmp

A utility for comparing Rust micro-benchmark output

cargo-nextest

A next-generation test runner for Rust

cargo-unleash

Tooling to manage releasing of crates in massiv workspaces/monorepos

cargo-pio

Cargo<->PlatformIO integration: a cargo subcommand

cargo-insta

A review tool for the insta snapshot testing library for Rust

cargo-public-api

List and diff the public API of Rust library crates between releases and commits. Allows you to detect breaking API changes and semver violations.

cargo-clean-recursive

A cargo subcommand cleans all projects under specified directory

cargo-quickinstall

Precompiled binary installs for cargo install

cargo-show

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

cargo-cacher

cargo-cacher is a crates.io proxy that will proxy requests made when building a package with Cargo

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

A cargo subcommand to print information in a shell-convenient format

cargo-deadlinks

Cargo subcommand for checking your documentation for broken links

cargo-index

Cargo subcommand to manage a registry index

cargo-native-install

Installs cargo targets in a manner similar to make install or cmake –install

cargo-hf2

Cargo Subcommand for Microsoft HID Flashing Library for UF2 Bootloaders

cargo-hackerman

Workspace hack management and package/feature query

cargo-supply-chain

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

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

A command line tool for creating a Wasm smart contract and tests for use on the Casper network

cargo-scaffold

cargo scaffold lets you scaffold and generate an entire stack based on a simple toml file and make templating into your templates

cargo-clean-all

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

cargo-whatfeatures

display features, versions and dependencies of crates

cargo-limit

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

cargo-rdme

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

cargo-skyline

A cargo subcommand for working with Skyline plugins written in Rust

cargo-raze

A Cargo subcommand to generate Bazel BUILD files

cargo-cyclonedx

CycloneDX Software Bill of Materials (SBOM) for Rust Crates

cargo-workspaces

Cargo workspace manager

cargo-generate

cargo, make me a project

cargo-single-line

A cargo plugin to shrink cargo’s output

cargo-flaky

A cargo sub-command to helps you find flaky tests

cargo-clone

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

cargo-script

A Cargo subcommand designed to let people quickly and easily run Rust “scripts” which can make use of Cargo’s package ecosystem

cargo-bom

Bill of Materials for Rust Crates

rerast

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

cargo-profile

Cargo subcommand to profile performance

cargo-wasi-exe-x86_64-unknown-linux-musl

Precompiled binary of cargo-wasi for x86_64-unknown-linux-musl

cargo-diet

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

cargo-web

A Cargo subcommand for the client-side Web

cargo-local-registry

A Cargo subcommand for managing local registries

cargo-toml-lint

Linter for Cargo.toml

cargo-release

Cargo subcommand for you to smooth your release process

cargo-binstall

Rust binary package installer for CI integration

cargo-xwin

Cross compile Cargo project to Windows MSVC target with ease

cargo-get

Cargo plugin to easily query information from Cargo.toml files

cargo-rx

A simple fuzzy finder that allows you to search and run examples from the command line. It comes with the rx command.

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

Detect (possible) no_std compatibility of your crate and dependencies

cargo-man

CLI tool to improve Cargo file management

cargo-docs

A cargo plugin for serving rust and crate doc locally

wargo

cargo’s evil twin to work with projects in the twilight zone of WSL2

cargo-dephell

Analyzes a project’s third-party dependencies

cargo-deps-list

Cargo subcommand to get a list of dependencies in a typical build

cargo-duplicates

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

cargo_atelier

Cargo integration for the AWS Smithy IDL

cargo-cake

A cake for celebrating Rust’s birthday

cargo-bundle-licenses

Bundle licensing of dependencies

cargo-about

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

cargo-local

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

cargo-markdown

Local crates.io readme development server with ultra-fast hot reloading goodness

cargo-brief

Display a brief summary of cargo dependencies

cargo-equip

A Cargo subcommand to bundle your code into one .rs file for competitive programming

cargo-public-items

This project has been renamed to cargo-public-api, see https://github.com/Enselic/cargo-public-api

cargo-ensure-prefix

Cargo subcommand to check that all target files have a fixed prefix

cargo-updater

A npm inspired cargo subcommand for listing and updating binaries installed in $CARGO_HOME/bin

cargo-ex

This cargo sub-command execute cargo run --example easily via fuzzy finder

runcc

run commands concurrently with rust and cargo

arch_test_core

Rule based architecture test library

cargo-asm

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

cargo-appimage

Converts your crate into an AppImage

semververfork

Automatic verification of SemVer adhrence in rust library crates

cargo-build-deps

A cargo subcommand to build dependencies, helps speed up docker builds by allowing dependencies to be built earlier and cached

cargo-upgrades

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

cargo-sphinx

Cargo subcommand for building and publishing Sphinx documentation to GitHub Pages

cargo-inspect

This extends Cargo to allow you to desugar your Rust code and see what happens behind the curtains

cargo-cvm

Rust Crate Version Manager (CVM)

cargo-ament-build

Cargo plugin for use with colcon workspaces

cargo-recursive

Cargo subcommand for running a (cargo) command in all cargo projects under a specified directory

cargo-doc2readme

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

cargo-todox

Ensure source files in a cargo project do not contain TODOX issues

cargo-manifmt

rustfmt for your Cargo.toml

debcargo

Create a Debian package from a Cargo crate

cargo-count

Cargo subcommand for displaying statistics about projects, such as code, comments, and unsafe counters

cargo-sort-ck

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

nextest-runner

Core runner logic for cargo nextest

cargo-scout

Run clippy::pedantic on your diffs only

cargo-nav

Navigate directly to crate links from your terminal

cargo-travis

Run coverage, upload docs, and more on travis

cargo-fund

Discover funding links for your project’s dependencies

cargo-checkmate

checkmate checks all the things - comprehensive out-of-the-box safety & hygiene checks

cargo-wasix

Subcommand for Cargo to easily build code for wasm64-wasi

cargo-spec

A tool to specify your code

cargo-cli

Create a command line interface binary with some common dependencies ((clap || docopt) and error_chain)

cargo-so

Helps cargo build Android .so lib files

cargo-readme

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

cargo-watt

generate watt versions of procedural macro crates

cargo-exe

A Cargo plugin to print the path to the output executable from cargo build

cargo-rm

Remove Cargo.lock lockfile

cargo-structure

A simple tool for analyzing the structure of a cargo project

cargo-sync-readme

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

millennium-bundler

Wrap Rust executables in OS-specific app bundles for Millennium

cargo-bitbar

Cargo subcommand for the bitbar crate

cargo-do

A Cargo plugin that adds the ‘do’ subcommand to let you run multiple cargo commands by running e.g. cargo do clean, build

cargo-hdk

Cargo subcommand for building Houdini plugins

cargo-force-build

Allow soft force build

cargo-wop

Cargo for single-file projects

cargo-http-registry

A cargo registry allowing for quick publishing of crates when using crates.io is just not desired

cargo-innit

Bri’ish cargo init

cargo-feature-matrix

run cargo commands on a matrix of feature sets

cargo-funnel

cargo subcommand to reorganize and sort your Cargo.toml

cyclonedx-bom

CycloneDX Software Bill of Materials (SBOM) for Rust Crates

cargo-kcov

Cargo subcommand to run kcov to get coverage report on Linux

cargo-psx

cargo wrapper for the Sony PS1

cargo-xcode

Make Xcode project files from Cargo projects

cargo-show-asm

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

cargo-lichking

Display info about licensing of dependencies

cargo-creator

Tool that helps build apps for Android and iOS

cargo-weblabtest

wrapper around cargo test to provide weblab-compatible output

cargo-scripter

A Cargo subcommand designed to let people quickly and easily run Rust “scripts” which can make use of Cargo’s package ecosystem

cargo-todo

Cargo tool to display TODOs

cargo-test-all

Cargo extension for running tests of the used dependencies

cargo-outdir

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

cargo-solid

Subcommand for cargo to genereate Solidity struct definitions

cargo-fak

Cargo Faaaaaak! is an ADR tool for your Rust projects. You don’t need to help, you are human and therefore limited. What you need is better tools, Cargo Faaaaaak! aims to help you out.

cargocleaner

Runs cargo clean on all subdirectories

cargo-rclean

Clean your rust projects, recursively

undepend

Trys to remove dependencies from your git checkout. Needs to work on a clean checkout.

cargo-intraconv

A simple helper to transform Markdown links to intra-doc links in Rust projects when appropriate

cargo-merge

A cargo subcommand to merge the source code of a crate into a single file

cargo-spdx

Generate an SPDX SBOM for a crate

cargo-whatis

Quickly show the description of a crate on crates.io

cargo-swipl

Tool for working with crates that use the SWI-Prolog Foreign Language Interface

cargo-jfrog-dl-spec

A cargo subcommand that based on a Cargo.lock file generates JFrog CLI spec file to download crates from a private registry

cargo-mono

Cargo subcommand to manage mono repository

cargo-fel4

A cargo subcommand for automating feL4 (seL4 for Rust) development

cargo-ghp-upload

Upload documentation straight to GitHub Pages, maintaining branch separation and history

cargo-mpirun

cargo mpirun allows you to easily build and run your MPI applications in a single command. It emulates cargo run, allowing you to specify a target to be built and run, and cargo takes care of the rest.

cargo-cook

A third-party cargo extension which allows you to cook your crate

cargo-with

A third-party cargo extension to run the build artifacts through tools like gdb

cargo-profiler

Cargo subcommand to profile your applications

cargo-modoc

Generate module documentation from markdown files

cargo-extras

A collection of cargo subcommands

cargo-new-deps

List the newly added dependencies and their features

cargo-repeat

Repeats a command until it exits with the right code

cargo-compiler-interrupts

Cargo subcommands that integrate the Compiler Interrupts to the package

dors

No-fuss workspace-friendly task runner for cargo

cargo-xcodebuild

Helps cargo build and run apps for iOS

cargo-uwp

Custom Cargo command to create, manage, and package UWP applications

cargo-remote

Cargo subcommand to build rust projects remotely

cargo-webassembly

A cargo utility for working on WebAssembly

cargo-cocoapods

Generate a Cocoapods wrapper for your Rust project

cargo-pkgconfig

pkg-config like interface for exposing crate metadata to primitive build systems

cargo-publish-all

Tool to publish all packages

cargo-quickbench

Quickly create a cargo bench package

enzyme

A helper crate to simplify experimenting with Enzyme

cargo-3pl

The easy way to ship dependency licenses with your Rust binaries

cargo-cmd

Alias any shell command in your Cargo.toml. It’s like npm scripts, but for cargo.

cargo-monorepo

A cargo extension that helps with managing monorepos

cargo-build-dependencies

A cargo subcommand to build dependencies, helps speed up docker builds by allowing dependencies to be built earlier and cached

cargo-tests

generate llvm-cov reports when testings

cargo-memex

Compile and execute rust code as memes

cargo-next

A cargo subcommand to set the next crate version

cargo-fixeq

Fix assert_eq! test errors automatically

cargo-sideload

Tools for working with private Cargo registries

cargo-single

Extends Cargo to simplify working with single-file programs with dependencies

cargo-download

Cargo subcommand for downloading crate sources

cargo-makedocs

A cargo doc wrapper that only builds the documentation you care about

cargo-eval

A cargo subcommand designed to let people quickly and easily run Rust “scripts” which can make use of cargo’s package ecosystem

cargo-cats

CATS’s

cargo-trend

Cargo subcommand to generate trend graph of dependent crates

cargo-when

Cargo commands run conditionally upon rust compiler version and environment

cargo-docco

cargo docco generates literate programming style documentation pages from source code. Port of Jash Kenas’ Docco in Rust.

cargo-first

A cargo subcommand to stop execution after the first error

cargo-pack-docker

pack artifacts into a docker image

cargo-linebreak

A cargo subcommand for printing linebreaks when using cargo-watch

cargo_bullhorn

CLI tool to publish articles and update them

arguman

Command-line argument parsing library

error_show

Show error code information

cargo-wasi-exe-x86_64-apple-darwin

Precompiled binary of cargo-wasi for x86_64-apple-darwin

emils-cargo-release

Cargo subcommand for you to smooth your release process

cargo-rocket-docker

Cargo sub-command tool for docker images into Rocket projects

cargo-build-dist

A cargo extension that helps with building distribution packages in various formats

ros-project-generator

cargo subcommand for generate ROS projects of the rosrust client library

cargo-ctags

analyze dependencies and generate single TAGS for cargo projects

cargo-disasm

Disassembly viewer for Rust projects (and more)

cargo-pando

Perform tasks concurrently over multiple copies of your repo, over multiple toolchains and/or git revisions

codesnip

snippet bundle tool

cargo-ebuild

Generates an ebuild for a package using the in-tree eclasses

cargo-alias

Easily view, create, and delete cargo aliases

cargo-check

wrapper around cargo rustc – -Zno-trans

mol

Package versioning with ease

cargo-ramdisk

Create target folder as a ramdisk for faster Rust compilation

mdmg

A scaffold prototype code tool

cargo-travis-fork

Run coverage, upload docs, and more on travis

cargo-ligen

Cargo command for Ligen (https://github.com/sensorial-systems/ligen)

lts

Yank other people’s crates. Helpful for using old compilers and avoiding broken deps

cargo-minimal-versions

Cargo subcommand for proper use of -Z minimal-versions

cargo-gui

A browser interface for working through rustc errors and running cargo commands

cargo-single-pyo3

Generate a Python module from a single Rust file

cargo-git

An opinionated helper command to use git with cargo. This does not replace the git command but should be used in conjunction with.

cargo-build-docker

A cargo subcommand to build rust using docker

cargo-ver

A cargo extension to manage crate versions

cargo-squat

Easily reserve a crates.io package name

reg-index

Library to manage a registry index

cargo-roogle

A Cargo subcommand to run Roogle on local crates

cargo-newvsc

Cargo new extension for initialising VS Code tasks.json

cargo-kythe

A cargo subcommand for generating and viewing Kythe graphs of cargo projects

cargo-docker

A cargo subcommand to build binary with other OS

cargo-modify

allows changes to the cargo toml via cmd line

json2struct

Json 2 struct for golang

cargo-lambda-metadata

Cargo subcommand to work with AWS Lambda

cargo-msix

A cargo subcommand to build MSIX installers for Rust projects

cargo-incversion

A cargo plugin to increment the Cargo.toml’s version in command line

cargo-archtest

CLI of arch_test_core for rule based architecture tests

cargo-version-sync

Cargo subcommand for keeping the version numbers in sync with Cargo.toml

cargo-blinc

Notifies about commands exit code using LED light blink(1)

cargo-brust64

cargo command to encode a bunch of static files into base64 and contained in a rust file as Hashmap

cargo-at

Compile and run your project on a (fast) remote host

cargo-reinstall

A subcommand for cargo to reinstall an exisiting crate. It may also be seen as a command to update an installed crate.

cargo-xwinbuild

Cross compile Cargo project to Windows msvc target with ease

cargo-armory

Cargo workspaces tool

cargo-hatch

Hatch new projects like a chick coming out of its egg

cargo-firstpage

Shows only the first page of rustc output

cargo-pyinit

A cargo plugin to make it easier to write and convert crates into Python extension modules

cargo-turbofish

Add turbofish to your project

cargo-feature-set

Extract the features for every compiled crate from cargo metadata

cargo-search2

cargo search, optimized for CI caching in GitHub Actions and elsewhere

cargo-quad-apk

Cargo subcommand that allows you to build Android packages

cargo-program

Utility to simplify Gear programs development

cargo-kill

Save disk space by removing old target directories from your rust projects

cargo-proc-macro

Kickstart a proc-macro project with a straight-forward template

cargo-mach

Cargo wrapper for mozillas mach

cargo-frc

A cargo extension for deploying rust code to FRC robots

cargo-distribute

Template generator for continuous distribution of rust projects to homebrew, linuxbrew and scoop

x96check

Check if the executable file is 32-bit or 64-bit on windows

cargo-pubs

how to pub a crate

cargo-grammarly

A third-party cargo extension for checking grammar in the documentation and comments

cargo-strip

Strip Rust binaries created with cargo

cargo-fast

car go fast

basic_timer

A basic timer implementation for benchmarking

cargo-lock2rpmprovides

Cargo Lock to Rpm Provides

cargo-x

A very simple third-party cargo subcommand to execute a custom command

cargo-osha

A small utility to count the uses of unsafe code in a Rust program

cargo-workspace2

A tool to query and manage complex cargo workspaces

cargo-sls-distribution

A Cargo subcommand which packages a binary crate into a distribution archive

cargo-up

Upgrade your dependencies by automatically fixing your code

cargo-sym

Prints various binary symbols in your crate

cargo-drone

A cargo subcommand for Drone

cargo-ssearch

cargo-ssearch: cargo search on steroids

cargo-nodex

cargo tool for creating nodejs native addon

badgeland

Fast badge generator for any purpose

cargo-review-deps

A cargo subcommand for reviewing the source code of crates.io dependencies

cargo-ws-version

Cargo plugin, which helps to update versions of changed cargo packages in workspace and update all dependencies in packages

cargo-run-script

Bringing npm run-script to Rust

cargo-user

A Cargo plugin for managing multiple sets of credentials

cargo-bdeps

A cargo subcommand to build dependencies, helps speed up docker builds by allowing dependencies to be built earlier and cached

cargo-erlangapp

Build Rust crates embedded in an Erlang application

cmake_config

A parser for CMakeCache.txt files

cargo-member

Cargo subcommand for managing workspace members

cargo-owo

br3adina7or’s custom program to make a new rust project

cargo-incremental

A tool for using and testing rustc’s incremental compilation support

cargo-dependencies

A Cargo extension that prepares (downloads & builds) the dependencies of a specific Rust project

cargo-shorts

Cargo shorts generator

cargo-stress

A utility for catching non-deterministic test failures

cargo-bin-lib

Cargo subcommand for more ergonomically creating a bin or lib crate

cargo-shuttle

A cargo command for the shuttle platform (https://www.shuttle.rs/)

cargo-bin

help to manage all binares in Cargo.toml

cargo-nuget

Bundle Rust libraries as Nuget packages