Lib.rs

strum

macros for working with enums and strings

proc-macro-crate

Replacement for crate (macro_rules keyword) in proc-macros

proc-macro-error2

Almost drop-in replacement to panics in proc-macros

synstructure

Helper methods and macros for custom derives

proc-macro2

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

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.

unicode-ident

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

linkme

Safe cross-platform linker shenanigans

quote

Quasi-quoting macro quote!(...)

macrotest

Test harness for macro expansion

serde_tokenstream

A serde deserializer for proc_macro::TokenStreams

syn

Parser for Rust source code

paste

Macros for all your token pasting needs

unicode-id-start

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

displaydoc

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

venial

A very small syn

macro_magic

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

enum_dispatch

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

delegate

Method delegation with less boilerplate

attribute-derive

Clap like parsing for attributes in proc-macros

derive_utils

A procedural macro helper for easily writing derive macros for enums

proc-macro-warning

Emit warnings from inside proc macros

r2r

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

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

derive-new

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

expander

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

dylo-cli

Generate dyn-compatible traits with proc macros

pyo3-stub-gen

Stub file (*.pyi) generator for PyO3

getset

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

proc-macro2-diagnostics

Diagnostics for proc-macro2

manyhow

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

derive-getters

boilerplate getters generator

rstml

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

utoipauto

Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase

ra_ap_proc-macro-srv-cli

A standalone binary for the proc-macro-srv crate of rust-analyzer

rustfmt-wrapper

wrapper around rustfmt for use by code generators

smart-default

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

dynasm

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

databake

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

enum-as-inner

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

jsonrpsee-proc-macros

Procedueral macros for jsonrpsee

parse-variants

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

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

macro_railroad

generate syntax diagrams for Rust macros

specr-transpile

Converts Specr lang code to Rust

derive_setters

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

docify

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

ambassador

Trait implementation delegation via procedural macros

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

simple-mermaid

Mermaid diagrams RustDoc integration

function_name

macro that expands to the name of the annotated function

derive-deftly

An ergonomic way to write derive() macros

scryer-prolog

A modern Prolog implementation written mostly in Rust

derive-syn-parse

Derive macro for syn::parse::Parse

deluxe

Procedural macro attribute parser

bitmask-enum

A bitmask enum attribute macro

concat-idents

Allows concatenating multiple identifiers and using them everywhere

structmeta

Parse Rust's attribute arguments by defining a struct

k9

rust testing library

asn1-compiler

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

rusteron-code-gen

Code generator for aeron c bindings

terrars

Terraform in Rust

wasm-bindgen-macro-support

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

unsynn

Proc-macro parsing made easy

cargo-hax

The high assurance translation toolchain

maybe-async-cfg

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

stability

Rust API stability attributes for the rest of us

frunk_proc_macro_helpers

Common internal functions for frunk's proc macros

relib_interface

relib is a framework for reloadable dynamic libraries

messageforge

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

is-macro

Derive methods for using custom enums like Option / Result

tryexpand

Test harness for macro expansion

syn-mid

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

impl-tools

Helper macros: autoimpl

uniffi_meta

fv-template

Field-value based string templating

do-with-in

A template language for Rust metaprogramming using partial staging

proc-macro-utils

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

syn_derive

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

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

int-enum

A derive macro for conversion between integer and enum types

percpu

Define and access per-CPU data structures

form

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

stageleft

Type-safe staged programming for Rust

pearlite-syn

A syn parser for the Pearlite specification language

prost-derive

Generate encoding and decoding implementations for Prost annotated types

fieldx

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

const-random

compile time random number generation

curve25519-dalek-derive

curve25519-dalek Derives

proc-macro-rules

Emulate macro-rules pattern matching in procedural macros

template-quote

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

pit-cli

Portal Interface 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.

quote2

An alternative lightweight version of quote

pmutil

Utils for proc-macro

supply-chain-trust-example-crate-000001

Parser for Rust source code

gix-trace

provide minimal tracing support that can be turned off to zero cost

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.

chalk-derive

A helper crate for use by chalk crates for derive macros

macroific

Proc macro development utilities

swift-bridge-ir

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

github-languages

All GitHub's supported languages

postcompile

Helper crate for post-compiling Rust code

napi-derive-backend-ohos

Codegen backend for napi-harmony procedural macro

