Lib.rs

syn

Parser for Rust source code

darling

A proc-macro library for reading attributes into structs when implementing custom derives

quote

Quasi-quoting macro quote!(...)

strum

macros for working with enums and strings

proc-macro-crate

Replacement for crate (macro_rules keyword) in proc-macros

ctor

__attribute__((constructor)) for Rust

proc-macro-error2

Almost drop-in replacement to panics in proc-macros

macrotest

Test harness for macro expansion

unicode-ident

Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31

litrs

Parse and inspect Rust literals (i.e. tokens in the Rust programming language representing fixed values). Particularly useful for proc macros, but can also be used outside of a proc-macro context.

synstructure

Helper methods and macros for custom derives

conjure-codegen

Rust code generation for Conjure definitions

serde_tokenstream

A serde deserializer for proc_macro::TokenStreams

proc-macro2

A substitute implementation of the compiler’s proc_macro API to decouple token-based libraries from the procedural macro use case

delegate

Method delegation with less boilerplate

unsynn

(Proc-macro) parsing made easy

attribute-derive

Clap like parsing for attributes in proc-macros

expander

Expands proc macro output to a file, to enable easier debugging

macro_magic

Allows the exporting and importing of the tokens of items across module, file, and crate boundaries

syn-mid

Providing the features between "full" and "derive" of syn

enum_dispatch

Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed

proc-macro2-diagnostics

Diagnostics for proc-macro2

scx_stats

Statistics transport library for sched_ext schedulers

proc-macro-warning

Emit warnings from inside proc macros

specr-transpile

Converts Specr lang code to Rust

rstml

Rust templating for XML-based formats (HTML, SVG, MathML) implemented on top of proc-macro::TokenStreams

unicode-id-start

Determine whether characters have the ID_Start or ID_Continue properties according to Unicode Standard Annex #31

memoize

Attribute macro for auto-memoizing functions with somewhat-simple signatures

pastey

Macros for all your token pasting needs. Successor of paste.

spider_chromiumoxide_cdp

Contains all the generated types for chromiumoxide

derive-deftly

An ergonomic way to write derive() macros

percpu

Define and access per-CPU data structures

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

r2r

Easy to use, runtime-agnostic, async rust bindings for ROS2

hyperlight-component-util

Shared implementation for the procedural macros that generate Hyperlight host and guest bindings from component types

safe-quote

Quasi-quoting macro quote!(...)

ra_ap_proc_macro_api

RPC Api for the proc-macro-srv crate of rust-analyzer

displaydoc

A derive macro for implementing the display Trait via a doc comment and string interpolation

duplicate

macros for duplication of code with variable substitution

getset

we're ready to go! A procedural macro for generating the most basic getters and setters on fields

enum-as-inner

A proc-macro for deriving inner field accessor functions on enums

venial

A very small syn

derive-new

#[derive(new)] implements simple constructor functions for structs and enums

derive_utils

A procedural macro helper for easily writing derive macros for enums

ambassador

Trait implementation delegation via procedural macros

dynasm

A plugin for assembling code at runtime. Combined with the runtime crate dynasmrt it can be used to write JIT compilers easily.

smart-default

Rust custom-derive macro for Default with more control on the fields

server_fn_macro

RPC for any web framework

verus_syn

Parser for Rust source code extended to support Verus

document-features

Extract documentation for the feature flags from comments in Cargo.toml

test-with

A lib help you run test with condition

tansu-sans-io

A Kafka protocol implementation using serde

derive-getters

boilerplate getters generator

jsonrpsee-proc-macros

Procedueral macros for jsonrpsee

kopium

kubernetes openapi unmangler

wasm-bindgen-macro-support

APIs for the #[wasm_bindgen] attribute

uniffi_bindgen

a multi-language bindings generator for rust (codegen and cli tooling)

simple-mermaid

Mermaid diagrams RustDoc integration

manyhow

proc macro error handling à la anyhow x proc-macro-error

strum_macros

macros for working with enums and strings

facet-macro-types

Unsynn grammar and type definitions for facet macro ecosystem

rustfmt_if_chain

An if_chain-aware rustfmt (kind of)

parse-variants

Derive the syn::parse::Parse trait for enumerations and use it to comfortably parse a variant of the enumeration

ra_ap_load-cargo

Loads a Cargo project into a static instance of rust-analyzer for analysis

rust-reorder

Reorder top-level items in Rust source files from the command line

