Lib.rs

cargo-hack

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

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

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

cargo-deb

Debian packages (.deb) easily with a Cargo subcommand

cargo-outdated

Cargo subcommand for displaying when dependencies are out of date

cargo-dylint

running Rust lints from dynamic libraries

flamegraph

cargo subcommand for generating flamegraphs, using inferno under the hood

cargo-generate

cargo, make me a project

cargo-ndk

Makes building Rust libraries for Android simpler

cargo-binstall

binary package installer for CI integration

cargo-wasi

Subcommand for Cargo to easily build code for wasm32-wasi

cargo-careful

Execute Rust code carefully, with extra checking along the way

cargo-afl

Fuzzing Rust code with american-fuzzy-lop

cargo-instruments

Profile binary targets on macOS using Xcode Instruments

cargo-espflash

Cargo subcommand for flashing Espressif devices

cargo-audit

Audit Cargo.lock for crates with security vulnerabilities

cargo-dinghy

Cross-compilation made easier

cargo-temp

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

cargo-modules

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

cargo-llvm-lines

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

cargo-make

task runner and build tool

cargo-tarpaulin

determine code coverage achieved via tests

cargo-watch

Watches over your Cargo project’s source

cargo-dist

Shippable application packaging for Rust

clap-cargo

Re-usable CLI flags for cargo plugins

cargo-readme

cargo subcommand to generate README.md content from doc comments

cargo-cache

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

cargo-aoc

Cargo Advent of Code Helper

cargo-get

Cargo plugin to easily query information from Cargo.toml files

tauri-bundler

Wrap rust executables in OS-specific app bundles for Tauri

cargo-zigbuild

Compile Cargo project with zig as linker

cargo-update

cargo subcommand for checking and applying updates to installed executables

cargo-commander

Like npm scripts, but better

cargo-c

Helper program to build and install c-like libraries

cargo-nextest

next-generation test runner for Rust

cargo-all-features

Cargo subcommand to build and test all feature flag combinations

cargo-clean-all

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

cargo-leptos

Build tool for Leptos

cargo-bolero

cargo command for running bolero fuzz tests

cargo-generate-rpm

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

cargo-workspaces

Cargo workspace manager

cargo-wix

Build Windows installers using the WiX Toolset

cargo-deny

Cargo plugin to help you manage large dependency graphs

cyclonedx-bom

CycloneDX Software Bill of Materials Library

cargo-hakari

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

cargo-quickinstall

Precompiled binary installs for cargo install

cargo-llvm-cov

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

cargo-udeps

Find unused dependencies in Cargo.toml

cargo-release

Cargo subcommand for you to smooth your release process

cargo-prebuilt

Download prebuilt crate binaries for many different platforms

cargo-apk

cargo build APKs

cargo-codspeed

Cargo extension to build & run your codspeed benchmarks

cargo-chef

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

rustdoc-json

working with rustdoc JSON

cargo-msrv

Find your minimum supported Rust version (MSRV)!

cargo-insta

review tool for the insta snapshot testing library for Rust

dinghy-build

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

cargo-auditable

production Rust binaries auditable

cargo-deps

Cargo subcommand for building dependency graphs of Rust projects

cargo-index

Cargo subcommand to manage a registry index

cargo-husky

husky for cargo

cargo-crev

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

cargo-aur

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

cargo-binutils

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

libcnb-cargo

Cargo command for managing buildpacks written with libcnb.rs

cargo-machete

Find unused dependencies with this one weird trick!

cargo-component

cargo extension for authoring WebAssembly components

cargo-cyclonedx

CycloneDX Software Bill of Materials (SBOM) for Rust Crates

cargo-show-asm

cargo subcommand that displays the generated assembly of Rust source code

cargo-crate

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.

parity-publish

manage publishing Parity's crates

cargo-i18n

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

cargo-qtest

interactive test runner for rust projects

cargo-screeps

Build tool for deploying Rust WASM code to Screeps game servers

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

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

cargo-vita