vercel_runtime_router

Vercel Rust Function Runtime Router

ra_ap_proc_macro_api

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

string_cache_codegen

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

actix-multipart-derive

Multipart form derive macro for Actix Web

napi_sym

proc macro for writing N-API symbols

as_derive_utils

private derive utilities used by abi_stable and structural

dbg-pls

Syntax aware pretty-printing debugging

napi-derive-backend

Codegen backend for napi procedural macro

makepad-micro-proc-macro

Makepad micro proc macro util lib

wasmtime-versioned-export-macros

Macros for defining versioned exports in Wasmtime

malloc_size_of_derive

Firefox memory reporting, not intended for external use

drylib

Rust macro-library for Don't Repeating Yourself

workflow-macro-tools

Macro utility functions used by the workflow-rs framework

rustmax

A collection of useful crates

swc_eq_ignore_macros

Macros for EqIgnoreSpan and TypeEq

simpl_cache

caching tools

structstruck

Nested struct and enum definitions

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

penum

Make enum conform to a given pattern

futures-macro

The futures-rs procedural macro implementations

EnumBitFlags

EnumBitFlags is an implementation of flags support for enums

sample-test

Sampling strategies and machinery for testing arbitrary data

format-bytes

A macro to format bytestrings

test_each_file

Generates a test for each file in a specified directory

symbols

Proc-macro utility to populate enums from database data

shank_render

Renders implementaions derived from shank macros

cfg_eval

#[cfg_eval] in stable Rust 🙃

strum_macros

macros for working with enums and strings

derive-adhoc

An ergonomic way to write derive() macros

dfir_lang

Hydro's Dataflow Intermediate Representation (DFIR) implementation

rand_derive2

Generate customizable random types with the rand crate

positional

author/parse positional files

better_default

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

include_proc_macro

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

unique-type-id

A unique id proc-macro generator for types

command-rpc

cli crate and api for replacing rpc

rustifact

A seamless bridge between a build script and the main crate

synthez

Steroids for syn, quote and proc-macro2 crates

scopegraphs-regular-expressions

A well-documented port of scopegraphs to Rust

mantra-rust-macros

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

sqltk

Enhanced Visitor implementation for sqlparser

cargo-manifest-proc-macros

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

isr

Intermediate Symbol Representation

sea-bae

proc-macro attribute parser

stak-macro-util

Macro utilities for Stak Scheme

noir_macros_core

Essential proc-macros and utilities for no_std Rust development

async-generic

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

rustfmt_if_chain

An if_chain-aware rustfmt (kind of)

tokenstream2-tmpl

Runtime TokenStream interpolation for Rust macros

syn-helpers

Framework for building derive macros

netsblox-extension-util

Allows for automatic generation of a NetsBlox extension that uses WASM

spider_chromiumoxide_pdl

Contains a PDL parser and rust generator

default-struct-builder

Generates builder methods of every field of a struct

extruct

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

by-macros

Biyard Macros

neli-proc-macros

Procedural macros for neli

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

aws-dynamo-derive

Helper crate for aws-sdk-dynamodb

myn

Minimalist Rust syntax parsing for procedural macros

casey

Case transforming macros for ident tokens

json_proc

proc macro for parsing JSON-like syntax

epics_gen

macros for deserializing xlsx tables and serializing them as EPICS PVs

quasiquote

quote compatible quasiquote macro with support for interpolating expressions

ocaml-build

OCaml code generation

scarb-proc-macro-server-types

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

eiffel

language inspired guard clauses with Rust macros

rust_minify

minify rust code

cdk-ansible-cli

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

reflect

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

vtable_gen

A C++-ABI VTable Generator for Rust

derive_deref

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

yewlish-fetch

A macro for generating Yew fetch API bindings

ctor_bare

Register constructor functions for Rust at complie time under no_std

mlang-rs

scheme definition language for markup languages

glib-macros

Rust bindings for the GLib library, proc macros crate

opentalk-proc-macro-fields-helper

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

rigz_vm

Stack based VM for rigz

compact-thrift-runtime

Runtime library for compact-thrift code generator

opendp_tooling

Tooling for proc-macros and code generation

from-attr

that makes it easy to parse attributes

supply-chain-trust-example-crate-000036

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

re_types_builder

Generates code for Rerun's SDKs from flatbuffers definitions

