Lib.rs

syn

Parser for Rust source code

proc-macro-error

Almost drop-in replacement to panics in proc-macros

quote

Quasi-quoting macro quote!(...)

proc-macro-crate

Replacement for crate (macro_rules keyword) in proc-macros

strum

Helpful macros for working with enums and strings

derive_more

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

ctor

__attribute__((constructor)) for Rust

enum_dispatch

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

proc-macro2

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

delegate

Method delegation with less boilerplate

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.

hex-literal

Procedural macro for converting hexadecimal string to byte array at compile time

derive_builder_core

Internal helper library for the derive_builder crate

getset

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

serde_tokenstream

A serde deserializer for proc-macro TokenStreams

derive-new

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

enum-as-inner

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

doc-comment

Macro to generate doc comments

unicode-ident

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

displaydoc

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

syn-rsx

syn-powered parser for JSX-like TokenStreams

futures-macro

The futures-rs procedural macro implementations

paste

Macros for all your token pasting needs

macrotest

Test harness for macro expansion

venial

A very small syn

moveit

A library for safe, in-place construction of Rust (and C++!) objects

wasm-bindgen-macro-support

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

utoipa-gen

Code generation implementation for utoipa

diesel_derives

You should not use this crate directly, it is internal to Diesel

ambassador

Trait implementation delegation via procedural macros

tinyvec_macros

Some macros for tiny containers

as_derive_utils

private derive utilities used by abi_stable and structural

git-testament

Record git working tree status when compiling your crate

proc-quote

A procedural macro implementation of quote!

cstr

Macro for building static CStr reference

expander

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

const-random

Provides compile time random number generation

casper-node-macros

A macro to create reactor implementations for the casper-node

structmeta

Parse Rust's attribute arguments by defining a struct

dylint_linting

Utilities for writing Dylint libraries

databake

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

bitmask-enum

A bitmask enum attribute macro

darling_core

Helper crate for proc-macro library for reading attributes into structs when implementing custom derives. Use https://crates.io/crates/darling in your code.

concat-idents

Allows concatenating multiple identifiers and using them everywhere

worker-macros

Macros to support the worker crate and remove FFI boilerplate / conversion from user code

derive_utils

A procedural macro helper for easily writing derive macros for enums

protobuf-build

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

napi-derive-backend

Codegen backend for napi procedural macro

multihash-derive

Proc macro for deriving custom multihash tables

is-macro

Easily create methods for to use yout custom enum like Option / Result

bit-struct

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

wasmer-derive

Wasmer derive macros

dlib

Helper macros for handling manually loading optional system libraries

test-generator

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

usdt-macro

Procedural macro for generating Rust macros for USDT probes

biscuit-parser

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

amplify_syn

Amplifying syn capabilities: helper functions for creating proc macro libraries

yew-router-macro

Contains macros used with yew-router

smart-default

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

derive-getters

Simple boilerplate getters generator

zoet

Adds #[zoet] macro to reduce boilerplate when implementing common traits

serde-enum-str

Serialize and deserialize enum string

arrow2_convert_derive

Proc macros for arrow2_convert

clap_derive

Parse command line argument by defining a struct, derive crate

fltk-derive

Rust bindings for the FLTK GUI library

miette-derive

Derive macros for miette. Like thiserror for Diagnostics.

command-macros

Macros for creating std::process::Command with shell-like syntax

impl-tools

Helper macros: autoimpl

struct-field-names-as-array

Provides a procedural macro that generates an array of the field names of a named struct

crepe

Datalog in Rust as a procedural macro

genemichaels

Makes your code formatty

macro-machines

State machine macros with logging and graphviz DOT file generation

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

huber-procmacro

Internal package used by Huber

swift-bridge-macro

Powers swift-bridge module code generation

strum_macros

Helpful macros for working with enums and strings

leptos_macro

view macro for the Leptos web framework

prometheus-static-metric

Static metric helper utilities for rust-prometheus

unicode-id-start

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

rsbind

Provide tools to bind rust trait with other language and export library artifact directly. Invoke rust functions just like you write it in native language.

rand_derive2

Generate customizable random types with the rand crate

napi-derive

N-API procedural macros

testing_macros

General purpose testing macros

ff_ce

Library for building and interfacing with finite fields

dbg-pls

