Lib.rs

quote

Quasi-quoting macro quote!(...)

syn

Parser for Rust source code

darling

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

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

utoipa

Compile time generated OpenAPI documentation for Rust

synstructure

Helper methods and macros for custom derives

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.

cargo-util-schemas

Deserialization schemas for Cargo

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

swc_macros_common

Common utilities for swc 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

delegate

Method delegation with less boilerplate

venial

A very small syn

enum_dispatch

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

phf_codegen

Codegen library for PHF types

r2r

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

proc-macro2

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

attribute-derive

Clap like parsing for attributes in proc-macros

rstml

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

displaydoc

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

derive_utils

A procedural macro helper for easily writing derive macros for enums

proc-macro-warning

Emit warnings from inside proc macros

dylo-cli

Generate dyn-compatible traits with proc macros

memoize

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

scx_stats

Statistics transport library for sched_ext schedulers

ra_ap_project_model

A representation for a Cargo project for rust-analyzer

getset

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

derive-getters

boilerplate getters generator

proc-macro2-diagnostics

Diagnostics for proc-macro2

duplicate

macros for duplication of code with variable substitution

macro_tools

Tools for writing procedural macroses

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

safe-quote

Quasi-quoting macro quote!(...)

kopium

kubernetes openapi unmangler

enum-as-inner

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

server_fn_macro

RPC for any web framework

good-ormning

Maybe an ORM

dynasm

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

bevy_macro_utils

A collection of utils for Bevy Engine

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

git-ignore-generator

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

derive-new

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

manyhow

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

smart-default

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

document-features

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

jsonrpsee-proc-macros

Procedueral macros for jsonrpsee

wasm-bindgen-macro-support

The part of the implementation of the #[wasm_bindgen] attribute that is not in the shared backend crate

docify

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

vercel_runtime_router

Vercel Rust Function Runtime Router

unsynn

(Proc-macro) parsing made easy

ra_ap_test_utils

Assorted testing utilities for rust-analyzer

parse-variants

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

macro_railroad

generate syntax diagrams for Rust macros

specr-transpile

Converts Specr lang code to Rust

databake

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

test-with

A lib help you run test with condition

derive_setters

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

pmutil

Utils for proc-macro

function_name

macro that expands to the name of the annotated function

ambassador

Trait implementation delegation via procedural macros

loess

Small proc macro grammar and parser (generator) with great UX

clap_derive

Parse command line argument by defining a struct, derive crate

rustfmt_if_chain

An if_chain-aware rustfmt (kind of)

string_cache_codegen

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

validated_struct

Easily generate nested structures with getters and predicated setters

proc_macro_roids

Traits and functions to make writing proc macros more ergonomic

jsonptr

Data structures and logic for resolving, assigning, and deleting by JSON Pointers (RFC 6901)

bitmask-enum

A bitmask enum attribute macro

deluxe

Procedural macro attribute parser

necessist-frameworks

moon_common

Common utilities

forest

Explore and summarise Rust projects

genemichaels

Makes your code formatty

yew-fmt

Code formatter for the Yew framework

seq-macro

Macro to repeat sequentially indexed copies of a fragment of code

code-status-scanner

CLI tool to scan codebases for code-status-macros usage

syn-ext

Human friendly or editable extension for syn

pgrx-bindgen

additional bindgen support for pgrx

hax-lib

Hax-specific helpers for Rust programs

cynic-codegen

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

maybe-async-cfg

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

rusteron-code-gen

Code generator for aeron c bindings

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.

contracts

Design-by-contract attributes

messageforge

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

frunk_proc_macro_helpers

Common internal functions for frunk's proc macros

process-wrap

Wrap a Command, to spawn processes in a group or session or job etc

git-cinnabar

git remote helper to interact with mercurial repositories

wasmtime-versioned-export-macros

Macros for defining versioned exports in Wasmtime

stability

