Lib.rs

cargo

Cargo, a package manager for Rust

cargo-hack

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

cargo-outdated

Cargo subcommand for displaying when dependencies are out of date

cargo-dylint

A tool for running Rust lints from dynamic libraries

cargo-sort

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

cargo-ndk

Makes building Rust libraries for Android simpler

cargo-make

Rust task runner and build tool

cargo-cache

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

cargo-wasi

Subcommand for Cargo to easily build code for wasm32-wasi

cargo-generate-rpm

Generate a binary RPM package (.rpm) from Cargo 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.

cargo-deb

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

cargo-generate

cargo, make me a project

tauri-bundler

Wrap rust executables in OS-specific app bundles for Tauri

cargo-semver-checks

Scan your Rust crate for semver violations

cargo-binutils

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

cargo-tarpaulin

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

cargo-instruments

Profile binary targets on macOS using Xcode Instruments

cargo-audit

Audit Cargo.lock for crates with security vulnerabilities

cargo-edit

Cargo commands for modifying a Cargo.toml file

cargo-binstall

Rust binary package installer for CI integration

cargo-commander

Like npm scripts, but better

flamegraph

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

Cargo plugin to help you manage large dependency graphs

cargo-watch

Watches over your Cargo project’s source

cargo-c

Helper program to build and install c-like libraries

libcnb-cargo

Cargo command for managing buildpacks written with libcnb.rs

cargo-update

A cargo subcommand for checking and applying updates to installed executables

cargo-deps

Cargo subcommand for building dependency graphs of Rust projects

cargo-insta

A review tool for the insta snapshot testing library for Rust

cargo-espflash

Cargo subcommand for flashing Espressif devices over serial

cargo-bloat

Find out what takes most of the space in your executable

cargo-depgraph

Creates dependency graphs for cargo projects using cargo metadata and graphviz

cargo-quickinstall

Precompiled binary installs for cargo install

cargo-dinghy

Cross-compilation made easier

cargo-aoc

Cargo Advent of Code Helper

cargo-chef

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

cargo-pgx

Cargo subcommand for 'pgx' to make Postgres extension development easy

cargo-careful

Execute Rust code carefully, with extra checking along the way

clap-cargo

Re-usable CLI flags for cargo plugins

cargo-zigbuild

Compile Cargo project with zig as linker

cargo-apk

Helps cargo build APKs

cargo-clean-all

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

cargo-workspaces

Cargo workspace manager

cargo-hakari

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

cargo-nextest

A next-generation test runner for Rust

cargo-local-registry

A Cargo subcommand for managing local registries

cargo-coverage-annotations

Ensure annotations in code match actual coverage

cargo-temp

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

cargo-supply-chain

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

cargo-rdme

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

cargo-udeps

Find unused dependencies in Cargo.toml

cargo-show-asm

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

cargo-msrv

Find your minimum supported Rust version (MSRV)!

cargo-modules

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

cargo-valgrind

A cargo subcommand for running valgrind

cargo-all-features

A Cargo subcommand to build and test all feature flag combinations

cargo-lipo

cargo lipo subcommand to automatically create universal libraries for iOS

cargo-bundle

Wrap rust executables in OS-specific app bundles

cargo-updater

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

cargo-limit

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

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

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

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

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

cargo-lambda

Cargo subcommand to work with AWS Lambda

cargo-generate-type

Cargo subcommand to generate Rust code from and for input data

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

Validate wgsl in rust projects

cargo-llvm-cov

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

cargo-wix

Build Windows installers using the WiX Toolset

cyclonedx-bom

CycloneDX Software Bill of Materials Library

cargo_atelier

Cargo integration for the AWS Smithy IDL

cargo-aur

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

cargo-action-fmt

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

cargo-bisect-rustc

Bisects rustc toolchains with rustup

cargo-ebuild

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

cargo-screeps

Build tool for deploying Rust WASM code to Screeps game servers

cargo-checkmate

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

cargo-sonar

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

cargo-3pl

The easy way to ship dependency licenses with your Rust binaries

cargo-local-install