Cargo wrapper for developing Sony PlayStation Vita homebrew apps

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

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

Creates dependency graphs for cargo projects using cargo metadata and graphviz

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

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

cargo-local-registry

Cargo subcommand for managing local registries

cargo-xwin

Cross compile Cargo project to Windows MSVC target with ease

cargo-bisect-rustc

Bisects rustc toolchains with rustup

cargo-info

Extends cargo to query crates.io registry for crates details

cargo-mommy

Mommy's here to support you when running cargo~

cargo-test-fuzz

cargo-expand

Wrapper around rustc -Zunpretty=expanded. Shows the result of macro expansion and #[derive] expansion.

cargo-playdate

Build tool for neat yellow console

cargo-rdme

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

cargo-compete

Cargo subcommand for competitive programming

cargo-lambda

Cargo subcommand to work with AWS Lambda

cargo-boj

Cargo-BOJ: test and submit solutions to BOJ problems

cargo-updater

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

cargo-spellcheck

Checks all doc comments for spelling mistakes

cargo-semver-checks

Scan your Rust crate for semver violations

cargo-indicate

running GraphQL queries on Rust dependency trees

cargo-action-fmt

Converts cargo check (and clippy) JSON output to the GitHub Action error format

crm

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

cargo-coverage-annotations

Ensure annotations in code match actual coverage

cargo-featalign

Cargo features alignment tool

ziggy

multi-fuzzer management utility for all of your Rust fuzzing needs 🧑‍🎤

cargo-diet

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

cargo-smart-release

Cargo subcommand for fearlessly releasing crates in workspaces

cargo-local-install

Wraps cargo install for better local, non-conflicting installation

cargo-edit

Cargo commands for modifying a Cargo.toml file

cargo-liner

Cargo subcommand to install and update binary packages listed in configuration

cargo-pio

Cargo<->PlatformIO integration: a cargo subcommand

zepter

Analyze, Fix and Format features in your Rust workspace

cargo-wasix

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

cargo-geiger

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

cargo-xcode

Xcode project files from Cargo projects

cargo-supply-chain

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

cargo-zbuild

cargo-ramdisk

Create target folder as a ramdisk for faster Rust compilation

cargo-makepad

Makepad cargo extension

cargo_marker

Marker's CLI interface to automatically compile and run lint crates

cargo-checkmate

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

cargo-limit

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

cargo-license

Cargo subcommand to see license of dependencies

cargo-ui

GUI for cargo

cargo-unused-features

Find unused enabled feature flags and prune them

prdoc

cli

cargo-pgml-components

bundling SCSS and JavaScript Stimulus components like Rails does

cargo-appimage

Converts your crate into an AppImage

cargo-nav

Navigate directly to crate links from your terminal

cargo-vistree

cargo extension for visualize dependencies

ruoka-rs

Fetch the mayk.fi menu efficiently

cargo-pretty-test

console command to format cargo test output

cargo-deps-list

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

cargo-bitbake

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

cargo-fetcher

🎁 Alternative to cargo fetch

cargo-nw

Cargo subcommand for building NW application deployment packages (redistributables) for Windows, MacOS and Linux

cargo-npk

Northstar is an container runtime for Linux targetting embedded systems

cargo-nbuild

builder that uses the nix package manager

cargo-vendor-filterer

cargo vendor, but with filtering for platforms and more

nextest-runner

Core runner logic for cargo nextest

cargo-acl

code ACL checker

cargo-bundle-licenses

Bundle licensing of dependencies

publish-ws

Publish Workspace Packages

cargo-docs

cargo plugin for serving rust and crate doc locally

cargo-subcommand

creating cargo subcommands

cargo_atelier

Cargo integration for the AWS Smithy IDL

cargo-criterion-means

Cargo command to gather the mean and standard error values from criterion benchmarks

cargo-list

List and update installed crates

cargo-ebuild

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

cargo-bloat

Find out what takes most of the space in your executable

cargo-xdk

Makes building Rust libraries for Android simpler

cargo-sort-ck

