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!(...)

proc-macro-crate

Replacement for crate (macro_rules keyword) in proc-macros

strum

macros for working with enums and strings

ctor

__attribute__((constructor)) for Rust

proc-macro-error2

Almost drop-in replacement to panics in proc-macros

linkme

Safe cross-platform linker shenanigans

synstructure

Helper methods and macros for custom derives

macrotest

Test harness for macro expansion

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.

proc-macro2-diagnostics

Diagnostics for proc-macro2

proc-macro2

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

serde_tokenstream

A serde deserializer for proc_macro::TokenStreams

unicode-id-start

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

unicode-ident

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

garde

Validation library

facet

Re-exports the Facet trait and derive macros, along with Shape and all related types

expander

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

attribute-derive

Clap like parsing for attributes in proc-macros

conjure-codegen

Rust code generation for Conjure definitions

delegate

Method delegation with less boilerplate

enum_dispatch

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

swc_macros_common

Common utilities for swc macros

mem_dbg

Traits and associated procedural macros to display recursively the layout and memory usage of a value

scx_stats

Statistics transport library for sched_ext schedulers

proc-macro-warning

Emit warnings from inside proc macros

rstml

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

derive-deftly

An ergonomic way to write derive() macros

derive_utils

A procedural macro helper for easily writing derive macros for enums

memoize

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

getset

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

unsynn

(Proc-macro) parsing made easy

venial

A very small syn

kopium

kubernetes openapi unmangler

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

duplicate

macros for duplication of code with variable substitution

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

macro_magic

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

safe-quote

Quasi-quoting macro quote!(...)

manyhow

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

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

displaydoc

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

simple-mermaid

Mermaid diagrams RustDoc integration

ra_ap_proc_macro_api

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

macro_tools

Tools for writing procedural macroses

enum-as-inner

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

wasm-bindgen-macro-support

APIs for the #[wasm_bindgen] attribute

derive-new

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

vercel_runtime_router

Vercel Rust Function Runtime Router

server_fn_macro

RPC for any web framework

parse-variants

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

csskit_spec_generator

Refreshing CSS!

document-features

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

dynasm

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

clippy_utils

tools for writing lints, provided as they are used in Clippy

jsonrpsee-proc-macros

Procedueral macros for jsonrpsee

derive-getters

boilerplate getters generator

specr-transpile

Converts Specr lang code to Rust

mcplease-cli

CLI tool for creating MCP servers with mcplease

deluxe

Procedural macro attribute parser

test-with

A lib help you run test with condition

rustfmt_if_chain

An if_chain-aware rustfmt (kind of)

smart-default

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

python-ast

compiling Python to Rust

bitmask-enum

A bitmask enum attribute macro

tryexpand

Test harness for macro expansion

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

validated_struct

Easily generate nested structures with getters and predicated setters

shuttle-ifc

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

derive_setters

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

awint_macro_internals

Internal macro utilities for the awint system of crates

rs-hack

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

impl-tools

Helper macros: autoimpl

k9

rust testing library

ambassador

Trait implementation delegation via procedural macros

pastey

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

clap_derive

Parse command line argument by defining a struct, derive crate

proc_macro_roids

Traits and functions to make writing proc macros more ergonomic

runtime-macros

Simulate expansion of procedural macros at run time

databake

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

makepad-micro-proc-macro

Makepad micro proc macro util lib

ra_ap_hir_expand

Macro expansion for rust-analyzer

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.

string_cache_codegen

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

fieldx

Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax

stageleft

Type-safe staged programming for Rust

jnix

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

debtmap

Code complexity and technical debt analyzer

asn1-compiler

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

carbond-lib

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

int-enum

A derive macro for conversion between integer and enum types

verus_syn

Parser for Rust source code extended to support Verus

macro_railroad

generate syntax diagrams for Rust macros

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

katexit

Insert KaTeX autorender script into rustdoc

is-macro

Derive methods for using custom enums like Option / Result

waybackend-scanner

Waybackend implementation of wayland-scanner

proc-bitfield

expressively declare bitfield-like structs

pmutil

Utils for proc-macro

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

hooks

Compile-time, async hooks

structmeta

Parse Rust's attribute arguments by defining a struct

napi-derive

N-API procedural macros

wasm-bindgen-backend

Backend code generation of the wasm-bindgen tool

garbage-code-hunter

A humorous Rust code quality detector that roasts your garbage code

cubecl-cpp

CPP transpiler for CubeCL

wasmtime-versioned-export-macros

Macros for defining versioned exports in Wasmtime

dyn-clonable

Attribute wrapper for dyn-clone

leptos_hot_reload

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

prettier-please

A minimal syn syntax tree pretty-printer

