Lib.rs

strum

macros for working with enums and strings

libsqlite3-sys

Native bindings to the libsqlite3 library

quote

Quasi-quoting macro quote!(...)

proc-macro-crate

Replacement for crate (macro_rules keyword) in proc-macros

syn

Parser for Rust source code

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.

proc-macro2

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

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

paste

Macros for all your token pasting needs

macrotest

Test harness for macro expansion

linkme

Safe cross-platform linker shenanigans

expander

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

serde_tokenstream

A serde deserializer for proc_macro::TokenStreams

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

r2r

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

proc-macro-error2

Almost drop-in replacement to panics in proc-macros

displaydoc

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

delegate

Method delegation with less boilerplate

derive_utils

A procedural macro helper for easily writing derive macros for enums

attribute-derive

Clap like parsing for attributes in proc-macros

proc-macro-warning

Emit warnings from inside proc macros

venial

A very small syn

ctor

__attribute__((constructor)) for Rust

unicode-id-start

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

rstml

Rust templating for XML-based formats (HTML, SVG, MathML) implemented on top of 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

proc-macro2-diagnostics

Diagnostics for proc-macro2

getset

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

derive-getters

boilerplate getters generator

manyhow

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

ra_ap_proc-macro-srv-cli

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

structmeta

Parse Rust's attribute arguments by defining a struct

rustfmt-wrapper

wrapper around rustfmt for use by code generators

utoipauto

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

databake

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

smart-default

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

bevy_macro_utils

A collection of utils for Bevy Engine

k9

rust testing library

dynasm

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

specr-transpile

Converts Specr lang code to Rust

pmutil

Utils for proc-macro

terrars

Terraform in Rust

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

macro_railroad

generate syntax diagrams for Rust macros

derive-deftly

An ergonomic way to write derive() macros

asn1-compiler

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

concat-idents

Allows concatenating multiple identifiers and using them everywhere

unsynn

Proc-macro parsing made easy

pyo3-stub-gen

Stub file (*.pyi) generator for PyO3

template-quote

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

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

messageforge

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

parse-variants

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

proc_macro_roids

Traits and functions to make writing proc macros more ergonomic

tryexpand

Test harness for macro expansion

deluxe

Procedural macro attribute parser

scryer-prolog

A modern Prolog implementation written mostly in Rust

syn-mid

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

derive_setters

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

simple-mermaid

Mermaid diagrams RustDoc integration

ambassador

Trait implementation delegation via procedural macros

clap_derive

Parse command line argument by defining a struct, derive crate

bitmask-enum

A bitmask enum attribute macro

uniffi_meta

proc-macro-rules

Emulate macro-rules pattern matching in procedural macros

function_name

macro that expands to the name of the annotated function

docify

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

proc-macro-utils

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

syn-helpers

Framework for building derive macros

fv-template

Field-value based string templating

is-macro

Derive methods for using custom enums like Option / Result

do-with-in

A template language for Rust metaprogramming using partial staging

frunk_proc_macro_helpers

Common internal functions for frunk's proc macros

wadl

parser for Rust

prost-derive

Generate encoding and decoding implementations for Prost annotated types

stability

Rust API stability attributes for the rest of us

maybe-async-cfg

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

jnix

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

cargo-hax

The high assurance translation toolchain

dbg-pls

Syntax aware pretty-printing debugging

pearlite-syn

A syn parser for the Pearlite specification language

curve25519-dalek-derive

curve25519-dalek Derives

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

dsl_auto_type

Automatically expand query fragment types for factoring as functions

derive-syn-parse

Derive macro for syn::parse::Parse

rstml-control-flow

Custom nodes with control flow implementation for rstml. Usefull when you need to implement If, For, etc.

dioxus-rsx

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

safe-proc-macro2

A fork of proc_macro2 crate with unsafe code removed

genemichaels

Makes your code formatty

call2-for-syn

Apply parser functions to proc-macro2 token streams

percpu

Define and access per-CPU data structures

protobuf-build

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

github-languages

All GitHub's supported languages

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.

rustifact

A seamless bridge between a build script and the main crate

unique-type-id

A unique id proc-macro generator for types

quote2

An alternative lightweight version of quote

int-enum

A derive macro for conversion between integer and enum types

rustfmt_if_chain

An if_chain-aware rustfmt (kind of)

rem-utils

Extraction Maestro

chalk-derive

A helper crate for use by chalk crates for derive macros

safe-quote

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

eiffel

language inspired guard clauses with Rust macros

form

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

diol

benchmark lib

swift-bridge-ir

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

vercel_runtime_router

Vercel Rust Function Runtime Router