Syntax aware pretty-printing debugging

r3bl_rs_utils_macro

Internal support for a proc-macro library for reading attributes into structs when implementing custom derives. Use https://crates.io/crates/r3bl_rs_utils in your code.

schemars_derive

Macros for #[derive(JsonSchema)], for use with schemars

display_json

Procedural macros for implementing Display, Debug and FromStr for (de)serializing json strings

syn-helpers

Framework for building derive macros

dioxus-core-macro

Core macro for Dioxus Virtual DOM

jnix

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

com_macros_support

Support library for COM crate macros

sqlx-macros

Macros for SQLx, the rust SQL toolkit. Not intended to be used directly.

migrations_macros

Codegeneration macros for diesels embedded migrations

vectrix-macro

A macro for composing matrices

prost-derive

A Protocol Buffers implementation for the Rust Language

sauron-component-macro

An html library for building client side webapps

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

deno_ops

Proc macro for writing Deno Ops

rquickjs-macro

Procedural macros for rquickjs

devise

A library for devising derives and other procedural macros

saphir_macro

Macro generation for http server framework

argp

Derive-based argument parser optimized for code size

windows-implement

The implement macro for the windows crate

markup-proc-macro

A blazing fast, type-safe template engine for Rust

string_cache_codegen

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

reflect

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

proc_macro_roids

Traits and functions to make writing proc macros more ergonomic

maybe-async-cfg

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

ast2str

A crate for pretty-printing ASTs and other recursive data structures

symbols-models

Proc-macro utility to populate enums from database data (shared traits)

rust-i18n-macro

Macro for rust-i18n crate

num_enum_derive

Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)

wai-bindgen-wasmer-impl

Generate WAI glue for a Rust Wasmer host

rustler_codegen

Compiler plugin for Rustler

attribute-derive

Clap for proc macro attributes

asn1-compiler

ASN.1 Compiler in Rust

sauron-node-macro

An html library for building client side webapps

ouroboros_macro

Proc macro for ouroboros crate

deluxe

Procedural macro attribute parser

napi_sym

proc macro for writing N-API symbols

parse-display-derive

Procedural macro to implement Display and FromStr using common settings

safe-quote

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

ra_ap_proc-macro-srv-cli

TBD

find-crate

Find the crate name from the current Cargo.toml

metamorphose

Macros collection for converting Structure to Model, for a green-barrel project

prometheus-client-derive-text-encode

Auxiliary crate to derive text Encode trait from prometheus-client

derive_deref

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

wai-bindgen-rust-impl

Generate WAI glue for a Rust guest

bae

A Rust proc-macro attribute parser

const-random-macro

Provides the procedural macro used by const-random

debugger_test

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

argh_derive

Derive-based argument parsing optimized for code size

from_variant

Automatically derive From impls for enums

inventory-impl

Implementation of macros for the inventory crate

gettext-macros

A few proc-macros to help internationalizing Rust applications

dioxus-rsx

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

qmetaobject_impl

Custom derive for the qmetaobject crate

simd-json-derive-int

procmacros for simd-json-derive

diesel_filter_query

Procedural macros for Diesel filter

microsoft-directx

Rust bindings for the latest DirectX (Agility SDK) headers

self-rust-tokenize

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

defmt-macros

defmt macros

thiserror-core-impl

Implementation detail of the thiserror crate

katexit

Insert KaTeX autorender script into rustdoc

rustfmt-wrapper

Library wrapper around rustfmt for use by code generators

stronghold-derive

Proc macros and derives for Stronghold

dynasm

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

asn1_codecs_derive

ASN.1 Codecs derive Macros

uucore_procs

uutils ~ 'uucore' proc-macros

packed_struct_codegen

This crate implements the code generation for the packed_struct library

EnumBitFlags

EnumBitFlags is an implementation of flags support for enums

proc-bitfield

A crate to expressively declare bitfield-like structs

gdnative-impl-proc-macros

Internal dependency of the gdnative bindings

derive-syn-parse

Derive macro for syn::parse::Parse

serde-intermediate-derive

Derive proc macro for intermediate representation of Serde serialization

actix-web-codegen

Routing and runtime macros for Actix Web

indoc-impl

Indented document literals

frunk_derives

frunk_derives contains the custom derivations for certain traits in Frunk

validated_struct

