Lib.rs

syn

Parser for Rust source code

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

proc-macro2

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

proc-macro-error2

Almost drop-in replacement to panics in proc-macros

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.

macrotest

Test harness for macro expansion

proc-macro2-diagnostics

Diagnostics for proc-macro2

const-str

compile-time string operations

serde_tokenstream

A serde deserializer for proc_macro::TokenStreams

derive-where

Deriving with custom trait bounds

expander

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

typify

JSON schema to rust type code generator

venial

A very small syn

auto_impl

Automatically implement traits for common smart pointers and closures

derive_utils

A procedural macro helper for easily writing derive macros for enums

virtue

A sinless derive macro helper

proc-macro-warning

Emit warnings from inside proc macros

memoize

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

safe-quote

Quasi-quoting macro quote!(...)

bitfield-struct

Struct-like procedural macro for bitfields

hyperlight-component-util

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

rustc-literal-escaper

code to unescape string literals

macro_tools

Tools for writing procedural macroses

duplicate

macros for duplication of code with variable substitution

unsynn

(Proc-macro) parsing made easy

hard-xml

Strong typed xml, based on xmlparser

manyhow

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

macro_magic

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

cxx-gen

C++ code generator for integrating cxx crate into higher level tools

enum-as-inner

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

derive-deftly

An ergonomic way to write derive() 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

mem_dbg

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

aquamarine

A mermaid.js integration for rustdoc

genco

A whitespace-aware quasiquoter for beautiful code generation

git-testament

Record git working tree status when compiling your crate

reflect

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

deluxe

Procedural macro attribute parser

fixed-map

A fixed map where storage layout is calculated by a procedural macro

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

macro-string

Eager evaluation of macros like concat! and env!

test-strategy

Procedural macro to easily write higher-order strategies in proptest

dyn-clonable

Attribute wrapper for dyn-clone

tryexpand

Test harness for macro expansion

sealed

Macro for sealing traits and structures

ascent

Logic programming in Rust

watt

Runtime for executing Rust procedural macros compiled as WebAssembly

strum_macros

macros for working with enums and strings

validated_struct

Easily generate nested structures with getters and predicated setters

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

p9

Server implementation of the 9p file system protocol

quote-use

Support use in procmacros hygienically

awint_macro_internals

Internal macro utilities for the awint system of crates

documented

Derive and attribute macros for accessing your type's documentation at runtime

template-quote

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

devise

devising derives and other procedural macros

ambassador

Trait implementation delegation via procedural macros

function_name

macro that expands to the name of the annotated function

gc-arena

safe, incrementally garbage collected arenas

allocative

Inspect rust object tree and output it as flamegraph

ar_row

Row-oriented access to Arrow arrays

impl-tools

Helper macros: autoimpl

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.

derive_setters

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

ruast

A printable & modifiable Rust AST

syn-mid

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

proc_macro_roids

Traits and functions to make writing proc macros more ergonomic

runtime-macros

Simulate expansion of procedural macros at run time

clap_derive

Parse command line argument by defining a struct, derive crate

maybe-async-cfg

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

cxxbridge-flags

Compiler configuration of the cxx crate (implementation detail)

enum-assoc

Procedural macro to associate constants with enum variants

verus_syn

Parser for Rust source code

int-enum

A derive macro for conversion between integer and enum types

lexgen

A fully-featured lexer generator implemented as a proc macro

dylo-cli

Generate dyn-compatible traits with proc macros

makepad-micro-proc-macro

Makepad micro proc macro util lib

neli-proc-macros

Procedural macros for neli

cubecl-reduce

CubeCL Reduce Algorithms

syn_util

helper APIs for procedural macros

loess

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

clientix

building HTTP clients and requests declaratively with procedural macros - no need to write complex imperative or functional logic

futures-macro

The futures-rs procedural macro implementations

proc-macro-utils

low-level utilities on proc-macro and proc-macro2 types

binfarce

Extremely minimal parser for ELF, Mach-O, PE and ar

derive-adhoc

An ergonomic way to write derive() macros

ferment

Traits for FFI conversions and some helper methods

napi-derive-backend-ohos

Codegen backend for napi-harmony procedural macro

typesafe_builder

A procedural macro to generate type-safe builder patterns for Rust structs

fv-template

Field-value based string templating

instant-xml

A more rigorous way to map XML to Rust types

napi-derive-backend

Codegen backend for napi procedural macro

telety

Access type information across crates and modules in your proc macros

ra_ap_proc_macro_srv

Proc-macro server for rust-analyzer