pax-lang

Pax language parser

test-generator

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

ewe-logs

Logging package macros that call tracing crate underneath, used in the eweplatform crate

r2a

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

synthez

Steroids for syn, quote and proc-macro2 crates

as_derive_utils

private derive utilities used by abi_stable and structural

napi-derive-backend

Codegen backend for napi procedural macro

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.

quote-use

Support use in procmacros hygienically

quasiquote

quote compatible quasiquote macro with support for interpolating expressions

makepad-micro-proc-macro

Makepad micro proc macro util lib

krpc-client

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

ra_ap_proc_macro_api

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

napi_sym

proc macro for writing N-API symbols

glib-macros

Rust bindings for the GLib library, proc macros crate

workflow-macro-tools

Macro utility functions used by the workflow-rs framework

positional

author/parse positional files

malloc_size_of_derive

Firefox memory reporting, not intended for external use

spl-discriminator-syn

Token parsing and generating library for the spl-discriminator library

wasmtime-versioned-export-macros

Macros for defining versioned exports in Wasmtime

actix-multipart-derive

Multipart form derive macro for Actix Web

proc-quote

A procedural macro implementation of quote!

impl-tools

Helper macros: autoimpl

swc_eq_ignore_macros

Macros for EqIgnoreSpan and TypeEq

gengo

Get the language distribution stats of your repository

rand_derive2

Generate customizable random types with the rand crate

twust

Static checker for tailwindcss class names in rust for rust

pit-rust-generator

Portal Interface Types

simpl_cache

caching tools

futures-macro

The futures-rs procedural macro implementations

symbols

Proc-macro utility to populate enums from database data

test_each_file

Generates a test for each file in a specified directory

derive_deref

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

extendable-data

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

napi-derive-backend-ohos

Codegen backend for napi-harmony procedural macro

strum_macros

macros for working with enums and strings

tokenstream2-tmpl

Runtime TokenStream interpolation for Rust macros

argp

Derive-based argument parser optimized for code size

reflect

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

biscuit-parser

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

native-windows-derive

A very light and simple rust GUI library

zksync_protobuf_build

ZKsync consensus protobuf codegen

sea-bae

proc-macro attribute parser

contracts-try

Design-by-contract attributes

volo-build

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

jacklog

Easy way to get logging the way Jack always wants anyway

rusty-bind-parser

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

vtable_gen

A C++-ABI VTable Generator for Rust

re_types_builder

Generates code for Rerun's SDKs from flatbuffers definitions

vba_extract

extract a vbaProject.bin binary from an Excel xlsm macro file for insertion into an rust_xlsxwriter file

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.

derive-adhoc

An ergonomic way to write derive() macros

scopegraphs-regular-expressions

A well-documented port of scopegraphs to Rust

common-error-build

High performance universal error code management for Rust in Rust

defamed

Default, positional and named parameters

rust2antd

Generate Ant Design table from Rust struct

better_default

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

rust-decouple

ease the process of parsing environment variables

lombokrs

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

async-generic

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

syn_derive

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

command-rpc

cli crate and api for replacing rpc

stageleft

Type-safe staged programming for Rust

serde_default

Generate a Default impl using serde attributes

mantra-rust-macros

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

drylib

Rust macro-library for Don't Repeating Yourself

rem-extract

Providing extract method capability for the REM toolchain

function-wrapper

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

deno_ops

Proc macro for writing Deno Ops

iso-rs

query ISO data, which includes countries, currencies, etc

checked-rs-macro-impl

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

include_proc_macro

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

ocaml-build

OCaml code generation

macroific

Proc macro development utilities

reflected

Something like reflection

dict_derive

Derive macros for some PyO3 traits to convert python dicts into rust structs

cargo-cabal

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

contracts

Design-by-contract attributes

from-attr

that makes it easy to parse attributes

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

dupit

copy or clone a value

macro-field-utils

work with darling fields

machine-check-machine

Machine crate for the formal verification tool machine-check

savvy-bindgen

Parse Rust functions, and generate C and R code

extruct

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

penum

Make enum conform to a given pattern

catalytic_query_parser

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

command_attr

Procedural macros for command creation for the Serenity library

assert_type_match

Statically assert that a type matches another type

aws-dynamo-derive

Helper crate for aws-sdk-dynamodb

opimps

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

jsonrpc-derive

High level, typed wrapper for jsonrpc-core

kira_qqbot

KiraFramework proc macro

surreal_derive_plus

Query builder for surrealdb

netsblox-extension-util

Allows for automatic generation of a NetsBlox extension that uses WASM

moosicbox_env_utils

MoosicBox env utilities package