Wraps cargo install for better local, non-conflicting installation

cargo-index

Cargo subcommand to manage a registry index

cargo-play

Run your Rust code without setting up Cargo

crm

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

cargo-auditable

Make production Rust binaries auditable

cargo-xwin

Cross compile Cargo project to Windows MSVC target with ease

cargo-compete

A Cargo subcommand for competitive programming

cargo-cabal

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

cargo-spellcheck

Checks all doc comments for spelling mistakes

cargo-arch

Rust Arch Linux package packer

cargo-emanate

Cargo subcommand for publishing workspace-based crates

cargo-shuttle

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

rustdoc-json

Utilities for working with rustdoc JSON

cargo-task

Ultra-Lightweight Zero-Dependency Rust Cargo Task Runner

libbpf-cargo

Cargo plugin to build bpf programs

rhdxmr-publish-test

Cargo plugin to manage eBPF probes using redbpf

cargo-fetcher

🎁 Alternative to cargo fetch

cargo-whatfeatures

display features, versions and dependencies of crates

cargo-vendor-filterer

cargo vendor, but with filtering for platforms and more

bfom

Brendan's Flavor of Markdown: I'll build my own markdown format, what could go wrong?

cargo-machete

Find unused dependencies with this one weird trick!

cargo-license

Cargo subcommand to see license of dependencies

cargo-swipl

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

cargo-smart-release

Cargo subcommand for fearlessly releasing crates in workspaces

cargo-doc2readme

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

cargo-prebuilt

Download prebuilt crate binaries for many different platforms

debcargo

Create a Debian package from a Cargo crate

cargo-cleanall

Cargo plugin to clean all cargo projects in a directory

cargo-skyline

A cargo subcommand for working with Skyline plugins written in Rust

cargo-husky

husky for cargo

cargo-subcommand

Library for creating cargo subcommands

cargo-pio

Cargo<->PlatformIO integration: a cargo subcommand

cargo-xdk

Makes building Rust libraries for Android simpler

ograc

like cargo, but backwards

cargo-sweep

A tool for cleaning unused build files created by Cargo

cargo-bitbake

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

cargo-feature-combinations

run cargo commands for all feature combinations

cargo-vet

Supply-chain security for Rust

cargo-i18n

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

cargo-my-bin

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

cargo-mommy

Mommy's here to support you when running cargo~

cargo-cyclonedx

CycloneDX Software Bill of Materials (SBOM) for Rust Crates

cargo-ui

GUI for cargo

cargo-examples

Run all examples for any locally cloned crate

cargo-compiler-interrupts

Cargo subcommands that integrate the Compiler Interrupts to the package

cargo-bom

Bill of Materials for Rust Crates

cargo-cats

CATS's

cargo-leptos

Build tool for Leptos

cargo-offline

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

cargo-unused-features

Find unused enabled feature flags and prune them

cargo-clone

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

cargo-espmonitor

Cargo subcommand for monitoring ESP8266 and ESP32 execution over serial

cargo-zbuild

cargo-installed

Easy manage programs installed by cargo install

cargo-sync-rdme

Cargo subcommand to synchronize README with crate documentation

cargo-sysroot

Simply and Easily cross-compile the Rust sysroot crates

cargo-appimage

Converts your crate into an AppImage

cargo-liner

Cargo subcommand to install and update binary packages listed in configuration

cargo-wapm

Publish a Rust crate to the WebAssembly Package Manager

cargo-uwp

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

cargo-crev

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

cargo-hook

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

dinghy-test

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

cargo-cranky

Easy to configure wrapper for clippy

cargo-dist

Shippable application packaging for Rust

cargo-pgo

Cargo subcommand for optimizing Rust binaries with PGO and BOLT

cargo-release

Cargo subcommand for you to smooth your release process

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

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

cargo-tally

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

cargo-http-registry

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

cargo-whichp

Cli for debugging executable lookup

cargo-foreach

Run cargo command in multiple folders

cargo-rost

translation of Python code to Rust code

cargo-wasix

Subcommand for Cargo to easily build code for wasm64-wasi