Easily generate nested structures with getters and predicated setters

test-fuzz-macro

opaque_typedef

Supports defining opaque typedefs

packable-derive

Derive macro for the packable crate

parquet_derive

Derive macros for the Rust implementation of Apache Parquet

jsonrpsee-proc-macros

Procedueral macros for jsonrpsee

sort_by_derive

Derive macro SortBy and helper macros EnumAccessor and EnumSequence, deriving traits Ord, PartialOrd, Eq, PartialEq and Hash for structs and enums that can’t automatically derive from those traits

vtable-macro

Helper crate to generate ffi-friendly virtual tables

property

Generate several common methods for structs automatically

ext-php-rs-derive

Derive macros for ext-php-rs

nekosbest

nekos.best API wrapper

darling_macro

Internal support for a proc-macro library for reading attributes into structs when implementing custom derives. Use https://crates.io/crates/darling in your code.

quote_into

Easily & efficiently generate code by quoting it in a macro

statig_macro

Macro’s for statig

zerocopy-derive

Custom derive for traits from the zerocopy crate

oso-derive

macros for oso, an open source policy engine for authorization that’s embedded in your application

typify-macro

typify macro implementation

conjure-codegen

Rust code generation for Conjure definitions

semester

High efficiency classnames macro

trace

A procedural macro for tracing the execution of functions

sqlx-type

Typed sql macros for sqlx

mwt

proc macros for generating mut and non-mut methods without duplicating code

swc_macros_common

Common utilities for swc macros

wa-serde-derive

serde_derive compiled to wasm

relm-gen-widget

Utility crate for relm-attributes and relm-derive

web_macro

A library for interacting with the web browser

cameleon-impl-macros

Utilities used by other cameleon crates implementation

synom

Stripped-down Nom parser used by Syn

microsoft-direct3d

Rust bindings for the latest DirectX (Agility SDK) headers

enum-display-derive

Display trait's custom derive for simple enums

clippy-mini-macro-test

A macro to test clippy's procedural macro checks

form

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

worker-plus-macros

Macros to support the worker crate and remove FFI boilerplate / conversion from user code

cffi

Safe* C FFI interface generation

wasm-bindgen-macro

Definition of the #[wasm_bindgen] attribute, an internal dependency

typify-impl

typify backend implementation

serde_derive

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

fortuples

Procedural macros to generalize inherent and trait implementations over tuples

pmutil

Utils for proc-macro

test-shisho-policy-sdk

This is the SDK of Shisho Cloud policies to write your custom policies in Rust

pgx-utils

Utility functions for 'pgx'

kmacros

Useful macros

lazy-regex-proc_macros

proc macros for the lazy_regex crate

early_returns

Macros to make early returns easier to work with in Rust

syntactic-for

A syntactic 'for' loop macro

rkyv_derive_test

Derive macro for rkyv

wasmbus-macros

derive macros for wasmbus-rpc

integral-enum

Simple way to define integer-like enums

macro_state

A set of macros allowing storing and loading global state at compile-time within proc macros

safe-proc-macro2

A fork of proc_macro2 crate with unsafe code removed

fix-hidden-lifetime-bug-proc_macros

Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue

ractor_cluster_derive

Derives for ractor_cluster

vehicle-signals

DDS topics (for cyclonedds-rs) created from GENIVI/W3C Vehicle Signal Specification

ra_ap_proc_macro_srv

TBD

surge-macros

surge synthesizer -- common macros

arg_enum_proc_macro

A procedural macro compatible with clap arg_enum

structmapper-codegen

A library to help you generate code that mapped one struct to another

dropshot_endpoint

macro used by dropshot consumers for registering handlers

proc-macro-error-attr

Attribute macro for proc-macro-error crate

rustfmt-config_proc_macro

A collection of procedural macros for rustfmt

cw-storage-macro

Macro helpers for storage-plus

safe-regex-macro

Macro for the safe-regex package

quote-doctest

A simple doctest generator for quote

celery-codegen

Macros for rusty-celery

juniper_codegen

Internal custom derive trait for Juniper GraphQL

assertx

Additional test assertions

linkme-impl

Implementation detail of the linkme crate

wai-bindgen-wasmtime-impl

Generate WAI glue for a Rust Wasmtime host

edgedb-derive