command_attr

Procedural macros for command creation for the Serenity library

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

surreal_derive_plus

Query builder for surrealdb

function-wrapper

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

jsonrpc-derive

High level, typed wrapper for jsonrpc-core

axsys-noun

working with Noun data

doc_consts

get doc comments on fields as runtime constants

rusty-bind-parser

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

boxed_error

Macro for easily boxing an error

pax-language-server

Language Server for Pax Language

fn-decorator

contains macros for implementing wrapper functions around member or static functions

savvy-bindgen

Parse Rust functions, and generate C and R code

attr-parser-fn

parse attribute procedual macros in functional way

quote-use

Support use in procmacros hygienically

contracts

Design-by-contract attributes

enutil

General Enum Utility Macros

micro_games_macros

macros to make it easier to build complex systems with Bevy

betfair-typegen

interacting with Betfair from Rust

necessist-backends

pu-239

serverside fns in the client

flamer

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

abi-singleton

singleton trait

checked-rs-macro-impl

procedural macros for checked-rs. This crate is not intended to be used directly.

actix-prost-build

Generate actix handles from Protocol Buffer files

call2-for-syn

Apply parser functions to proc-macro2 token streams

machine-check-machine

Machine crate for the formal verification tool machine-check

stageleft_tool

Helper macros for the stageleft crate

brisk-egui-components

Components for brisk-egui

macroific_attr_parse

Attribute parsing utilities for the macroific crate

optee-utee-build

Build tool for TA

supply-chain-trust-example-crate-000004

Quasi-quoting macro quote!(...)

extendable-data

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

contracts-try

Design-by-contract attributes

genemichaels-lib

Makes your code formatty, the library

unit-enum

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

firmware-controller

Controller to decouple interactions between components in a no_std environment

safe-quote

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

db-set-macros

A derive for some ORM functions utilising SQLX

tailwag_macro_logic

The logic for A collection of macros to support the tailwag crate

no-panic

Attribute macro to require that the compiler prove a function can't ever panic

google-fonts-axisregistry

Google Fonts font axis support data

defamed

Default, positional and named parameters

frc42_macros

Filecoin FRC-0042 calling convention procedural macros

enum_stringify

Macro to generate string conversion functions for enums

needy

Requirements tracing macro

easy_proc

Helper macros for making proc macros

trident-idl-spec

Custom implementation of IDL specification for the Trident fuzzing framework

zyc_getset

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

zoo-endpoint

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

xan-actor

Akka actor

brisk-it

core library of the brisk declarative engine

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.

lombokrs

lightweight Rust macro library. It is the simple implementation of lombok Java in Rust.

opimps

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

dioxus-rsx-rosetta

Autofomatter for Dioxus RSX

modus_ponens

develop forward chaining inference engines

tauri-types

Type generating macros for Tauri apps

frunk_derives

contains the custom derivations for certain traits in Frunk

typed-fields

A collection of macros that generate newtypes

relib_exportify

relib is a framework for reloadable dynamic libraries

ckb-script-ipc

Proc macros for CKB Script IPC

validated_struct

Easily generate nested structures with getters and predicated setters

portrait-framework

Framework for implementing portrait fillers

triton-constraint-builder

Emits efficient code from Triton VM's AIR

serde_inner_serialize

A package of proc macros to assist in serializing nested structures flatly via serde

stilts-lang

The parser for stilts

kind-openai-schema

OpenAI schema generation macro public library

chur-build

A wrapper around tonic-build which adds dependencies

winter-maybe-async

sync/async macro for winterfell

cargo-cabal

that helps you to turn in one command a Rust crate into a Haskell Cabal library

proc-quote

A procedural macro implementation of quote!

tnj-air

TNJ Assembly Intermediate Representation (AIR)

macro-dep-test

testing version resolution for associated macros

rem-borrower

Permission repairer for Rusty Extraction Maestro

opentelemetry-derive

Derive macros for OpenTelemetry

partial_struct

A proc-macro crate that generates partial versions of Rust structs. Specify omitted fields and custom derives via attributes, then use the generated conversion method to build the full struct.

apidoc-expand

Apidoc expand

windows-interface

The interface macro for the windows crate

proc-debug

Dump proc-macro output for efficient debugging

mpst-seq

DEPRECIATED: A library with macro for mpstthree

