Lib.rs

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

quote

Quasi-quoting macro quote!(...)

synstructure

Helper methods and macros for custom derives

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

macrotest

Test harness for macro expansion

serde_tokenstream

A serde deserializer for proc_macro::TokenStreams

proc-macro2

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

safer-ffi

Write safer FFI code in Rust without polluting it with unsafe code

unicode-id-start

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

dylo-cli

Generate dyn-compatible traits with proc macros

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

attribute-derive

Clap like parsing for attributes in proc-macros

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

pyo3-stub-gen

Stub file (*.pyi) generator for PyO3

memoize

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

virtue

A sinless derive macro helper

getset

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

rstml

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

ra_ap_project_model

A representation for a Cargo project for rust-analyzer

specr-transpile

Converts Specr lang code to Rust

derive-getters

boilerplate getters generator

proc-macro2-diagnostics

Diagnostics for proc-macro2

macro_tools

Tools for writing procedural macroses

safe-quote

Quasi-quoting macro quote!(...)

duplicate

macros for duplication of code with variable substitution

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

pyo3-polars

Expression plugins and PyO3 types for polars

derive-new

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

git-ignore-generator

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

derive-deftly

An ergonomic way to write derive() macros

jid

struct for Jabber IDs

dynasm

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

simple-mermaid

Mermaid diagrams RustDoc integration

wasm-bindgen-backend

Backend code generation of the wasm-bindgen tool

argp

Derive-based argument parser optimized for code size

smart-default

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

manyhow

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

document-features

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

rustfmt-wrapper

wrapper around rustfmt for use by code generators

jsonrpsee-proc-macros

Procedueral macros for jsonrpsee

enum-as-inner

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

dyn-clonable

Attribute wrapper for dyn-clone

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

server_fn_macro

RPC for any web framework

databake

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

parse-variants

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

arr_macro

Initialize arrays with ease!

macro_railroad

generate syntax diagrams for Rust macros

test-with

A lib help you run test with condition

forest

Explore and summarise Rust projects

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.

windows-bindgen

Code generator for Windows metadata

function_name

macro that expands to the name of the annotated function

clap_derive

Parse command line argument by defining a struct, derive crate

ambassador

Trait implementation delegation via procedural macros

derive_setters

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

validated_struct

Easily generate nested structures with getters and predicated setters

twust

Zero-config Static type-checker for Tailwind CSS

ra_ap_test_utils

Assorted testing utilities for rust-analyzer

docify

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

awint_macro_internals

Internal macro utilities for the awint system of crates

proc_macro_roids

Traits and functions to make writing proc macros more ergonomic

zoet

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

unsynn

(Proc-macro) parsing made easy

bitmask-enum

A bitmask enum attribute macro

yew-fmt

Code formatter for the Yew framework

syn-ext

Human friendly or editable extension for syn

necessist-frameworks

pearlite-syn

A syn parser for the Pearlite specification language in Creusot

deluxe

Procedural macro attribute parser

genemichaels

Makes your code formatty

proc-bitfield

expressively declare bitfield-like structs

structmeta

Parse Rust's attribute arguments by defining a struct

testutils

Offers a range of utility functions, macros, and tools, such as simple_benchmark() and dbg_ref!(), os_cmd::Runner, designed for testing purposes

maybe-async-cfg

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

terrars

Terraform in Rust

percpu

Define and access per-CPU data structures

cynic-codegen

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

dfir_lang

Hydro's Dataflow Intermediate Representation (DFIR) implementation

stageleft

Type-safe staged programming for Rust

rusteron-code-gen

Code generator for aeron c bindings

is-macro

Derive methods for using custom enums like Option / Result

git-cinnabar

git remote helper to interact with mercurial repositories

fv-template

Field-value based string templating

relib_interface

relib is a framework for reloadable dynamic libraries

stability

Rust API stability attributes for the rest of us

neli-proc-macros

Procedural macros for neli

frunk_proc_macro_helpers

Common internal functions for frunk's proc macros

rust-i18n-support

Support for rust-i18n crate

wasmtime-versioned-export-macros

Macros for defining versioned exports in Wasmtime

int-enum

A derive macro for conversion between integer and enum types

erg_common

A common components library of Erg

do-with-in

A template language for Rust metaprogramming using partial staging

derive-syn-parse

Derive macro for syn::parse::Parse

carbond-lib

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

impl-tools

Helper macros: autoimpl

hax-lib

