syn

Parser for Rust source code

quote

Quasi-quoting macro quote!(...)

trybuild

Test harness for ui tests of compiler diagnostics

strum

macros for working with enums and strings

test-case

#[test_case(...)] procedural macro attribute for generating parametrized test cases easily

num_enum

Procedural macros to make inter-operation between primitives and enums easier

proc-macro-crate

Replacement for crate (macro_rules keyword) in proc-macros

pin-project

safe and ergonomic pin-projection

rstest

Rust fixture based test framework. It use procedural macro to implement fixtures and table based tests.

proc-macro2

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

ctor

__attribute__((constructor)) for Rust

cached

Generic cache implementations and simplified function memoization

proc-macro-error2

Almost drop-in replacement to panics in proc-macros

macro_rules_attribute

Use declarative macros in attribute or derive position

self_cell

Safe-to-use proc-macro-free self-referential structs in stable Rust

zerovec

Zero-copy vector backed by a byte array

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.

serde_tokenstream

A serde deserializer for proc_macro::TokenStreams

macrotest

Test harness for macro expansion

flagset

Data types and a macro for generating enumeration-based bit flags

nutype

The newtype with guarantees

educe

offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits

derive-where

Deriving with custom trait bounds

orchestra

Generate an orchestra of subsystems from a single struct

macro_magic

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

progenitor

An OpenAPI client generator

auto_impl

Automatically implement traits for common smart pointers and closures

const-str

compile-time string operations

venial

A very small syn

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

crokey

Parse and describe keys - helping incorporate keybindings in terminal applications

proc-macro-warning

Emit warnings from inside proc macros

expander

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

auto_enums

allow multiple return types by automatically generated enum

dylo-cli

Generate dyn-compatible traits with proc macros

getset

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

pyo3-polars

Expression plugins and PyO3 types for polars

pyo3-stub-gen

Stub file (*.pyi) generator for PyO3

test-strategy

Procedural macro to easily write higher-order strategies in proptest

virtue

A sinless derive macro helper

memoize

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

proc-macro2-diagnostics

Diagnostics for proc-macro2

trybuild2

Test harness for ui tests of compiler diagnostics (with support for inline tests)

manyhow

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

duplicate

macros for duplication of code with variable substitution

rstml

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

with_locals

Function attribute to return references to locals by using CPS

culpa

error-handling syntax in Rust

yare

Lean parameterized test case library for Rust 🚀

macro_tools

Tools for writing procedural macroses

reflect

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

parse-display

Procedural macro to implement Display and FromStr using common settings

inline_tweak

Tweak values directly from the source code

parameterized

Procedural macro which brings a compact parameterized testing implementation to Rust (inspired by JUnit @ParameterizedTest)

git-testament

Record git working tree status when compiling your crate

aquamarine

A mermaid.js integration for rustdoc

fixed-map

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

syn-mid

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

genco

A whitespace-aware quasiquoter for beautiful code generation

enum-as-inner

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

jsonrpsee-proc-macros

Procedueral macros for jsonrpsee

poem-openapi

OpenAPI support for Poem

hard-xml

Strong typed xml, based on xmlparser

docify

allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples

stylance

Scoped CSS for rust projects

proc-macro-utils

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

o2o

Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.

sealed

Macro for sealing traits and structures

sarge

Zero-dependencies arguments parser

derive-syn-parse

Derive macro for syn::parse::Parse

ascent

Logic programming in Rust

const_fn

A lightweight attribute for easy generation of const functions with conditional compilations

watt

Runtime for executing Rust procedural macros compiled as WebAssembly

bitfield-struct

Struct-like procedural macro for bitfields

strum_macros

macros for working with enums and strings

easy-ext

A lightweight attribute macro for easily writing extension trait pattern

wiggle

Runtime components of wiggle code generator

derive_setters

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

async-recursion

Recursion for async functions

ambassador

Trait implementation delegation via procedural macros

syn-serde

serialize and deserialize Syn syntax trees

oct

Octonary transcoder

clap_derive

Parse command line argument by defining a struct, derive crate

rusty_lr

GLR, LR(1) and LALR(1) parser generator with custom reduce action

proc_macro_roids

Traits and functions to make writing proc macros more ergonomic

function_name

macro that expands to the name of the annotated function

ct-python

Execute Python code at compile time to generate Rust code

derive-deftly

An ergonomic way to write derive() macros

documented

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

devise

devising derives and other procedural macros

awint_macro_internals