Check Cargo.toml for sorted dependencies

cargo-3ds

Cargo wrapper for developing Nintendo 3DS homebrew apps

cargo-tpl

cargo tpl [--lib,-l] [--workspace,-w] <project_name>

cargo-bom

Bill of Materials for Rust Crates

cargo-blflash

BL602 serial flasher

cargo-wgsl

Validate wgsl in rust projects

semverver

Automatic verification of SemVer adherence in Rust library crates

kurit

Static website generator

cargo-hackerman

Workspace hack management and package/feature query

cargo-doc2readme

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

cargo-dl

Cargo subcommand for downloading crate sources

cargo-swipl

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

cargo-hoist

Dead simple, memoized cargo subcommand to hoist cargo-built binaries into scope

cargo-3pl

easy way to ship dependency licenses with your Rust binaries

cargo-so

cargo build Android .so lib files

cargo-odeps

Easy manage rust crate deps by cargo odeps

cargo-whatfeatures

display features, versions and dependencies of crates

mdbook-tailor

mdbook preprocessor for image-tailor

ziggy-honggfuzz-2

Fuzz your Rust code with Google-developped Honggfuzz !

cargo-squatty

Helper tool to reserve names for your crates on https://crates.io

cargo-export

export compiler artifacts from cargo build process

cargo-begin

template project initializer

cargo-wapm

Publish a Rust crate to the WebAssembly Package Manager

cargo-cats

CATS's

cargo-packager

executable packager and bundler CLI and library

cargo-tauri-version

cargo subcommand to output the current version of a tauri app. Future versions will allow for setting the version and ensuring the version is set in the Cargo manifest.

cargo-arps

arp tool on windows

cargo-progenitor

cargo command to generate a Rust client SDK from OpenAPI

cargo-ohrs

cli tool for ohos-rs

cargo-sync-rdme

Cargo subcommand to synchronize README with crate documentation

cargo-edit-9

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

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

fs-lock

Locked files that can be used like normal File

cargo-bak

backup and restore $CARGO_HOME cache to cargo_bak.zip

cargo-offline

cargo-offline是标准cargo命令的包装器。其被用来，根据距离cargo-offline命令执行目录最近的Cargo.toml文件是否曾经被修改，来给被包装的cargo命令聪明地添加--offline…

cargo-oj

Cargo-OJ: package a crate into single file, minimized and formatted

cargo-doc-l10n

that bring to cargo support for localization of the documentation and help to maintain the localization in sync with the original documentation

cargo-trend

Cargo subcommand to generate trend graph of dependent crates

cargo-incver

small utility for manipulating the project version in Cargo.toml

cargo-disasm

Disassembly viewer for Rust projects (and more)

cargo-cabal

that helps you to turn in one command a Rust crate into a Haskell Cabal library

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

cargo subcommand for managing PROS projects

cargo-minimal-versions

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

cargo-pgo

Cargo subcommand for optimizing Rust binaries with PGO and BOLT

dinghy-test

Cross-compilation made easier - see main crate cargo-dinghy

cargo-which-nightly

Find the latest Rust nightly with combinations of features present

cargo-swift

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

cargo-local

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

cargo-clean-recursive

cargo subcommand cleans all projects under specified directory

rerast

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

cargo-all

Manage all your crates with a single command

cargo-date

short description of my package

cargo-web

Cargo subcommand for the client-side Web

fli

good way of building a CLI app in Rust

cargo-fund

Discover funding links for your project's dependencies

cargo-roast

Built in cargo command to roast you on your compiler errors

cargo-bundle

Wrap rust executables in OS-specific app bundles

cargo-feature-combinations

run cargo commands for all feature combinations

cargo-px

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

cargo-vsc

autogenerate .vscode folders

cargo-davinono

Detect (possible) no_std compatibility of your crate and dependencies

cargo-autoken

rust-lang static analysis tool to automatically check for runtime borrow violations

cargo-wasmer

Publish a Rust crate to the WebAssembly Package Manager