codama-nodes

Node specifications and helpers for the Codama standard

dtrace-parser

Parse DTrace provider definitions into Rust

from

A procedural macro that generates custom parsing and validation code

rewriter

rewriting files

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

blanket

macro to derive blanket implementations for your traits

comlexr

Dynamically build Command objects with conditional expressions

cynic-codegen

Procedural macro code generation for cynic - a code first GraphQL client for Rust

safe_math

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

swc_typescript

Proc macro for performance trace of swc

cargo-manifest-proc-macros

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

gratte

macros for working with enums and strings; forked from strum

num-derive

Numeric syntax extensions

async-recursion

Recursion for async functions

moku

creating hierarchical state machines (HSM)

pmutil

Utils for proc-macro

teleparse

frunk_proc_macro_helpers

Common internal functions for frunk's proc macros

proc-easy

Macros to make writing proc-macro crates easy

tokio-macros

Tokio's proc macros

salsa-macro-rules

Declarative macros for the salsa crate

test_each_file

Generates a test for each file in a specified directory

seedframe

A clean, macro driven Rust library for building LLM apps

lockjaw

Compile time dependency injection framework inspired by dagger

matched_enums

A macro that provides the option to bin enum attribute to match-statements. This makes it easier to convert values into enums.

structstruck

Nested struct and enum definitions

proc-macro-tool

Some common simple tool for proc-macro impl

salsa-macros

Procedural macros for the salsa crate

enpow

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

proc-macro-rules

Emulate macro-rules pattern matching in procedural macros

pistonite-cu

Battery-included common utils to speed up development of rust tools

double-trait

A procedural macro to derive a mirror of a trait designed to make it easier to implement test doubles

ansic

does ansi parsing in a dynamic DSL and at compile time for efficient and zero cost ansi styling

synthez

Steroids for syn, quote and proc-macro2 crates

rust_writer

useful for editing a Rust file from Rust code

async-generic

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

napi_sym

proc macro for writing N-API symbols

penum

Make enum conform to a given pattern

typed_grid

Macro generator for typed grid navigation

cast_checks

A procedural macro to check for invalid casts

include_tt

Macros for ultra-flexible injection of compiler trees, literals, or binary data into Rust syntax trees from external sources

proc-quote

A procedural macro implementation of quote!

better_comprehension

collection and iterator comprehensions for Rust

i18n-format

macro to allow formatting with gettext while keeping xgettext to work

positional

author/parse positional files

flexml

Quickly and easily define namespaced XML serialization

derive-sql

Structure the interaction with SQL databases - currently SQLite and MySQL via trait and a procedural macro

test-each

Generate tests at compile-time based on file resources

bignumbe-rs

Large, medium-precision numbers

scarb-proc-macro-server-types

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

codama-syn-helpers

Extension of syn for Codama

dylo

Generate dyn-compatible traits with procedural macros

doc_for

📖 Get the documentation comment for structs, enums and unions, in a zero-cost fashion

mpst-seq

DEPRECIATED: A library with macro for mpstthree

postcompile

Helper crate for post-compiling Rust code

cubecl-random

CubeCL Random Number Generation

place_macro

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

derive_fuzztest

proc-macro to enable using the same implementation for fuzz tests and property tests

deno-bindgen2-cli

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

mcp-spec

Core types for Model Context Protocol

sylvia-runtime-macros

Simulate expansion of procedural macros at run time

ferment-sys

Syntax tree morphing of FFI-compatible stuff

trait_mux

Proc macro library for generating enums that can multiplex different trait objects

recuerdame

Pre-calculate functions at compile-time rather than run-time

storeit_core

Core traits, errors, and abstractions for the storeit repository framework

strong-xml

Strong typed xml, based on xmlparser

python-mod

A macro library for including a Python module in Rust. At this point, very imcomplete.

bevy_derive

derive implementations for Bevy Engine

int-to-c-enum

TryFromInt - A convenient derive macro for converting an integer to an enum

format-bytes

A macro to format bytestrings

macron

Comprehensive Rust macros toolkit for everyday development tasks. Includes convenient string formatting (str!), regex pattern matching (re!), streamlined collection creation, and custom derive macros for Display…

command-rpc

cli crate and api for replacing rpc

syn-helpers

Framework for building derive macros

syn-test-suite

Test suite of the syn crate

enum-bitset

Generate efficient bitsets out of your enum types

functor_derive

A derive macro to derive a functor for a type

enum_discriminant

Procedural macro to add functions on enum types to get discrimnant value from variant or create unit variant from discriminant value