ra_ap_load-cargo

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

dsl_auto_type

Automatically expand query fragment types for factoring as functions

loess

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

yew-fmt

Code formatter for the Yew framework

uniffi_udl

udl parsing for the uniffi project

github-languages

All GitHub's supported languages

v_utils

My utils crate

polyquine

Teach Rust types to codegen their own constructors

rustfmt-wrapper

wrapper around rustfmt for use by code generators

testutils

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

messageforge

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

git-ignore-generator

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

truc

Rust code generator for safe, fixed size, evolving records

moosicbox_env_utils

MoosicBox env utilities package

asn1_len

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

terrars

Terraform in Rust

pavexc_rustdoc_types

The slimmed down schema used by pavexc to work with rustdoc's JSON output

getdoc

Get information related to compiler errors

telety

Access type information across crates and modules in your proc macros

safe-proc-macro2

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

attrs

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

thag_common

Common types, macros, and utilities shared across thag_rs subcrates

contracts

Design-by-contract attributes

rusteron-code-gen

Code generator for Aeron C bindings

dfir_lang

Hydro's Dataflow Intermediate Representation (DFIR) implementation

validify

struct validation and modification functionality through the use of derive macros

neli-proc-macros

Procedural macros for neli

git-cinnabar

git remote helper to interact with mercurial repositories

napi-derive-backend-ohos

Codegen backend for napi-harmony procedural macro

unique-type-id

A unique id proc-macro generator for types

dioxus-rsx

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

do-with-in

A template language for Rust metaprogramming using partial staging

salsa-macro-rules

Declarative macros for the salsa crate

positional

author/parse positional files

maybe-async-cfg

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

eggplant

High-Level Rust API crate for Egglog

atomic-dbg

Atomic dbg/eprintln/eprint macros

instant-xml

A more rigorous way to map XML to Rust types

crabtime

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

devise

devising derives and other procedural macros

prebindgen

Separate FFI implementation and language-specific binding into different crates

pearlite-syn

A syn parser for the Pearlite specification language in Creusot

pgrx-bindgen

additional bindgen support for pgrx

rewriter

rewriting files

curve25519-dalek-derive

curve25519-dalek Derives

stability

Rust API stability attributes for the rest of us

safe_math

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

derive-syn-parse

Derive macro for syn::parse::Parse

quote-use

Support use in procmacros hygienically

const-random

compile time random number generation

comlexr

Dynamically build Command objects with conditional expressions

cfg_eval

#[cfg_eval] in stable Rust 🙃

maudfmt

An opinionated yet customizable Maud formatter

volo-build

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

macroific

Proc macro development utilities

service_kit

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

typed-openrpc

Typed JSON-RPC 2.0 method definitions with OpenRPC document generation

re_types_builder

Generates code for Rerun's SDKs from flatbuffers definitions

dover

A CLI tool for summarizing git diffs of Rust code

gratte

macros for working with enums and strings; forked from strum

rmcp-macros

Rust SDK for Model Context Protocol macros library

durbat

Write Rust in Black Speech from Lord of the Rings

gin-tonic

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

enum_companion

A procedural macro for generating companion enums for structs

google-fonts-languages

Google Fonts script and language support data

dtor

__attribute__((destructor)) for Rust

steel-derive

Derive macros for use within steel

prost-derive

Generate encoding and decoding implementations for Prost annotated types

proc-macro-tool

Some common simple tool for proc-macro impl

route_match

A context-agnostic http routing utility

fixlite

FIX parser core library

napi-derive-backend

Codegen backend for napi procedural macro

futures-macro

The futures-rs procedural macro implementations

moosicbox_async_service

MoosicBox async service package

better_comprehension

collection and iterator comprehensions for Rust

seq-macro

Macro to repeat sequentially indexed copies of a fragment of code

warden-bpf-core

eBPF enforcement programs for the cargo-warden sandbox

structstruck

Nested struct and enum definitions

synbounds

Helper methods and macros for custom derives

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.

lambda-appsync

A type-safe framework for AWS AppSync Direct Lambda resolvers

format-bytes

A macro to format bytestrings

rust-code-analysis

compute and export code metrics

leptosfmt-prettyplease

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

async-generic

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

as_derive_utils

private derive utilities used by abi_stable and structural

xml-struct-gen

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

betfair-typegen

interacting with Betfair from Rust

cargo-manifest-proc-macros

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

strum_macros

macros for working with enums and strings

phnt

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

fsmentry-cli

Finite State Machines with an entry API and data storage

macro-string

Eager evaluation of macros like concat! and env!

portus

A Congestion Control Plane

penum

Make enum conform to a given pattern

syn_derive

Derive macros for syn::Parse and quote::ToTokens