cargo-spec

A tool to specify your code

cargo-bundle-licenses

Bundle licensing of dependencies

cargo-raze

A Cargo subcommand to generate Bazel BUILD files

cargo-acap

A tool to build Rust programs for the AXIS Camera Application Platform

cargo-clean-recursive

A cargo subcommand cleans all projects under specified directory

cargo-info

Extends cargo to query crates.io registry for crates details

cargo-single-pyo3

Generate a Python module from a single Rust file

cargo-onedoc

Generate your README.md from Rust doc comments

cargo-doc-ngrok

A cargo subcommand to build and serve documentation via ngrok

cargo-criterion

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

cargo-duplicates

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

cargo-unleash

Tooling to manage releasing of crates in massiv workspaces/monorepos

cargo-vs

autogenerate visual studio solutions / projects

cargo-pipe

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

cargo-codspeed

Cargo extension to build & run your codspeed benchmarks

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

Cargo plugin to manage eBPF probes using redbpf

cargo-ado

Azure DevOps wrapper for Cargo

cargo-web

A Cargo subcommand for the client-side Web

cargo-nag

Custom lints runner

cargo-quad-apk

Cargo subcommand that allows you to build Android packages

cargo-psx

cargo wrapper for the Sony PlayStation 1

cargo-arps

a arp tool on windows

cargo-docs

A cargo plugin for serving rust and crate doc locally

cargo-structure

A simple tool for analyzing the structure of a cargo project

runcc

run commands concurrently with rust and cargo

cargo-print

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

cargo-cacher

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

cargo-diet

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

cargo-feature

Cargo plugin to manage dependency features

cargo-xcode

Make Xcode project files from Cargo projects

cargo-hf2

Cargo Subcommand for Microsoft HID Flashing Library for UF2 Bootloaders

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

Workspace hack management and package/feature query

cargo-about

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

cargo-fund

Discover funding links for your project's dependencies

cargo-get

Cargo plugin to easily query information from Cargo.toml files

badgeland

Fast badge generator for any purpose

phpfmt

Opinionated code formatting for PHP projects

cargo-todo

Cargo tool to display TODOs

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

Cargo subcommand for checking your documentation for broken links

cargo-native-install

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

cargo-ensure-prefix

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

cargo-manifmt

rustfmt for your Cargo.toml

semverver

Automatic verification of SemVer adherence in Rust library crates

cargo-profile

Cargo subcommand to profile performance

cargo-inspect

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

ReplaceInFile

A small package for replacing words in a file

cargo-cuddle

OwO

cargo-zproxy

Switch warehouse image

kelpdot

Simple dotfiles manager

cargo-ws

cargo plugin, generate vscode workspace file

cargo-demangle

Extends cargo to demangle files generated by objdump or nm

cargo-show

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

cargo-feature-matrix

run cargo commands on a matrix of feature sets

cargo-is-tested

Ensure that your items are checked with high-quality testing!

cargo-cleans

A cargo subcommand cleans all projects under a specified directory with high performance

example_api

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

cargo-scan

Scan and analyze Cargo dependencies

rerast

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

cargo-sphinx

Cargo subcommand for building and publishing Sphinx documentation to GitHub Pages

cargo-swift

A cargo plugin to easily build Swift packages from Rust code

cargo-todox

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

cargo-minimal-versions

Cargo subcommand for proper use of -Z minimal-versions

cargo-single-line

A cargo plugin to shrink cargo's output

cargo-vibe

Cargo x Buttplug.io

cargo-feature-tree

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

publish-cool-workspace

Cargo subcommand for releasing crates in workspaces

cargo-function-history

cargo frontend for git-function-history

cargo-pkg

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

cargo-subgraph

Manage subgraphs written in Rust 🦀

cargo-select

Cargo subcommand to easily run targets/examples/tests

cargo-asm

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

lrcat-extractor

Extract data from Adobe Lightroom™ catalogs

cargo-suity

Utility to automate test runs and report results in JUnit format

cargo-sync-readme

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

cargo-build-deps

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

cargo-kill-all