Derive macros for EdgeDB database client

syn-mid

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

positional

A library to author/parse positional files

thiserror-impl

Implementation detail of the thiserror crate

nom-rule

A procedural macro for defining nom combinators in simple DSL

derive_validator

Derive macros for the Validate trait of validify

thiserror-impl-no-std

Implementation detail of the thiserror crate

unzip-n

Procedural macro to generate unzip for iterators over n-sized tuples

bevy_ecs_macros

Bevy ECS Macros

bevycheck

Helpful bevy error messages by proc-macro

nacos-macro

Nacos's proc macros

lofty_attr

Macros for Lofty

serde_derive_state

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

dummy

Macros implementation of #[derive(Dummy)]

pgx-pg-sys

Generated Rust bindings for Postgres internals, for use with 'pgx'

standalone-syn

Fork of syn that turns of the proc-macro feature in proc-macro2 and standalone-quote so as to remove the rustc dylib dependency

askama_shared

Shared code for Askama

bagel

Compile-time evaluation and other tools

usdt-attr-macro

Procedural macro for generating Rust macros for USDT probes

hackfn

Fake implementation of std::ops::Fn for user-defined data types

retry_macro

A set of declarative macros which retries executing a function upon failure

nameless-clap_derive

Parse command line argument by defining a struct, derive crate

devise_codegen

A library for devising derives and other procedural macros

quote-use

Support use in procmacros hygienically

diesel_as_jsonb

Use your structs as Jsonb with diesel and PG

macro_rules_attribute-proc_macro

Use declarative macros as proc_macro attributes or derives

thruster-socketio-proc

The proc macros behind the thruster web framework

mybatis-macro

mybatis macro driver

tabled_derive

Derive macros which is used by tabled crate

dysql-macro

Dysql is a rust crate that do dynamic-sql query through proc-macro, it bases on tokio-postgres (default feature) and sqlx crate

modus_ponens

Library to develop forward chaining inference engines

hex-literal-impl

Internal implementation of the hex-literal crate

swc_plugin_macro

Macro support for authoring plugin's transform fn

binrw_derive

Derive macro for binrw

hkalbasi-rustc-ap-rustc_macros

Automatically published version of the package rustc_macros in the hkalbasi/rust repository from commit 56126fb149ea810db234e210893833e97a5c8e36 The publishing script for this crate lives at: https://github…

cassandra_macro_derive

Macros 1.1 implementation of #[derive(Cassandra)]

unroll

An attribute-like procedural macro for unrolling for loops

autd3-traits

Wav Modulation for AUTD

aquamarine-demo-crate

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

generic-bytes-derive

A macro for derivation of SizedBytes, a trait for conversion to and from an array of bytes with a type-level size

mry_macros

Macro crate for mry, a simple but powerful mocking library that supports struct, trait, and function

html-macro

html macro

cynic-codegen

Codegen for cynic - a GraphQL query builder & data mapper for Rust

edgedb-query-derive

Crate that provide a bunch of derive macros that help to build EdgeDB query using edgedb-tokio crate

r18-trans-support

r18 translation support

unimock_macros

Procedural macros used by unimock

slint-macros

Macro helper for slint crate

swc_trace_macro

Proc macro for performance trace of swc

soroban-sdk-macros

Soroban SDK macros

native-json-macro

Native JSON for Rust

cypher_derive

A flexible and intuitive query builder for Neo4j and Cypher

pub-sub-client-derive

Google Cloud Pub/Sub client library

from-to-repr

Derives TryFrom and From implementations for the representation type of a Rust enumeration

sqlxmq_macros

Procedural macros for sqlxmq

config_parser_derive

A proc-macro for implementing ConfigParser trait of config_parser library

snafu-derive

An ergonomic error handling library

opendp_tooling

Tooling for proc-macros and code generation

vtable_gen

A C++-ABI VTable Generator for Rust

derive-env-url

Derives for env-url

surrealdb-derive

Private implementation of procedural macros for surrealdb

template-quote

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

sscanf_macro

Proc-Macros for the sscanf Crate. Not meant to be used as a standalone Crate

jsonrpc-derive

High level, typed wrapper for jsonrpc-core

relm-derive

Custom derive required by the relm crate

command_attr

Procedural macros for command creation for the Serenity library

tylift