diagen

generating a diagram for a Rust project based on its source code

typed_grid

Macro generator for typed grid navigation

swift-bridge-ir

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

pit-cli

Portal Interface Types

forest

Explore and summarise Rust projects

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.

deserialize_untagged_verbose_error

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

form

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

heroicons

Easily include Heroicons SVGs in Rust

seedframe

A clean, macro driven Rust library for building LLM apps

percpu

Define and access per-CPU data structures

place_macro

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

rspack-allocative

Inspect rust object tree and output it as flamegraph

fv-template

Field-value based string templating

optee-utee-build

Build tool for TA

portaldi

An ergonomic lightweight compile-time depencency injection library

instability

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

desynt

Convert syn paths & idents to normalised names

cot_codegen

web framework for lazy developers - code generation utils

humanbyte

A procedural macro for deriving human readable byte functions

http-request-derive

Use derive to create HTTP requests

uniffi_meta

compose-idents

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

quick-timer

timer macro library

colorsnamed

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

rsx-parser

Helper for the rsx crate

glib-macros

Rust bindings for the GLib library, proc macros crate

r2a

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

elif-openapi

OpenAPI 3.0 specification generation for elif.rs framework

syn-ext

Human friendly or editable extension for syn

spez

Macro to specialize on the type of an expression

pest3_generator

Early WIP prototype version of pest 3.0

syn-mid

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

relib_interface

relib is a framework for reloadable dynamic libraries

reflect

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

malloc_size_of_derive

Firefox memory reporting, not intended for external use

template-quote

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

flexml

Quickly and easily define namespaced XML serialization

bevy_derive

derive implementations for Bevy Engine

rust_arkitect

lightweight library for defining and validating architectural rules in Rust projects

dylo-cli

Generate dyn-compatible traits with proc macros

elm-parser

Elm markup parser to leptos

rem-repairer

Lifetime repairer for Rusty Extraction Maestro

casey

Case transforming macros for ident tokens

rb-sys-build

Build system for rb-sys

mpst-seq

DEPRECIATED: A library with macro for mpstthree

ctor_bare

Register constructor functions for Rust at complie time under no_std

by-macros

Biyard Macros

scarb-proc-macro-server-types

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

dbg-pls

Syntax aware pretty-printing debugging

deribit-api

Deribit API client

macro_expand

Expand procedural macros in-place

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.

aws-dynamo-derive

Helper crate for aws-sdk-dynamodb

dynamodb-helper

Macro that creates a struct for interacting with AWS DynamoDB

tao-macros

Proc macros for tao

command_attr

Procedural macros for command creation for the Serenity library

actix_failwrap

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

sylvia-runtime-macros

Simulate expansion of procedural macros at run time

brisk-egui-components

Components for brisk-egui

flow-record-common

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

cdk-ansible-cli

cdk-ansible is a tool to generate Ansible playbooks from Rust code

ssdv-fec

SSDV systematic erasure FEC

command-rpc

cli crate and api for replacing rpc

runtime-macros-derive

Simulate expansion of procedural macros at run time

pavexc_attr_parser

A parser to extract Pavex diagnostic attributes from the output of rustdoc-json

debugger_test

proc macro for writing tests that launch a debugger and run commands while verifying the output

rust-sitter-tool

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

proc-macro-rules

Emulate macro-rules pattern matching in procedural macros

cargo-derive-doc

Automatically document macro expansions by adding inline comments showing added impls and items

savvy-bindgen

Parse Rust functions, and generate C and R code

ferment-sys

Syntax tree morphing of FFI-compatible stuff

drylib

Rust macro-library for Don't Repeating Yourself

postcompile

Helper crate for post-compiling Rust code

impl-tools-lib

Helper macros: autoimpl

ra_ap_project_model

A representation for a Cargo project for rust-analyzer

dev_utils

A collection of utilities for development

schema

Access the schema for a Rust item

dbc-data

Derive macro for CAN DBC code generation

pgrx-sql-entity-graph

Sql Entity Graph for pgrx

crate_interface

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

tokrepr

Turn Rust instances into token representations

suitest

quality of life test suites

macro-wasmer-universal-test

Universal test macro for wasmer-test

greentic-interfaces-wasmtime

Wasmtime host & guest shims for greentic WIT worlds (sync; auto-discovered)

leptosfmt-formatter

view macro formatter for the Leptos web framework

aranya-policy-ifgen-build

Code generator for aranya-policy-ifgen

attrimpl

attributes to automatically implement common traits and reduce boilerplate code

mongodb-internal-macros

Internal macros for the mongodb crate

micro_games_macros

macros to make it easier to build complex systems with Bevy

defile