Remove old node_modules, cargo target to save space

cargo-hdk

Cargo subcommand for building Houdini plugins

cargo-simple-todo

cargo-simple-todo, a simple cargo tool for checking todo(s)

cargo-sort-ck

Check Cargo.toml for sorted dependencies

cargo-travis

Run coverage, upload docs, and more on travis

cargo-cake

A cake for celebrating Rust's birthday

cafuc

cargo publish demo project

cargo-cli

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

nextest-runner

Core runner logic for cargo nextest

cmasfo-dev

cmasfo dev dependency

millennium-bundler

Wrap Rust executables in OS-specific app bundles for Millennium

cargo-kconfig

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

cargo-hatch

Hatch new projects like a chick coming out of its egg

cargo-flaky

A cargo sub-command to helps you find flaky tests

cargo-bavy

A third-party command line utility for the Bevy game engine

cargo-ament-build

Cargo plugin for use with colcon workspaces

cargo-contemplate

fetch templates for stuffs

cargo-wheel

Use milksnake and cbindgen to generate python binding to your Rust crate

cargo-so

Helps cargo build Android .so lib files

hacspec

The hacspec compiler

tango

Markdown-based Literate programming in Rust, integrated with Cargo

cargo-post

A cargo wrapper that executes a post build script after a successful build

quine

cargo-count

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

cargo-lichking

Display info about licensing of dependencies

cargo-wop

Cargo for single-file projects

cargo-list-cache

Lists the files in your crate cache (${CARGO_HOME}/registry/cache/...)

cargo-mod

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

cargo-set-rust-version

Update Cargo.toml rust-version to latest

clean_coder

todo

wargo

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

cargo-innit

Bri'ish cargo init

tauri-mobile

Rust on mobile made easy!

cargo-dover

A toolkit to manage cargo project version

cargo-vcs

Cargo workspace helper for Version Control System project management

cargo-featurex

cargo plugin to run tasks against feature powersets

cargo-add-dynamic

Cargo-add command to make dependencies into dylibs

cargo-funnel

cargo subcommand to reorganize and sort your Cargo.toml

cargo-todo-rs

A simple todo Cli app

cargo-markdown

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

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

Easily view, create, and delete cargo aliases

cargo-nodex

cargo tool for creating nodejs native addon

cargo-prof

Tools to make profiling Rust programs easier

cargo-cook

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

cargo-scout

Run clippy::pedantic on your diffs only

cargo-intraconv

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

cargo-nono

Detect (possible) no_std compatibility of your crate and dependencies

cargo-deps-list

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

cargo-up

Upgrade your dependencies by automatically fixing your code

homo-rs

HOMO argumentator in Rust

cargo-webassembly

A cargo utility for working on WebAssembly

apple-app-store-connect-api-token-cli

Apple - App Store Connect API - Token Cli

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

Cargo subcommand to profile your applications

cargo-toml-lint

Linter for Cargo.toml

cargo-ktra-login

Log in to private ktra registries using cargo

cargo-kcov

Cargo subcommand to run kcov to get coverage report on Linux

cargo-changelog

Changelog management tool

cargo-fel4

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

cargo-touch

A tiny utility that updates the modification time on all lib/main/test/example/bench files in the current cargo workspace/project to force its recompilation

cargo-unlock

Remove Cargo.lock lockfile

nkowne63-wordle-solver-rs-01

wordle solver by the nkowne63

cargo-clone-crate

Cargo subcommand to clone a repo from the registry

jassbot

github.com/cokemonkey11/jassbot

fakecargo

fake cargo for single rust files

cargo-service-message

Seamless integration of cargo with TeamCity

dinghy

Painless tests on mobile devices

cargo-cvm

Rust Crate Version Manager (CVM)

cargo-drive

cargo run? no, cargo drive

cargo-msix

A cargo subcommand to build MSIX installers for Rust projects

cargo-modoc

Generate module documentation from markdown files

cargo-vendor-add

Add crates directly to a cargo vendor directly

cargo-shiny

Cargo Shiny

semververfork

Automatic verification of SemVer adhrence in rust library crates