timrs_macro_utils

Macro helpers for Tim.rs

pax-language-server

Language Server for Pax Language

enumber

Provide useful impls on numerical enums

fn-decorator

contains macros for implementing wrapper functions around member or static functions

no-panic

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

macrors

custom macro library in Rust

flamer

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

micro_games_macros

macros to make it easier to build complex systems with Bevy

telety

Access type information across crates and modules in your proc macros

proc_macro2_helper

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

fieldx_aux

Various types and tools useful for fieldx crates and, potentially, to users of fieldx

tailwag_macro_logic

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

winter-maybe-async

sync/async macro for winterfell

juniper_codegen

Code generation for juniper crate

doc_consts

get doc comments on fields as runtime constants

attr-parser-fn

parse attribute procedual macros in functional way

pack_bools

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

syn-prelude

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

sdf-macros

SDF macros

typed-i18n-support

Support crate for the derive macro for typed-i18n

syn-impersonated

Parser for Rust source code

expand-mod

Expand mod module_name; in .rs files and combine the module tree consisting of multiple files into a single file

trace

A procedural macro for tracing the execution of functions

opentalk-proc-macro-fields-helper

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

cssparser-macros

Procedural macros for cssparser

frc42_macros

Filecoin FRC-0042 calling convention procedural macros

EasyAlgolia

EasyAlgolia is a Rust crate designed for utilizing the Algolia admin client. It simplifies the process of updating and inserting documents into Algolia's search index.

property

Generate several common methods for structs automatically

embed-licensing

Embed licensing information of dependencies to comply with free software licenses

crud-api-endpoint

CLI generator for your API. Enpoint description

sunbeam-ir

Sunbeams intermediary types used to parse and generate CSS

codde_protocol

Multi Communication protocol in heart of the C.O.D.D.E. Pi framework

string_cache_codegen

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

modus_ponens

develop forward chaining inference engines

necessist-backends

pesticide

ORM for CC based on pest

trustfall_stubgen

Generate a Trustfall adapter stub for a given schema

makepad-widgets

Makepad widgets

swimos_macro_utilities

SwimOS Macro Utilites

upgrayedd

Ergonomic function interposition in Rust

stageleft_tool

Helper macros for the stageleft crate

needs_env_var

Skip compilation if environment variable is missing

metrics-derive

Proc macro for automatically describing and initializing metrics

yewlish-fetch

A macro for generating Yew fetch API bindings

ct-python

Execute Python code at compile time to generate Rust code

ra_ap_hir_def

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

gradio_macro

A macro for generating Gradio interfaces

spread_macros

Macros around an extended spread syntax

opendp_tooling

Tooling for proc-macros and code generation

validated_struct

Easily generate nested structures with getters and predicated setters

serde_derive

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

mosaic-derive

proc-macro for the mosaic crate

syn-file-expand

load full source code of multi-file crates

apidoc-attr

Apidoc attr

ferment

Syntax tree morphing of FFI-compatible stuff

std-reset

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

machine-check-bitmask-switch

Bitmask switch crate for the formal verification tool machine-check

windows-interface

The interface macro for the windows crate

newtyperef

generate custom newtype reference types

structstruck

Nested struct and enum definitions

stak-macro-util

Macro utilities for Stak Scheme

hydroflow_lang

Hydroflow's Surface Syntax implementation

vermouth

a new kind of parser for procedural macros

grappler

function hooking through proc-macros

derive_util

tools for derive macros

instance_code

Turn instances into source code

ragkit_convex_macros

Macros to help make Convex in Rust nice

derive-elves

Writing inclusive derive macros is tedious, this creates provides helper functions that make it easier

rem-controller

Non-local control flow repairer for Rusty Extraction Maestro

flexpect

Attribute macro that falls back to #[allow] if #[expect] is not supported

actix_async_handler

Support for async syntax for Actix

prometheus-static-metric

Static metric helper utilities for rust-prometheus

triton-constraint-builder

Emits efficient code from Triton VM's AIR

couchbase-lite-core-sys

Native bindings to the couchbase-lite-core library

typed-fields

A collection of macros that generate newtypes

bomboni_prost

working with prost. Part of Bomboni library.

proc-macro-assertions

Easily create asserts on proc macro inputs

cfg_eval

#[cfg_eval] in stable Rust 🙃

hax-lib-macros-types

Hax-internal types

diesel_as_jsonb

Use your structs as Jsonb with diesel and PG

macro_types

easier to create procedural macros

vodca

Reduce boilerplate when writing DDD codes

tauri-ipc-macros

IPC bindings for using Tauri with a Rust Frontend (e.g. leptos)