structmeta

Parse Rust's attribute arguments by defining a struct

pearlite-syn

A syn parser for the Pearlite specification language in Creusot

function_name

macro that expands to the name of the annotated function

k9

rust testing library

python-ast

compiling Python to Rust

runtara-workflows

Workflow compilation library for runtara DSL

stageleft

Type-safe staged programming for Rust

tryexpand

Test harness for macro expansion

contracts

Design-by-contract attributes

validated_struct

Easily generate nested structures with getters and predicated setters

impl-tools

Helper macros: autoimpl

clap_derive

Parse command line argument by defining a struct, derive crate

rs-hack

AST-aware Rust refactoring tool for AI agents - transform, rename, inspect & more

cargo-docs-md

Generate per-module markdown documentation from rustdoc JSON output

testutils

Offers a range of utility functions, macros, and tools, such as simple_benchmark() and dbg_ref!(), os_cmd::Runner, designed for testing purposes

extern-trait

Opaque types for traits using static dispatch

protify

A Rust-first protobuf framework to generate packages from rust code, with validation included

subenum

A proc-macro to create subsets of enums, that can be converted to and from

databake

Trait that lets structs represent themselves as (const) Rust expressions

cowork

CLI tool for managing Claude Code skills - install, generate, and organize skills across AI coding agents

asn1-compiler

Compiler for compiling ASN.1 specs to Rust, with PER Codec support and derive macros for PER Codecs

zerocopy-derive

Custom derive for traits from the zerocopy crate

makepad-micro-proc-macro

Makepad micro proc macro util lib

include_proc_macro

A convenient macro for working with multiple procedural macros in one crate, and to import them from any arbitrary paths. Reduces boilerplate and repetition, and improves readability.

shuttle-ifc

Infrastructure from Code (IfC) parser for the Shuttle platform (shuttle.dev)

int-enum

A derive macro for conversion between integer and enum types

runtime-macros

Simulate expansion of procedural macros at run time

ron-lsp

An LSP and cli for RON files that provides autocomplete, diagnostics, go to definition, code actions, and hover support based on Rust type annotations

elo-rust

Rust code generation target for ELO validation language

napi-derive

N-API procedural macros

string_cache_codegen

A codegen library for string-cache, developed as part of the Servo project

css_ast

CSS Abstract Syntax Trees with visitable nodes and style value types

proc_macro_roids

Traits and functions to make writing proc macros more ergonomic

rsx-a11y

A linting tool for checking ARIA and accessibility attributes in Rust web frameworks (Yew, Leptos, Dioxus)

safe-proc-macro2

A substitute implementation of the compiler’s proc_macro API to decouple token-based libraries from the procedural macro use case

rusteron-code-gen

Code generator for Aeron C bindings

proc-bitfield

expressively declare bitfield-like structs

i18n-format

macro to allow formatting with gettext with a workaround for older xgettext

leptos_hot_reload

types used for dev mode and hot-reloading for the Leptos web framework

axum_doc

A CLI tool to generate OpenAPI 3.0 JSON from Axum Rust projects

syn-serde

serialize and deserialize Syn syntax trees

tansu-model

Kafka JSON protocol definitions, bootstrapping Tansu sans I/O

derive_setters

Rust macro to automatically generates setter methods for a struct's fields

seq-macro

Macro to repeat sequentially indexed copies of a fragment of code

tinyrick

a freeform Rust build system

zyn

A proc macro framework with templates, composable elements, and built-in diagnostics

loess

Small proc macro grammar- and parser-generator providing great UX

jnix

High-level extensions to help with the usage of JNI in Rust code

instability

Rust API stability attributes for the rest of us. A fork of the stability crate.

neli-proc-macros

Procedural macros for neli

git-cinnabar

git remote helper to interact with mercurial repositories

wasmtime-versioned-export-macros

Macros for defining versioned exports in Wasmtime

easy-macros

Toolkit for building Rust procedural macros + generating debug info

carbond-lib

Type-safe interface to the managed information provided by the system daemon 'carbond' for Rust

cubecl-cpp

CPP transpiler for CubeCL

proc-macro-tool

Some common simple tool for proc-macro impl

bevy_auto_plugin

Procedural attribute macros for Bevy apps that reduce boilerplate by automatically registering components, resources, events, states, and systems in your plugin's build function

swc_eq_ignore_macros