Lift enum variants to the type-level

kube-derive

Custom derives for the kube kubernetes crates

wasmedge-macro

The procedural macros for WasmEdge Rust bindings

execute_evcxr

A library for execution of evcxr-supported syntax via building and executing a binary crate

catalytic_table_to_struct

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

clapi

A framework for create command-line applications

flowmacro

Definition of a 'flow' attribute macro to help write implementations

portrait-framework

Framework for implementing portrait fillers

shuttle-codegen

Proc-macro code generator for the shuttle.rs service

dynamodb-helper

Macro that creates a struct for interacting with AWS DynamoDB

rtlola-macros

Procedural macros for more convenient handling of HirModes in the rtlola_hir crate

build-deps

Rust build-script dependencies generator for data/IDL files

awint_macro_internals

Internal macro utilities for the awint system of crates

nova-macro

Implementation for nova crate

remoc_macro

Procedural macros for Remoc

syn_util

helper APIs for procedural macros

alt_serde_derive

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

better-bae

A Rust proc-macro attribute parser

derive_validify

Derive macros for the Validify trait of validify

cps

Assists in the creation of readable and maintainable macro_rules! macros

ra_ap_proc_macro_api

TBD

syn-impersonated

Parser for Rust source code

structstruck

Nested struct and enum definitions

sea-strum

Helpful macros for working with enums and strings

bytes-lit

Create byte slices from literal integers

peg-macros

Procedural macros for rust-peg. To use rust-peg, see the peg crate.

catalytic_query_parser

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

chalk-derive

A helper crate for use by chalk crates for derive macros

sunfish_macro

Web Application Build Tool

derive-into-owned

Custom derives to help with types containing Cow fields

a2lmacros

provides macros in support of the a2lfile crate

windows-interface

The interface macro for the windows crate

dhall_proc_macros

Macros for dhall

rkyv_derive

Derive macro for rkyv

kmacros_shim

Useful macros

workflow-macro-tools

Macro utility functions used by the workflow-rs framework

validify

An extension of the validator crate that enables payload modification

build-info-proc

Part of the build-info crate: This crate provides the proc-macros

scroll_derive

A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate

uniffi_macros

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

lalrproc

Procedural macro built on LALRPOP

syn-file-expand-cli

CLI tool to read full source code of multi-file crates and output it to stdout

actix-helper-macros

Helper macros to make life easier developing actix-web applications

no-panic

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

struct-arithmetic

Provides a Trait to derive basic arithmetic operations for your structs

test-span-macro

macro to do snapshot tests on tracing spans, usint test-span

ref-cast-impl

Derive implementation for ref_cast::RefCast

test-results

A series of utility macros for outputting testing results

macro_railroad

A library to generate syntax diagrams for Rust macros

validator_derive

Macros 1.1 implementation of #[derive(Validate)]

libcnb-proc-macros

Procedural macros used within libcnb.rs

beady

A macro for writing tests in a Behaviour Driven (BD) style

bonfida-macros

Bonfida-utils macros

libipld-cbor-derive

ipld cbor codec proc macro

makepad-micro-proc-macro

Makepad micro proc macro util lib

wasmedge-bindgen-macro

Pass string, vec and primitive types from host to webassembly

s_test_fixture

s_test_fixture or simple test fixture is a macro library to implement test fixture with no hassle

diesel_enum_derive

Simple Enum derive for [Postgres only] Varchar fields

classic-bitfield

A bitfield enum with a classic feel

enum-kinds

Generate enums with matching variants but without any of the associated data

procedural-masquerade

macro_rules for making proc_macro_derive pretending to be proc_macro

memoize-inner

Helper crate for memoize

static_init_macro

Attribute macros for static_init crate

renum

From and TryFrom trait derive with customization

abomonation_derive

A custom derive plugin for abomonation

pen-ffi-macro

FFI macro library for Pen programming language

der-oid-macro

Macro to encode DER oids at compile time

thirtyfour-querier-derive

#[derive(Querier)] macro for thirtyfour WebDriver library

sierra-proc

Procedural macros for 'sierra' crate

async-stream-impl

proc macros for async-stream crate

bytes-cast-derive

Safely re-interpreting &[u8] bytes as custom structs without copying, for efficiently reading structured binary data. Procedural macro for compile-time soundness checking.