Hax-specific helpers for Rust programs

dev_utils

A collection of utilities for development

dsl_auto_type

Automatically expand query fragment types for factoring as functions

safe-proc-macro2

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

runtime-macros

Simulate expansion of procedural macros at run time

biscuit-parser

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

rem-utils

Extraction Maestro

rust_arkitect

lightweight library for defining and validating architectural rules in Rust projects

template-quote

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

portaldi

An ergonomic lightweight compile-time depencency injection library

string_cache_codegen

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

tryexpand

Test harness for macro expansion

gratte

macros for working with enums and strings; forked from strum

deno-bindgen2-cli

A CLI tool for parsing rust source code and generating a close TypeScript equivalent. works with the deno_bindgen2 crate

napi-derive

N-API procedural macros

ra_ap_hir_expand

Macro expansion for rust-analyzer

quote-use

Support use in procmacros hygienically

better_comprehension

collection and iterator comprehensions for Rust

ssdv-fec

SSDV systematic erasure FEC

typeshare-engine

Behavioral engine for typeshare: parsing, writing, configuration, and everything in between

malloc_size_of_derive

Firefox memory reporting, not intended for external use

dioxus-rsx-hotreload

CLI Configuration for dioxus-cli

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

dylint_linting

writing Dylint libraries

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.

wadl

parser for Rust

github-languages

All GitHub's supported languages

prost-derive

Generate encoding and decoding implementations for Prost annotated types

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.

seq-macro

Macro to repeat sequentially indexed copies of a fragment of code

syn_derive

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

syn-mid

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

lambda-appsync

A type-safe framework for AWS AppSync Direct Lambda resolvers

proc-macro-utils

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

form

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

actix-multipart-derive

Multipart form derive macro for Actix Web

napi-derive-backend

Codegen backend for napi procedural macro

swift-bridge-ir

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

quote2

An alternative lightweight version of quote

reflect

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

waybackend-scanner

Waybackend implementation of wayland-scanner

concat-idents

Allows concatenating multiple identifiers and using them everywhere

napi_sym

proc macro for writing N-API symbols

more-convert

adds macros for various conversions

as_derive_utils

private derive utilities used by abi_stable and structural

rustmax

A collection of useful crates

makepad-micro-proc-macro

Makepad micro proc macro util lib

suitest

quality of life test suites

pulumi_gestalt_generator

Pulumi Gestalt Codegen library

structstruck

Nested struct and enum definitions

nject

Zero cost dependency injection module

cfg_eval

#[cfg_eval] in stable Rust 🙃

positional

author/parse positional files

proc-macro-rules

Emulate macro-rules pattern matching in procedural macros

test_each_file

Generates a test for each file in a specified directory

teleparse

postcompile

Helper crate for post-compiling Rust code

ctor_bare

Register constructor functions for Rust at complie time under no_std

futures-macro

The futures-rs procedural macro implementations

nous

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

drylib

Rust macro-library for Don't Repeating Yourself

ligen

(Language Interface Generator) is an extensible automatic binding generator ecosystem

rust-code-analysis

compute and export code metrics

instability

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

reflected

Something like reflection

better_default

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

derive-adhoc

An ergonomic way to write derive() macros

EnumBitFlags

EnumBitFlags is an implementation of flags support for enums

mirror-mirror

Reflection library for Rust

runtime-macros-derive

Simulate expansion of procedural macros at run time

format-bytes

A macro to format bytestrings

syn-inline-mod

Inlines modules in Rust source code for source analysis

ra_ap_load-cargo

Loads a Cargo project into a static instance of rust-analyzer for analysis

macroific_attr_parse

Attribute parsing utilities for the macroific crate

cargo-manifest-proc-macros

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

fmt-derive

A more robust and versatile derive macro for Debug and Display

crabtime

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

glib-macros

Rust bindings for the GLib library, proc macros crate

derive_generic_visitor

Boilerplate for building rust visitors

remain

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

dbg-pls

Syntax aware pretty-printing debugging

macroific

Proc macro development utilities

proc_micro

Small conveniences for high-quality macros

syn-serde

serialize and deserialize Syn syntax trees

rb-sys-build

Build system for rb-sys

volo-build

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

elm-parser

Elm markup parser to leptos

simpl_cache

caching tools

bevygen

parked: opinionated bevy game design cli

derive-merge-struct

A derive macro to partially update a named struct

pit-rust-generator

Portal Interface Types

