Lib.rs

cc

A build-time dependency for Cargo build scripts to assist in invoking the native C compiler to compile native C code into a static archive to be linked into Rust code

cmake

A build dependency for running cmake to build a native library

vergen

Generate 'cargo:rustc-env' instructions via 'build.rs' for use in your code via the 'env!' macro

rustc_version

querying the version of a installed rustc compiler

pkg-config

run the pkg-config system tool at build time in order to be used in Cargo build scripts

shadow-rs

A build-time information stored in your rust project

built

information from the time it was built

version_check

Tiny crate to check the version of the installed/running rustc

git-version

Compile the git version (tag name, or hash otherwise) and dirty state into your program

system-deps

Discover and configure system dependencies from declarative dependencies in Cargo.toml

cargo-platform

Cargo's representation of a target platform

xshell

quick shell scripting in Rust

autocfg

Automatic cfg for Rust compiler features

sccache

ccache-like tool. It is used as a compiler wrapper and avoids compilation when possible. Sccache has the capability to utilize caching in remote storage environments, including various cloud storage options…

cxxbridge-cmd

C++ code generator for integrating cxx crate into a non-Cargo build

ci_info

current CI environment information

vcpkg

find native dependencies in a vcpkg tree at build time in order to be used in Cargo build scripts

cross

Zero setup cross compilation and cross testing

mktool

General purpose utility to enhance pkgsrc/mk infrastructure

laze

A declarative build system for C projects aiming to be simple, fast and correct

convco

Conventional commit tools

prost-build

Generate Prost annotated Rust types from Protocol Buffers files

scriptisto

A language-agnostic "shebang interpreter" that enables you to write scripts in compiled languages

cargo-xwin

Cross compile Cargo project to Windows MSVC target with ease

conjure-codegen

Rust code generation for Conjure definitions

pyproject-toml

pyproject.toml parser in Rust

pipeline-cli

A build tools written by rust to build project and execute a serials of task

rustcbuildx

$RUSTC_WRAPPER tool to sandbox cargo builds and execute jobs remotely

autotools

A build dependency to build native libraries that use configure&make-style build systems

jobslot

GNU make jobserver for Rust

git-testament

Record git working tree status when compiling your crate

mkrs

Build automation tool

rattler_index

that indexes directories containing conda packages to create local conda channels

ispc_rt

A runtime dependency for linking Rust code with pre-built ISPC binaries and Rust bindings. These modules and bindings should be built with ispc_compile.

link-cplusplus

Link libstdc++ or libc++ automatically or manually

incli

Automation Tool For Installing Compilers, Sdk's and Package Managers

glib-build-tools

Rust bindings for the Gio library, build script utils crate

wolfram-app-discovery

Find local installations of the Wolfram Language

cargo

package manager for Rust

thag_rs

A versatile script runner and REPL for Rust snippets, expressions and programs

is_ci

Super lightweight CI environment checker. Just tells you if you're in CI or not without much fuss.

jundler

The JavaScript executable bundler for Node.js projects

e-utils

utils

winresource

Create and set windows icons and metadata for executables

komodo_cli

Command line tool to execute Komodo actions

invil

A port of amboso to Rust

rua

Secure jailed AUR helper for Arch Linux

mask

A CLI task runner defined by a simple markdown file

cargo-auto

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

cargo_auto_github_lib

cargo-auto automation tasks written in rust language with functions for GitHub

nasm-rs

Run NASM during your Cargo build

build-wrap

Help protect against malicious build scripts

embuild

A build support library for embedded Rust

build-data

Include build data in your program: date, rustc version, git commit & branch, etc

bgt

automated Guix builds of Bitcoin Core

turtle-build

Ninja-compatible build system for high-level programming languages

apkeep

A command-line tool for downloading APK files from various sources

breakmancer

Drop a breakpoint into any shell

python3-dll-a

Standalone python3(y).dll import library generator

ra_ap_project_model

A representation for a Cargo project for rust-analyzer

embed_plist

Embed property list files like Info.plist directly in your executable binary

conan

wrapper of the conan C/C++ package manager (conan.io) to simplify usage in build scripts

flatc-rust

FlatBuffers flatc command as API

build-info

Collects build-information of your Rust crate

const_for

For loop in const implemented with a macro

semantic-release-cargo

A CLI to integrate Rust into a semantic-release workflow

cmvm

that manages multiple CMake versions