Proc-macro helper to ungroup macro metavariables

singleton-attr

singleton procedural attribute and derive macro

salsa-macros

Procedural macros for the salsa crate

brisk-it

core library of the brisk declarative engine

cvars

Configuration variables - a simple and ergonomic way to store and edit configuration at runtime

pit-rust-generator

Portal Interface Types for WebAssembly

rustic-jsonrpc

JSON-RPC 2.0 server library written in Rust

default-struct-builder

Generates builder methods of every field of a struct

crud-api-endpoint

CLI generator for your API. Enpoint description

procmeta

integration procmeta-core and procmeta-proc

funlog

A procedural macro for tracing Rust function calls

cfg_block

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

envl

load .envl and .envlconf

cachelito-macro-utils

Shared utilities for cachelito procedural macros

pax-compiler

Compiler APIs for parsing and building Pax projects into application executables

i18n-format

macro to allow formatting with gettext while keeping xgettext to work

hydro_lang

Choreographic programming for Hydro, built on DFIR

sexprs-formatter

sexprs is a minimal lisp dialect to evaluate written in Rust

path_scan

A lightweight Rust procedural macro for parsing path patterns (URLs, routes) with variable capturing, static binding, and compile-time checks

swc_eq_ignore_macros

Macros for EqIgnoreSpan and TypeEq

mac-keycode

Global hotkey manager

log_args

procedural macro to log function arguments using the tracing crate

match_t

Compare generic types with concrete types in Rust

frunk_derives

contains the custom derivations for certain traits in Frunk

yewlish-fetch

A macro for generating Yew fetch API bindings

struargs

A macro that converts a structure into a Command parameter list

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

ristretto_vm

Java Virtual Machine

vbare-gen

Code generator for VBARE (Versioned Binary Application Record Encoding), an extension to BARE with versioned schema evolution

cgp-macro-lib

Context-generic programming core component macros implemented as a library

surreal_derive_plus

Query builder for surrealdb

anodized

An ecosystem for correct Rust based on lightweight specification annotations

jsonrpc-derive

High level, typed wrapper for jsonrpc-core

trl

auto generation of some common methods based on Rust macros

coderlib

AI-powered code assistance and agentic system

opendp_tooling

Tooling for proc-macros and code generation

cargo-acl

code ACL checker

derive-adhoc

An ergonomic way to write derive() macros

tansu-model

Kafka JSON protocol definitions, bootstrapping Tansu sans I/O

rand_derive2

Generate customizable random types with the rand crate

grappler

function hooking through proc-macros

zoo-endpoint

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

clasma

A procedural macro for partial borrowing

efx

Rust XML templating engine for building egui UIs with procedural macros

sqlx-template

Template query library for Rust SQLx

orz

A procedural macro for generating field information methods for structs

rust_minify

minify rust code

linked-data-core

Core library for Linked Data crates

hey_chat_gpt

A proc-macro to delegate implementation to the ChatGPT API. ChatGPT APIに実装を代行してもらうマクロです。

sphinx-rustdocgen

Executable to extract rustdoc comments for Sphinx

akin

writing repetitive code easier and faster

derive-visitor

Derive visitor pattern for arbitrary data structures

test-generator

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

rules_derive

fast derive macros using macro_rules

fortuples

Procedural macros to generalize inherent and trait implementations over tuples

fn_macro

函数宏

db-set-macros

A derive for some ORM functions utilising SQLX

syn-path

macro to declare a syn::Path at compile time

mdbx-derive

poorman MDBX orm

bevy_toolbox

A collection of useful tools for Bevy game engine

borsh-incremental

Incremental Borsh deserialization with defaults for backward-compatible schema evolution

cruct

A procedural macro for loading configuration files into Rust structs with compile‑time validation and type safety

collection_macro

General-purpose seq![] and map! {} collection macros

macroific_attr_parse

Attribute parsing utilities for the macroific crate

rocal-ui

UI for Rocal - Full-Stack WASM framework

codama-korok-plugins

Korok plugins definitions

op_result

Thin syntactic sugar for writing associated type algebra with core::ops expressions

ckb-script-ipc

Proc macros for CKB Script IPC

hodu_macro_utils

hodu macro utils

dioxus-autofmt

Autofomatter for Dioxus RSX

json_proc

proc macro for parsing JSON-like syntax

deno-bindgen2-cli

A CLI tool for parsing rust source code and generating a close TypeScript equivalent. works with the deno_bindgen2 crate

dioxus-rsx-hotreload

CLI Configuration for dioxus-cli

napi-derive-ohos

N-API procedural macros

lumos_macro

Procedural macros for the Lumosai agent framework

datafusion-macros

Procedural macros for DataFusion query engine