Rust API stability attributes for the rest of us

spacetimedsl_derive-input

Contains structs which represent the input and output of SpacetimeDSL. Can be used by other proc-macro crates to build Macros which utilize SpacetimeDSL under the hood.

percpu

Define and access per-CPU data structures

leptos_hot_reload

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

neli-proc-macros

Procedural macros for neli

atomic-dbg

Atomic dbg/eprintln/eprint macros

napi-derive

N-API procedural macros

int-enum

A derive macro for conversion between integer and enum types

is-macro

Derive methods for using custom enums like Option / Result

do-with-in

A template language for Rust metaprogramming using partial staging

asn1-compiler

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

trustfall-rustdoc-adapter

Trustfall query adapter for rustdoc JSON data

derive-syn-parse

Derive macro for syn::parse::Parse

biscuit-parser

Datalog parser used in the biscuit-auth and biscuit-quote crates

i18n-format

macro to allow formatting with gettext while keeping xgettext to work

stageleft

Type-safe staged programming for Rust

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

carbond-lib

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

ra_ap_hir_expand

Macro expansion for rust-analyzer

truc

Rust code generator for safe, fixed size, evolving records

dsl_auto_type

Automatically expand query fragment types for factoring as functions

dioxus-rsx

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

rust_arkitect

lightweight library for defining and validating architectural rules in Rust projects

lazybe

Handy CRUD boilerplate macros and utils for Rust backend

pearlite-syn

A syn parser for the Pearlite specification language in Creusot

runtime-macros

Simulate expansion of procedural macros at run time

safe-proc-macro2

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

gengo

Get the language distribution stats of your repository

rustfmt-wrapper

wrapper around rustfmt for use by code generators

wadl

parser for Rust

leptosfmt-prettyplease

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

better_comprehension

collection and iterator comprehensions for Rust

waybackend-scanner

Waybackend implementation of wayland-scanner

quote-use

Support use in procmacros hygienically

lambda-appsync

A type-safe framework for AWS AppSync Direct Lambda resolvers

ssdv-fec

SSDV systematic erasure FEC

curve25519-dalek-derive

curve25519-dalek Derives

catalytic_query_parser

Query parser for the ORM for Scylla, fully compatible with Apache Cassandra™

malloc_size_of_derive

Firefox memory reporting, not intended for external use

napi-derive-backend

Codegen backend for napi procedural macro

dfir_lang

Hydro's Dataflow Intermediate Representation (DFIR) implementation

golem-cli

Command line interface for Golem

rocal-ui

UI for Rocal - Full-Stack WASM framework

futures-macro

The futures-rs procedural macro implementations

pavexc_rustdoc_types

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

debug3

Space Efficient Pretty Printer

gratte

macros for working with enums and strings; forked from strum

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.

prost-derive

Generate encoding and decoding implementations for Prost annotated types

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.

hydro_lang

Choreographic programming for Hydro, built on DFIR

swift-bridge-ir

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

cfg_eval

#[cfg_eval] in stable Rust 🙃

template-quote

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

attrs

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

napi_sym

proc macro for writing N-API symbols

frc42_macros

Filecoin FRC-0042 calling convention procedural macros

diol

benchmark lib

postcompile

Helper crate for post-compiling Rust code

accessory

A configurable get/set/get_mut derive macro

actix-multipart-derive

Multipart form derive macro for Actix Web

makepad-micro-proc-macro

Makepad micro proc macro util lib

structstruck

Nested struct and enum definitions

proc-macro-utils

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

pit-cli

Portal Interface Types

debug-ignore

A newtype wrapper that causes a field to be skipped while printing out Debug output

betfair-typegen

interacting with Betfair from Rust

quote2

An alternative lightweight version of quote

as_derive_utils

private derive utilities used by abi_stable and structural

form

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

syn-mid

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

drylib

Rust macro-library for Don't Repeating Yourself

rust-code-analysis