thebakery

Build engine for the Yocto/OE Projects

rsconf

A sane autoconf for rust. build.rs helpers for testing for system headers, libraries, and symbols

debian-analyzer

Debian analyzer

cxx-build

C++ code generator for integrating cxx crate into a Cargo build

armerge

merge and control visibility of static libraries

ocipkg-cli

CLI for ocipkg

scratch

Compile-time temporary directory shared by multiple crates and erased by cargo clean

deno_lockfile

lockfile used in Deno

tinyrick

a freeform Rust build system

cargo-emit

Talk to Cargo easily at build time

rofi-obsidian

Launch your Obsidian vaults from the comfort of rofi

nj-cli

build tool for node-bindgen

sbe-cli

sbe schema tool to facilitate working with SBE schema files and generating codes

zinoma

Žinoma - Make your build flow incremental

uniffi_build

a multi-language bindings generator for rust (build script helpers)

blue-build

A CLI tool built for creating Containerfile templates for ostree based atomic distros

radicle-ci-broker

add integration to CI engins or systems to a Radicle node

binstalk-fetchers

The binstall fetchers

publish-ws

Publish Workspace Packages

cargo-godot

cargo helper for godot developpers

windows_exe_info

A cargo build script library for adding file information to windows executables

flatcc

Build-time convenience utilities for flatbuffers

moon_common

Common utilities

cachepot

sccache-like tool. It is used as a compiler wrapper and avoids compilation when possible, storing a cache in a remote storage using cloud storage.

cmake-parser

parse cmake language

eas-env

CLI tool to manage environment variables for Expo projects

git-warp-time

CLI utility to reset file timestamps to repo state

simplebuild

build automation tool for c

cmake-version-manager

CMake version helps manage installed versions of cmake

msvc_spectre_libs

easy way to link with the Spectre-mitigated libraries for Windows MSVC targets. Does nothing for other targets

toolchain_find

A small library to help find installed Rust components

builder_cpp

build tool for building C and C++ applications

sticks

managing C and C++ projects

kbuild

This package help you to build rust kernel quickly and easily

cargo-limit

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

buck-resources

Load resource paths from a resources.json produced by Buck

unmake

a makefile linter

esp-metadata

Metadata for Espressif devices

cdylib-link-lines

Collection of link-lines useful to build correct cdylibs on targets

anda

Andaman Build toolchain

depot-js

A Javascript devtool orchestrator

rust-version-info-file

generating one file includes rustc version and cargo tree

zig-wraper

Wrapper for zig cc with logic to correcting args

ld-memory

Helper crate to programmatically create GNU ld MEMORY blocks

tsdl

A downloader/builder of many tree-sitter parsers

openblas-build

The package provides a build helper for OpenBLAS

git2version

way to get the version of the package from git and incorporate it as a constant into your program

risc0-build

RISC Zero zero-knowledge VM build tool

cargo-vroom

Car no go run, car go vroom!

dexterous_developer_instance

A modular hot reload system for rust

auto_generate_cdp

experimental crate to generate the Chrome Devtools Protocol

cargo-post

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

version-manager

version manager for your projects

cargo-all

Manage all your crates with a single command

tpot

A cargo inspired build tool for C

uneval_static

Serde serializer to embed data as Rust code

build_const

creating importable constants from build.rs or a script

august-build

Task-based build system with a custom syntax and focus on paralellism for all your artifact construction needs

git_info

Extracts git repository information

omake

A Rust implementation of make

sunbeam

A dynamic CSS class library

heron-rebuild-syntax

.hr file syntax and parsers for use in heron-rebuild

slinky-cli

Linker script generator for decompilation and modding projects

crate-git-revision

Embed git revision into crates built and published

ognibuild

Detect and run any build system

pargit

Git workflow utility

pcu

A CI tool to update change log in a PR

stak-build

Build scripts for Stak Scheme

codr

A CLI tool for interacting with OneDrive

maid

🔨 An easy to use make alternative

hugo-build

A wrapper around the hugo binary to proving building capabilities

ispc

build-time dependency for Cargo build scripts to help with compiling and linking to ISPC code and generating Rust bindings for the resulting library. This crate is a meta-crate for the ispc_compile and ispc_rt crates…

mc-sgx-sdk-tools

Tools for building SGX enclaves

inwelling

Collects information from downstream crates at compile-time

flatc

Vendored executable of flatbuffer’s flatc