Internal macro utilities for the awint system of crates

munge

Macro for custom destructuring

deluxe

Procedural macro attribute parser

twelf

configuration solution for Rust including 12-Factor support. It is designed with layers in order to configure different sources and formats to build your configuration. The main goal…

validify

struct validation and modification functionality through the use of derive macros

rust_decimal_macros

Shorthand macros to assist creating Decimal types

tracel-xtask

Reusable and Extensible xtask commands to manage repositories

tracing-attributes

Procedural macro attributes for automatically instrumenting functions

quote-use

Support use in procmacros hygienically

metered

Fast, ergonomic metrics for Rust!

wchar

Procedural macros for compile time UTF-16 and UTF-32 wide strings

qualifier_attr

Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items

template-quote

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

entrait

Loosely coupled Rust application design made easy

tokio-macros

Tokio's proc macros

clone_dyn

Derive to clone dyn structures

unsynn

Proc-macro parsing made easy

maybe-async-cfg

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

ruast

A printable & modifiable Rust AST

enum-assoc

Procedural macro to associate constants with enum variants

proc-bitfield

expressively declare bitfield-like structs

frunk_proc_macro_helpers

Common internal functions for frunk's proc macros

derive-adhoc

An ergonomic way to write derive() macros

jnix

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

butane

An ORM with a focus on simplicity and on writing Rust, not SQL

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

tryexpand

Test harness for macro expansion

iter-enum

#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums

num-derive

Numeric syntax extensions

metastruct

Abstractions for iterating and mapping over struct fields

impl-tools

Helper macros: autoimpl

serde_with_macros

proc-macro library for serde_with

io-enum

#[derive(Read, Write, Seek, BufRead)] for enums

fv-template

Field-value based string templating

rocket-grants

Authorization extension for rocket to protect your endpoints

blanket

macro to derive blanket implementations for your traits

do-with-in

A template language for Rust metaprogramming using partial staging

tblgen-alt

Safe Rust bindings for TableGen. Alternative updated version.

futures-macro

The futures-rs procedural macro implementations

biome_diagnostics_categories

Diagnostic categories for biome_diagnostics

generic-tests

Procedural macro to define tests and benchmarks generically

synthez

Steroids for syn, quote and proc-macro2 crates

cargo-manifest-proc-macros

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

int-enum

A derive macro for conversion between integer and enum types

proc-easy

Macros to make writing proc-macro crates easy

swc_typescript

Proc macro for performance trace of swc

from

A procedural macro that generates custom parsing and validation code

okapi-operation

Procedural macro for generating OpenAPI operation specification (using okapi)

supply-chain-trust-example-crate-000004

Quasi-quoting macro quote!(...)

rusty_lr_buildscript

buildscipt tools for rusty_lr

derive-sql

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

trybuild-internals-api

A fork of trybuild with the internals exposed as a public API

fieldx

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

proc-macro-rules

Emulate macro-rules pattern matching in procedural macros

test-each

Generate tests at compile-time based on file resources

markup

A blazing fast, type-safe template engine for Rust

allow

Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.

cynic-codegen

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

strong-type

Procedural macros for naming and strong-typing pritimives and strings

safe-quote

A fork of quote crate that adds forbid(unsafe_code) and depends on safe-proc-macro2 instead of proc-macro2

protect-axum

Authorization extension for axum to protect your endpoints

wiggle-generate

wiggle code generator

static-toml

Effortlessly embed TOML files into your Rust code as static data with custom data structures

pmutil

Utils for proc-macro

quote2

An alternative lightweight version of quote

derive_fuzztest

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

cargo-acl

code ACL checker

macroific

Proc macro development utilities

call2-for-syn

Apply parser functions to proc-macro2 token streams

safe-proc-macro2

A fork of proc_macro2 crate with unsafe code removed

ra_ap_proc_macro_srv

Proc-macro server for rust-analyzer

usdt

Dust your Rust with USDT probes

postcompile

Helper crate for post-compiling Rust code

bit-struct

Define structs which have fields which are assigned to individual bits, not bytes

structx

Simulating anonymous struct and named arguments in Rust

napi-derive-backend

Codegen backend for napi procedural macro

napi-derive-backend-ohos

Codegen backend for napi-harmony procedural macro

napi_sym

proc macro for writing N-API symbols

self-rust-tokenize

Turns instances of Rust structures into a token stream that creates the instance

syn-test-suite

Test suite of the syn crate