cargo-about

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

cargo-shopify

Unofficial cargo tool for managing Shopify projects written in Rust

cargo-raze

Cargo subcommand to generate Bazel BUILD files

cargo-clone

cargo subcommand to fetch the source code of a Rust crate

bybit_rs

Fork of the Official Python3 API connector for Bybit's HTTP (bybit) and WebSockets APIs to rust

bootimage

create a bootable OS image from a kernel binary

cargo-graphmod

cli utility to graph the dependencies between the modules of a package in the dot/graphviz format

cargo-arch

Arch Linux package packer

cargo-clone-crate

Cargo subcommand to clone a repo from the registry

cargo-testf

wrapper for cargo test that remembers and runs failed tests

cargo-minify

cargo utility to automatically remove unused code from a Rust project

ocipkg-cli

CLI for ocipkg

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

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

cargo-feature-tree

cargo feature-tree shows your features, and what they expand to, in a tree-like format

cargo-pub

cargo publish helper

cargo-daruse-test-app

testing

cargo-test-scripts

JUnit compatible test script driver

cargo-devcade

CLI tool for building and packaging devcade games

cargo-contracts

DO NOT INSTALL

cargo-primestack

help run the prime stack

cargo-utests

Find unused test targets in Cargo.toml

runcc

run commands concurrently with rust and cargo

cargo-inspect

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

cargo-ibuild

cargo-coverage

Cargo plugin for generating code coverage data

cargo-structure

analyzing the structure of a cargo project

cargo-skyline

cargo subcommand for working with Skyline plugins written in Rust

cargo-simd-detect

nightly cargo command to report which SIMD extensions your Intel/AMD CPU supports and are enabled

cargo-single-pyo3

Generate a Python module from a single Rust file

cargo-task

Ultra-Lightweight Zero-Dependency Rust Cargo Task Runner

tauri-mobile

on mobile made easy!

cargo-machete-nk

Find unused dependencies with this one weird trick!

cargo-armory

Cargo workspaces tool

cargo-script

Cargo subcommand designed to let people quickly and easily run Rust "scripts" which can make use of Cargo's package ecosystem

cargo-altvup

alt:V Rust Module Updater

cargo-rost

translation of Python code to Rust code

cargo-show

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

semververfork

Automatic verification of SemVer adhrence in rust library crates

cargo-onedoc

Generate your README.md from Rust doc comments

cargo-next

cargo subcommand to set the next crate version

cargo-alias

Easily view, create, and delete cargo aliases

cargo-hdk

Cargo subcommand for building Houdini plugins

cargo-valgrind

cargo subcommand for running valgrind

cargo-play

Run your Rust code without setting up Cargo

cargo-compiler-interrupts

Cargo subcommands that integrate the Compiler Interrupts to the package

cargo-unlock

Remove Cargo.lock lockfile

cargo-releasenotes

Cargo tool to list the release notes for a package

cargo-zproxy

Switch warehouse image

cargo-prepublish

cargo plugin to help prepare a crate for publishing to Crates.io

cargo-equip

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

cargo-newcpp

cargo plugin for creating new C++ projects

cargo-eichkat3r

eichkat3r unterstützt dich bei cargo

cargo-sphinx

Cargo subcommand for building and publishing Sphinx documentation to GitHub Pages

cargo-vs

autogenerate visual studio solutions / projects

cargo-gc-bin

Garbage collect outdated cargo build artifacts

cargo-clean

A cargo-clean utility

cargo-builds

Cargo subcommand to fetch builds from builds.rs

cargo-fill

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

cargo-deadlinks

Cargo subcommand for checking your documentation for broken links

test_bin

getting the crate binary in an integration test

improved-rm

Safely remove files via your terminal

cargo-spec

specify your code

cargo-mono

Cargo subcommand to manage mono repository

transgender-flag

Prints a large 🏳️‍⚧️ on your terminal

cargo-rusnap

Cargo tool for Rusnap

cargo-use

Cargo subcommand to start a new Rust project from a boilerplate/template repository