compute and export code metrics

positional

author/parse positional files

test_each_file

Generates a test for each file in a specified directory

penum

Make enum conform to a given pattern

more-convert

adds macros for various conversions

instability

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

EnumBitFlags

EnumBitFlags is an implementation of flags support for enums

ctor_bare

Register constructor functions for Rust at complie time under no_std

proc-macro-rules

Emulate macro-rules pattern matching in procedural macros

macro-string

Eager evaluation of macros like concat! and env!

fastapi

Compile time generated OpenAPI documentation for Rust

strum_macros

macros for working with enums and strings

default-struct-builder

Generates builder methods of every field of a struct

better_default

The std Default derive, but it allows to constomize the default fields values and has some upgrades

pax-compiler

Compiler APIs for parsing and building Pax projects into application executables

volo-build

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

syn-inline-mod

Inlines modules in Rust source code for source analysis

glib-macros

Rust bindings for the GLib library, proc macros crate

rustmax

A collection of useful crates

remain

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

proc_micro

Small conveniences for high-quality macros

gin-tonic

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

syn_derive

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

ra_ap_ide_diagnostics

Diagnostics rendering and fixits for rust-analyzer

rust-utils

Various utility routines used in the rust programs I have written

krpc-client

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

pastey

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

pgrx-sql-entity-graph

Sql Entity Graph for pgrx

unc-rpc-error-core

generates schema for Rust structs which can be used by TypeScript

bevygen

parked: opinionated bevy game design cli

elm-parser

Elm markup parser to leptos

rb-sys-build

Build system for rb-sys

runtime-macros-derive

Simulate expansion of procedural macros at run time

ekege-artifact

General-purpose build artifact generation crate

dbg-pls

Syntax aware pretty-printing debugging

aranya-policy-ifgen-build

Code generator for aranya-policy-ifgen

command-rpc

cli crate and api for replacing rpc

crud-api-endpoint

CLI generator for your API. Enpoint description

zorsh-gen-rs

Zorsh generator for Rust

aws-dynamo-derive

Helper crate for aws-sdk-dynamodb

reflect

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

crabtime

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

machine-check-machine

Machine crate for the formal verification tool machine-check

asmov-common-traitenum-parse

Parsing library for Asmov Common Traitenum

prettier-please

A minimal syn syntax tree pretty-printer

syn-serde

serialize and deserialize Syn syntax trees

noir_macros_core

Essential proc-macros and utilities for no_std Rust development

command_attr

Procedural macros for command creation for the Serenity library

functor_derive

A derive macro to derive a functor for a type

rustc-ap-rustc_expand

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

proc-macro-tool

Some common simple tool for proc-macro impl

context_manager

Python's like context_managers in Rust

procmeta

integration procmeta-core and procmeta-proc

swc_eq_ignore_macros

Macros for EqIgnoreSpan and TypeEq

derive_deref

Adds #[derive(Deref)] and #[derive(DerefMut)]

spark-orm

Mongodb ORM in Rust

r2a

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

fsmentry-cli

Finite State Machines with an entry API and data storage

cargo-unfmt

unformat code into perfect rectangles

warframe

An async crate to wrap Warframe's Worldstate API

structmeta

Parse Rust's attribute arguments by defining a struct

optee-utee-build

Build tool for TA

px-wsdom-ts-parse

wsdom crate, and potentially other uses

symbols

Proc-macro utility to populate enums from database data

script-macro

Write proc-macros inline with other source code

test-generator

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

uniffi_macros

a multi-language bindings generator for rust (convenience macros)

mainstay-syn

Mainstay syntax parsing and code generation tools

match-template

procedural macro that generates repeated match arms by pattern

moosicbox_env_utils

MoosicBox env utilities package

evtcall

Rust Event Driven Framework

leptosfmt-formatter

view macro formatter for the Leptos web framework

extruct

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

napi-derive-backend-ohos