json_compilation_db

read/write JSON compilation database file

vergen-gitcl

Generate 'cargo:rustc-env' instructions via 'build.rs' for use in your code via the 'env!' macro

readme-rustdocifier

rustdocifying README.md for inclusion in lib.rs

qt-build-utils

Build script helper for linking Qt libraries and using moc code generator. Intended to be used together with cc, cpp_build, or cxx_build

zigcli

A build dependency for running zig to build a native library

rustc-ap-rustc_feature

Automatically published version of the package rustc_feature in the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github…

garden-tools

Garden grows and cultivates collections of Git trees Garden lets you define and run commands over collections of configuration-defined multi-worktree Git environments

robuild

writing build recipes in Rust

conan2

Pulls the C/C++ library linking flags from Conan dependencies

meddl_translate

Translate German to Meddlfrängisch

cfg_rust_features

Set cfg options according to probing for Rust compiler, language, and library features

pai-inject-so

inject shared object files into processes

farmfe_compiler

Farm Compiler

uneval

Serde serializer to embed data as Rust code

pectin

Checks Quake map jam submissions

cargo-coverage-annotations

Ensure annotations in code match actual coverage

chrono-tz-build

internal build script for chrono-tz

build-target

that provides programmatic access to information about the current build target

neon-build

Build logic required for Neon projects

rustc-simple-version

Access the rustc version used to build your project using a simple constant

gitlab-runner

Helper crate to build custom gitlab runners

deppatcher

Automate patching Cargo.toml files using jsonnet

make-tools

Makefile utility

meson-next

A build dependency crate for running Meson to build a native library

include_tt

Macro for embedding (trees, strings, arrays) into macro trees directly from files

dinghy-lib

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

nu_plugin_query

A Nushell plugin to query JSON, XML, and various web data

nixci

Define and build CI for Nix projects anywhere

pkg-version

Macros expanding to the package version

coin-build-tools

set of tools to build COIN-OR libraries from source

crit

Rust cross-compiler

static_vcruntime

Statically link the VCRuntime when using the MSVC toolchain

trait_variable

Make variable fields feasible in trait definition

avrogen

This program allow allow to generate rust code from avro definition files. Modules are created from namespace information

ecargo

Cargo metadata viewer using egui

xous-semver

porting semantic versions between build system and binary objects

wdk-build

configure a Cargo build script for binding generation and downstream linking of the WDK (Windows Driver Kit)

labt

Lab-t Lightweight Android build tool

codes-common

Support capabilities for codes-* packages

license-retriever

Retrieves licenses of all Rust dependencies

dreamy-cli

A cli to work with dependencies

andax

Andaman scripting runtime

makemake

building Makefiles programmatically

thunk-rs

Thunk the Rust program to support Windows XP, Vista and more!

cargo-matrix

Run feature matrices against cargo commands that support feature lists

moon_config

Core workspace, project, and moon configuration

vortex-build

Helpers used in build.rs file for the Vortex project

parcel_css

A CSS parser, transformer, and minifier

pyflow

A modern Python installation and dependency manager

steward

Task runner and process manager for Rust

derive-codegen

Highly-configurable code generation tooling based on Rust types

project-origins

Resolve project origins and kinds from a path

web-static-pack

Embed static resources (GUI, assets, images, styles, html) within executable. Serve with hyper or any server of your choice.

aya-rustc-llvm-proxy

Dynamically proxy LLVM calls into Rust own shared library

rusty-bind-build

Build script for generating gluecode using rusty-bind

cxx-qt-gen

Code generation for integrating cxx-qt into higher level tools

selium-std

dependent crate of Selium. Do not use directly.

xmake

A build dependency for running xmake to build a native library

embed-manifest

Build script library to easily embed a Windows manifest

gsdtool

CLI utility for PROFIBUS GSD files (Generic Station Descripions)

czo

A short description of my package

fortanix-sgx-tools

Tools for building and running enclaves for the Fortanix SGX ABI. This contains ftxsgx-runner to run generic x86_64-fortanix-unknown-sgx enclaves, as well as ftxsgx-elf2sgxs…

aortiz-workshop-example-cli

Arturo's example for Cargo

rustversion-detect

Detect rustc compiler version

mmrbi

MaulingMonkey's Rust Build Infrastructure

build-probe-mpi

Probes the system for an installation of an MPI library

rustflags