Macros for EqIgnoreSpan and TypeEq

utoipa-gen

Code generation implementation for utoipa

prettier-please

A minimal syn syntax tree pretty-printer

synbounds

Helper methods and macros for custom derives

ctest

Automated testing of FFI bindings in Rust

rust-doctor

A unified code health tool for Rust — scan, score, and fix your codebase

archidoc-rust

Rust language adapter — parses //! annotations, emits ModuleDoc

synthez

Steroids for syn, quote and proc-macro2 crates

pmutil

Utils for proc-macro

maybe-async-cfg

A procedure macro to unify sync and async implementations depending on the features of your crate

gratte

macros for working with enums and strings; forked from strum

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

marauders

hand-crafted mutation analysis and management

find-crate

Find the crate name from the current Cargo.toml

macroforge_ts_syn

TypeScript syntax types for compile-time macro code generation

telety

Access type information across crates and modules in your proc macros

yew-fmt

Code formatter for the Yew framework

curve25519-dalek-derive

curve25519-dalek Derives

fieldwork

derivable accessors for struct fields

dioxus-rsx

Core functionality for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences

rewriter

rewriting files

typed-quote

A fully typed quote!() alternative for both proc-macro and proc-macro2

macro-string

Eager evaluation of macros like concat! and env!

ftm-types

FollowTheMoney types code generator for Rust

ferrous-forge

System-wide Rust development standards enforcer

devise

devising derives and other procedural macros

banish

A declarative DSL for building rule-based state machines

truc

Rust code generator for safe, fixed size, evolving records

unique-type-id

A unique id proc-macro generator for types

syn-path

macro to declare a syn::Path at compile time

split_by_discriminant

A small utility for partitioning a sequence of items by enum discriminant

lambda-appsync

A type-safe framework for AWS AppSync Direct Lambda resolvers

macro_railroad

generate syntax diagrams for Rust macros

dioxus-modal

Modal composable for Dioxus

messageforge

lightweight Rust library for creating structured messages in chat systems, including HumanMessage, AiMessage, SystemMessage, and more. It supports easy extensibility through macros…

hotspots-core

Core library for static analysis and Local Risk Score (LRS) computation across TypeScript, JavaScript, Go, Python, Rust, and Java

github-languages

All GitHub's supported languages

type-leak

Enable sharing type context beyond crate boundary

pedant

An opinionated Rust linter, with special focus on AI-generated code

test-generator

Rust Test generator: enumerating entries according to file-system pattern and generating a test function for each entry

crabtime

A powerful yet easy-to-use Rust macro that generates code by evaluating inline Rust logic at compile time

macroific

Proc macro development utilities

unzip-n

Procedural macro to generate unzip for iterators over n-sized tuples

moosicbox_env_utils

MoosicBox env utilities package

prometheus-metric-storage

Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code

pulumi_gestalt_generator

Pulumi Gestalt Codegen library

atomic-dbg

Atomic dbg/eprintln/eprint macros

adk-doc-audit

Documentation audit system for ADK-Rust that validates documentation against actual crate implementations

is-macro

Derive methods for using custom enums like Option / Result

maudfmt

An opinionated yet customizable Maud formatter

deserialize_untagged_verbose_error

procedural macro for creating verbose errors when deserializing untagged enums with Serde

portaldi

An ergonomic lightweight compile-time depencency injection library

obfuse

Compile-time string obfuscation with runtime decryption and secure memory wiping

check_keyword

A trait for String-like types to check if it is a keyword and convert it to a safe non-keyword if so

dyn-clonable

Attribute wrapper for dyn-clone

cfg_eval

#[cfg_eval] in stable Rust 🙃

rust-sitter-tool

The external tool for Rust Sitter that extracts grammars from Rust definitions

crate_interface

way to define an interface (trait) in a crate, but can implement or use it in any crate

asn1_len

convert back and forth between unsigned int and ASN.1 Length

wry-bindgen-macro-support

Internal macro support for wry-bindgen

dover

A CLI tool for summarizing git diffs of Rust code

napi-derive-backend-ohos

Codegen backend for napi-harmony procedural macro

garbage-code-hunter

A humorous Rust code quality detector that roasts your garbage code

ll-sparql-parser

A resilient LL parser for SPARQL

macro_tools

Tools for writing procedural macroses

elicitor

Derive interactive surveys for Rust types. Backend-agnostic. Backends are provided in elicitor-wizard-requestty, elicitor-wizard-ratatui, elicitor-form-egui, and many others.