embed-licensing

Embed licensing information of dependencies to comply with free software licenses

makepad-widgets

Makepad widgets

common-error-build

High performance universal error code management for Rust in Rust

syn-prelude

prelude traits and helpers for enhancing 'syn'/'proc-macro2' lib

crud-api-endpoint

CLI generator for your API. Enpoint description

macro-field-utils

work with darling fields

proc-macro-assertions

Easily create asserts on proc macro inputs

clappen

Clap flatten prefix macro

proc_macro2_helper

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

autogen

set of macros that allows you to automatically apply generics to impl blocks

dmacro

define C-like debug trace macro: enter!() and leave!()

cgp-component-macro-lib

Context-generic programming core component macros implemented as a library

bevy_auto_plugin_nightly_shared

shared lib for bevy_auto_plugin that require nightly rust

battler-wamprat-uri

Procedural macro for dynamically matching WAMP URIs

std-reset

Many reworked implementations from the standard library, as well as new solutions for easy coding

juniper_codegen

Code generation for juniper crate

fusen-derive-macro

fusen-common

instance_code

Turn instances into source code

aksr

derive macro designed to automatically generate getter and setter methods for both named and tuple structs

tabler-icon-definer

Macros for fast incremental loading tabler icons

muchin_model_state_derive

Derive macros for muchin model state

syn-file-expand

load full source code of multi-file crates

rssyin

depends on ra_ap_syntax to identify rust context for tracing and code replacement

vodca

Reduce boilerplate when writing DDD codes

dylo

Generate dyn-compatible traits with procedural macros

dupit

copy or clone a value

codama-attributes

Codama attributes definitions and parsers

reflected

Something like reflection

noop_proc_macro

No-op proc_macro, literally does nothing

pack_bools

Attribute macro to pack all boolean fields of a struct into a bitfield

serde_nested_with

Use serde attributes on nested fields

grappler

function hooking through proc-macros

pit-rust-generator

Portal Interface Types

gen_parser

parsers for gen (Template, Style, Script)

fn-error-context

An attribute macro to add context to errors from a function

wasmworker-proc-macro

Dispatching tasks to a WebWorker without SharedArrayBuffers

kona-common-proc

Proc macro extension for the kona-common crate

ra_ap_hir_def

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

schema

Access the schema for a Rust item

default2

Default implementation using macros

r3bl_core

Helper crate for r3bl_tui and r3bl_tuify crates. Used by workspace in https://github.com/r3bl-org/r3bl-open-core

machine-check-bitmask-switch

Bitmask switch crate for the formal verification tool machine-check

realhydroper-smodel-proc

Semantic modeling for Rust: procedural macros

dioxus-check

Checks Dioxus RSX files for issues

architect-api-schema-builder

Auxiliary crate for building architect-api

clappos

flagless version of Clap that uses argument position for assignment with zero dependencies

prometheus-static-metric

Static metric helper utilities for rust-prometheus

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.

trace

A procedural macro for tracing the execution of functions

drydoc

Keep your doctests DRY with flexible/reusable templates

nextera_jwt

Next Era JSON Web Token Attribute

cast_checks_convert

jni_macro

A macro library for simplifying JNI code generation in Rust, enabling easy execution of Rust code in Java

derive_more_preview

Adds #[derive(x)] macros for more traits

serde_derive

Macros 1.1 implementation of #[derive(Serialize, Deserialize)]

sunbeam-ir

Sunbeams intermediary types used to parse and generate CSS

inttype-enum

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

enum_from_derive

Implement From For the Enumeration

metrics-derive

Proc macro for automatically describing and initializing metrics

diesel-enum-sqltype

derive macro for FromSql and ToSql traits for postgres enums

xmacro

rust macro producing multiple expansions

gen_mk_script_objs

only for support needed structs for gen script and give these structs to the rssyin to handle

rocal-macro

Macros for local-first-development driven web application framework

gensym

Creates unique identifiers for macros using procedural macros

rust2antd

Generate Ant Design table from Rust struct

alisa-proc-macros

Procedural macros for the Alisa framework

macro-string

Eager evaluation of macros like concat! and env!

macro_railroad_annotation

Easily embed macro_railroad images in your docs using this attribute macro!

constime

Zig's comptime for Rust with zero dependencies. Mostly something to play around with until more stuff is const fn.