Codegen backend for napi-harmony procedural macro

bevy_toolbox

A collection of useful tools for Bevy game engine

rust_minify

minify rust code

savvy-bindgen

Parse Rust functions, and generate C and R code

ethbind

code generation framework for Solidity(Contract) ABI

catalytic_table_to_struct

Table mapper for the ORM for Scylla, fully compatible with Apache Cassandra™

ra_ap_test_fixture

Test fixtures for rust-analyzer

dtor

__attribute__((destructor)) for Rust

arcis-interpreter

Arcis Interpreter

winter-maybe-async

sync/async macro for winterfell

unique-type-id

A unique id proc-macro generator for types

pulumi_gestalt_generator

Pulumi Gestalt Codegen library

lockjaw_common

lockjaw common lib. only to be used by https://crates.io/crates/lockjaw.

enum-update

representing state changes as enums

secrust

source-level verification using Weakest Precondition calculus

tool_calling

Don't know yet

surreal_derive_plus

Query builder for surrealdb

yewlish-fetch

A macro for generating Yew fetch API bindings

db-set-macros

A derive for some ORM functions utilising SQLX

boxed_error

Macro for easily boxing an error

yew_icons

Easily include a variety of SVG icons into your Yew app

casey

Case transforming macros for ident tokens

paste2

Macros for all your token pasting needs

ferment-sys

Syntax tree morphing of FFI-compatible stuff

ocaml-build

OCaml code generation

micro_games_macros

macros to make it easier to build complex systems with Bevy

cargo-test-support

Testing framework for Cargo's testsuite

deki_proc

Some proc macro helpers!

wars

Wasm to Rust converter

skia-svg-macros

Skia SVG Macros for Dom bindings

proc-macro-api

A macro helping with exporting APIs in a proc-macro library crate

schema

Access the schema for a Rust item

macroific_attr_parse

Attribute parsing utilities for the macroific crate

macro-wasmer-universal-test

Universal test macro for wasmer-test

linked-data-core

Core library for Linked Data crates

apidoc-expand

Apidoc expand

brisk-egui-components

Components for brisk-egui

odebug

flexible debug logging utility that allows simple and practical logging to a text file especially during proc-macro compilation

aws-sdk-compile-checks-macro

Macros that add compile time checks to the AWS SDKs

function-wrapper

Rust attribute macro library that makes it easy to wrap functions in code that runs before and / or after a function executes

fastmetrics

OpenMetrics client library in Rust

kona-std-fpvm-proc

Proc macro entry point for kona-std-fpvm targeted programs

stylers

Scoped CSS for Rust web frameworks like leptos

maidenx_macro_utils

maidenx macro utils

swimos_macro_utilities

SwimOS Macro Utilites

rust-sitter-common

Shared logic for the Rust Sitter macro and tool

countroo

give basic code analysis inside your rust projects, it supports line counting, module counting, dependency counting, project listing as well as Rust Edition & rustc Version detection

axsys-noun

working with Noun data

easy_proc

Helper macros for making proc macros

flamer

a procedural macro to insert flame::start_guard(_) calls

skip-if

Attribute macro to skip running a function that produces files

google-fonts-languages

Google Fonts script and language support data

brisk-it

core library of the brisk declarative engine

rust-style-guide

applying Rust coding guidelines

doc_for

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

pkenum

PKaiser's enum utilities

macroific

Proc macro development utilities

attr-parser-fn

parse attribute procedual macros in functional way

gset

A procedural macro for generating the most basic getters and setters on fields

async-generic

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

fn-decorator

contains macros for implementing wrapper functions around member or static functions

from-attr

that makes it easy to parse attributes

variants-struct

A derive macro to convert enums into a struct where the variants are members

syn-args

parsing function arguments

nested_enum_utils

Macros to provide conversions for nested enums

rem-repairer

Lifetime repairer for Rusty Extraction Maestro