struct-field-names-as-array

generating the field names of named structs as constants

structstruck

Nested struct and enum definitions

typed-openrpc

Typed JSON-RPC 2.0 method definitions with OpenRPC document generation

rmcp-macros

Rust SDK for Model Context Protocol macros library

napi-derive-backend

Codegen backend for napi procedural macro

orcs-lint

Architecture lint rules for ORCS (OL002: unwrap ban)

seraphic

Lightweight JSON RPC 2.0

solar_sonar_dev

Development tools for solar_sonar

rustilities

offers a few utils for Rust development

uniffi_meta

google-fonts-glyphsets

Google Fonts font axis support data

rx_core_macro_common

Macro helper functions used in rx_core and its crates

swift-bridge-ir

Holds the data structures and logic for bridge module parsing and code generation

prost-derive

Generate encoding and decoding implementations for Prost annotated types

salsa-macros

Procedural macros for the salsa crate

ctor-lite

Run code at program startup or shutdown

syn-ext

Human friendly or editable extension for syn

comlexr

Dynamically build Command objects with conditional expressions

terrars

Terraform in Rust

warcrwlock

in Rust that provides an attribute macro for structs and traits. Rewrite code using under the hood asynchronous reference (Arc) and asynchronous writing and read(RWlock) control elements.

dfir_lang

Hydro's Dataflow Intermediate Representation (DFIR) implementation

volo-build

Compile thrift and protobuf idls into rust code at compile-time

rust_arkitect

lightweight library for defining and validating architectural rules in Rust projects

kajit

A facet-based JIT for (de)serializing Rust values real fast

safe_math

Safe arithmetic using a procedural macro. Write normal math expressions with automatic overflow checks. No panics, no boilerplate.

polyquine

Teach Rust types to codegen their own constructors

codestyle

A code style checker and formatter for Rust

dsl_auto_type

Automatically expand query fragment types for factoring as functions

gin-tonic

main gin-tonic crate - rust protobuf with gin and tonic

debtmap

Code complexity and technical debt analyzer

scarb-proc-macro-server-types

Types for interacting with an RPC server set up by the scarb proc-macro-server command

leptosfmt-prettyplease

A fork of David Tolnay's prettyplease that adds the ability to format single expressions

deluxe

Procedural macro attribute parser

spez

Macro to specialize on the type of an expression

dtor

__attribute__((destructor)) for Rust

configurable_serde

A proc-macro to apply reusable serde configurations

cronus_spec

The definitions for cronus API spec

aranya-policy-ifgen-build

Code generator for aranya-policy-ifgen

waybackend-scanner

Waybackend implementation of wayland-scanner

async-generic

Write code that can be both async and synchronous without duplicating it

csaf-rs

A parser for the CSAF standard written in Rust

optee-utee-build

Build tool for TA

getdoc

Get information related to compiler errors

git-ignore-generator

Quickly and easily fetch .gitignore templates from www.gitignore.io

stability

Rust API stability attributes for the rest of us

rsmap

Generate multi-layered, LLM-friendly index files for Rust codebases

format-bytes

A macro to format bytestrings

katexit

Insert KaTeX autorender script into rustdoc

enum_companion

A procedural macro for generating companion enums for structs

accessory

A configurable get/set/get_mut derive macro

template-quote

A new-fasioned quote! macro implementation with pretty template-engine like syntax

remain

Compile-time checks that an enum, struct, or match is written in sorted order

betfair-typegen

interacting with Betfair from Rust

quote-use

Support use in procmacros hygienically

as_derive_utils

private derive utilities used by abi_stable and structural

enum_variant_type

Generates types for each enum variant and conversion trait impls

glib-macros

Rust bindings for the GLib library, proc macros crate

better_comprehension

collection and iterator comprehensions for Rust

pax-compiler

Compiler APIs for parsing and building Pax projects into application executables

rust-code-analysis

compute and export code metrics

bevy_derive

derive implementations for Bevy Engine

vacro

A progressive DevX framework for building Rust procedural macros. Painless parsing, visual debugging, and robust tooling.

cot_codegen

web framework for lazy developers - code generation utils

derive-syn-parse

Derive macro for syn::parse::Parse

rspack-allocative

Inspect rust object tree and output it as flamegraph

spacetime-bindings-macro-input