opendp_tooling

Tooling for proc-macros and code generation

attrs

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

ekege-artifact

General-purpose build artifact generation crate

jni-toolbox

tools to make writing JNI native functions less tiresome

zorsh-gen-rs

Zorsh generator for Rust

swc_eq_ignore_macros

Macros for EqIgnoreSpan and TypeEq

fsmentry-cli

Finite State Machines with an entry API and data storage

enum-lexer

A proc_macro lexer generator. using enum-like syntax.

command-rpc

cli crate and api for replacing rpc

crud-api-endpoint

CLI generator for your API. Enpoint description

machine-check-machine

Machine crate for the formal verification tool machine-check

rust-utils

Various utility routines used in the rust programs I have written

aranya-policy-ifgen-build

Code generator for aranya-policy-ifgen

noir_macros_core

Essential proc-macros and utilities for no_std Rust development

epics_gen

macros for deserializing xlsx tables and serializing them as EPICS PVs

pax-language-server

Language Server for Pax Language

extruct

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

optee-utee-build

Build tool for TA

syn-args

parsing function arguments

cargo-unfmt

unformat code into perfect rectangles

default-struct-builder

Generates builder methods of every field of a struct

sqltk

Enhanced Visitor implementation for sqlparser

stak-macro-util

Macro utilities for Stak Scheme

linker-set

Declarative programming via linker-constructed arrays

procmeta

integration procmeta-core and procmeta-proc

symbols

Proc-macro utility to populate enums from database data

mantra-rust-macros

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

derive_deref

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

aws-dynamo-derive

Helper crate for aws-sdk-dynamodb

netsblox-extension-util

Allows for automatic generation of a NetsBlox extension that uses WASM

bevy_toolbox

A collection of useful tools for Bevy game engine

scopegraphs-regular-expressions

A well-documented port of scopegraphs to Rust

strum_macros

macros for working with enums and strings

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

casey

Case transforming macros for ident tokens

ct-python

Execute Python code at compile time to generate Rust code

context_manager

Python's like context_managers in Rust

asmov-common-traitenum-parse

Parsing library for Asmov Common Traitenum

script-macro

Write proc-macros inline with other source code

structre

Static-checked parsing of regexes into structs

test-generator

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

fn_macro

函数宏

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…

spez

Macro to specialize on the type of an expression

proc_macro2_helper

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

value-expr

easy expression

leptosfmt-formatter

view macro formatter for the Leptos web framework

syn-impersonated

Parser for Rust source code

typhoon-cpi-generator

TODO

option-chain

A macro for using ? operator in functions that don’t return Option

rust_minify

minify rust code

savvy-bindgen

Parse Rust functions, and generate C and R code

betfair-typegen

interacting with Betfair from Rust

napi-derive-backend-ohos

Codegen backend for napi-harmony procedural macro

doc_for

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

native_api_1c

Main library for Native API 1C

pmutil

Utils for proc-macro

ocaml-build

OCaml code generation

hydro_lang

Choreographic programming for Hydro, built on DFIR

unique-type-id

A unique id proc-macro generator for types

function-wrapper

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

covey-schema

Shared types for Covey's configuration

db-set-macros

A derive for some ORM functions utilising SQLX

lockjaw_common

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

yewlish-fetch

A macro for generating Yew fetch API bindings

relib_exportify

relib is a framework for reloadable dynamic libraries

ra_ap_test_fixture

Test fixtures for rust-analyzer

swimos_macro_utilities

SwimOS Macro Utilites

rigz_ast

AST parser for the rigz programming language

boxed_error

Macro for easily boxing an error

deki_proc

Some proc macro helpers!

opentalk-proc-macro-fields-helper

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

surreal_derive_plus

Query builder for surrealdb

contracts

Design-by-contract attributes

command_attr

Procedural macros for command creation for the Serenity library

eager2

Proc-macros for eager macro expansion

enum-update

representing state changes as enums

json_proc

proc macro for parsing JSON-like syntax

ferment-sys

Syntax tree morphing of FFI-compatible stuff

actix-prost-build

Generate actix handles from Protocol Buffer files

penum

Make enum conform to a given pattern

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

async-generic

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

brisk-egui-components

Components for brisk-egui

kona-std-fpvm-proc

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

odebug

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

pastey

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

maidenx_macro_utils

maidenx macro utils

schema

Access the schema for a Rust item

pavexc

The compiler powering Pavex

sea-bae