Parser for CARGO_ENCODED_RUSTFLAGS

dev_bestia_cargo_completion

Auto-completion for cargo-auto and automation_tasks_rs and partial auto-completion for cargo in bash

rustc-ap-serialize

Automatically published version of the package serialize in the rust-lang/rust repository from commit 10c2316a6bf7cf9255f991e06e82ce692e6f84d5 The publishing script for this crate lives at: https://github…

cgo_oligami

build scripts to compile custom Go code

cargo-xcode-build-rs

Build script for XCode when compiling rust for iOS

conan-build

Extracts linker flags from conan packages for use in build scripts

re_build_tools

build.rs helpers for generating build info

pies_openapi_spacetraders_api

SpaceTraders is an open-universe game and learning platform that offers a set of HTTP endpoints to control a fleet of ships and explore a multiplayer universe. The API is documented using [OpenAPI]…

codify_hoijui

in automatic code generation at compile-time, for initializing structs and enums containing data, which is to be available at runtime

build-solidity-contracts

A helper function to build Solidity contracts

flp

Get fullpath of file or working directory

pifu

Cross platform package build tool

ruxgo

A Cargo-like build tool for building C and C++ applications

enpow

Generating methods for user defined enums as known from Option<T> or Result<T, E>

license-fetcher

Fetch licenses of dependencies at build time and embed them into your program

gitpatcher

that uses git to maintain a set of patches around a submodule

vcpkg_rs_mf

find native dependencies in a vcpkg tree at build time in order to be used in Cargo build scripts

bootloader_linker

program that links your executables created using bootloader_api with the actual bootloader

chur

A wrapper around tonic-build which adds dependencies

playdate-build

Utils that help to build package for Playdate

glibc_version

Discover GNU libc version at build time

ke

Half make

build-info-build

data consumed by the build-info crate. Use as a build-dependency.

moon_target

Project + task target identifier

package-bootstrap

An embeddable solution for installing build artifacts

get-license-helper

Help in automatically downloading dependencies license files (using the cargo-license json output). Motivation: help in building conda-forge recipes

rb-sys-build

Build system for rb-sys

makefile-lossless

Lossless Parser for Makefiles

cargo-ibuild

shutdown

can be used to gracefully exit (part of) a running program

rsinfo

Add vergen to your [build-dependencies], then get all build info in single struct

rspack_plugin_limit_chunk_count

rspack limit chunk count plugin

build-parallel

A helper library to let you parallelize work in build.rs using the jobserver

cicero

Automate CI builds with the cargo-xtask pattern

vectorscan

wrapper for Vectorscan

llvmenv

Manage LLVM/Clang builds

i18n-build

Designed for use within the cargo-i18n tool for localizing crates. It has been published to allow its direct use within project build scripts if required.

cargo-obs-build

A CLI tool used to build the libobs library and put it in the taregt directory

cargo-script

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

boringssl-src

building boringssl

komodo_client

Client for the Komodo build and deployment system

protoc-fetcher

Fetches official Protocol Buffer compiler (protoc) releases for use in build scripts

kontroll

connects to Keymapp's API, allowing control of ZSAs keyboard programmaticaly

owoify_rs

port of mohan-cao's owoify-js is released under MIT license, which is also the same license of owoify-js. This simple library will turn any string into nonsensical babyspeak similar…

rust-to-npm

deploy a rust project to npm in one command

ju-tcs-tbop-24-spyrzewski

project to get head and tail of the file

build-time

proc-macros to generate build timestamp string literals

prost-build-config

A prost toolkit to build protobuf with extra derive/attrs support

rspit

A command-line tool to run Rust snippet

mklinker

为对应架构生成链接脚本

logix-xtask

helper library that provides cargo xtask functionality for the Logix crates

ndk-build

building Android binaries

own

Wraps an owned or borrowed value

radicle-native-ci

Radicle native CI adapter for running directly on node host

po6

A C POSIX library in Rust

digtask

Dig is a YAML-defined, OS-level task orchestrator. It can 'dig into' a specifed task, or 'dig out' a desired output file

heron-rebuild-intern

String interners for use in heron-rebuild

cargo-cats

CATS's

nix-build

A build dependency for running nix to build a package

windres

Compiles Windows resource files (.rc) into a Rust program

rattler-build

build conda packages on Windows, macOS and Linux

set-git-hooks-dir

Deadly simple Git hooks directory setup tool