command_attr

Procedural macros for command creation for the Serenity library

surqx

Query macro for SurrealDB

raw_struct

procedural macro for easily declaring C-style structs that reference local or external memory, based on your memory implementation. It generates appropiate getter methods for easy access.

efx

Rust XML templating engine for building egui UIs with procedural macros

rustic-jsonrpc

JSON-RPC 2.0 server library written in Rust

enum_ext

procedural macro that enhances enums with additional methods and conversions

iderive

Drop-in replacement for derive that doesn't directly depend on generic bounds

derive-finite-automaton

Procedural macro for generating finite automaton

codama-errors

Errors and result types for Codama

proc-utils

A series of traits, macros, functions, and utilities that make writing and debugging proc macros easier

reflected

Something like reflection

newer-type

Support defining newtype wrapper with inheriting trait implementations

clasma

A procedural macro for partial borrowing

jni-toolbox

tools to make writing JNI native functions less tiresome

orcxx

Rust bindings for the official C++ library for Apache ORC

enum_companion

A procedural macro for generating companion enums for structs

swc_trace_macro

Proc macro for performance trace of swc

derive-ctor

Adds #[derive(ctor)] which allows for the auto-generation of struct, enum, and union constructors

heterob

conversion between bytes/bits and heterogeneous lists (tuples)

runtime-macros-derive

Simulate expansion of procedural macros at run time

clone_dyn

Derive to clone dyn structures

wgcore

abstractions for composable WGSL shaders

syn-impersonated

Parser for Rust source code

path_scan

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

funlog

A procedural macro for tracing Rust function calls

hooq

macro that inserts a method before ?. (? 前にメソッドを挿入するシンプルなマクロ)

opendp_tooling

Tooling for proc-macros and code generation

cffi

Safe* C FFI interface generation

json_proc

proc macro for parsing JSON-like syntax

call2-for-syn

Apply parser functions to proc-macro2 token streams

cfg_block

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

serde-ordered

A procedural macro for deserializing ordered arrays into keyed structs using Serde

struct_iterable

providing a proc macro to make a struct iterable

pattern-wishcast

Pattern types emulation for conditional variants using conditional never types

nodyn

Easy polymorphism with enums

pistonite-pm

Procedural Macro Common Utils

lachs

automatically creating a lexer based on a given enum

unwrapped

The unwrapped crate

simpl_cache

caching tools

noir_macros_core

Essential proc-macros and utilities for no_std Rust development

match-template

procedural macro that generates repeated match arms by pattern

proc-macro2-fallback

Only the non-libproc_macro-based codepath of the proc-macro2 crate

yart

wrapper crate re-exporting the rig_tool macro and shared utilities for rig::tool::Tool

df-derive

Procedural derive macro for efficiently converting Rust structs into Polars DataFrames

easy_proc

Helper macros for making proc macros

kind-openai-schema

OpenAI schema generation macro public library

otel-instrument

Instrument macro for opentelemetry

turul-mcp-derive

Procedural macros for the MCP framework

elif-macros

Procedural macros for elif.rs framework

unit-enum

A procedural macro for deriving ordinal methods in unit-like enums for Rust

name-index

accessing struct fields by name at runtime

syllogism

allow for some specialization using stable Rust

snake_to_camel

that generates camelCase fields structs from struct with snake_case fields

snowfinch

proc-macro wrapper around tailwindcss

log_args

procedural macro to log function arguments using the tracing crate

rustmax

A collection of useful crates

sqlx-template

Template query library for Rust SQLx

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

c0nst

proc-macro for sharing code between const and non-const traits

immediate_stats

Game stats that reset every frame, inspired by immediate mode rendering

macro_rules_attr

Use declarative macros as proc_macro attributes. (#[apply] your macro_rules!)

deki_proc

Some proc macro helpers!

autotrait

Reduces boilerplate by auto-generating trait definitions from impl blocks for dynamic dispatch

rasset

Rust Asset Management Library

find-crate

Find the crate name from the current Cargo.toml

script-macro

Write proc-macros inline with other source code

build-time

proc-macros to generate build timestamp string literals

beerec-variants

Procedural derive macro to generate boilerplate on unit variants enum types

fut-ret

parse the return type generated by async_trait in procedural macro

howlast

A procedural macro to easily misure computation times

quote_into

Easily & efficiently generate code by quoting it in a macro

phyto-fsm

procedural macro for generating type-safe state machines from PlantUML diagrams

hey_chat_gpt

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

wrap-match

A procedural macro to wrap a function in match statement to make error logging super easy