proc-macro attribute parser

myn

Minimalist Rust syntax parsing for procedural macros

stylers

Scoped CSS for Rust web frameworks like leptos

winter-maybe-async

sync/async macro for winterfell

ra_ap_hir_def

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

macro-wasmer-universal-test

Universal test macro for wasmer-test

dtor

__attribute__((destructor)) for Rust

gset

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

rustifact

A seamless bridge between a build script and the main crate

aws-sdk-compile-checks-macro

Macros that add compile time checks to the AWS SDKs

attr-parser-fn

parse attribute procedual macros in functional way

fn-decorator

contains macros for implementing wrapper functions around member or static functions

brisk-it

core library of the brisk declarative engine

easy_proc

Helper macros for making proc macros

hey_chat_gpt

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

flamer

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

rust-style-guide

applying Rust coding guidelines

vtable_gen

A C++-ABI VTable Generator for Rust

cryptify

A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.

assert_type_match

Statically assert that a type matches another type

derive-regex

Easily parse a regex into a struct or enum variant

axsys-noun

working with Noun data

syn-rsx

syn-powered parser for JSX-like TokenStreams

machine-check-bitmask-switch

Bitmask switch crate for the formal verification tool machine-check

quasiquote

quote compatible quasiquote macro with support for interpolating expressions

typed-fields

A collection of macros that generate newtypes

extendable-data

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

inttype-enum

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

syn-prelude

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

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.

protobuf-build

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

frunk_derives

contains the custom derivations for certain traits in Frunk

opaque_typedef

Supports defining opaque typedefs

derive_util

tools for derive macros

verty

procedural macro to generate different versions of a type

cdk-ansible

generate Ansible playbooks from Rust code

tokenstream2-tmpl

Runtime TokenStream interpolation for Rust macros

syn_util

helper APIs for procedural macros

defile

Proc-macro helper to ungroup macro metavariables

rem-constraint

Extraction Maestro

generic-array-struct

An attribute proc macro to convert structs with named fields of the same generic type into a single-array-field tuple struct with array-index-based accessor and mutator methods

zoo-endpoint

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

macro-string

Eager evaluation of macros like concat! and env!

micro_games_macros

macros to make it easier to build complex systems with Bevy

size-of-no-padding

A procedural macro to calculate the size of a type without padding

cfg_block

allow using #[cfg(...)] and other macros on blocks

rustfmt_if_chain

An if_chain-aware rustfmt (kind of)

ll-sparql-parser

A resilient LL parser for SPARQL

unit-enum

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

rust-sitter-common

Shared logic for the Rust Sitter macro and tool

aquamarine-demo-crate

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

windows-implement

The implement macro for the windows crate

singleton-attr

singleton procedural attribute and derive macro

flexpect

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

unique-uuid

generate unique UUIDs

pu-239

serverside fns in the client

cfg-exif

Conditional compilation in expressions

impl-tools-lib

Helper macros: autoimpl

zyc_getset

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

limousine_core

Building blocks for hybrid index data structures

rand_derive2

Generate customizable random types with the rand crate

modus_ponens

develop forward chaining inference engines

cot_codegen

web framework for lazy developers - code generation utils

oberst

A type-safe command parser and dispatcher inspired by Brigadier and written in Rust

pfetch-logo-parser

A parser for pfetch logos

macro-field-utils

work with darling fields

validator_types

Basic type for validator and validator_derive

dioxus-google-fonts

A declarative Google Fonts embedding for Dioxus

google-fonts-languages

Google Fonts script and language support data

synthez

Steroids for syn, quote and proc-macro2 crates

enutil

General Enum Utility Macros

syn-lite

limited but lite syntax parsing with only macro_rules

pesticide

ORM for CC based on pest

cgp-component-macro-lib

Context-generic programming core component macros implemented as a library

opimps

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

fusen-derive-macro

fusen-common

clappen

Clap flatten prefix macro

unroll

An attribute-like procedural macro for unrolling for loops

compose-idents

Rust macro that makes possible to concatenate idents from multiple parts

tauri-types

Type generating macros for Tauri apps

mpst-seq

DEPRECIATED: A library with macro for mpstthree

forint

A proc macro for invoking macros for each integer type

macro-dep-test

testing version resolution for associated macros

bodkin

Proc macro to simplify the integration of Arrow Data

aksr

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

macroex

An extractor based low level macro parsing crate that provides high level parsing support through derive macros