Unofficial Input Crate for the SpacetimeDB Macro Bindings

bobtail

Generate macro proxies of functions whose tails can be "bobbed" as in cut off

validify

struct validation and modification functionality through the use of derive macros

napi-derive-ohos

N-API procedural macros

place_macro

Macros you wish you had while you were writing your non-proc macro

lingora-core

Core code for lingora-cli and lingora-tui

prebindgen

Separate FFI implementation and language-specific binding into different crates

const-random

compile time random number generation

penum

Make enum conform to a given pattern

proc-macro-rules

Emulate macro-rules pattern matching in procedural macros

typed_grid

Macro generator for typed grid navigation

oxapi

Generate type-safe Rust server stubs from OpenAPI specs

triblespace-macros-common

Shared implementation helpers for triblespace procedural macros

cachelito-macro-utils

Shared utilities for cachelito procedural macros

bronzite

🔮 Compile-time type reflection for Rust - inspect traits, fields, and methods from proc-macros with an ergonomic navigation API

durbat

Write Rust in Black Speech from Lord of the Rings

xml-struct-gen

Generates Rust structs for working in a type-safe way with some XML formats

cast_checks_convert

reinhardt-admin-cli

Command-line tool for Reinhardt project management

resource-bound

Compile-time enforcement of struct size limits and heap allocation constraints

cargo-manifest-proc-macros

Find the syn::Path to your own crate from proc-macros reliably

re_types_builder

Generates code for Rerun's SDKs from flatbuffers definitions

command_attr

Procedural macros for command creation for the Serenity library

ferment-sys

Syntax tree morphing of FFI-compatible stuff

debug3

Space Efficient Pretty Printer

syn_util

helper APIs for procedural macros

service_kit

A foundational toolkit for building high-performance, modular services in Rust

dbg-pls

Syntax aware pretty-printing debugging

cargo-oxichrome

CLI build tool for oxichrome

migration-check

check for migration in Rust code

waynest-gen

Codegen glue for waynest

url-macro

A compile-time URL validation macro. Parses and checks URLs at compile-time, converting valid URLs into url::Url objects. Provides early error detection for malformed URLs.

moduvex

— Structured backend framework for Rust. Structure before scale.

protobuf-build

functions for generating Rust code from protobufs (using protobuf-rust or Prost)

brisk-egui-components

Components for brisk-egui

tokel-engine

The core parsing, AST, and bottom-up evaluation engine for the Tokel macro language

rem-repairer

Lifetime repairer for Rusty Extraction Maestro

soft_rust_runtime

Runtime support library for soft_rust macros

rb-sys-build

Build system for rb-sys

flexml

Quickly and easily define namespaced XML serialization

toggly

High-performance Rust SDK for Toggly feature flags

syn-match

a macro for matching on syn paths

envl

load .envl and .envlconf

actix_failwrap

A micro-package that enables ergonomic error propagation (using thiserror) inside actix-web route handlers

thag_common

Common types, macros, and utilities shared across thag_rs subcrates

steel-derive

Derive macros for use within steel

agentrs-tools

Tooling primitives and built-in tools for agentrs

leo3-macros-backend

detail of Leo3 procedural macros

macro-field-utils

work with darling fields

boa_macros

Macros for the Boa JavaScript engine

syn-helpers

Framework for building derive macros

phnt

Rust bindings to the System Informer’s (formerly known as Process Hacker) phnt native Windows headers

trl

auto generation of some common methods based on Rust macros

domainstack-cli

CLI to generate TypeScript/Zod, JSON Schema, and GraphQL from Rust validation rules. Single source of truth for frontend + backend.

proc-quote

A procedural macro implementation of quote!

ctor_bare

Register constructor functions for Rust at complie time under no_std

cfg_block

allow using #[cfg(...)] and other macros on blocks

krpc-client

A stand-alone client for the Kerbal Space Program kRPC mod

axconfig-macros

Procedural macros for converting TOML format configurations to Rust constant definitions

armature-macros

Declarative macros for Armature framework

pforge-codegen

Zero-boilerplate MCP server framework with EXTREME TDD methodology

flow-record-common

common types used by flow-record and flow-record-derive

macro_paste

Macros for all your token pasting needs. Maintained, drop-in replacement for paste.

elif-openapi

OpenAPI 3.0 specification generation for elif.rs framework

compose-idents

macro for generating new identifiers (names of variables, functions, traits, etc) by concatenating one or more arbitrary parts and applying other manipulations