serde_keyed_derive

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

specialized-dispatch

dispatching specialized versions of a function

mainstay-syn

Mainstay syntax parsing and code generation tools

schemafy_lib

Generates serializeable Rust types from a json schema

rtlola-hir

A high-level intermediate representation for RTLola specifications

synext

extension library for syn crate to help developers quickly develop derive macros

windows-implement

The implement macro for the windows crate

schema

Access the schema for a Rust item

znap-syn

Collection of utilities for parsing and code generation that power znap-macros

derive_more_preview

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

sgxs-tools

working with the SGX stream format

EnumBitFlags

EnumBitFlags is an implementation of flags support for enums

swc_visit_macros

Visitor generator for stable rustc

gensym

Creates unique identifiers for macros using procedural macros

quic-rpc-macros

quic-rpc库的高级封装

null-terminated

slices and UTF-8-encoded strings with thin references

mpst-seq

DEPRECIATED: A library with macro for mpstthree

code-product

macro producing multiple expansions

code-product-lib

macro producing multiple expansions

timrs_hkt_macro

Rust Higher-Kinded Types emulation procedural macros

chandeliers-san

AST definition and static analysis procedures of Candle

packed_struct_codegen

implements the code generation for the packed_struct library

ssa-rust

SSA to Rust converter

serde_nested_with

Use serde attributes on nested fields

rglw_codegen_utils

Root project for all the utilities that rustyglware offers to the community

tokio-wrap

run asynchronous code within synchronous functions

unit-enum

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

progenitor-macro

An OpenAPI client generator - macros

noop_proc_macro

No-op proc_macro, literally does nothing

after-test

A procedural macro that allows you to run a clean up function after each test from a test module

sneks

macros for naming enum variants

eagle

creating RPC protocols

axum_grants

A set of attribute macros for protecting Axum URI resources

find-crate

Find the crate name from the current Cargo.toml

easyfix-messages-gen

Easy FIX (Financial Information Exchange) toolset - messages generator

fn-error-context

An attribute macro to add context to errors from a function

apidoc-expand

Apidoc expand

parquetry-gen

Parquet code generator

zoo-endpoint

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

clappos

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

Boot-Banner

An elegant banner library that enhances project launches with eye-catching terminal displays and helpful assistance

jni_fn

JNI-compatible method signature generator

despatma-lib

Common tokens for Despatma

atri_plugin

AtriPlugin

a0

generate structs and their values from external data

tiny-rsx

A fast and minimal syn RSX (JSX in Rust) parser

clap_config

Automatically merge CLI args, environment variables, config files, and default values in clap apps

derive-into-owned

Custom derives to help with types containing Cow fields

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.

macro_optim

procedural macro crate for optimizing and simplifying various expressions at compile time

autogen

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

place_macro

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

aws-sdk-compile-checks-macro

Macros that add compile time checks to the AWS SDKs

duchess-reflect

Internal component of duchess crate

variantly

Derive helper methods for enum variants that are familiar from std::option::Option & std::result::Result such as unwrap_or or and_then

dynex

Inherit and derive object-unsafe traits for dynamic Rust

racc

port of Berkeley YACC to Rust, and allows you to write grammar definitions directly in Rust source code

syn-rsx

syn-powered parser for JSX-like TokenStreams

compile-time

Macros for getting compile time information

gandiva_rust_udf_build

A basic shared library for gandiva rust udf

enum_from_derive

Implement From For the Enumeration

fire

fire implementation for rust

enum-kinds

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

proc-macro-faithful-display

A Display implementation for proc-macro types more faithful to the input stream

procout

Output a proc macro's TokenStream to a file

inttype-enum

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

kproc-parser

minimal procedural macros parser that produce a convenient AST by including only the necessary code

macroific_attr_parse

Attribute parsing utilities for the macroific crate

bool_to_bitflags

compact multiple bools into a single bitflags field automatically with getters and setters

set_builder

A procedural macro to create Iterators over a set defined by Haskell-inspired set-builder notation

onionpack

Unpack your structs into DTOs, Entities and Schemas

c-like-concat

macro that works just like C's ##

confused

treat scary functions with the respect they deserve

custom_attrs

that allows you to configure values specific to each variants of an enum

rkyv-with

Third-party derive macro for rkyv's *With traits

jaffi

Support for the jaffi code generator

time_this

two macros to quickly time functions for debugging purposes

into-jsvalue-derive

derive into-jsvalue for enum return values in async wasm_bindgen functions

rust-oop

use macro to implement inheritance

arc-trait

Automagically implement any trait for Arc<T>

lucidity

A distributed orchestrator platform for Rust