enutil

General Enum Utility Macros

proc_macro2_helper

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

machine-check-bitmask-switch

Bitmask switch crate for the formal verification tool machine-check

hey_chat_gpt

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

assert_type_match

Statically assert that a type matches another type

proc-debug

Dump proc-macro output for efficient debugging

cargo-manifest-proc-macros

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

epics_gen

macros for deserializing xlsx tables and serializing them as EPICS PVs

mongodb-internal-macros

Internal macros for the mongodb crate

impl-tools-lib

Helper macros: autoimpl

quasiquote

quote compatible quasiquote macro with support for interpolating expressions

eager2

Proc-macros for eager macro expansion

compose-idents

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

syn-impersonated

Parser for Rust source code

protobuf-build

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

duchess-reflect

Internal component of duchess crate

bye_pcl_rs

The Point Cloud Library (PCL) is a standalone, large scale, open project for 2D/3D image and point cloud processing.Implemented in pure Rust

unique-uuid

generate unique UUIDs

autoargs

A proc macro for generating argument structs with defaults

dioxus-rsx-hotreload

CLI Configuration for dioxus-cli

extendable-data

A set of rust macros that allows you to specify data that can be "extended" or inherited from

zoo-endpoint

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

inttype-enum

Converts an [enum] into an [inttype], and try to convert it back

typed-fields

A collection of macros that generate newtypes

sea-bae

proc-macro attribute parser

rusty-bind-parser

Parses Rust module, generates Rust code with C ABI bindings and C/C++ header files and Swift gluecode

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.

dioxus-google-fonts

A declarative Google Fonts embedding for Dioxus

unit-enum

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

windows-implement

The implement macro for the windows crate

pyo3_special_method_derive

Automatically derive Python dunder methods for your Rust code

chandeliers-sem

Semantics of Candle, a shallow embedding of Lustre in Rust

flexpect

#[flexpect::e(...)] compiles to #[expect(...)] for newer versions of Rust and to #[allow(...)] when not supported

verty

procedural macro to generate different versions of a type

eiffel

language inspired guard clauses with Rust macros

pu-239

serverside fns in the client

promptkit_rs

LLM structured prompting library

opendp_tooling

Tooling for proc-macros and code generation

nous

lightweight and efficient web framework in Rust designed for handling HTTP requests with built-in gatekeeping middleware

by-macros

Biyard Macros

modus_ponens

develop forward chaining inference engines

kanamaru-build

the build script required for kanamaru

vtable_gen

A C++-ABI VTable Generator for Rust

grappler

function hooking through proc-macros

cdk-ansible-cli

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

re_types_builder

Generates code for Rerun's SDKs from flatbuffers definitions

jsonrpc-macros

Helper macros for jsonrpc-core

portrait-framework

Framework for implementing portrait fillers

ct-python

Execute Python code at compile time to generate Rust code

triton-constraint-builder

Emits efficient code from Triton VM's AIR

relib_interface

relib is a framework for reloadable dynamic libraries

actix-prost-build

Generate actix handles from Protocol Buffer files

pesticide

ORM for CC based on pest

code-status-macros

Procedural macros for annotating code with development status markers and tracking technical debt

opimps

attribute macros to assist with overloading operators for borrowed and owned data

limousine_core

Building blocks for hybrid index data structures

hax-lib-macros-types

Hax-internal types

rustifact

A seamless bridge between a build script and the main crate

zyc_getset

当前 crate是对’getset’ 的扩展。 主要添加了 get_clone来返回字段的克隆对象， 当为基础类型时 get 自动转为 get_copy ， 当字段有自定义注解时，自动对…

windows-interface

The interface macro for the windows crate

cio

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

pavexc

The compiler powering Pavex

opentalk-proc-macro-fields-helper

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

cot_codegen

web framework for lazy developers - code generation utils

forint

A proc macro for invoking macros for each integer type