makepad-micro-proc-macro

Makepad micro proc macro util lib

bevy-butler

making Bevy systems more self-documenting

suitest

quality of life test suites

format-bytes

A macro to format bytestrings

buffi_macro

A proc-macro to generate ergonomic, buffer-based C++ APIs

structstruck

Nested struct and enum definitions

simpl_cache

caching tools

serde-inline-default

Serde default values via inline declaration

embedded-registers

Procedural macro for effortless definitions of registers in embedded device drivers

positional

author/parse positional files

penum

Make enum conform to a given pattern

runtime-macros-derive

Simulate expansion of procedural macros at run time

teleparse

EnumBitFlags

EnumBitFlags is an implementation of flags support for enums

ar_row

Row-oriented access to Arrow arrays

neli-proc-macros

Procedural macros for neli

rustifact

A seamless bridge between a build script and the main crate

hex_lit

Hex macro literals without use of hex macros

supply-chain-trust-example-crate-000003

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

defile

Proc-macro helper to ungroup macro metavariables

robusta_jni

Easy interop between Rust and Java

test_each_file

Generates a test for each file in a specified directory

syn-helpers

Framework for building derive macros

symbols

Proc-macro utility to populate enums from database data

glsl-lang-quote

Quoting proc-macro for glsl-lang

askama_parser

Parser for Askama templates

include_proc_macro

shorthand for including proc-macro source files in the module tree for external tooling like IDEs or other similar purposes

sqlx-type

Typed sql macros for sqlx

mapper

Mapping macro to help to reduce mapping boilerplate

mil_std_1553b

MIL STD 1553B message parsing and types

wrap-match

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

async-generic

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

derive-ctor

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

dysql

that do dynamic-sql query through proc-macro, it bases on sqlx crate

dylo

Generate dyn-compatible traits with procedural macros

cast_checks

A procedural macro to check for invalid casts

ftswarm_emulator

Procedural macros for the ftswarm crate

aquamarine-demo-crate

A demo crate for aquamarine -- the mermaid.js integration for rustdoc

prost-unwrap

A procedural macro for prost-generated structs validation and type-casting

quasiquote

quote compatible quasiquote macro with support for interpolating expressions

unique-type-id

A unique id proc-macro generator for types

opentalk-proc-macro-fields-helper

Helper function for working with fields in proc macros, used in OpenTalk crates

humanbyte

A procedural macro for deriving human readable byte functions

clone_dyn_types

Derive to clone dyn structures

extruct

proc-macro library that provides tools for listing named struct fields and implementing conversion from a larger struct containing fields with same names

sycamore-web

proc-macro crate for Sycamore

enum-update

representing state changes as enums

test-generator

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

mantra-rust-macros

macros to create requirement traces and coverage logs for the mantra framework

rinja_parser

Parser for Rinja templates

noir_macros_core

Essential proc-macros and utilities for no_std Rust development

bondrewd

Bit-Level field packing with proc_macros

include_tt

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

spandoc

Procedural macro attribute for converting doc comments into tracing spans

tokenstream2-tmpl

Runtime TokenStream interpolation for Rust macros

find-crate

Find the crate name from the current Cargo.toml

cargo-equip

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

tulisp

An embeddable lisp interpreter

ormx

lightweight procedural macros bringing orm-like features to sqlx

proc-quote

A procedural macro implementation of quote!

syn-impersonated

Parser for Rust source code

limousine_engine

can reason about a large design continuum of hybrid key-value store designs and materialize an optimal implementation using procedural macros

abcgen

A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern

impl-tools-lib

Helper macros: autoimpl

script-macro

Write proc-macros inline with other source code

rustic-jsonrpc

JSON-RPC 2.0 server library written in Rust

myn

Minimalist Rust syntax parsing for procedural macros

proc_macro2_helper

Various utility code to extract data that can be used with proc macro2

orcxx

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

json_proc

proc macro for parsing JSON-like syntax

sized-data

Sized data trait + macro implementation for use in Anchor framework

bunt

macros to write colored and formatted text to a terminal. Based on termcolor, thus also cross-platform

tracing-proc-macros-ink

working tracing integration for logging from within procedural macros

pomelo

Lemon parser generator as a Rust procedural macro

epics_gen

macros for deserializing xlsx tables and serializing them as EPICS PVs

vte_generate_state_changes

Proc macro for generating VTE state changes

sql_minifier

providing methods and procedural macros to minify SQL code, optionally at compile time