build_script

A wrapper for build.rs instructions

android-build

A build-time dependency to compile Java source files for Android as part of a Rust build. Use this from your build.rs Cargo build script

xbuild

Builds rust mobile/desktop projects

clp-src

Redistribution of Coin-OR Clp as a crate

ohos_ndk_env

set ohos build env for cc

bosion

Gather build information for verbose versions flags

farmfe_plugin_tree_shake

Tree shake plugin of farm

locate-cargo-manifest

Retrieves the Cargo manifest path by parsing the output of cargo locate-project

ninja-metrics

RAII based metrics gathering crate created for ninja-rs but usable independently

laze-insights

Helper library to parse laze insight output

tighterror-build

The tighterror code generation library

fs-dir-cache

A CLI tool for CIs and build scripts, making file system based caching easy and correct (locking, eviction, etc.)

memora

A build artifact cache for Git repositories

gxib

build tool for the gxi-rs project

cargo-packager-resource-resolver

Cargo packager resource resolver

cc-args

The clue between pkg-config and bindgen, cc

script-meditate

Supercharge Cargo scripts with inline structured data/configuration

bind-builder

Build dependency to help make crates that rely on native dependencies more portable

rustc-host

Get host target triplet of rustc

versioned-feature-core

Minimal logic for versioned features

gpr

Libgpr binding for Rust. Provides an easy way to build Ada projects with cargo.

cargo-chadr

build CHADstack programs

pyoxidizer

Package self-contained Python applications

publish_demo_luispdm

Pluralsight demo project

jpegxl-src

Source of libjxl and logic to build it

pipeline-script

Script engine designed for the project construction tool pipeline(crate name pipeline-cli)

playdate-build-utils

Utils that help to build program with Rust and Playdate API

CargoLibrary

Cargo by danielshih lab

npm_rs

npm bindings to use in your build scripts

cargo_gn

Cargo integration with the GN build system

rustiverse

Demo Library

jerk

Java Embedding Rust Kit

vkcargo

Fork of Cargo, a package manager for Rust. This fork is for testing of vojtechkral's changes and is temporary

mom-task

Task runner for teams and individuals

artifact-dependency

Lightweight artifact dependency utilities

criner-cli

A command-line interface for the 'Criner' crates mining platform

cargo-eval

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

darling-cargo

Darling implementation for global cargo crates

oro-script

Execute scripts for NPM packages

coffee_break

Take a break while your code compiles

modus

A language for building container images

libperl-config

Extract perl's build configs from Config.pm and others

buck2

Fast multi-language build system

pm-bin

Util for rust CLI program

snafu-upgrade-assistant

upgrade SNAFU between semver-incompatible versions

rebuilderd-common

rebuilderd - common code

test_crate2

A test crate for testing cargo

elite

New generation, simple & clean build system

test_e6910ed6

test cargo publish with hello world

mkhtml

that builds static websites

wax-rs

Experiment to Rewrite Wax (latte-soft/wax) Natively, in Rust - A Fast Runtime Lua 5.1x+/Luau Project Bundler, Using Roblox Models and Module-Require Semantics

tauri-winres

Create and set windows icons and metadata for executables

supergreen

Lib of common utils for cargo-green & rustcbuildx

kusabira

Integrated frontend for C library build and Rust FFI binding generation

minutus-mruby-build-utils

Build utilities for minutus

ptx-linker

NVPTX modules linker

irox-build-rs

Compile-time build metadata injection inspired by shadow-rs

project-base-directory

common base directory system for software projects

cargo-l1x

L1X build tool

testCargoTwo

test cargo publish

mei

Cargo build subsystem

app-task

tokio task manager

rmake

task runner like make

crate-and-cargo

nothing specific

editpe

Resource Editor for Portable Executables

what-bump

Detect required version bump based on conventional commit messages

fakecargo

fake cargo for single rust files

blaze-devkit

Rust devkit for the Blaze build system

ispc_compile

build-time dependency for Cargo build scripts to help with compiling and linking to ISPC code, and generating Rust bindings to the resulting library. The generated bindings can be imported by using ispc_rt…

aquascope_workspace_utils

Handy utilities for working in the Aquascope workspace

dexterous_developer_test_utils

A modular hot reload system for rust

include-blob

Include large binary files in an application without incurring the compile time cost

crossbundle

Build and publish apps for Android/iOS

cargo-scripter

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