macro_expand

Expand procedural macros in-place

desynt

Convert syn paths & idents to normalised names

attrs

An ergonomic parser library for #[attributes], built on parser combinators

necessist-backends

nestify

offers a macro to simplify and beautify nested struct definitions in Rust, enabling cleaner, more readable code structures with less verbosity. It's especially valuable for handling API responses.

rustmax

A collection of useful crates

verus_builtin_macros

Verus Builtin Macros: Various macros used by Verus

schema

Access the schema for a Rust item

tot_spec

The lib for json model

liaise

diagnostic error propagation

positional

author/parse positional files

brisk-it

core library of the brisk declarative engine

futures-macro

The futures-rs procedural macro implementations

rusty-store

managing and storing serialized data using RON (Rusty Object Notation). It provides utilities for handling various types of stores, managing their persistence, and offering abstractions for modifying and committing data.

generic-array-struct

An attribute proc macro to convert structs with named fields of the same generic type into a single-array-field tuple struct with array-index-based accessor and mutator methods

frunk_derives

contains the custom derivations for certain traits in Frunk

by-macros

Biyard Macros

moosicbox_async_service

MoosicBox async service package

quick-timer

timer macro library

elm-parser

Elm markup parser to leptos

rust2json

Reads a Rust project, and builds JSON for indexing

mir-extractor

MIR extraction and security rule engine for Rust-cola. (Requires nightly)

rialo-syngen-dsl

Rialo Syngen DSL

fieldx_aux

Various types and tools useful for fieldx crates and, potentially, to users of fieldx

rshack

Alias for rs-hack - AST-aware Rust refactoring tool (install with: cargo install rshack)

qq

lightweight alternative quote

ra_ap_proc_macro_srv

Proc-macro server for rust-analyzer

rust-guardian

Dynamic code quality enforcement preventing incomplete or placeholder code

orz

A procedural macro for generating field information methods for structs

savvy-bindgen

Parse Rust functions, and generate C and R code

opendp_tooling

Tooling for proc-macros and code generation

forest

Explore and summarise Rust projects

derive_util

tools for derive macros

google-fonts-axisregistry

Google Fonts font axis support data

battler-wamprat-schema

Procedural macro for strongly-typed WAMP peers

reflect

The "but I thought Rust doesn't have reflection?" memorial brand new way of defining procedural macros

server-less-parse

Shared parsing utilities for server-less proc macros

form

A small script to move inline modules into the proper directory structure

funlog

A procedural macro for tracing Rust function calls

coverage_lint

A no-config Rust test coverage linter

r2a

that provides a typesafe way to convert ROS 2 messages into Apache Arrow format

unused-pub

detect unused public items (structs, enums, functions, etc.) in a Rust codebase

tokrepr

Turn Rust instances into token representations

fmtparse

Parse format!-like strings

fv-template

Field-value based string templating

zoo-endpoint

Macro used by zoo consumers for registering handlers. This wraps dropshot’s Endpoint and adds some extra functionality for tracing.

micro_games_macros

macros to make it easier to build complex systems with Bevy

cgp-macro-lib

Context-generic programming core component macros implemented as a library

mcplease-cli

CLI tool for creating MCP servers with mcplease

colorsnamed

Names for a large set of widely understood color sets, like HTML/CSS or xkcd

whippyunits

A zero-cost, pure rust units-of-measure library for applied computation

argh_complete

Autocompletion generators for argh-based CLIs

abi-audit-core

Core analysis engine for cargo-abi-audit, a C-ABI-first Rust/native boundary auditor

malloc_size_of_derive

Firefox memory reporting, not intended for external use

bolt-rs

Lightning-fast Rust type checker - get instant feedback 10-100x faster than cargo check

rustfmt-wrapper

wrapper around rustfmt for use by code generators

singleton-attr

singleton procedural attribute and derive macro

crud-api-endpoint

CLI generator for your API. Enpoint description

surreal_derive_plus

Query builder for surrealdb

libvirt-codegen

Code generator for libvirt protocol (.x files)

relib_exportify

relib is a framework for reloadable dynamic libraries

cio

two powerful procedural macros (println! and input!) that enhance console I/O operations in Rust, bringing Python-like convenience to Rust’s type-safe environment

akin

writing repetitive code easier and faster

spoke

[coming soon] Simplified unit testing for Rust