cargo-extras

A collection of cargo subcommands

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.

cargx

Execute local cargo package binaries

cargo-mono

Cargo subcommand to manage mono repository

cargo-with

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

cargo-single

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

cargo-ex

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

cargocleaner

Runs cargo clean on all subdirectories

cargo-gitv

Reasonable and opinionated version management based on Cargo and Git metadata

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

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

cargo-nav

Navigate directly to crate links from your terminal

eduardo_more_cargo

A study with examples from The Rust Programming Language Book - Chapter 14

cargo-force-build

Allow soft force build

cargo-cmd

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

minigrepyuqing

demo

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

A cargo subcommand to stop execution after the first error

cargo-benchcmp

A utility for comparing Rust micro-benchmark output

cargo-recursive

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

astar_rust

A rust implementation of astar search alogorithm

minigrep_z

我的测试

minigrep_cargo_publish_example

Based on the official rust book

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

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

cargo-kythe

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

cargo-equip

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

cargo-rclean

Clean your rust projects, recursively

cargo-pack-docker

pack artifacts into a docker image

arguman

Command-line argument parsing library

cargo-test-all

Cargo extension for running tests of the used dependencies

cargo-remote

Cargo subcommand to build rust projects remotely

cargo-suicide

Tool to fix your code forever

cargo-memex

Compile and execute rust code as memes

cargo-linebreak

A cargo subcommand for printing linebreaks when using cargo-watch

cargo-fixeq

Fix assert_eq! test errors automatically

wakeup

It wants to wake you up

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

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

cargo-travis-fork

Run coverage, upload docs, and more on travis

cargo-ramdisk

Create target folder as a ramdisk for faster Rust compilation

cargo-sideload

Tools for working with private Cargo registries

dors

No-fuss workspace-friendly task runner for cargo

cargo-license-page

Create an HTML page for the licenses of all dependencies

cargo-whatis

Quickly show the description of a crate on crates.io

joyful_minigrep

grep but mini and colored though

c74d

alex_cargo_release

Alex's rust learning

cargo-pando

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

cargo-publish-all

Tool to publish all packages

cargo-armory

Cargo workspaces tool

cargo-pubs

how to pub a crate

cargo-owo

br3adina7or's custom program to make a new rust project

cargo-merge

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

emils-cargo-release

Cargo subcommand for you to smooth your release process

cargo-culture

Tool to check Rust project conventions

cargo-dephell

Analyzes a project's third-party dependencies

cargo-archtest

CLI of arch_test_core for rule based architecture tests

cargo-brief

Display a brief summary of cargo dependencies

src-graph

cargo subcommand which shows struct dependencies

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

analyze dependencies and generate single TAGS for cargo projects

cargo-disasm

Disassembly viewer for Rust projects (and more)

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

cargo publish helper

cargo-s

Cargo Shiny

cargo-makedocs

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

cargo-frc

A cargo extension for deploying rust code to FRC robots

cargo-build-dependencies

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

cargo-ship

A cargo command to ship a tested release build

crabsay

A cowsay-like package using ferris-says

cargo-gui

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

cargo-squat

Easily reserve a crates.io package name

cargo-lock2rpmprovides

Cargo Lock to Rpm Provides

cargo-check

wrapper around cargo rustc -- -Zno-trans

cargo-nuget

Bundle Rust libraries as Nuget packages

cargo-blinc

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

cargo-quickbench

Quickly create a cargo bench package

cargo-testify

Tool to automatically run tests on your Rust project and notify about the result

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-build-docker

A cargo subcommand to build rust using docker

cargo-cross-test

Run native and web tests with a single command

rust_black_tree

Please don't use this in something serious lol

cargo-cocoapods

Generate a Cocoapods wrapper for your Rust project

cargo-repeat

Repeats a command until it exits with the right code

cargo-mach

Cargo wrapper for mozillas mach

cargo-prune

Prune dependency cache

cargo-version-sync

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

cargo-whynot

Cargo subcommand to discover why a function is unsafe

cargo-brust64

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

cargo-pkgconfig

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