cargo-files

List all source files in a cargo crate

cargo-gpt

Dump your crate contents into a format which can be passed to GPT

cargo-examples

Run all examples for any locally cloned crate

cargo-aoc-zen-runner

Advent of Code runner aiming to streamline a variety of repository layouts and tasks

cargo-ktra-login

Log in to private ktra registries using cargo

cargo-information

cargo subcommand to show information about crates

cargo-my-bin

cargo subcommand displaying the contents of ~/.cargo/bin/

cargo-foreach

Run cargo command in multiple folders

cargo-travis

Run coverage, upload docs, and more on travis

cargo-scout

Run clippy::pedantic on your diffs only

cargo-asm

cargo subcommand that displays the generated assembly of Rust source code

cargo-cake

cake for celebrating Rust's birthday

indicate

behind cargo-indicate

cargo-upgrades

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

cargo-hatch

Hatch new projects like a chick coming out of its egg

cargo-count

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

cargo-chadr

build CHADstack programs

fast-cli

fast.com, but from the terminal

cargo-cleanall

Cargo plugin to clean all cargo projects in a directory

cargo-example2

cargo run --example without git cloning

cargo-file-gen

program to generate files with a certain size

cargo-group

Create and Modify workspaces from the terminal

cargo-advrunner

advanced configurable cargo runner

cargo-unleash

Tooling to manage releasing of crates in massiv workspaces/monorepos

cargo-makima

Makima's here to abuse you when running cargo~

cargo-espmonitor

Cargo subcommand for monitoring ESP8266 and ESP32 execution over serial

cargo-nono

Detect (possible) no_std compatibility of your crate and dependencies

cargo-suity

automate test runs and report results in JUnit format

cargo-cook

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

cargo-source

registry manager, fast switch between different registries.1

cargo-acap

build Rust programs for the AXIS Camera Application Platform

cargo-upload

Cargo tool for upload crate files to private registry (like crates-registry)

cargo-remark

Cargo subcommand for displaying LLVM optimization remarks from compiling Rust programs

cargo-uwp

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

cargo-lichking

Display info about licensing of dependencies

hola

👋 Hello CLI in Rust

cargo-deplint

enforcing rules about crate dependency graphs

cargo-hook

Add a hook to git which will fmt, clippy and test rust code prior to commit

hax-subcommands

high assurance translation toolchain

cargo-sync-readme

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

cargo-context

build context for gpt4

cargo-publish-workspace-v2

Cargo command to publish a workspace mono repo

cargo-pkg

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

cargo-cranky

Easy to configure wrapper for clippy

cargo-emanate

Cargo subcommand for publishing workspace-based crates

cargo-review

Security audit tooling container

cargo-build-deps

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

cargo-pipe

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

wasm-bundle

Compile Rust code to self-contained .js and .html files using WASM

cargo-profiler

Cargo subcommand to profile your applications

cargo-dad

Fix your typos with dad jokes

cargo-tanker

create great project structure for Rust

cargo-lints

running lints specified from files

cargo-hf2

Cargo Subcommand for Microsoft HID Flashing Library for UF2 Bootloaders

cargo-feature

Cargo plugin to manage dependency features

cargo-glab-release

cargo cli tool used to publish a Gitlab release with binaries for cargo-binstall

logga

minimal logger and console printer for my loggas

cli-tables

generating ASCII tables in a CLI application

minigrep_tutorials_20231109

tutorials: publish crate

cargo-cacher

crates.io proxy that will proxy requests made when building a package with Cargo

cargo-mod

cargo sub command for generating modules in your project. Reducing time spent writing boilerplate.

cargo-service-message

Seamless integration of cargo with TeamCity

cargo-kcov

Cargo subcommand to run kcov to get coverage report on Linux

cargo-duplicates

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

example_api

Example API used in the cargo-public-api test suite

cargo-craft

cargo subcommand to scaffold/generate boilerplate code for your Rust projects

cargocleaner

Runs cargo clean on all subdirectories

feature

See out how Rust dependencies and features are enabled

command_line_calculator

command-line calculator

cargo-intraconv

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

cargo-eval

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

ziggy-honggfuzz-1

Fuzz your Rust code with Google-developped Honggfuzz !

cargo-todo

Cargo tool to display TODOs

cargo-manifmt

rustfmt for your Cargo.toml

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

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

cargo-fel4

cargo subcommand for automating feL4 (seL4 for Rust) development

cargo-native-install

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

unix-watch

Unix watch command

cargo-with

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

cargo-tally

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

cargo-gha

Version lock, cache, and run binaries from any Github Release assets. Pull in external tools and keep the versions in sync across your team, and forget installing globally.

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

badgeland

Fast badge generator for any purpose

cargo-select

Cargo subcommand to easily run targets/examples/tests

cargo-wop

Cargo for single-file projects

cargo-do

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

aleph-zero-cargo-nono

Detect (possible) no_std compatibility of your crate and dependencies

cargo-wasi-exe-x86_64-pc-windows-msvc

Precompiled binary of cargo-wasi for x86_64-pc-windows-msvc

cargo-watch-plus

Cross-platform file watching library

cargo-open

third-party cargo extension to allow you to open a dependent crate in your $EDITOR

cargo-modoc

Generate module documentation from markdown files

cargo-no-dev-deps

Cargo subcommand for running cargo without dev-dependencies

cargo-pack-docker

pack artifacts into a docker image

cargo-ws

cargo plugin, generate vscode workspace file

cargo-quad-apk

Cargo subcommand that allows you to build Android packages

rawcmd

Command-line application framework

arguman

Command-line argument parsing library

cargo-publish-crates

Publish rust crates with support for cargo workspaces

sourcegear-bridge-cargo

Cargo subcommand for SourceGear Bridge, a binding generator for .NET

cargo-self

build and install a package using cargo enhanced with LLM models

cargo-docker-build

Build Dockerfile and script from Cargo.toml for a Rust workspace project

cargo-feature-matrix

run cargo commands on a matrix of feature sets

cargo-mutagen

Mutation testing for Rust – Runner

cargo-installed

Easy manage programs installed by cargo install

cargo-travis-fork

Run coverage, upload docs, and more on travis

cargo-docs-rs

Immitate the documentation build that docs.rs would do

cargo-qemu-runner

cargo subcommand that allows running Limine kernels using cargo run

cargo-zclean

dors

No-fuss workspace-friendly task runner for cargo

cargo-node

cargo sub command to build, run and deploy rust wasm applications as browser, electron or cordova app

cargo-heaptrack

cargo subcommand for generating heaptrack flamegraphs

test_for_zeven

konw for my test

cargo-rclean

Clean your rust projects, recursively

cargo-ensure-prefix

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

cargo-pando

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

cargo-flaky

cargo sub-command to helps you find flaky tests

cargo-test-all-features

Cargo subcommands that build and test all feature flag combinations for a crate

cargo-devserver

recompile harness for rust web app development on cfg(unix)

cargo-cmd

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

cargo-clearlydefined

checking dependencies with clearlydefined.io

cargo-kconfig

Kconfig macro library and user interface for the Kconfig file format from the Linux Kernel

cargo-sideload

Tools for working with private Cargo registries

cargo-profile

Cargo subcommand to profile performance

cargo-prune

Prune dependency cache

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.

cargo-fly

Cargo can run, but running is slow. Rust is 🚀blazingly🚀 fast, and so cargo should fly

cargo-single-line

cargo plugin to shrink cargo's output

cargo-print

cargo subcommand to print information in a shell-convenient format

cargo-gui

browser interface for working through rustc errors and running cargo commands

cargo-up

Upgrade your dependencies by automatically fixing your code

cargo-single

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

cargo-first

cargo subcommand to stop execution after the first error

cargo-metadata-resolver

executable designed to get you the current package's metadata in json format. This was a "learn how to rust" project for me so don't expect a large amount of updates/improvements.