-
syn
Parser for Rust source code
-
derive_more
Adds #[derive(x)] macros for more traits
-
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
-
quote
Quasi-quoting macro quote!(...)
-
proc-macro-error2
Almost drop-in replacement to panics in proc-macros
-
synstructure
Helper methods and macros for custom derives
-
macrotest
Test harness for macro expansion
-
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
-
dylo-cli
Generate dyn-compatible traits with proc macros
-
serde_tokenstream
A serde deserializer for proc_macro::TokenStreams
-
proc-macro2
A substitute implementation of the compiler’s
proc_macroAPI 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
-
expander
Expands proc macro output to a file, to enable easier debugging
-
swc_macros_common
Common utilities for swc macros
-
venial
A very small syn
-
macro_magic
Allows the exporting and importing of the tokens of items across module, file, and crate boundaries
-
delegate
Method delegation with less boilerplate
-
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
-
virtue
A sinless derive macro helper
-
pyo3-stub-gen
Stub file (*.pyi) generator for PyO3
-
maybe-async
A procedure macro to unify SYNC and ASYNC implementation
-
getset
we're ready to go! A procedural macro for generating the most basic getters and setters on fields
-
derive-new
#[derive(new)]implements simple constructor functions for structs and enums -
linkme
Safe cross-platform linker shenanigans
-
memoize
Attribute macro for auto-memoizing functions with somewhat-simple signatures
-
proc-macro2-diagnostics
Diagnostics for proc-macro2
-
specr-transpile
Converts Specr lang code to Rust
-
safe-quote
Quasi-quoting macro quote!(...)
-
derive-getters
boilerplate getters generator
-
rstml
Rust templating for XML-based formats (HTML, SVG, MathML) implemented on top of proc-macro::TokenStreams
-
duplicate
macros for duplication of code with variable substitution
-
manyhow
proc macro error handling à la anyhow x proc-macro-error
-
git-ignore-generator
Quickly and easily fetch .gitignore templates from www.gitignore.io
-
enum-as-inner
A proc-macro for deriving inner field accessor functions on enums
-
derive-deftly
An ergonomic way to write derive() macros
-
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
-
rustfmt-wrapper
wrapper around rustfmt for use by code generators
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
document-features
Extract documentation for the feature flags from comments in Cargo.toml
-
server_fn_macro
RPC for any web framework
-
databake
Trait that lets structs represent themselves as (const) Rust expressions
-
jsonrpsee-proc-macros
Procedueral macros for jsonrpsee
-
arr_macro
Initialize arrays with ease!
-
parse-variants
Derive the syn::parse::Parse trait for enumerations and use it to comfortably parse a variant of the enumeration
-
cargo-manifest-proc-macros
Find the syn::Path to your own crate from proc-macros reliably
-
vercel_runtime_router
Vercel Rust Function Runtime Router
-
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
-
test-with
A lib help you run test with condition
-
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.
-
hooks
Compile-time, async hooks
-
wesl
compiler
-
windows-bindgen
Code generator for Windows metadata
-
clap_derive
Parse command line argument by defining a struct, derive crate
-
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
-
function_name
macro that expands to the name of the annotated function
-
proc-macro-utils
low-level utilities on proc-macro and proc-macro2 types
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
syn-ext
Human friendly or editable extension for syn
-
yew-fmt
Code formatter for the Yew framework
-
syn-mid
Providing the features between "full" and "derive" of syn
-
reflect
The "but I thought Rust doesn't have reflection?" memorial brand new way of defining procedural macros
-
k9
rust testing library
-
genemichaels
Makes your code formatty
-
pearlite-syn
A syn parser for the Pearlite specification language in Creusot
-
devise
devising derives and other procedural macros
-
deluxe
Procedural macro attribute parser
-
structmeta
Parse Rust's attribute arguments by defining a struct
-
git-cinnabar
git remote helper to interact with mercurial repositories
-
terrars
Terraform in Rust
-
derive-syn-parse
Derive macro for
syn::parse::Parse -
unsynn
(Proc-macro) parsing made easy
-
rusteron-code-gen
Code generator for aeron c bindings
-
maybe-async-cfg
A procedure macro to unify sync and async implementations depending on the features of your crate
-
pdl-compiler
Parser and serializer generator for protocol binary packets
-
percpu
Define and access per-CPU data structures
-
dfir_lang
Hydro's Dataflow Intermediate Representation (DFIR) implementation
-
is-macro
Derive methods for using custom enums like Option / Result
-
proc_macro_roids
Traits and functions to make writing proc macros more ergonomic
-
relib_interface
relib is a framework for reloadable dynamic libraries
-
stability
Rust API stability attributes for the rest of us
-
stageleft
Type-safe staged programming for Rust
-
neli-proc-macros
Procedural macros for neli
-
ra_ap_load-cargo
Loads a Cargo project into a static instance of rust-analyzer for analysis
-
do-with-in
A template language for Rust metaprogramming using partial staging
-
asn1-compiler
Compiler for compiling ASN.1 specs to Rust, with PER Codec support and derive macros for PER Codecs
-
opendp
differential privacy algorithms for the statistical analysis of sensitive private data
-
fv-template
Field-value based string templating
-
messageforge
lightweight Rust library for creating structured messages in chat systems, including HumanMessage, AiMessage, SystemMessage, and more. It supports easy extensibility through macros…
-
safe-proc-macro2
A substitute implementation of the compiler’s
proc_macroAPI to decouple token-based libraries from the procedural macro use case -
wasmtime-versioned-export-macros
Macros for defining versioned exports in Wasmtime
-
carbond-lib
Type-safe interface to the managed information provided by the system daemon 'carbond' for Rust
-
template-quote
A new-fasioned quote! macro implementation with pretty template-engine like syntax
-
int-enum
A derive macro for conversion between integer and enum types
-
fieldx
Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax
-
runtime-macros
Simulate expansion of procedural macros at run time
-
gengo
Get the language distribution stats of your repository
-
dsl_auto_type
Automatically expand query fragment types for factoring as functions
-
truc
Rust code generator for safe, fixed size, evolving records
-
prost-derive
Generate encoding and decoding implementations for Prost annotated types
-
impl-tools
Helper macros: autoimpl
-
proto_pdk
A plugin development kit for creating proto WASM plugins
-
rem-utils
Extraction Maestro
-
dioxus-rsx
Core functionality for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences
-
rust_writer
useful for editing a Rust file from Rust code
-
zorsh-gen-rs
Zorsh generator for Rust
-
tryexpand
Test harness for macro expansion
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
curve25519-dalek-derive
curve25519-dalek Derives
-
rust-sitter-tool
The external tool for Rust Sitter that extracts grammars from Rust definitions
-
ssdv-fec
SSDV systematic erasure FEC
-
string_cache_codegen
A codegen library for string-cache, developed as part of the Servo project
-
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.
-
positional
author/parse positional files
-
quote-use
Support
usein procmacros hygienically -
optee-utee-build
Build tool for TA
-
dtor
__attribute__((destructor)) for Rust
-
syn_derive
Derive macros for
syn::Parseandquote::ToTokens -
wadl
parser for Rust
-
napi-derive-backend
Codegen backend for napi procedural macro
-
upstream-ontologist
tracking of upstream project metadata
-
quote2
An alternative lightweight version of quote
-
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.
-
swift-bridge-ir
Holds the data structures and logic for bridge module parsing and code generation
-
actix-multipart-derive
Multipart form derive macro for Actix Web
-
more-convert
adds macros for various conversions
-
subenum
A proc-macro to create subsets of enums, that can be converted to and from
-
napi_sym
proc macro for writing N-API symbols
-
proc-macro-rules
Emulate macro-rules pattern matching in procedural macros
-
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
-
postcompile
Helper crate for post-compiling Rust code
-
as_derive_utils
private derive utilities used by abi_stable and structural
-
cfg_eval
#[cfg_eval]in stable Rust 🙃 -
malloc_size_of_derive
Firefox memory reporting, not intended for external use
-
makepad-micro-proc-macro
Makepad micro proc macro util lib
-
structstruck
Nested struct and enum definitions
-
futures-macro
The futures-rs procedural macro implementations
-
ctor_bare
Register constructor functions for Rust at complie time under no_std
-
comlexr
Dynamically build Command objects with conditional expressions
-
drylib
Rust macro-library for Don't Repeating Yourself
-
github-languages
All GitHub's supported languages
-
ligen
(Language Interface Generator) is an extensible automatic binding generator ecosystem
-
doc_for
📖 Get the documentation comment for structs, enums and unions, in a zero-cost fashion
-
mevy_core_syntax
token handling for mevy_core!
-
instability
Rust API stability attributes for the rest of us. A fork of the
stabilitycrate. -
mpst-seq
DEPRECIATED: A library with macro for mpstthree
-
impl-trait-for-tuples
Attribute macro to implement a trait for tuples
-
phnt
Rust bindings to the System Informer’s (formerly known as Process Hacker)
phntnative Windows headers -
seq-macro
Macro to repeat sequentially indexed copies of a fragment of code
-
EnumBitFlags
EnumBitFlags is an implementation of flags support for enums
-
glib-macros
Rust bindings for the GLib library, proc macros crate
-
runtime-macros-derive
Simulate expansion of procedural macros at run time
-
prettier-please
A minimal
synsyntax tree pretty-printer -
better_default
The std Default derive, but it allows to constomize the default fields values and has some upgrades
-
dbg-pls
Syntax aware pretty-printing debugging
-
test_each_file
Generates a test for each file in a specified directory
-
pax-compiler
Compiler APIs for parsing and building Pax projects into application executables
-
nous
lightweight and efficient web framework in Rust designed for handling HTTP requests with built-in gatekeeping middleware
-
rb-sys-build
Build system for rb-sys
-
syn-inline-mod
Inlines modules in Rust source code for source analysis
-
pastey
Macros for all your token pasting needs. Successor of paste.
-
rustmax
A collection of useful crates
-
stak-macro-util
Macro utilities for Stak Scheme
-
frunk_derives
contains the custom derivations for certain traits in Frunk
-
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.
-
async-generic
Write code that can be both async and synchronous without duplicating it
-
mirror-mirror
Reflection library for Rust
-
derive-adhoc
An ergonomic way to write derive() macros
-
macroific
Proc macro development utilities
-
test-generator
Rust Test generator: enumerating entries according to file-system pattern and generating a test function for each entry
-
actix-prost-build
Generate actix handles from Protocol Buffer files
-
elm-parser
Elm markup parser to leptos
-
syn-args
parsing function arguments
-
jni-toolbox
tools to make writing JNI native functions less tiresome
-
casey
Case transforming macros for ident tokens
-
command-rpc
cli crate and api for replacing rpc
-
macro-string
Eager evaluation of macros like
concat!andenv! -
strum_macros
macros for working with enums and strings
-
fsmentry-cli
Finite State Machines with an entry API and data storage
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
znap-syn
Collection of utilities for parsing and code generation that power znap-macros
-
default-struct-builder
Generates builder methods of every field of a struct
-
pavexc
The compiler powering Pavex
-
mantra-rust-macros
macros to create requirement traces and coverage logs for the
mantraframework -
procmeta
integration procmeta-core and procmeta-proc
-
leptosfmt-formatter
view macro formatter for the Leptos web framework
-
swc_eq_ignore_macros
Macros for EqIgnoreSpan and TypeEq
-
ra_ap_proc_macro_api
RPC Api for the
proc-macro-srvcrate of rust-analyzer -
bevy_auto_plugin_nightly_shared
shared lib for bevy_auto_plugin that require nightly rust
-
aranya-policy-ifgen-build
Code generator for aranya-policy-ifgen
-
ll-sparql-parser
A resilient LL parser for SPARQL
-
syn-serde
serialize and deserialize Syn syntax trees
-
ct-python
Execute Python code at compile time to generate Rust code
-
aws-dynamo-derive
Helper crate for aws-sdk-dynamodb
-
script-macro
Write proc-macros inline with other source code
-
rustifact
A seamless bridge between a build script and the main crate
-
penum
Make enum conform to a given pattern
-
rustic-jsonrpc
JSON-RPC 2.0 server library written in Rust
-
ethbind
code generation framework for Solidity(Contract) ABI
-
maidenx_macro_utils
maidenx macro utils
-
native_api_1c
Main library for Native API 1C
-
ocaml-build
OCaml code generation
-
unique-type-id
A unique id proc-macro generator for types
-
value-expr
easy expression
-
skia-svg-macros
Skia SVG Macros for Dom bindings
-
epics_gen
macros for deserializing xlsx tables and serializing them as EPICS PVs
-
context_manager
Python's like context_managers in Rust
-
custom_derive
(Note: superseded by
macro-attr) This crate provides a macro that enables the use of custom derive attributes -
workflow-macro-tools
Macro utility functions used by the
workflow-rsframework -
proc_macro2_helper
Various utility code to extract data that can be used with proc macro2
-
hydro_lang
Choreographic programming for Hydro, built on DFIR
-
spez
Macro to specialize on the type of an expression
-
syn-impersonated
Parser for Rust source code
-
swimos_macro_utilities
SwimOS Macro Utilites
-
rustfmt_if_chain
An if_chain-aware rustfmt (kind of)
-
napi-derive-backend-ohos
Codegen backend for napi-harmony procedural macro
-
extruct
proc-macro library that provides tools for listing named struct fields and implementing conversion from a larger struct containing fields with same names
-
promptkit_rs
LLM structured prompting library
-
symbols
Proc-macro utility to populate enums from database data
-
rust_minify
minify rust code
-
cot_codegen
web framework for lazy developers - code generation utils
-
machine-check-bitmask-switch
Bitmask switch crate for the formal verification tool machine-check
-
pit-cli
Portal Interface Types
-
savvy-bindgen
Parse Rust functions, and generate C and R code
-
opentalk-proc-macro-fields-helper
Helper function for working with fields in proc macros, used in OpenTalk crates
-
re_types_builder
Generates code for Rerun's SDKs from flatbuffers definitions
-
syn-helpers
Framework for building derive macros
-
macroific_attr_parse
Attribute parsing utilities for the macroific crate
-
quasiquote
quote compatible quasiquote macro with support for interpolating expressions
-
yewlish-fetch
A macro for generating Yew fetch API bindings
-
relib_exportify
relib is a framework for reloadable dynamic libraries
-
boxed_error
Macro for easily boxing an error
-
command_attr
Procedural macros for command creation for the Serenity library
-
surreal_derive_plus
Query builder for surrealdb
-
spider_chromiumoxide_pdl
Contains a PDL parser and rust generator
-
sqltk
Enhanced Visitor implementation for sqlparser
-
tokenstream2-tmpl
Runtime TokenStream interpolation for Rust macros
-
myn
Minimalist Rust syntax parsing for procedural macros
-
rigz_ast
AST parser for the rigz programming language
-
rusty-cmd
creating custom line-oriented command interpreters in Rust
-
bevy_toolbox
A collection of useful tools for Bevy game engine
-
contracts
Design-by-contract attributes
-
macro-wasmer-universal-test
Universal test macro for wasmer-test
-
aws-sdk-compile-checks-macro
Macros that add compile time checks to the AWS SDKs
-
gen_utils
Utils for GenUI
-
synthez
Steroids for
syn,quoteandproc-macro2crates -
odebug
flexible debug logging utility that allows simple and practical logging to a text file especially during proc-macro compilation
-
dioxus-rsx-hotreload
CLI Configuration for dioxus-cli
-
brisk-egui-components
Components for brisk-egui
-
deki_proc
Some proc macro helpers!
-
kona-std-fpvm-proc
Proc macro entry point for
kona-std-fpvmtargeted programs -
protobuf-build
functions for generating Rust code from protobufs (using protobuf-rust or Prost)
-
stylers
Scoped CSS for Rust web frameworks like leptos
-
schema
Access the schema for a Rust item
-
google-fonts-languages
Google Fonts script and language support data
-
fn-decorator
contains macros for implementing wrapper functions around member or static functions
-
lockjaw_common
lockjaw common lib. only to be used by https://crates.io/crates/lockjaw.
-
vtable_gen
A C++-ABI VTable Generator for Rust
-
scopegraphs-regular-expressions
A well-documented port of scopegraphs to Rust
-
brisk-it
core library of the brisk declarative engine
-
rust-style-guide
applying Rust coding guidelines
-
flamer
a procedural macro to insert
flame::start_guard(_)calls -
assert_type_match
Statically assert that a type matches another type
-
extendable-data
A set of rust macros that allows you to specify data that can be "extended" or inherited from
-
axsys-noun
working with Noun data
-
eiffel
language inspired guard clauses with Rust macros
-
hey_chat_gpt
A proc-macro to delegate implementation to the ChatGPT API. ChatGPT APIに実装を代行してもらうマクロです。
-
derive_util
tools for derive macros
-
syn-rsx
syn-powered parser for JSX-like TokenStreams
-
call2-for-syn
Apply parser functions to proc-macro2 token streams
-
ferment-sys
Syntax tree morphing of FFI-compatible stuff
-
enutil
General Enum Utility Macros
-
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
-
typed-fields
A collection of macros that generate newtypes
-
option-chain
A macro for using
?operator in functions that don’t returnOption -
inttype-enum
Converts an [
enum] into an [inttype], and try to convert it back -
micro_games_macros
macros to make it easier to build complex systems with Bevy
-
mongodb-internal-macros
Internal macros for the mongodb crate
-
cdk-ansible
generate Ansible playbooks from Rust code
-
catalytic_query_parser
Query parser for the ORM for Scylla, fully compatible with Apache Cassandra™
-
defile
Proc-macro helper to ungroup macro metavariables
-
db-set-macros
A derive for some ORM functions utilising SQLX
-
zoo-endpoint
Macro used by zoo consumers for registering handlers. This wraps dropshot’s
Endpointand adds some extra functionality for tracing. -
winter-maybe-async
sync/async macro for winterfell
-
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
-
pfetch-logo-parser
A parser for pfetch logos
-
ab-code-gen
Functions to generate boilerplate code for objects implementing the 'Actor' pattern. Used by the abcgen crate.
-
hax-lib-macros-types
Hax-internal types
-
validator_types
Basic type for validator and validator_derive
-
flexpect
#[flexpect::e(...)] compiles to #[expect(...)] for newer versions of Rust and to #[allow(...)] when not supported
-
unique-uuid
generate unique UUIDs
-
unit-enum
A procedural macro for deriving ordinal methods in unit-like enums for Rust
-
windows-implement
The implement macro for the windows crate
-
trident-idl-spec
Custom implementation of IDL specification for the Trident fuzzing framework
-
sea-bae
proc-macro attribute parser
-
pu-239
serverside fns in the client
-
macro-field-utils
work with darling fields
-
machine-check-machine
Machine crate for the formal verification tool machine-check
-
marlin-verilog-macro-builder
🦀 No nonsense hardware testing in Rust 🛠️
-
cfg_block
allow using #[cfg(...)] and other macros on blocks
-
modus_ponens
develop forward chaining inference engines
-
useful_macro
Collections of useful macros
-
cgp-component-macro-lib
Context-generic programming core component macros implemented as a library
-
checked-rs-macro-impl
procedural macros for checked-rs. This crate is not intended to be used directly.
-
opendp_tooling
Tooling for proc-macros and code generation
-
rust_to_dtr
Convert Rust Soroban contracts to DTR format
-
proc-debug
Dump proc-macro output for efficient debugging
-
portrait-framework
Framework for implementing portrait fillers
-
crud-api-endpoint
CLI generator for your API. Enpoint description
-
opimps
attribute macros to assist with overloading operators for borrowed and owned data
-
migration-check
check for migration in Rust code
-
macro-dep-test
testing version resolution for associated macros
-
zyc_getset
当前
crate是对’getset’ 的扩展。 主要添加了get_clone来返回字段的克隆对象， 当为基础类型时get自动转为get_copy， 当字段有自定义注解时，自动对… -
remain
Compile-time checks that an enum, struct, or match is written in sorted order
-
url-macro
A compile-time URL validation macro. Parses and checks URLs at compile-time, converting valid URLs into
url::Urlobjects. Provides early error detection for malformed URLs. -
syn-prelude
prelude traits and helpers for enhancing 'syn'/'proc-macro2' lib
-
doc_consts
get doc comments on fields as runtime constants
-
tauri-types
Type generating macros for Tauri apps
-
dylo
Generate dyn-compatible traits with procedural macros
-
pesticide
ORM for CC based on pest
-
proto_convert_derive
Automatically derive Protobuf and Rust conversions
-
abi-singleton
singleton trait
-
contracts-try
Design-by-contract attributes
-
unroll
An attribute-like procedural macro for unrolling for loops
-
revision-lock
keeping track of changes to revisioned items
-
pest-ast
Derive to convert from pest parse tree to typed syntax tree
-
needy
Requirements tracing macro
-
err_code
that sets error codes for program errors, and has the ease of use of alerts, and has very good compatibility with this error
-
apidoc-expand
Apidoc expand
-
vitasdk-sys-build-util
Internal build utilities for raw bindings to vitasdk
-
clappen
Clap flatten prefix macro
-
timelang
A DSL (Domain Specific Language) and grammar for parsing and rendering human-readable date/time and duration values
-
firmware-controller
Controller to decouple interactions between components in a no_std environment
-
ijzer_lib
IJzer. Provides tools for tensors, parsing syntax tree of the IJ language and transpiling it to rust code.
-
gravitron_macro_utils
Gravitron's Macro Utils
-
rand_derive2
Generate customizable random types with the rand crate
-
bomboni_prost
working with prost. Part of Bomboni library.
-
defamed
Default, positional and named parameters
-
verty
procedural macro to generate different versions of a type
-
leptos-pretty
find and fix Leptos view! macro formatting issues
-
compose-idents
Rust macro that makes possible to concatenate idents from multiple parts
-
pestle
typed AST facade for the pest parser
-
docify_clone
Docify allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
display_json
Procedural macros for implementing Display, Debug and FromStr for (de)serializing json strings
-
windows-interface
The interface macro for the windows crate
-
betfair-typegen
interacting with Betfair from Rust
-
std-reset
Many reworked implementations from the standard library, as well as new solutions for easy coding
-
do-with-in-base
A template language for Rust metaprogramming using partial staging
-
cargo-test-macro
Helper proc-macro for Cargo's testsuite
-
fieldname-access
Derive macro for safe struct field access by their names in runtime
-
syn-file-expand
load full source code of multi-file crates
-
function-wrapper
Rust attribute macro library that makes it easy to wrap functions in code that runs before and / or after a function executes
-
codama-errors
Errors and result types for Codama
-
vodca
Reduce boilerplate when writing DDD codes
-
rem-controller
Non-local control flow repairer for Rusty Extraction Maestro
-
rocket_sunset
A procedural macro crate for Rocket that provides functionality for HTTP deprecation headers
-
grappler
function hooking through proc-macros
-
metrics-derive
Proc macro for automatically describing and initializing metrics
-
mr_utils_macro
utils attribute for Rust
-
fusen-derive-macro
fusen-common
-
derive-visitor
Derive visitor pattern for arbitrary data structures
-
procedural-masquerade
macro_rules for making proc_macro_derive pretending to be proc_macro
-
prometheus-static-metric
Static metric helper utilities for rust-prometheus
-
exact_format
procedural macro for compile time string replacement without using the standard format placeholder syntax (
{}). This is most useful when dealing with strings that contain{ }blocks you do no wish to interpolate e… -
jni_macro
A macro library for simplifying JNI code generation in Rust, enabling easy execution of Rust code in Java
-
architect-api-schema-builder
Auxiliary crate for building architect-api
-
aquamarine-demo-crate
A demo crate for aquamarine -- the mermaid.js integration for rustdoc
-
tigerbeetle-unofficial-sys
Native bindings to the tigerbeetle library
-
type-sig
Ever needed to inspect types more precisely? Then this crate is for you!
-
lombokrs
lightweight Rust macro library. It is the simple implementation of lombok Java in Rust.
-
derive_more_preview
Adds #[derive(x)] macros for more traits
-
by-macros
Biyard Macros
-
chandeliers-san
AST definition and static analysis procedures of Candle
-
impl-tools-lib
Helper macros: autoimpl
-
default2
Default implementation using macros
-
kernelx
𐲕
-
forestrie-builder
Build a trie and convert it TokenStream
-
pack_bools
Attribute macro to pack all boolean fields of a struct into a bitfield
-
xmacro
rust macro producing multiple expansions
-
derive-into-owned
Custom derives to help with types containing Cow fields
-
montycat_serialization_derive
A derive trait for custom compact serialization/deserialization
-
gensym
Creates unique identifiers for macros using procedural macros
-
stilts-lang
The parser for stilts
-
constime
Zig's comptime for Rust with zero dependencies. Mostly something to play around with until more stuff is const fn.
-
instance_code
Turn instances into source code
-
trace
A procedural macro for tracing the execution of functions
-
vivinq
query the Vivino service
-
notation_dsl
Fun notation - DSL to create notation files
-
swift-bridge-build
Parse Rust files for swift-bridge modules and generate the corresponding Swift and C code for them
-
kanamaru-build
the build script required for kanamaru
-
actix_async_handler
Support for async syntax for Actix
-
mosaic-derive
proc-macro for the mosaic crate
-
prql-compiler-macros
Macros for PRQL compilation at build time
-
proc-macro-faithful-display
A Display implementation for proc-macro types more faithful to the input stream
-
pmutil
Utils for proc-macro
-
struct_as_array2
that allows you to represent the structure as an array. Ported from https://github.com/Nikitamuraviev10/struct_as_array.git to proc_macro2, syn 2.0 and quote 1.0
-
c-like-concat
macro that works just like C's ##
-
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
portus
A Congestion Control Plane
-
telety
Access type information across crates and modules in your proc macros
-
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.
-
api-client-macro
Declaratively express a REST API client
-
despatma-lib
Common tokens for Despatma
-
multihash-derive
Proc macro for deriving custom multihash tables
-
clappos
flagless version of Clap that uses argument position for assignment with zero dependencies
-
proc-macro-kwargs
Keyword argument parsing for function-like proc-macros
-
easy_proc
Helper macros for making proc macros
-
pit-rust-generator
Portal Interface Types
-
lead_lang_macros
Interpreter of the Lead Programming Language
-
diesel-enum-sqltype
derive macro for FromSql and ToSql traits for postgres enums
-
naga-rust-macros
Macros for the
naga-rust-embedlibrary -
ethcontract-generate-fork
Code generation for type-safe bindings to Ethereum smart contracts
-
procout
Output a proc macro's TokenStream to a file
-
gherkin_rust
A pure Rust implementation of the Gherkin (
.featurefile) language for the Cucumber testing framework -
python-ast
compiling Python to Rust
-
after-test
A procedural macro that allows you to run a clean up function after each test from a test module
-
yuuka
A helper library to generate complex and nested structures by a simple macro
-
duchess-reflect
Internal component of duchess crate
-
eprocedural
create proc!()s and call them, passing in implicit arguments using with!()
-
code-timing-macros
Macros for easily measuring execution time of various code pieces
-
into-from
Rust macro for impl Into<T> or From<T> for Struct
-
fn-error-context
An attribute macro to add context to errors from a function
-
enum_from_derive
Implement From For the Enumeration
-
ra_ap_proc_macro_srv
Proc-macro server for rust-analyzer
-
strim
Macro to trim whitespace from string literals
-
int-seq
A procedural macro for generating integer sequences
-
jaffi
Support for the jaffi code generator
-
gen_parser
parsers for gen (Template, Style, Script)
-
pragma
An experimental inline DSL for conditional compilation
-
waynest-gen
Codegen glue for waynest
-
rust-sitter-common
Shared logic for the Rust Sitter macro and tool
-
bool_to_bitflags
compact multiple bools into a single bitflags field automatically with getters and setters
-
unsafe_target_feature
A more convenient #[target_feature] replacement
-
derive_step
A derive macro for the unstable Step trait
-
complex-enum-macros
Convert enums with non-unit variants to privitives and back
-
r18-trans-support
r18 translation support
-
clown
approximation of capture-by-closure lambdas
-
compiletime-regex
proc macro for compile time regex
-
terse_cli
building no-boilerplate CLI apps
-
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
-
schema2code
Generate Code in any language from a JSON Schema compliant document
-
apidoc-attr
Apidoc attr
-
const-currying
A procedural macro for speeding up your function using currying
-
wd_macro
wd macro for rust
-
structured-map
generating structured maps with a set of known keys
-
pio-proc
proc-macro for assembling PIO code in a Rust program at compile time
-
appinfo
Macro to derive appinfo at compile time using cargo compile-time env vars and
clap-rs -
auto-rust
automatically generate Rust code using LLMs at compilation time
-
variegated-board-cfg
Store pin and other HAL configurations for your embedded project in a TOML file
-
debugger_test
proc macro for writing tests that launch a debugger and run commands while verifying the output
-
dry
Rust macros for idiomatic deduplication of code. Use whenever
macro_rules!are too powerful and clunky. -
hephae-macros
Common utilities for Hephae's macros
-
constable
const lookup table generation
-
struct-field-offsets
Procedural macro to retrieve field names and offsets from a struct
-
hashmatch
More efficient
static &strmatching when match #arm > 30 -
kfghdfghdfkgh_js_macros
internal crate
-
openssl-macros
Internal macros used by the openssl crate
-
assert-offset
Derive macro for asserting the memory offset of fields in a struct
-
spread_macros
Macros around an extended spread syntax
-
tauri-plugin-async-wrapper
A procedural macro for offloading blocking tasks to background threads in Tauri apps, ensuring smooth and responsive performance
-
pmrpc
Poor man's RPC. Not pretty, but plenty versatile.
-
enum_macros
A collection of useful macros to make working with enums easier
-
test-builder
A test builder for all function of an impl block
-
ragkit_convex_macros
Macros to help make Convex in Rust nice
-
katexit
Insert KaTeX autorender script into rustdoc
-
gradio_macro
A macro for generating Gradio interfaces
-
const_gen_proc_macro
Create proc macro that adds compile time functionality for the creation of constants
-
context_attr
Attribute macro to add context to all errors a function produces
-
tarnik
Macro for generating WASM AST
-
membrane_types
A companion crate for
membrane -
enum_desc
A set of column-derived macros is provided to add descriptive information to enumerations and translate enumeration codes
-
attr-parser-fn
parse attribute procedual macros in functional way
-
askama-derive-axum
Derive macro for Askama templates with Axum integration. Replacement for future deprecation of askama_axum crate.
-
gen_mk_script_objs
only for support needed structs for gen script and give these structs to the rssyin to handle
-
sabry_intrnl
Sabry internal, yet still public library
-
tabler-icon-definer
Macros for fast incremental loading tabler icons
-
xladd-derive
macro that helps write Excel UDF functions in Rust
-
auto_new
basic macro for removing the need to write new(...) on structs
-
dioxus-autofmt
Autofomatter for Dioxus RSX
-
ramp_gen
Generate color ramps in rust and wgsl
-
compile-dotenv
Add environment variables defined in the environment or in a .env file at compile time
-
a0
generate structs and their values from external data
-
diesel_derives
You should not use this crate directly, it is internal to Diesel
-
proc-macro-assertions
Easily create asserts on proc macro inputs
-
timrs_hkt_macro
Rust Higher-Kinded Types emulation procedural macros
-
common-error-build
High performance universal error code management for Rust in Rust
-
sneks
macros for naming enum variants
-
deno-proc-macro-rules
Deno fork of proc-macro-rules. Emulate macro-rules pattern matching in procedural macros
-
small_iter_fields
get an iterator, or get the length, or convert to a hashmap from an enum
-
wasmworker-proc-macro
Dispatching tasks to a WebWorker without
SharedArrayBuffers -
overf
Customize overflow behavior in mathematical operations
-
getter-methods
Derive macro to create getter / accessor methods
-
regex_capture
Auto implement FromStr trait for struct with regex capture
-
easyfix-messages-gen
Easy FIX (Financial Information Exchange) toolset - messages generator
-
taos-macros
TDengine connector internal macros
-
clap_main
provide a #[clap_main] macro to automatically parse and pass args to your main function
-
aksr
derive macro designed to automatically generate getter and setter methods for both named and tuple structs
-
neon-frame-macro
Macros to simplify writing Neon apps
-
timer_macro
A macro to print time taken to execute a function
-
derive_builder_core
Internal helper library for the derive_builder crate
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
rs-macro-di
Rust dependency injection by macro
-
pastiche
exposing non public types, fields, and functions from a crate
-
ff_macro
TryFrom impl HashMap<String,String> -> Struct
-
enum_stringify
Macro to generate string conversion functions for enums
-
ceasar_macro
A proc macro for evaluating ascii alphabetic character ciphers
-
tailwag_macro_logic
The logic for A collection of macros to support the tailwag crate
-
module_path_extractor
procedural macro helper for determining the module path of macro invocations
-
vehicle-signals
DDS topics (for cyclonedds-rs) created from GENIVI/W3C Vehicle Signal Specification
-
ssa-rust
SSA to Rust converter
-
fsmentry
Finite State Machines with an entry API and data storage
-
drain_macros
A macro library for use in Drain dynamic pages
-
quick-macros
providing simple useful macros
-
timrs_macro_utils
Macro helpers for Tim.rs
-
sourcegen-cli
In-place Rust source generator CLI utility
-
actix-response-macro
Helper crate for
actix-responsewhich defines the proc macro used -
definition_string
Rust macro to convert a struct definition to a String
-
mlua-bridge
Generate UserData implementations for mlua
-
horfimbor-client-derive
derive macro for yew and custom-elements
-
global-id-creator-macro
A procedural macro library for generating constants
-
diesel_as_jsonb
Use your structs as Jsonb with diesel and PG
-
rem-constraint
Extraction Maestro
-
sphinx-rustdocgen
Executable to extract rustdoc comments for Sphinx
-
parquet_derive
Derive macros for the Rust implementation of Apache Parquet
-
packed_struct_codegen
implements the code generation for the packed_struct library
-
from-attr
that makes it easy to parse attributes
-
foxerror
proc macro for deriving Error on enums
-
todo2
An enhanced todo macro inspired by todo_or_die
-
infix_fn
Procedural macro used to make infix function calls similarly to Haskell’s syntax with pound (#) instead of backticks (`)
-
racc
port of Berkeley YACC to Rust, and allows you to write grammar definitions directly in Rust source code
-
find-crate
Find the crate name from the current Cargo.toml
-
test-group
Organize tests into groups with macros for filtering in nextest
-
css-modules
CSS Modules with a macro for convenience
-
fire
fire implementation for rust
-
canadensis_macro
A procedural macro that generates Rust data types and serialization code from inline and/or external Cyphal DSDL files
-
rust-oop
use macro to implement inheritance
-
forestrie
Quick string matches
-
gen_plugin
GenUI plugin analyzer and generator
-
log-execution-time
procedural macro to log the execution time of functions
-
utoipauto-core
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
drydoc
Keep your doctests DRY with flexible/reusable templates
-
symbols-models
Proc-macro utility to populate enums from database data (shared traits)
-
hydroflow_lang
Hydroflow's Surface Syntax implementation
-
deno-bindgen2-common
Common library used by the deno-bindgen2 project. Contains mainly implmenentations for parsing and transforming Rust source code.
-
mu_macro
XCENA mu Macro
-
nameth
macro to generate a static &str representing the name of a function, a struct or an enum
-
napi-derive
N-API procedural macros
-
derive-elves
Writing inclusive derive macros is tedious, this creates provides helper functions that make it easier
-
gettext-macros
A few proc-macros to help internationalizing Rust applications
-
nano_parser_gen_macro
A parser generator inspired by yacc (procedural macro)
-
cgp-field-macro-lib
Context-generic programming field macros as a library
-
bflib
a BrainFuck-to-Rust transpiler using Rust proc macro
-
altgetset
An alternative getters/setters proc-macro library
-
inherits
Improved Practices for the Composition Pattern in Rust
-
struct_baker
enable ergonomic creation of compile time parsers
-
preserves-schema-macros
Preserves Schema code generation macros for Rust
-
named_func_args
Proc macro to create boilerplate to simulate function with named arguments
-
codama-attributes
Codama attributes definitions and parsers
-
vermouth
a new kind of parser for procedural macros
-
enum_inject
Implement inject For the Enumeration
-
kona-common-proc
Proc macro extension for the
kona-commoncrate -
redpen-shim
A proc-macro attribute provider that allows crates to annotate their code with redpen lints without breaking their build
-
Boot-Banner
An elegant banner library that enhances project launches with eye-catching terminal displays and helpful assistance
-
codama-syn-helpers
Extension of syn for Codama
-
bbgun
A builder for builders running builders!
-
mlua_proc_macro
used to convert structs into lua tables with mlua
-
dupit
copy or clone a value
-
proc_nuhound
Nuhound error handling macros
-
simple-ternary
macro for C/C++ style ternary expressions in Rust
-
super-seq-macro
Macro to repeat a fragment of code based on a RHAI expression
-
deserter
Procedural macros to initialize Rust structs from JavaScript-like object syntax
-
yew-callback
Macro helps you to create yew::Callback
-
rust2antd
Generate Ant Design table from Rust struct
-
zerocopy-derive
Custom derive for traits from the zerocopy crate
-
yew-alt-html
Alternative macro for building Html in Yew
-
watt-non-static-runtime
Runtime for executing Rust procedural macros compiled as WebAssembly
-
named_constants
Procedural macro makes enums behave like named constants in languages like C/C++ or C#
-
build-deps
Rust build-script dependencies generator for data/IDL files
-
include_url_macro
A procedural macro to include URL content as static strings at compile time
-
enum_all_values_const
a proc macro which provides access to all values of an enum even in const contexts
-
axum-error-handler
error handler for axum
-
rust-i18n-macro
Macro for rust-i18n crate
-
proc-quote
A procedural macro implementation of quote!
-
crabstructor
constructor generator for named structures
-
tiny-rsx
A fast and minimal syn RSX (JSX in Rust) parser
-
ezno-ast-generator
Quasi-quoted constant compiled TS definitions for Ezno AST
-
swc_ecma_transforms_macros
Macros for swc_ecma_transforms
-
execute_evcxr
execution of evcxr-supported syntax via building and executing a binary crate
-
enso-macro-utils
writing macros
-
brisk-common-components
Common components for the brisk declarative engine
-
faasta-macros
Proc macros for Faasta
-
gpui-router-macros
Router macros for gpui
-
google-fonts-axisregistry
Google Fonts font axis support data
-
confused
treat scary functions with the respect they deserve
-
pinkie-parser
Internal crate. Please use 'pinkie' instead.
-
runtime-struct-field-names-as-array
procedural macro that generates an array of the field names of a named struct
-
sh_serde_derive
watt serde derive
-
git_rev
Procedural macros for including git revision hashes in code
-
norrland
macro for implementing traits on SQLx types
-
band_proc_macro
Support library for band
-
syn-pub-items
Parser for Rust source code (patched for pub items)
-
autogen
set of macros that allows you to automatically apply generics to impl blocks
-
derive-docs
generating documentation from Rust derive macros
-
proclet
Proc macros made easy
-
mockers_macros
Compiler plugin for 'mockers' mocking library
-
eagle
creating RPC protocols
-
relm-derive-common
Common derive implementation internally used by relm crates
-
argh_derive
Derive-based argument parsing optimized for code size
-
kproc-parser
minimal procedural macros parser that produce a convenient AST by including only the necessary code
-
enum2pos
derive macro for enums that generates "from_index(usize, Vec<String>) -> Option<Self>" and "to_index()" methods for converting between an variants and their position within the enum declaration (similar to an index)
-
nextera_jwt
Next Era JSON Web Token Attribute
-
double-dyn
Macro for implementing functions with multiple dynamic argument dispatch
-
typeshare-core
The code generator used by Typeshare's command line tool
-
safe_decimal_core
fixed-point numeric library targeting blockchain development. Originally created and used as a part of the Invariant Protocol. The current version leverages macros, traits and generics…
-
gen_layouts_sys
Generated keyboard layouts
-
macro_tt_utils
Procedural Macro Utilities
-
libninja_macro
Macros for inline code
-
brisk-eframe
brisk declarative engine with eframe
-
net-literals
Literals for IP/socket addresses
-
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.
-
chandeliers-lus
Procedural macros for the Chandeliers project, implementing a deep embedding of Lustre in Rust
-
serde_int_tag
A procedural macro for tagging struct fields with integer values
-
shuttle-codegen
Proc-macro code generator for the Shuttle platform (shuttle.dev)
-
dora-ros2-bridge-msg-gen
Message generation for ROS2 bridge
-
dncl_trans
DNCL (大学入試センター言語, Daigaku Nyushi Center Language) をRustにトランスパイルするマクロ
-
proptest-attr-macro
Procedural attribute macro for writing proptest tests
-
the-usual
derive the usual
-
tramer
A lightweight procedural macro library for profiling function execution time with customizable time units
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
randstruct
implements a subset of the features of the GCC randomize_layout plugin
-
js_proxy_gen
Javascript code generator
-
ferogram-macros
providing procedural macros for the Ferogram framework. These macros simplify the creation and management of handlers and other functionalities within the ferogram ecosystem. "
-
cps
Assists in the creation of readable and maintainable macro_rules! macros
-
compose-macro
A macro for composing functions
-
fort
Proc macro attributes for Bastion runtime
-
protokit_build
Usable protocol buffers
-
dot-parser-macros
contains companion proc macros for the dot_parser crate
-
protobuf-macros
Protobuf proc macro implementation (internal)
-
rust_hdl_private_macros
Macro support for RustHDL
-
rem-repairer
Lifetime repairer for Rusty Extraction Maestro
-
test-shisho-policy-sdk
SDK of Shisho Cloud policies to write your custom policies in Rust
-
structdump
Dump structure to source code
-
invade
reflect on Rust types and generate code
-
mlua_derive
Procedural macros for the mlua crate
-
quote_into
Easily & efficiently generate code by quoting it in a macro
-
pseudonym
Declare aliases with ease!
-
doc-search-dsl
procedural macro for creating complex regex patterns using a Domain-Specific Language (DSL)
-
fluent_field_assertions
FluentFieldAssertions is a library that allows you to write tests in a natural language-like syntax. With this library, you can perform field assertions in an intuitive and readable way
-
expand-mod
Expand
mod module_name;in.rsfiles and combine the module tree consisting of multiple files into a single file -
juniper_codegen
Code generation for
junipercrate -
dotenv-proc
proc-macro crate to use a .env file
-
debug_display
Small crate to allow using Debug as regular Display (Why isn't this just part of std?)
-
has-some-field
Check whether a struct has any field that is_some()
-
wasmer-derive
Wasmer derive macros
-
casco
CSS-like parser for procedural macros
-
test-attr
Custom test attributes for convenience
-
ambient_package_macro_common
Common implementation of a proc-macro that generates boilerplate from an
ambient.toml -
macro-ruby
Execute ruby code at compile time trough mruby
-
tokio-wrap
run asynchronous code within synchronous functions
-
bodkin
Proc macro to simplify the integration of Arrow Data
-
noob-builder
proc macro that allows the user to auto generate a simple builder pattern
-
constructivist
Simplify the construction of structured data
-
flexi_func
designed to supercharge your Rust programming experience with two powerful macros: ff (Flexi Func) and fb (Flexi Block) or (Function Builder) 🛠️. These macros are crafted to simplify…
-
diesel_derives_extra
Automatically derive some simple CRUD methods for your Diesel models
-
cdefines
A proc macro that translates c #define constants to rust consts
-
yew-lmth
A macro crate for writing HTML-like syntax for Yew application, inspired by Sycamore and Dioxus
-
codas-macros
Macros for Codas
-
prpc-build
Build prpc from protobuf definitions
-
agb_xm_core
converting XM tracker files for use with agb-tracker on the Game Boy Advance. You shouldn't use this package directly
-
mwt
proc macros for generating mut and non-mut methods without duplicating code
-
wasset
Embed external assets into WASM modules
-
predawn-schema-macro
Macros for predawn-schema
-
awesome-glib
Bunch of macros to make a life of gtk/glib user easier
-
substrait-expr-funcgen
automatically generating code from Substrait YAML files
-
macroex
An extractor based low level macro parsing crate that provides high level parsing support through derive macros
-
introspect-core
containing the core functionality used for
introspectand supporting crates -
set_builder
A procedural macro to create Iterators over a set defined by Haskell-inspired set-builder notation
-
rusty-asm
A layer of syntactic sugar between Rust and inline assembly
-
ctor-lite
Run code at program startup or shutdown
-
register-actix-routes
Macro designed to simplify the registration of routes in an Actix Web application
-
nscfg
Nifty Simple CFG provides a revamped syntax and macros to easily manage all #[cfg] parameters in one package. Compatible with stable toolchain and no dependencies. See README / Homepage for more details.
-
auto-context
Auto-add context to anyhow errors (without nightly)
-
tl_str_macro
Procedural macros for composing type-level string
-
ampiato-macro
🧮 The Rust Powerplant Scheduling Toolkit. A Rust crate to build a great powerplant optimization and scheduling software. Automatic database migrations, consistent code and schema…
-
clap_config
Automatically merge CLI args, environment variables, config files, and default values in clap apps
-
axconfig-gen-macros
Procedural macros for converting TOML format configurations to Rust constant definitions
-
maybe_matches
macro to map enums to Option
-
px-linkme
Safe cross-platform linker shenanigans
-
typed-i18n-support
Support crate for the derive macro for typed-i18n
-
mono-macro
Force monomorphizing on functions with
share-genericsto minimalize binary size -
cynic-proc-macros
Procedural macro crate for cynic - a code first GraphQL client for Rust
-
enum-mapping-macro
Maps enum variants to numbers and viceversa
-
sabry_build
Sabry build magic as a separate crate
-
relm-gen-widget
relm-attributes and relm-derive
-
macro_railroad_annotation
Easily embed macro_railroad images in your docs using this attribute macro!
-
sqlx-macros
Macros for SQLx, the rust SQL toolkit. Not intended to be used directly.
-
decent-synquote-alternative
alternative to the syn and quote crates for when you want to write your own derive proc-macro. It was originally based on the microserde code, but has grown a lot since then. It is not as complete…
-
grass-macro
Procedual Macros for GRASS
-
derive_dumb
Derive
Dumbgenerates a structure in which all fields are public. Original structure can be converted using function calldumb. -
diesel-json-derive
Macro crate implementing the proc macro for diesel-json-derive
-
dotenvy_macro
A macro for compile time dotenv inspection
-
struct_layout
Customize your struct layout with this one weird trick
-
puroro-codegen
Google Protocol Buffer's compiler plugin implementation for puroro
-
to_query
Structure to HTTP_GET/SQL Query Parameters
-
process_macros
Macros to improve Rust Kinode process DevEx
-
keypath
Derivable, type-safe Swift-style keypaths
-
enum_to_vec
Enum to vec
-
foxtive-macros
Foxtive Macros
-
route_controller
An attribute macro enabling a structured approach to defining routes and attaching middleware for axum servers
-
playout
DSL for creating Vulkan pipeline layout and descriptor set layout
-
error-enum
Provide a easy way to define an enum that represents errors with error codes, document comments and several other functionalities
-
lsp_doc_stable
Embed markdown/text files into Rust documentation attributes for LSP hover/preview
-
rstml-control-flow
Custom nodes with control flow implementation for rstml. Usefull when you need to implement If, For, etc.
-
static-graph
Generate static parallel computation graph from DSL at compile time
-
core_extensions_proc_macros
detail of the
core_extensionscrate -
crdts_derive
CRDTs proc_macro
-
migrations_macros
Codegeneration macros for diesels embedded migrations
-
invoke_impl
Proc macro to generate functions that can invoke all identical functions or methods inside impl blocks
-
short_default
Compactly define structs with default values
-
csharp_binder
generate C# bindings for a Rust foreign function interface (FFI)
-
pyo3_macro
macro crate builds PyO3-compatible Rust
protobufandgRPCstructures. So you can easily expose your generated protobuf code as Pythin binding through PyO3. Features Macro… -
xxh3_hashid_macro
XXH3 hashed identifier literals
-
tauri-ipc-macros
IPC bindings for using Tauri with a Rust Frontend (e.g. leptos)
-
lazy-regex-proc_macros
proc macros for the lazy_regex crate
-
plex
A syntax extension for writing lexers and parsers
-
felysium
Macros for the Felys programming language
-
struct-iter
A very naughty proc macro to generate an iterator over the fields of your struct as a trait object
-
asset-derive
asset handling derive macro for enums, and a proc-macro learning resource!
-
opentelemetry-derive
Derive macros for OpenTelemetry
-
progenitor-impl
An OpenAPI client generator - core implementation
-
extpat
A procedural macro for implement extractor pattern
-
kopium
kubernetes openapi unmangler
-
terse_cli_lib
building no-boilerplate CLI apps
-
prqlc-macros
Macros for PRQL compilation at build time
-
ext_format
A small, yet powerful, Rust crate for string interpolation
-
kago-macros
A macros for Kago
-
just-convert
Easy conversion of structures
-
tarantool-proc
Tarantool proc macros
-
wit-bindgen-rust-macro
Procedural macro paired with the
wit-bindgencrate -
win_etw_macros
Enables apps to report events to Event Tracing for Windows (ETW)
-
catchr
A testing framework inspired by Catch for C++
-
enum-display-derive
Display trait's custom derive for simple enums
-
ast_openapi
Generate OpenAPI without any boilerplate
-
macro_types
easier to create procedural macros
-
unrest_tmp_syn
don't use
-
config_to_rs
Convert config files to Rust code
-
fieldx_aux
Various types and tools useful for fieldx crates and, potentially, to users of fieldx
-
test-data-file
test macro helper to provide test data from a file
-
include-crypt-bytes
Rust macro to embed encrypted files in compiled binary
-
rvv-asm
Procedure macro to encode RISC-V V extension (rvv) instructions
-
scyllax-macros-core
Core macro impl for scyllax
-
wrapcenum-derive
Derive macro for nvml-wrapper, not for general use
-
mdd
MDD
-
url-cleaner-macros
Macros for URL Cleaner
-
influxdb2-structmap
Procedural macro library for converting between Rust structs and associative containers
-
ephemeral-vrf-sdk-vrf-macro
-
iter_all_proc
Iterate all enum vases
-
o2o-impl
'o2o' crate
-
rglw_codegen_utils
Root project for all the utilities that rustyglware offers to the community
-
jj-lib-proc-macros
Proc macros for the jj-lib crate
-
yaserde_derive
Serialization and deserialization macros
-
parsegen
A parser generator implemented as a proc macro
-
permafrost
Write. Macros. Everywhere.
-
include-flate-codegen-exports
Macro codegen for the include-flate crate
-
gix-macros
Proc-macro utilities for gix
-
bevy_derive
derive implementations for Bevy Engine
-
include-repo
implements the 'include_repo!' macro for easy AGPL compliance! Include a tarball as a const in your code!
-
smarterr-macro
Smart error handling library
-
try-from-map
A derive macro for converting a HashMap<String, String> into a struct
-
override_macro
An attribute-like macro for Rust programs to override trait methods with default methods of other traits
-
razy-importer-macros
Proc macros for razy-importer
-
tao-macros
Proc macros for tao
-
genemichaels-lib
Makes your code formatty, the library
-
tlkit-expand
Tool kit
-
more_collection_macros
Adds new macros to rust for creating collections
-
compiler-tools
A proc-macro for deriving powerful and fast tokenizers with compile-time regex
-
conflicting
generate compile time errors for mutually exclusive feature flags
-
z3d
Z3 DSL interface for Rust
-
elfo-macros-impl
Macros for matching and deriving messages, implementation internals
-
r2r_msg_gen
Internal dependency to the r2r crate
-
actix-web-codegen
Routing and runtime macros for Actix Web
-
syn-dissect-closure
Analyze syn ExprClosure body
-
qsync
Generate react-query hooks for your rust backend (see https://github.com/Wulf/create-rust-app)
-
aoc-companion-codegen
Codegen module for the aoc-companion crate
-
meilisearch-index-setting-macro
Helper tool to generate settings of a Meilisearch index
-
uniffi_checksum_derive
a multi-language bindings generator for rust (checksum custom derive)
-
glory-hot-reload
types used for dev mode and hot-reloading for the Glory web framework
-
gtk-properties-macro
Experimental property declaration macro for gtk-rs
-
pareg_core
contains the implementation for the pareg library
-
derive_static_str
A procedural macro to derive static str implementations
-
wec
Useful vec!-like macros
-
map-enum
This package introduces a procedural macro for generating typed enums
-
nom-rule
A procedural macro for writing nom parsers using a grammar-like DSL
-
debug-span
Visualize proc-macro2 spans for debugging and assertions
-
oso-derive
macros for oso, an open source policy engine for authorization that’s embedded in your application
-
static_table_derive
Procedural macros for investments crate
-
js-macros
Quickly prototype procedural macros using JavaScript or TypeScript!
-
rbac-macro
rbca-macro
-
tfhe-versionable-derive
set of proc macro for easier implementation of the tfhe-versionable traits
-
typemarker
Procedural macro for easily creating multiple linked marker types
-
no-panic
Attribute macro to require that the compiler prove a function can't ever panic
-
proc-caesar
Procedural macro to break Rust IDEs
-
gadget-blueprint-proc-macro
Procedural macros for writing Tangle blueprints
-
winnow-rule
A procedural macro for defining winnow combinators in simple DSL
-
easify
Development tools. Includes various helper functions and proc-macros to simplify your code and boost your development
-
struct_derive
automatically apply function on certain type of struct
-
macrors
custom macro library in Rust
-
macros-utils
macros crate
-
dioxus-rsx-rosetta
Autofomatter for Dioxus RSX
-
linked_macros_impl
Internal dependency of the 'linked_macros' crate - do not reference directly
-
simpleml_macro
A macro for placing SimpleML content directly into Rust source code
-
spanr
proc-macro authors to visualize the spans on generated code
-
stidgen
Strongly Typed ID types macro
-
fastsim-proc-macros
Procedural macros for FASTSim
-
devise_core
devising derives and other procedural macros
-
inherent-pub
Mark methods in
impl Trait for Typeblocks inherent to the type -
relib_host
relib is a framework for reloadable dynamic libraries
-
miniserde-enum
Derive macros for miniserde on enums
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
http-error-derive
Create an enum with error message and http code
-
quirky_binder
Quirky Binder
-
rio-proc-macros
Rio proc macros
-
liberty-macros
libertymacros -
gnostr-lib-proc-macros
Proc macros for the gnostr-lib crate
-
color-hex
Procedural macro for converting hexadecimal strings to an RGB or RGBA byte array at compile time
-
substruct
A proc-macro to create subsets of structs
-
function-frame
Procedural macro to wrap any function outputs within a text frame
-
sully_peg
Proc macro for PEG generation
-
const_env_impl--value
Configure const and static items by environment variables
-
actix-type-handler
procedural macro crate for Actix-web designed to simplify API creation. It enhances code readability by allowing direct struct argument passing, error handling with Result, and unique…
-
message_macro_derive
A macro to generate/parse binary representation of messages
-
stageleft_tool
Helper macros for the stageleft crate
-
prost-dto-core
Data transfer object conversion macros for prost
-
chema
An external DSL for JSON Schema
-
pipewire-wrapper-macro-impl
Attribute and prop macroses implementations for pipewire-wrapper crate
-
default-args
zero-cost default arguments in rust
-
enum-methods
Generates methods for each enum variant
-
wayrs-scanner
Generates code for wayrs-client from xml files
-
klvm-derive
Derive macros for implementing KLVM traits
-
validator_struct
ergonomic addition to the validator crate
-
auto_impl_trait
auto impl trait by provide trait file
-
gurkle_codegen
gurkle
-
dummy_tmp_fork
Macros implementation of #[derive(Dummy)]
-
conjure-macros
Macros exposed by conjure-http. Do not consume directly.
-
autokani
macro for generating kani harness
-
biscuit-quote
macros for compile time datalog parsing for Biscuit authorization tokens
-
webwire-cli
Contract-First API System - Command Line Interface
-
tasm-object-derive
Derive-macro for TasmObject
-
ai_functions_vasile
A copy of procedural macro by Shawn McDonough for creating text from a function for use in LLMs
-
moosicbox_env_utils
MoosicBox env utilities package
-
doc-chunks
Clusters of doc comments and dev comments as coherent view
-
const_panic_proc_macros
detail of the
const_paniccrate -
pax-macro
Macros for Pax, used both for parser codegen and for showing Pax where to attach to Rust code
-
maikklein/unreal-api-derive
Rust integration for Unreal Engine 5
-
fimi_magic
Procedural macros for fimi-rs (generic file migration framework)
-
gpt3_macro
Macro that uses GPT3 codex to generate code at compiletime
-
twust_macro
Zero-config Static type-checker for Tailwind CSS
-
pest_tree
Convert output from pest parser into statically typed trees
-
match_type
Match on the type of an expression at compile time
-
machine_uuids
retrieve a machines UUID
-
kalosm-parse-macro
A macro to derive kalosm parsing traits
-
custom_debug_derive
Derive Debug with a custom format per field
-
convert_by_name
Derive From and Into for structs and enums based on field and variant names
-
derive-enum-all-values
A procedural derive macro which exposes a method named
all_valuesthat returns all defined values as a compile-time static -
equator-macro
Composable assertion library
-
temp
A procedural macro to manage temporary variables
-
rust_swig
connecting libraries written in Rust with other languages
-
sqlx-plus-rs
CRUD library using sqlx plus macros
-
brisk-egui
brisk declarative engine with egui
-
scx_stats_derive
Derive macro for scx_stats
-
asm_unroll
unrolled for-loops within inline asm
-
r3bl_rs_utils_macro
Internal support for a proc-macro library for reading attributes into structs when implementing custom derives. Used by workspace in https://crates.io/crates/r3bl_rs_utils.
-
uucore_procs
uutils ~ 'uucore' proc-macros
-
noggin
A declarative, zero-copy, proc-macro based HTTP header parser
-
console-log-rs
replaces console.log in a rust module with println!
-
bevy_commandify
A macro for creating bevy commands
-
prost-validate-derive-core
the prost-validate derive implementation
-
sub-model
a proc marco for easy generate sub models
-
worker-macros
Macros to support the
workercrate and remove FFI boilerplate / conversion from user code -
conseq
Macro to conditionally repeat a piece of code in a sequence
-
utility-types
proc-macro to realize several utility types of TypeScript
-
lombok
port for Rust
-
forwarding_gen
Syntax processing for emulating OOP Inheritance in Rust by forwarding trait methods
-
quick-impl
procedural macro auto-generating common methods on enums and structs
-
callback_fn
callback functions
-
antlion
Handy way to evaluate at compile-time any Rust expression
-
macro_magic_core
Core implementation behind macro_magic
-
rustpython-derive-impl
Rust language extensions and macros specific to rustpython
-
defmt-macros
defmt macros
-
wasmtime-c-api-macros
Support macros for
wasmtime-c-api -
ts-macros
tree-sitter convenience macros
-
traceback-derive
Procedural macros made to work with the traceback-error crate
-
modelfox_macro
ModelFox makes it easy for programmers to train, deploy, and monitor machine learning models
-
regexp2rust_macro
regexp(ecma262) to rust code macro
-
backtrait_error
Errors with backtraces
-
kameo_macros
Fault-tolerant Async Actors Built on Tokio macros
-
dfa-regex
Match regular expressions using a corresponding DFA
-
mockimbap
macro for mocking Rust functions
-
dict_derive
Derive macros for some PyO3 traits to convert python dicts into rust structs
-
clickhouse-derive
A macro for deriving clickhouse::Row
-
named-array
A procedural macro for accessing struct fields as an array
-
no_debug
Helper types to omit debug info for select values
-
concat-mulidents
concatenating multiple identifiers
-
newtyperef
generate custom newtype reference types
-
faux_macros
Implementations for #[create], #[methods], when!
-
deno_ops
Proc macro for writing Deno Ops
-
forsyde-io-generator
Code generation component for traits and others of the Rust ForSyDe IO supporting library
-
async-trait-static
async fn in trait for no_std
-
on_your_marks
Getters and Setters for Rust
-
rustler_codegen
Compiler plugin for Rustler
-
krenz
collection of my frequently used functions and macros
-
owo-code
OwO Code owo! pwogwam owo in ur nyative wanguage owo!
-
dlopen2_derive
Derive macros for the dlopen2 crate
-
example-html-highlight-macro
macro for embedding syntax highlighted copies of code in the binary
-
get_files_macro
macro that can resolve a directory's file names before compile-time
-
croc-look
expand macros and watch them in real time
-
gsettings-macro
Macro for typesafe GSettings key access
-
smart-serde-default
An annotation to implement #[serde(default)] and Default
-
serde_infer
Don't you hate #[serde(rename)]-ing every field in your struct
-
insert-only-set
A procedural macro to generate insert-only sets from enums
-
mrml-common-macros
Common macros for the MRML crate
-
neon-macros
Procedural macros supporting Neon
-
amt-macros
A collection of procedural macros used for development of AMT tools
-
chandeliers-syn
Syntax of the Lustre language, to be parsed by procedural macros
-
runa-wayland-scanner-codegen
Generate code from wayland protocol specifications
-
salsa-macros
Procedural macros for the salsa crate
-
machine_uuid
retrieve a machines UUID
-
shower
get string of code block
-
datafusion-macros
Procedural macros for DataFusion query engine
-
pymoors_macros
Procedural macros for pymoors project
-
fsm-macro
A statically checked finite state machine written in rust
-
hsr-codegen
Build fast HTTP APIs fast, with Rust + OpenAPI
-
for-else
Python-esque for-else construct for Rust
-
sparkles-macro
Macro crate for sparkles tracing library
-
jeep-train
An experimental high level web framework
-
rattler_macros
that provideds some procedural macros for the rattler project
-
time_this
two macros to quickly time functions for debugging purposes
-
u-num-it
typenum macro for matching types from a given range
-
unrest_tmp_synom
don't use
-
cvt_str
Convert to text use in LLMs
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
twine-macros
Macros for Twine, a Rust framework for functional and composable system modeling
-
better-macro
better versions of common macros like println
-
list-mod
A procedural macro for generating a list of string slices of the names of the modules inside a source code directory in the current project
-
cbit
A proc-macro to use callback-based iterators with
for-loop syntax and functionality -
mry_macros
Macro crate for mry, a simple but powerful mocking library that supports struct, trait, and function
-
intuicio-derive
Procedural macro module for Intuicio scripting platform
-
gandiva_rust_udf_shared
A basic shared library for gandiva rust udf
-
type-utilities-rs
Type utilities in Rust
-
litcrypt2
Let's encrypt your string statically during compile time
-
vts
Macro to generate boiler plate to define new types with associated constraints
-
agb_macros
Macro for declaring the entry point for a game using the agb library
-
nidrs-openapi-macro
a openapi macro
-
aoc-auto
Automatically imports your solutions to Advent of Code challenges for easy running
-
variants-struct
A derive macro to convert enums into a struct where the variants are members
-
bang_notation
!-notation for Rust
-
getters2
Generate getters, mutable getters, setters, and copy accessors for structs and enums
-
event_bridge
A procedural macro library for generating event handlers
-
a2lmacros
macros in support of the a2lfile crate
-
custom_attrs
that allows you to configure values specific to each variants of an enum
-
syn-file-expand-cli
CLI tool to read full source code of multi-file crates and output it to stdout
-
krk
The shuttle cli helper for (js like experience)
-
hashed-type-def
hash based type identifier: hash code is computed on the basis of type definition
-
same_enum
Generates
Fromtrait implementations for enums with the same unit variants -
canyon_macros
ORM and QueryBuilder
-
struct_auto_from
auto generating conversion methods between structs
-
brisk-cartography
brisk declarative engine with cartography
-
frunk_proc_macros
Proc macros for Frunk
-
libcnb-proc-macros
Procedural macros used within libcnb.rs
-
disintegrate-macros
Disintegrate macros. Not for direct use. Refer to the
disintegratecrate for details. -
inkwell_internals
Internal macro crate for inkwell
-
arma-rs-proc
proc macros for arma-rs
-
dapr-macros
Dapr Rust SDK (Macros)
-
pgrx-macros
Proc Macros for 'pgrx'
-
all-the-same
A procedural macro that copy-pastes match arms for new type variant enums
-
user_doc-doc_data
Metadata describing user-facing documentation
-
pm-lexer
sample lexer using the proc-macro crate, to be used in the pomelo testings
-
utoipa_auto_discovery
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
tailwind_fuse_macro
Macros for tailwind-fuse
-
stateful_macro_rules
Generate macro_rules macros that have states
-
enumcapsulate-macros
Procedural macros for 'enumcapsulate' crate
-
arc-trait
Automagically implement any trait for Arc<T>
-
cameleon-impl-macros
used by other cameleon crates implementation
-
rustlings-macros
A macros crate intended to be used only by Rustlings
-
lox-derive
Derive macros for the Lox ecosystem
-
quic-rpc-macros
quic-rpc库的高级封装
-
subimpl
A procedural macro that generates all the implementations of a type for a struct containing a field of that type
-
tlayuda
A derive procedural macro for structs that adds a static method that generates instances of the struct with minimal configuration
-
rxing-one-d-proc-derive
proc macros to simplify the development of one-d barcode symbologies in rxing (https://github.com/rxing-core/rxing)
-
hclua-macro
hclua macro
-
disjoint_impls
Support for mutually disjoint impls
-
cubecl-macros
Procedural macros for CubeCL
-
avr-device-macros
Attribute macros for re-export in
avr-device -
esso
Jest style tests in RUST
-
debug3
Space Efficient Pretty Printer
-
inertia-macros
attribute macros to assist with overloading operators for borrowed and owned data
-
dervy
Auto-derivation for entity types in domain-driven design
-
p9_wire_format_derive
Supporting proc-macro for the
p9crate -
axum_grants
A set of attribute macros for protecting Axum URI resources
-
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.
-
doko
Run methods from submodules by name
-
complexity
Calculate cognitive complexity of Rust code
-
literalext
A helper crate for interpreting proc-macro
Literalvalues -
cargo-files-core
Core functionality for cargo-files
-
ascent_macro
ascent macros
-
config_parser_derive
A proc-macro for implementing ConfigParser trait of config_parser library
-
ni-fpga-macros
Macros to be used with the ni-fpga crate
-
future_gadget_laboratory
time travel experiments
-
aide-macros
Macros for the Aide library
-
spade-macros
Helper crate for https://spade-lang.org/
-
teloxide-macros
The teloxide's procedural macros
-
ffishim
behind ffishim_derive
-
px-llvm-codegen-utils-version-macros
Version macros for LLVM codegen utilities
-
join_impl
join!macro -
macro-rules-rt
Transforms text or TokenStream using Rust's macro_rules syntax
-
dioxus-check
Checks Dioxus RSX files for issues
-
current_semver
Get the current semver type from the environment
-
autophagy
AOT compiler for Rust
-
mauzi
Experimental i18n library using proc-macros
-
test-context-macros
Macro crate for test-context
-
rotate-enum
macro that implements prev() and next() methods to an enum
-
astmaker
Build Abstract Syntax Trees and tree-walking models quickly in Rust
-
sylvia-runtime-macros
Simulate expansion of procedural macros at run time
-
narrative-macros
Procedural macros for the narrative crate
-
extend1
Alternative to
Extend::extend_onethat is stable and does not require#![feature(extend_one)] -
codegen-libc
A codegen tool for extracting libc cfg
-
sdf-macros
SDF macros
-
expression-formatter
Insert complex expressions directly into format strings
-
tot_spec
The lib for json model
-
sdi
Rust statically resolved dependency injection lib
-
async-backtrace-attributes
Procedural macros for the
async-backtracecrate -
include_cstr
Macro for building static CStr reference from file content
-
enum-fields
Quickly access shared enum fields in Rust
-
iconify
Proc-macros for generating icons from the Iconify API
-
better
rustcoed make better
-
ambient_project_macro_common
Common implementation of a proc-macro that generates boilerplate from an
ambient.toml -
mutself
Create self-modifying executables
-
vhdl_lang_macros
VHDL Language Frontend - Macros
-
ferrotype
An opinionated wrapper for insta.rs
-
entropy-macro
Macros library for ENTROPY<rust>
-
covey-manifest-macros
Proc macro export for covey-plugin
-
git-ref-format-macro
Macros for the git-ref-format crate
-
constany_stage_two
Convert any function to constant
-
destructure
Automation of Destructure Pattern
-
swc_ecma_codegen_macros
Macros for swc_ecma_codegen
-
ra-ap-rustc_macros
Automatically published version of the package
rustc_macrosin the rust-lang/rust repository from commit f6cb952dc115fd1311b02b694933e31d8dc8b002 The publishing script for this crate lives at:… -
meme_options_derive
MemeOptions derive macro for meme_generator
-
celery-codegen
Macros for rusty-celery
-
bevy_caravan
A function-like proc macro designed for making expressing Bevy's query.get statements easier
-
bitfld-macro
Macro library supporting bitfld
-
lombok-rs
Lombok port for Rust
-
match-by-hash
Match statement, but for any value and with a hash function
-
swx
general purpose development
-
tracelogging_macros
TraceLogging for Rust Proc Macros
-
compilation-guard
Force compilation to fail when certain condition is met
-
autoload
macro,single scan load ioc aop
-
trigraph
macro for your rust code
-
sleigh2macro
Macro used to transpile Ghidra code into rust
-
syn-miette
A
syn::Errorwrapper that provides pretty diagnostic messages usingmiette -
str-match
Format pattern like str match macro
-
macropol
Ergonomic string literal interpolation in macro definitions
-
brisk-machine
brisk declarative engine to generate state machines
-
functional_macro
A functional macro for Rust
-
chorus-macros
Macros for the chorus crate
-
memory-serve-macros
Macro for memory-serve
-
derive-discriminant
A derive macro for enum discriminants
-
angust_macros
Procedural macros for the Angust GUI framework
-
proc-macro-error
Almost drop-in replacement to panics in proc-macros
-
ntree-macros
Complementary proc macros for ntree-rs
-
near-self-update-proc
Near contract update helper procedural macro
-
ffi_rpc_macro
Proc macros for ffi_rpc
-
leftwm-macros
A window manager for Adventurers
-
quote-impersonated
Quasi-quoting macro quote!(...)
-
codesnip_core
snippet bundle tool
-
nanosql_macros
Tiny, strongly-typed data mapper for SQLite (procedural macros)
-
notionrs_macro
Macro for generating Notion API client
-
specit
Spec "it" for Rust testing
-
enum-flags
EnumFlags is a csharp like enum flags implementation
-
impl-new-derive
Derive macro for implementing the
newmethod for structs -
multiversion-macros
multiversion
-
creusot-contracts-proc
Proc macro crate for creusot-contracts
-
leptos-mview-core
Main implementation of leptos-mview
-
python-mod
A macro library for including a Python module in Rust. At this point, very imcomplete.
-
debug_code
The util to remove code when not debug build
-
akin
writing repetitive code easier and faster
-
macroscope
makes writing proc macros a breeze
-
literify
Stringifies tokens inside token stream
-
parse-it-codegen
A user-friendly, opinionated parser generator for Rust
-
cvt_strs
Convert to text use in LLMs
-
aleo-std-timed
A profiler to conveniently time function executions
-
tiaojian-macro
conditional compile proc-macro
-
leafwing_input_manager_macros
Macros for the
leafwing-input-managercrate -
humblegen
An experimental code-generator in the vain of protobuf, but a little more humble
-
roadblk-expand
Validator proc-macro expand impl
-
deref-derive
Derive Deref and DerefMut for structs
-
lock_order
macro for helping produce a deterministic lock ordering to prevent deadlocks
-
from-to-repr
Derives TryFrom and From implementations for the representation type of a Rust enumeration
-
ctrlgen-impl
Generate enums for message-passing services
-
caravel_export_poc
Caravel Module Wrapper
-
to_and_fro
Proc macro for generating implimentations of Display and FromStr for Enum Variants
-
micromegas-tracing-proc-macros
macros to help with instrumentation, part of micromegas
-
ygw-macros
The goal of Yamcs Gateway is to allow Yamcs to control instruments/payloads as part of an EGSE. This crate facilitates easier definition of parameters and commands in Yamcs.
-
calculate-macro
Expand the bit number of the parameters in the calculation formula to obtain the result with the expected bit number
-
lwb-parser
parser framwork with automatically generated ASTs for the LWB project
-
tiny-web-macro
macro library for automatically connecting a web engine to the web project
-
enum-utils
A set of useful proc macros for enums
-
waiter_codegen
Macro for Waiter DI
-
parsql-macros
Parsql için yardımcı makroları barındıran küfedir
-
clippy-tracing
add, remove and check for
tracing::instrumentin large projects where it is infeasible to manually add it to thousands of functions -
asset_procmac
Some i/o macros that help with applications that need assets, by importing them using normal FS in debug builds, but directly embedding the data in the application in release builds
-
proxygen-macros
proc-macros for proxygen
-
midi2_proc
Internal procedural macro crate. Only intended for use with midi2
-
macroific_core
Shared functionality for macroific & macroific_macro
-
limbo_macros
The Limbo database library
-
feather-macro
Helper macros for Feather UI library
-
ft-derive
ft-sdk: Rust SDK for fastn and FifthTry Platform
-
assert2-macros
procedural macros for assert2
-
cmd-impl
-
poise_macros
Internal macro implementation crate of poise
-
udf-macros
UDF procedural macros implementation
-
byteme
Converts a struct into Vec<u8> and back. The conversion is Big Endian by default.
-
janetrs_macros
Attribute macros for JanetRS
-
dora-operator-api-macros
Rust API Macros for Dora Operator
-
test-log-macros
Supporting procedural macro crate for test-log
-
sh-builtin-bash
Procedural macro and bindings for creating bash builtins
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
file_enum_macro
Macros to generate an enum with a variant for each file in a project subdirectory. Extremely sloppy for now.
-
match_deref
Deref patterns in "match" for stable Rust. Now you can match through Rc, String, etc
-
usdt-impl
Main implementation crate for the USDT package
-
is-tree-macro
Everything is a tree
-
struct-box
Securely encrypt any serializable struct / enum
-
ai_functions
Procedural macro for creating text from a function for use in Large Language Models
-
shopify_function_macro
Macros for the
shopify_functioncrate -
farmfe_macro_plugin
macro for farm plugins
-
accio
Retrieves code blocks distributed to multiple sites
-
typify-impl
typify backend implementation
-
ngyn_macros
Modular backend framework for web applications
-
rfs_test_macro
This package provides macro to simplify usage of rfs_tester crate
-
simple_cache_macros
caching tools
-
hpt-macros
An internal library for generating helper functions for hpt
-
saturating_arithmetic
Proc macro #[saturateit] to rewrite operators into their saturating equivalents
-
const_field_count
procedural macro to derive a constant function for counting the number of fields in a struct
-
test-fuzz-macro
-
syn-test-suite
Test suite of the syn crate
-
ct-for
macro to repeat code multiple times with different substitutions
-
reduct-macros
Macros crate for ReductStore
-
cargo-rtic-scope
RTIC Scope backend
-
pit-rust-guest
Portal Interface Types
-
polymorphic_enum
Automatically wrap enum variant data in a struct. Implement a given trait for the enum that delegates to the structs. Also implement From and To to convert between the enum and the structs.
-
derive-deftly-macros
Macros that implement the derive_deftly crate
-
small_read_only
A macro to implement getters on a struct
-
as_warp_reply
Macro to implement the warp reply trait on custom structs
-
mser_macro
-
bytes-lit
Create byte slices from literal integers
-
dummy
Macros implementation of #[derive(Dummy)]
-
expansion
expant the native libs
-
qroc
Perl for procedural macros
-
bounded-integer-macro
Proc macro for
bounded-integer. Do not use directly. -
ok_macros
The standard library that's ok
-
dunge_macros
Procmacro for the dunge library
-
lib3d6
Potentially my personal utility library, for now a test
-
enum2map
A small macro to convert enums with associated data into a HashMap
-
toolfront-macro
A procedural macro for generating type-safe API clients from OpenAPI endpoints
-
inherit
derive macro
-
obelix
Obélix is a tool to reduce Rust source files to produce MVEs
-
confique-macro
Macro crate for 'confique'. Do not use directly! Semver not guaranteed!
-
remoc_macro
Procedural macros for Remoc
-
single-trait-impl
A macro for declaring and implementing a trait at the same time
-
markup-proc-macro
A blazing fast, type-safe template engine for Rust
-
mm1-proc-macros
M/M/1! Queueing, do you speak it?!
-
struct-arithmetic
Trait to derive basic arithmetic operations for your structs
-
prime-derived
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
eventheader_macros
Rust macros for eventheader-encoded Linux Tracepoints via user_events
-
include-lua
that allows the embedding of a lua source tree into a Rust application binary
-
pacaptr-macros
several macros used in pacaptr
-
shellfn-attribute
Attribute macro for
shellfncrate -
cocoa-purity
macro collection
-
frunk-enum-derive
Derive macros to implement the frunk::LabelledGeneric trait on enums
-
color-print-proc-macro
package color-print
-
defmt-test-macros
defmt-test macros
-
proc-macro-generator-wrapper
An proc-macro wtapper crate for demonstrating a regression
-
envtime
Runtime and compile time environment resolution for Rust
-
melior-macro
Internal macros for Melior
-
foundationdb-macros
Macro definitions used to maintain the FoundationDB's crate
-
aidecomment
that can get the OpenAPI operation summary and description from doc comments and provide them to aide
-
xitca-codegen
proc macro for xitca
-
wiwi-macro-proc
proc macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
json_typegen_shared
Codegen from JSON samples. Not intended to be used directly. See repository for the intended crates.
-
ene_kafka_derive
Derive macros used for Ene Kafka
-
steel-derive
Derive macros for use within steel
-
nacos-macro
Nacos's proc macros
-
scrapelect-filter-proc-macro
proc-macros for making scrapelect Filters
-
guard_macros
Convenient Rust guard macros
-
prosa-macros
ProSA macros
-
envhead
build environment variable names using a static prefix. Works great with the popular clap crate.
-
aya-ebpf-macros
Proc macros used by aya-ebpf
-
mock_derive
An easy to setup, rich mocking library for the Rust programming language
-
io-excel
package that wraps around Calamine and rust_xlsxwriter, allowing for simple Excel read and write operations through procedural macros
-
maydon
Generating enumation for fields of a struct
-
workflow_macro
Derive Macro for Workflow-Aurras
-
flatfish
A macro to write Fully Qualified Syntax without nesting turbofishes
-
build-info-proc
Part of the build-info crate: This crate provides the proc-macros
-
hdv_derive
proc_macro_derivefor hdv -
unconst
Macro to unconst const/fn/enum/struct/trait/impl/type items
-
memoeyes
Procedural macros for automatic memoization
-
suitest_macros
suitest macros
-
struct_db_macro
A procedural macro for struct_db
-
roop
attributes to simulate inheritance in Rust
-
xbinser-macros
binary structure transporation, macros to generate encode and decode tools
-
pinned-init-macro
Proc macros for the pinned-init crate
-
include_json
Parse JSON file at compile time and embed as serde_json::Value
-
spooky-season
👻 SPOOKY! 👻🎃👻
-
tamasfe-macro-utils
Proc-macro utilities, intended for personal use
-
optbuilder
A optional builder derive macro for helping with big constructors with mostly optional parameters
-
cssparser-macros
Procedural macros for cssparser
-
around
execute code around a function
-
despatma-dependency-container
Design Pattern Macro for dependency container
-
instant-xml-macros
Procedural macros for instant-xml
-
macro-compose
trying to simplify and organize proc-macros
-
makepad_gen_plugin
gen plugin for makepad, a generator for genui to makepad
-
service-builder-macro
Procedural macros for service-builder
-
lofty_attr
Macros for Lofty
-
tl-proto-proc
A collection of traits for working with TL serialization/deserialization
-
ascii-literal
Compile time checked ASCII strings
-
tylift
Lift enum variants to the type-level
-
rkyv-with
Third-party derive macro for rkyv's *With traits
-
thirtyfour-querier-derive
#[derive(Querier)] macro for thirtyfour WebDriver library
-
rsdoc
Transform PlandUML/Drawio diagrams in doc comments as PNG images
-
azalea-block-macros
Proc macros used by azalea-block
-
sql_tool_macros
这个库用于存储宏
-
dynimp-macros
extended version of razy-importer-macros
-
hermit-macro
Proc macro implementation to defined system calls
-
workflow-wasm-macros
Macros for workflow-wasm
-
moisture
Rust-based parsing library intended for use with procedural macros!
-
egui_struct_macros
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
sigma-types-macros
Macros to enhance the
sigma-typescrate -
extendr-macros
Generate bindings from R to Rust
-
comparable_helper
comparing data structures in Rust, oriented toward testing
-
mpfs-hal-procmacros
Procedural macros for mpfs-hal
-
turbo-tasks-macros-shared
TBD
-
altrios-proc-macros
ALTRIOS procedural macros
-
tonbo_macro
TonboRecord macro
-
easy_proc_macro
Rust's last proc-macro crate
-
simd-json-derive-int
procmacros for simd-json-derive
-
recursive-proc-macro-impl
Procedural macros for the recursive crate
-
do-with-in-internal-macros
A template language for Rust metaprogramming using partial staging
-
tco
A macro for transforming a tail-calling recursive function to eliminate recursion
-
derive_merge
A derive macro to partially update a named struct
-
unpat
Unboxing the pattern with easy syntax
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
ri-utils
Ut
-
property
Generate several common methods for structs automatically
-
atomic-dbg
Atomic
dbg/eprintln/eprintmacros -
from_proc
A procedural macro for
fromcrate -
ks-placeholder
A macro help user create pesudo source file
-
rust_hls_macro_lib
Helper functions for rust_hls and rust_hls_macro
-
prest-html-macro
Compile-time HTML templates
-
wolfram-library-link-macros
Procedural macros used by wolfram-library-link
-
handy-dandy-macros
A collection of some handy dandy macros
-
bye_pcd_derive_rs
Derive macros for bye_pcd_rs crate
-
simple_function_logger
function logger
-
ostd-macros
OSTD's proc macros
-
sickle_macros
Macros for sickle_ui
-
hcaptcha_derive_no_wasm
Derive macro for hCaptcha. Please use hcaptcha-no-wasm crate.
-
comptime
Compile-time code execution (i.e. lightweight proc-macro)
-
catalytic_macro
Macros for the ORM for Scylla, fully compatible with Apache Cassandra™
-
structs-from-excel
that adds a procedural macro that unravels structs via a given, purpose-formatted Excel spreadsheet
-
needs_env_var
Skip compilation if environment variable is missing
-
strand-derive
derive macro for a strand in rope
-
validated_struct_macros
Macros for validated_struct
-
testtesttest2
test
-
kcl-derive-docs
generating documentation from Rust derive macros
-
native-windows-derive
A very light and simple rust GUI library
-
fixed_width_derive
Derive trait for use with the fixed_width crate
-
yara-x-macros
Procedural macros used by the yara-x crate
-
dir-test-macros
procedural macro for
dir-test -
rotext_internal_macros
internal macros used by rotext
-
beady
A macro for writing tests in a Behaviour Driven (BD) style
-
hyprland-macros
Macros used in hyprland-rs
-
bevy_auto_plugin_proc_macros
proc macros for bevy_auto_plugin
-
fix-hidden-lifetime-bug-proc_macros
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
tui-helper-proc-macro
Macros for widgetui
-
product-os-store-macros
Product OS : Store Macros provides a highly flexible higher order framework for defining SQL queries by using Rust directly. This crate is to be used with Product OS : Store.
-
girolle_macro
A nameko macro proc-macro to generate a Nameko Function
-
c-closures-build
Generates C/C++ FFI compatible
*Closurestructures from rust closures, useful for cross language functional programming -
unsafe-access
macros for skipping bounds checks via get_unchecked(..)
-
bloom-rsx
A JSX-like syntax for bloom
-
nject-macro
Zero cost dependency injection macros
-
rquickjs-macro
Procedural macros for rquickjs
-
leon-macros
Proc macros for crate leon
-
rusty-bind
generating Swift, C++, SWIG and WebAssembly glue code out of the input rust module containing declarations of types and functions
-
actify-macros
Actify's procedural macros
-
unirust
Rust programming, in any language. Write rust like a true polyglot.
-
varnish-macros
framework for creating Varnish Caching Proxy extensions
-
cmd_lib_macros
Common rust commandline macros and utils, to write shell script like tasks easily
-
limousine_derive
Proc macros for building hybrid index data structures
-
miette-derive
Derive macros for miette. Like
thiserrorfor Diagnostics. -
optee-utee-macros
Procedural macros for TEE internal core API
-
arbitrary-model-tests
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
gcloud-spanner-derive
Google Cloud Platform spanner client library macro derive
-
rtaichi_attr_impl
Rust language binding to the Taichi Runtime C-API
-
cl-format-macros
Proc macro for cl-format
-
raffl-macro
Rust Asynchronous FFI Library - A library for writing asynchronous callback-friendly FFI
-
macroquad_macro
Proc macro for macroquad
-
primitive_enum
Little utility for dealing with enums no extra data in variants
-
aors
Useful rs tools for Advent of Code
-
equalia
Automatically implement PartialEq for your structs
-
tii-procmacro
proc macros for tii
-
af_bevy_plugin_macro
Automates generation of bevy plugins boilerplate
-
scheme-rs-macros
Embedded scheme for the async-rust ecosystem (macros)
-
deep_causality_macros
Procedural macros that generate constructurs and getters
-
frclib-structure-macros
A derive macro for implementing the FrcStruct trait on structs
-
tower-lsp-macros
Internal procedural macros for tower-lsp
-
overrider
Override funcitons, methods, and more
-
mmtk-macros
MMTk macros provides procedural macros used by mmtk-core
-
sqlx-type-macro
Proc macros for sqlx-type
-
myko-macros
myko macros
-
ggmath_proc_macros
proc-macros for the 'ggmath' crate
-
prometheus-client-derive-encode
Auxiliary crate to derive Encode trait from prometheus-client
-
reginleif-macro
The core library of nolauncher
-
sqlx-macros-oldapi
Macros for SQLx, the rust SQL toolkit. Not intended to be used directly.
-
pascal_ident_to_string
A macro to convert an identifier to a string literal in pascal case
-
justerror
Extension to
thiserrorthat helps reduce the amount of handwriting -
wasmer-derive-asml-fork
Wasmer derive macros
-
charify
proc macro to turn its token input into a char, similar to the built-in stringify! macro
-
quickstart-lib-rust
Just for testing
-
foxglove_derive
A derive macro for a Foxglove trait
-
erg_proc_macros
proc macros for Erg
-
comprehension
Iterator comprehension in Rust
-
borrow-macro
Helper for the borrow crate
-
replisdk-experimental-proc
Procedural macros crate for replisdk-experimental
-
enum_for_matches
enum_for_matchesis a procedural macro that runs a match arm for each enum variant passed into it regardless of type -
zips
Macros for wrapping up a bunch of Option<T>'s/Result<T, E>'s into a single Option<(T [, T...])>
-
bevy_trenchbroom_macros
TrenchBroom and ericw-tools integration with Bevy
-
orbital
Automation of boiler-templates generated by CakePattern
-
builders
Rust macros for building structs
-
rerust
Reactive programming with dataflow semantics
-
dremoc-macro
Procedural macros for dremoc
-
fn_overloads
Create functions with varying arguments and return types. Please don't use this.
-
rssyin
depends on ra_ap_syntax to identify rust context for tracing and code replacement
-
spatialos-macro
Procmacro crate used to expand SpatialOS component and types created with spatialos-codegen
-
lvbitfile2rust
Generate Rust register maps (
structs) from lvbitx files - in the spirit of svd2rust -
unimock_macros
Procedural macros used by unimock
-
qname-impl
Type for qualified names in XML - implementation
-
thruster-proc
The proc macros behind the thruster web framework
-
semx_entry
为对应架构定义汇编入口以及异常入口
-
nestruct
that provides macros to easily flatten or nest structs and enums in your code
-
canbench-rs-macros
Macros for canbench-rs
-
quickcheck_macros
A macro attribute for quickcheck
-
promkit-derive
A derive macro for promkit
-
darth-rust
DarthRust is a Rust procedural macro library that aims to enhance developer productivity by auto-generating essential methods for struct manipulation. It provides a suite of macros…
-
enum_to_string
Generate a serialized string using the display trait easily
-
kittycad-modeling-cmds-macros-impl
Macros for defining KittyCAD modeling commands
-
pyo3-prost
protobuf structs in Python
-
fpr-cli-derives
that allows one to write cli tools quickly. (derive macros)
-
vrs-core-macros
Core SDK for developing Verisense nucleus
-
proc-bitfield-macros
The supporting proc-macro library for the proc-bitfield crate
-
openai-macros
macros for the openai-utils crate
-
atmosphere-macros
Macro crate of atmosphere
-
curried
currying function to be used in normal && generic && map case, with procedural macro
-
dynamic-plugin-macros
Macros for dynamic-plugin
-
minecraft-net-proc
procedural macros for the minecraft-net crate
-
prove
struct
-
arh-macros
Macros for axum-router-helper
-
counting-macros
Stateful numeric incrementing macros
-
mantra-rust-procm
Defines procedural macros used by
mantra-rust-macros -
derive-async-local
Derives for async-local
-
brocproc
Procedural macros for BrocCLI
-
require_lifetimes
A proc-macro to force rust authors to write lifetimes in function signatures
-
auto_ref
Replace &T to impl AsRef<T>
-
bracer
Macros to help write ARM assembly
-
perstruct-proc-macros
macro for adding persistent backing to a struct
-
decimal-core
Oraichain Labs
-
pay-respects-parser
Compile time rule parser for the pay-respects CLI tool
-
traitlit
exposes an atribute for implementing traits for integer and float types
-
ruzhda
Rust programming, in Bulgarian
-
vertigo-macro
Reactive Real-DOM library with SSR for Rust - macros
-
flipperzero-test-macros
Procedural macros for flipperzero-test
-
wurst
Webby UI Rust abstraction
-
lex_derive
Some derive macros for creating a lexer
-
delegate-trait-impl
Delegate trait implementations
-
tmp-path
Test helper to create a temporary directory
-
version_macro
rust cargo build binary with git version and build time
-
bignumbe-rs-macro
Macro for an efficient arbitrary base for bignumbe-rs library
-
irrefutable
Procedural macro to convert a refutable let expression to an irrefutable
-
include_gif
procedural macro that packs a gif image into a byte representation
-
arg_ripper
A proc macro for pulling local variables out of functions as arguments
-
buffered
Implement SOA for independently buffered streams
-
matrix-sdk-test-macros
Helper macros to write tests for the Matrix SDK
-
extism-convert-macros
Macros to remove boilerplate with Extism
-
rlist-driver-macro
Processor macro for rList Driver
-
nfs3_macros
providing a derive macro for XDR codec implementation
-
dao-dao-macros
A package macros for deriving DAO module interfaces
-
volo-build
Compile thrift and protobuf idls into rust code at compile-time
-
diesel-selectable-macro
A derivable
Serializemacro that selects precise fields -
bfieldcodec_derive
Derive macro for BFieldCodec
-
hax-lib-macros
Hax-specific proc-macros for Rust programs
-
dmntk-macros
DMNTK | Procedural and derive macros
-
fav_derive
Derive macros for fav
-
callback-trait
Implement trait for Fn so that functions that accept traits as parameters can directly receive Fn parameters
-
osui-element
The element attribute for defining elements in OSUI
-
java-bindgen-macro
Java Bindgen | Macro
-
axum_thiserror
procedural macro for custom error handling in web applications, enabling the association of specific HTTP status codes with error types
-
peggen-macs
Generate recursive-descent & precedence climbing parsers. (macros)
-
parcelona_macros_derive
parcelona internal macro crate
-
xenosphere-macro
A macro function for handling Xenosphere framework
-
regiface-macros
implements the macros for the regiface crate
-
box-self
Easy way to duplicate a new function with self: Box<Self> signature
-
xls_table_derive
Procedural macros for investments crate
-
aranya-policy-derive
Proc macros for generating Aranya Policy Langauge FFIs
-
whichever-compiles
Please do not use this
-
templing
Minimal templating engine
-
arc_wrapper
A attribute macro to generate a wrapper for a struct
-
syn-path
macro to declare a syn::Path at compile time
-
polywrap_schemafy_lib
Generates serializable Rust types from a json schema
-
psl-codegen
Generate native Rust code from Mozilla's Public Suffix List
-
absolution
‘Freedom from
syn’. A lightweight Rust lexer designed for use in bang-style proc macros. -
rocketmq-macros
Unofficial Rust implementation of Apache RocketMQ
-
polyhal-macro
macros for polyhal
-
butane_codegen
Macros for Butane. Do not use this crate directly -- use the butane crate.
-
syndicate-macros
Support macros for programming with the Syndicated Actor model and Dataspaces
-
derive_hub
A proc-macro for a simple actor framework
-
derive_preset
Create presets, e.g. #[hash(Default)] for #[derive(PartialEq,Eq,Hash, Default)]
-
quork-proc
The proc macros for quork (not intended for independant use)
-
polywrap_paste
Macros for all your token pasting needs
-
units-relation
A procedural macro to be used with the library Rs-Measures to define relations among units of measurement
-
spideroak-crypto-derive
Proc macros for
spideroak-crypto -
extism-pdk-derive
Helper package for the Extism Plug-in Development Kit (PDK) for Rust
-
from-num
Attribute macro #[from_num(...)]
-
lucidity-core
A distributed orchestrator platform for Rust
-
partial-enum
proc-macro generating partially inhabited enums
-
hs-bindgen-types
types behind hs-bindgen ergonomics
-
kmacro
-
srcfiles
Extract source files for a Rust crate
-
diman_unit_system
Internal procedural macros for diman
-
pywr-v1-schema-macros
Procedural macros for pywr-v1-schema
-
keycode_macro
parsing Chrome’s mapping of keys. Used in the
keycodecrate. -
include_folder_macros
proc macro for include_folder
-
usecop-derive
Rust no_std implementation of the Sample Environment Control Protocol
-
cxx-qt-macro
A set of macros for Qt/C++ interop in Rust
-
uri_path_router
A proc-macro crate that generates flattened enums for routing
-
sgx_align_struct_attribute
Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language
-
masala
Automatic curry. Yum!
-
mapstruct-derive-lib
A derive macro for mapstruct
-
vsomeip-proc-macro
Useful proc macros for generating necessary extern 'C' fns for use with vsomeip
-
fn-fixture-lib
Internal library for fn-fixture
-
i-build
bui
-
bobo-oop
a part of bobo library about oop
-
glrs
Macros for padding-equivalent importing of OpenGL constructs
-
event-driven-macros
Macros for the Event Driven Finite State Machine library
-
hipcheck-macros
Helper macros for the
hipcheckcrate -
macro-visit
Function like proc-macro visitor for build.rs
-
statig_macro
Macro’s for
statig -
refuse-macros
Macros for the Refuse garbage collector
-
to_tokenstream
An interface for creating a compiler within a Rust macro
-
amplify_syn
Amplifying syn capabilities: helper functions for creating proc macro libraries
-
nested_enum_utils
Macros to provide conversions for nested enums
-
emmylua_diagnostic_macro
A proc-macro for generating diagnostic code for emmylua-analyzer-rust
-
trowel_macro
A macro for writing HTML in Rust
-
mobile-entry-point
Generate app entry-point boilerplate for iOS & Android!
-
tokio-actor
Macro based Asynchronous Actor System
-
acton-macro
Acton Macro provides procedural macros that simplify the creation of messages and agents in the Acton framework, enabling more concise and expressive code
-
minus-one
A proc-macro crate to subtract one from a number
-
gll-macros
Macros used with the gll crate
-
monistode-macros
A set of assembler-generating macros for monistode
-
toursql
a derive macro for gluesql
-
ir_arcane
personal mcaro library, not for public use(yet)
-
mapstic-derive-impl
derive macro provided by the mapstic crate
-
include_dir_macros
The procedural macro used by include_dir
-
felysian
Macros for the Felys programming language
-
nan-serve-dal-tx-impl
A collection of utilities for nanoservices
-
size_of_const_macro
Macro for generating the constant of a type's size
-
freenet-macros
Procedural macros for Freenet
-
panic_discard
A proc-macro that discards panics that happen within a function
-
tosho-macros
A macro library for tosho-mango
-
lotus_proc_macros
Lotus Proc Macros is a crate designed to store the 'Derive Macros' used in the Lotus project
-
inter-struct-codegen
Proc macro codegen crate for merge-struct
-
faer-macros
linear algebra library
-
microscpi-macros
Required macros for the microscpi library
-
tailwag_forms_macro_logic
The logic for a suite of macros supporting the tailwag_forms crate
-
hpl-toolkit-macro-platform-gate
HPL macro for defining an platform-gate
-
merge-cfg
Merge or cover config based on priorities
-
bevy_bundlication_macros
Macros for bevy_bundlication
-
actix-web-codegen-const-routes
Routing and runtime macros for Actix Web with support for const routes
-
zipkin-macros
Macros for use with
zipkin -
one_user
Constrain the number of instances that can possibly be used at a time. By default it constrains it to one instance at a time, hence one_user.
-
round_view_derive
Procedural macros to generate methods r2_view, r3_view and r4_view
-
securefmt
Drop-in replacement for the Debug derive macro that hides fields marked as sensitive
-
optional_struct_macro
Helper crate implementing the proc_macro for the optional_struct crate
-
ace_it
Macro to automate wrapping types into enums
-
bitlight-core-derive
providing derive macros for the Bitlight core
-
e-macros
macro definition that can handle Json and C data
-
literal-enum
Convert an [
enum] to a [literal], and try to convert it back -
rusql-alchemy-derive
macro for rusql-alchemy
-
bincode_macro
Add macros to bincode to make it easier to use
-
trust-me-2
A convenient macro to tell the Rust compiler that you know better and to leave you alone regarding unsafe code
-
dot15d4-macros
Procedural macros for the dot15d4 crate
-
nonparallelex
Rust macro for ensuring non-parallel execution of functions, extended Fork of
nonparallel -
dioxus-translate-macro
Libraries for internalization on Dioxus
-
unity_native_proc_macro
The derive macros for the unity_native library
-
exposed-macro
Contains macros required by "exposed"
-
rcss-bundler
Part of Rust CSS embedding library that allows using collect and save all styles in a file
-
reqwest-scraper-macros
Web scraping integration with reqwest
-
derive_everything
#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] everything if possible
-
edifact-types-macros
Macros for edifact-types
-
primwrap
Derive operation traits for primitive wrapper structs
-
xee-xpath-macros
Proc macros for xee-interpreter function library
-
test-r-macro
Test framework for Rust (macros)
-
macro-ob
a macro to inline rot13 to confuse IDEs
-
cpclib-macros
cpclib macros related to z80 assembling
-
test-impl
A macro for use in testing, to run a test on multiple trait implementations
-
spirv-std-macros
Macros for spirv-std
-
hermes-five-macros
Macros definitions for hermes-five
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
match_token
Procedural macro for html5ever
-
netdb_auth_macro_derive
Netdb Auth validation for rocket
-
wars-pit-plugin
PIT plugin for WaRs
-
thag_proc_macros
proc macros for the thag_rs crate. Copied from crokey crate under MIT licence
-
rscel-macro
Cel interpreter in rust
-
parabox-macros
Procedural macros for the Parabox game engine
-
div-int-procmacro
Proc macro implementation for the div-int crate
-
mozilla-central-workspace-hack
Workspace hack for mozilla-central
-
tuple_for_each
macros and methods to iterate over the fields of a tuple struct
-
lexopt_derive
Derive macros for lexopt
-
mp4ameta_proc
Procedural macros to generate common accessors for the mp4ameta crate
-
rtsan-standalone-macros
Macro crate for RTSan standalone
-
magnus-macros
Derive and proc macros for magnus
-
cpreprocess
Procedural macro that runs a C preprocessor on the input
-
bevy_startup_tree_macros_core
core of bevy_startup_tree_macros
-
allow-until
Allows an item until a specified semver version, and then errors on compilation
-
syntastica-macros
Macros for internal use in syntastica
-
shimkit-macros
Macros for shimskit
-
composint-macro
Space efficient structs using otherwise useless bits
-
packet_derive
Derive implementation for packet_enum
-
icecream
Print debugging with inspection
-
ai-chain-macros
Set of macros for use with ai-chain
-
forward_goto
bringing gotos to Rust
-
portfu_macros
Portfu Macros for Generating Endpoints and Tasks
-
trapeze-macros
Macros for trapeze
-
embed-rust
A macro that allows to embed a Rust executable
-
crepe
Datalog in Rust as a procedural macro
-
iffy
proc macro for simulating the ternary operator from C-like languages
-
sweet_macros
macro crate for sweet
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
into-jsvalue-derive
derive into-jsvalue for enum return values in async wasm_bindgen functions
-
semx_bsp
对应硬件板级定义
-
async-blocking-bridger
A way to write a blocking client and async client without repeating yourself
-
qt_macros
Macros for Qt
-
rspack_macros
rspack macros
-
ref-mut-n
Defines a nested mutable reference
-
derive-extras
Adds a number of useful extra
#[derive(...)]macros -
portaldi-macros
Macros for portaldi
-
proclet-utils
proclet
-
polyhorn-ui
Shared API contract for multi-platform Polyhorn UI
-
include-utils-macro
Internal proc macro for the
include-utilscrate -
prusto-macros
prusto macros
-
option_ord
configure ordering on 1+T with the 1 either smallest or largest, explicit vs derive default
-
diesel_sqltype_enum_pg
Diesel automatic derivation of
FromSqlandToSqlfor enums withSqlTypegenerated bydieseland takingToStringandFromStras base. Postgres binding only -
sidevm-macro
Macros for writing phat contract sidevm program
-
jsonrpc-utils-macros
Proc-macros for jsonrpc-utils
-
rcstruct
Generate transparent
Struct(Rc<RefCell<Struct>>)newtypes -
elm_to_view
A macro for parsing elm_markup to leptos view
-
pyderive-macros
Macros for pyderive crate
-
vise-macros
Procedural macros for
visecrate -
yfunc-rust-macro
-
java_asm_macro
Java bytecode reader & writer in rust
-
feature-gate
macro for feature-gating modules and types
-
lambda-lw-http-router-macro
Procedural macros for lambda-lw-http-router
-
stringvec
macro for creating Vec<String> from various types
-
everyday_macros
contains all the procedural macros you might use in your everyday life while coding. Things like a thread sleep timer or a retry on error.
-
microcad-builtin-proc-macro
µcad builtin proc-macro
-
starbase_macros
Macros for the starbase framework
-
sonic_spin
Reads ::() as a general postfix operator
-
xshell-macros
Private implementation detail of xshell crate
-
bevy_utils_proc_macros
Bevy Utils Proc Macros
-
docext
-
standalone-proc-macro2
Fork of proc-macro2 that uses rustc-ap-proc_macro so as to remove the rustc dylib dependency
-
yolo_keyword
Adds the yolo keyword
-
s2p
helper create to convert list of struct to polars dataframe
-
rusty_gate
lightweight and efficient web framework in Rust designed for handling HTTP requests with built-in gatekeeping middleware
-
sorted_locks_derive
Macro to aquire
std::syn::RwLockorstd::syn::Mutexlocks with consistent order to prevent deadlock -
elvish-macros
Overengineered Advent of Code framework - not quite Santa's elves
-
cubing_macros
Features from
cubing.jsin Rust -
dynamic_services_derive
A dynamic services injection framework implemented as macros
-
proc-macro2-impersonated
A substitute implementation of the compiler’s
proc_macroAPI -
rem-extract
Providing extract method capability for the REM toolchain
-
druid-lens-compose
Build druid lenses out of other lenses
-
laps_macros
Macros for crate
laps -
stry-attrouter
A attribute based router for various Rust web servers
-
ff_derive-zeroize
Procedural macro library used to build custom prime field implementations
-
bogdan_hello_macro_derive
adds the method hello_macro that generates a greeting based on the name of the struct
-
iced_layershell_macros
Wayland extra shell lib
-
crux_macros
Macros for use with crux_core
-
vmi-macros
Procedural macros for VMI
-
ndk-macro
Helper macros for android ndk
-
yew-attrs-macro
Dynamic attributes for Yew
-
snafu-cli-debug
Derive a debug implementation on snafu errors that prints pretty CLI output
-
sled_driver_macros
Procedural macros for use the in the sled crate
-
xy-rpc-macro
An RPC framework for Rust
-
mplusfonts-macros
Procedural macros re-exported in the mplusfonts crate
-
algorithm-macro
about algorithm data structure, now has ttl with lru/lru-k/lfu/arc and slab/rbtree/roaring_bitmap/timer_wheelss, 关于算法常用的数据结构
-
valence_entity
Minecraft entities for Valence
-
my-wgsl-macros
A procedural macro for my-wgsl crate
-
hs-hackathon-macros
Macro support crate for Helsing's Rust Nation hackathon
-
rzhavchina
Rust programming, in Russian
-
extra_args
Rust macro to pass implicit args to functions (use with care)
-
netxbuilder
netx builder assembly
-
wasmir
automating statically linking WASM binaries
-
mddd-std
small framework for DDD init sysmem and CLI interface. Sub crate with std tools. Use "mddd" crate
-
mainstay-derive-space
Mainstay Derive macro to automatically calculate the size of a structure or an enum
-
derive_generic_visitor_macros
Macros for
derive_generic_visitor -
crdts_macro
CRDTs proc_macro
-
variantly
Derive helper methods for enum variants that are familiar from
std::option::Option&std::result::Resultsuch asunwrap_ororand_then -
drias
spans and diagnostics
-
pavex_macros
Procedural macros for the Pavex framwork
-
pisserror_macros
The internal implemenation of
pisserror -
satrs-mib-codegen
satrs-mib proc macro implementation
-
async-openai-macros
Macros for async-openai
-
maelstrom-macro
Macros for Maelstrom internal usage
-
attribution
A declarative custom attribute parsing framework
-
routee-compass-macros
Macros for the RouteE-Compass energy-aware routing engine
-
dataclass-macro
A procedural macro for generating dataclasses in Rust
-
telexide_proc_macros
macros for subscribing to events in telexide
-
vls-policy-derive
implementing a Lightning signer, which externalizes and secures cryptographic operations
-
fieldwise
Derived field-wise conversions for Rust structs
-
gami_macros
Macros for the gami_mc_protocol crate
-
indiscriminant_lib
A proc-macro for mapping between values and enum discriminants
-
lower-macros
desugar math where the compiler wont
-
count-macro
macro to perform compile time counting
-
mun_codegen_macros
Macros used by mun code generation
-
subtle-ng-derive
Derive macros for subtle-ng traits
-
c2rust-macros
Procedural macro support crate for C2Rust
-
timrs_pipe_macro
Procedural macro providing Elixir-style pipe operators for function composition
-
flawless-macros
Macros for flawless
-
jsm
Jay's stupid macros
-
harled
Helper traits for developing derive macros similar to darling
-
trailbase-refinery-macros
Fork of Refinery's refinery-macros crate
-
sdl3-main-macros
Proc macros for sdl3-main
-
coreum-std-derive
Procedural macro for osmosis-std
-
ext-crud-derive
Derive macros for ext-crud-rs
-
lpu-macros
Macros used for lego-powered-up
-
try-let
Proc macro for a basic try-let form
-
radiation-macros
Macroses to derive traits for radiation crate
-
power-protobuf
a proc-macro for embedding protobuf inside rust code
-
memoizee-macro
A proc macro for simplifying usage of memoizee
-
enumorph
Derive macro to generate
TryFromandFromimplementations for converting between newtype enum variants and their wrapped values -
cloneable_dyn
Macros to make structs and enums clonable that use dyn Objects
-
code_gene_macro
code generation macros
-
ferrum_oxidize
Compiler library for the Ferrum programming language
-
transmute-tools
Proc macros and traits to assist with safely creating transmutable data structures
-
basic-text-literals
Basic Text string literal macro for basic-text
-
teloxide_tests_macros
Proc macros for teloxide_tests
-
smarty-rust-proc-macro
The official client macro for creating Smarty APIs for Rust
-
wgpu-pp
C-style preprocessor for WGSL using proc macros
-
enum-derived-macro
Macros for enum-derived
-
type-id-derive-impl
-
gset
A procedural macro for generating the most basic getters and setters on fields
-
cowlang-derive
Python-like scripting language: Macros
-
scrub
Remove span information to improve error messages
-
pam-macros
Macros for the pam crate
-
go-pmacro
some proc-macros for the goscript project
-
cast_checks_macro
-
encdec-macros
encdec simple encoder/decoder derive macros
-
virolution-macros
Proc macros for virolution
-
phper-macros
The proc-macros for phper crate
-
dont-expand
Dummy macros to shadow macros to avoid expansion in cargo expand
-
pmhelp
A WIP library to assist in the creation of procedural macros
-
adtest
better test generation
-
pathfinder-tagged-debug-derive
Debug trait derive macro for pathfinder-tagged types
-
function_from_equation
Creates a function from a math equation
-
rustradio_macros
Software defined radio library
-
typewit_proc_macros
detail of typewit
-
macro_optim
procedural macro crate for optimizing and simplifying various expressions at compile time
-
crows-service
Service macro used for the Crows RPC communication
-
rust-try-catch-macros
try catch proc macros
-
proc-macro2-fallback
Only the non-libproc_macro-based codepath of the proc-macro2 crate
-
geoip2-codegen
geoip2 macros
-
aigen_macros
Procedural macros for testing
-
tw_merge_variants
Variant macros for tw_merge
-
extends-rs
rust extends impl a macro attr
-
wrapping_proc_macro
A proc macro for cleaner wrapping arithmetic
-
clippy-tracing-attributes
add, remove and check for
tracing::instrumentin large projects where it is infeasible to manually add it to thousands of functions -
culpa-macros
Internal implementation details of
culpa -
global-secrets-manager
procedural macro for easy use of AWS Secrets Manager. This code allows you to create a global constant of the same type as the name of Secrets Manager by simply creating a structure…
-
puff_bench_macro
Benchmark macros
-
lazy-re
lazy reverse engineers
-
airgl
down into the white wind flow’rs
-
teenygame-macro
Macros for teenygame (implementation detail)
-
bend
Bend types (Forwarder macro to easily forward errors (auto-implements From trait for error type))
-
impl-opaque-macro
Macro for declaring complex struct and initializer
-
cronback-dto-core
Data transfer object library for Cronback
-
fantasy-cpu-emulator
Fantasy CPU Emulator
-
native_db_macro
A procedural macro for native_db
-
knuckles-macro
A procedural macro crate for generating Knuckles
-
i-love-jesus-macros
internal crate
-
srsql
cuckoo
-
knyst_macro
Real time dynamic audio graph and synthesis library
-
html-macro
html macro
-
adversary-macros
Procedural macros for the adversary crate
-
incdir
Compile-time including of directories
-
primitive-enum-derive
macros for get primitive enum from complex
-
hitrace-macro
Convienience macros for instrumenting code with hitrace
-
chorus_derive
Macros for ChoRus
-
print_each_line
It prints each line and execution time during execution. You can utilize it as a super simple profiler.
-
kexplain
Derive explanations for functions by 'showing the work' for things like math
-
youtube_chat_macro
proc_macro s for
youtube_chatcrate -
irox-derive-helpers
Helper traits & functions for the proc_macro crate to aid in writing less complex derive macros
-
spyglass-cli
A cli tool designed to make substreams development a more ergonomic and type safe experience
-
charted-testkit-macros
📦🦋 internal procedural macros that you shouldn't depend on
-
dbn-macros
Proc macros for dbn crate
-
xparse-macros
A parser combinator that is fully statically dispatched and supports both sync & async parsing
-
getset-macro
A procedural macro that simplifies the creation of getter, setter and constructor methods for fields in your Rust structs
-
goglob-proc-macro-tests
Internal library used for testing goglob, not for public use
-
nullable_struct
A derive macro that makes it easy to create nullable versions of structs
-
hc-homie5-macros
Helper crate for hc-homie5 to implement procedural macros for homie device creation
-
decolor
Asynchronous runtime abstractions for implicit function decoloring
-
indextree-macros
Macros for indextree
-
toolbelt_a_pm
toolbelt_a's proc macros
-
maxlen-macro
Length-bounded string and slice/vector
-
arouse
Arouse is
-
jump-kun-macros
jump-kun. Parses jump-kun config file and creates fucntions.
-
either_trait_macro
An attribute-like macro to implement traits for Either
-
include_optional
Option-returning versions of include_X macros
-
pam-macros-f
Macros for the pam crate
-
memoize-inner
Helper crate for memoize
-
lit-mod
collection of procedural macros for working with string literals
-
todo_by
Compile-time lifetimes for comments
-
embedded-test-macros
proc-macros for the embedded-test crate
-
turbolift_internals
macros for turbolift
-
dioxus-switch-macro
a macro to create Switchable enums in an easy way
-
natural-derive
Proc macros for naturally deriving basic trait impls for new types
-
default_fields
derive macro that adds a default getter function for each struct field
-
actix-json-responder
A procedural macro to reduce json response boilerplate on actix projects
-
annotation-rs-beta
Compile-time annotation parser for rust
-
spl-discriminator-syn
Token parsing and generating library for the
spl-discriminatorlibrary -
derive-ocaml
Custom derive and procedural macros for easy FFI with ocaml on top of the ocaml crate
-
prest-embed-macro
fork of embed macro from rust-embed
-
hidmystr
Hide string at compile time and treat variable value as original at runtime
-
http-request-derive-macros
Use derive to create HTTP requests
-
structified_enum
Marcos to structify unit-like enum with discriminants
-
bevy_tailwind_macro
TailwindCSS for Bevy
-
exemplar_proc_macro
Proc macros for the exemplar crate
-
uniffi_internal_macros
a multi-language bindings generator for rust (interal macro crate)
-
paperclip-macros
Macros for paperclip OpenAPI tooling library
-
small_derive_deref
Derive the Deref and DerefMut traits
-
jni_fn
JNI-compatible method signature generator
-
cxx_linker
A procedural macro for linking Rust functions with C++ using Itanium name mangling
-
r-lombok-macros
r-lombok is a rust macros that automatically plugs into your editor and build tools
-
compose_spec_macros
Procedural macros for use in the compose_spec crate
-
binf_macros
that adds utilities for dealing with binary flags
-
ruva-macro
Event Driven TEvent Handling
-
static-noise
generation static noise at compile time
-
axum-codec-macros
Procedural macros for axum-codec
-
veil-macros
Veil procedural macros
-
text-image
A proc-macro to generate raw image from text and a font file, for embedded-graphics
-
general-structs
General-structures - this library allows you to create structures with common fields, and those that are different can be specified individually
-
ntex-macros
ntex proc macros
-
zenoh-ros-derive
Common Rust struct for ROS 2 messages used by Zenoh
-
test-fork-macros
Supporting procedural macro crate for test-fork
-
delve
number of macros that make working with enums and strings more convenient
-
wiwiwiwiwi
proc macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
duchess-macro
Internal component of duchess crate
-
proc-macro-id
Identity procedural macro
-
teleparse-macros
Proc-macro crate for teleparse
-
nut_self
Makes your code nut
-
rmp-macros
Macros for Rust Multi Platform
-
bevy_derive_commands
A macro for creating bevy Commands methods
-
hippotat-macros
Asinine HTTP-over-IP, proc-macros
-
ctreg-macro
Proc-macro implementation for ctreg
-
pzmacro
general macro; demo: https://github.com/FaceWaller/pzmacro
-
frunk_utils_derives
Derives for frunk traits
-
noir_macros_core
Essential proc-macros and utilities for no_std Rust development
-
dynamodb-helper
Macro that creates a struct for interacting with AWS DynamoDB
-
llm-chain-macros
Set of macros for use with llm-chain
-
digestible-macros
Macros for generating digest implementations
-
test-trace-macros
Supporting procedural macro crate for test-trace
-
must-implement-trait
An attribute proc-macro which enforces that a type (auto-)implements the specified trait(s)
-
checksum_dir
generate checksums of directories at compile time
-
xflags-macros
Private implementation details of xflags
-
castle_schema_parser
Castle Schema Parser
-
ucc
Universal compiler invocator for heterogeneous CPU/GPU computation applications
-
type_pipe
Curry types
-
fill-array
macro allowing to fill arrays with an expression
-
mcp-macros
Macros for Model Context Protocol SDK
-
wiki-api-macros
Proc-macros for use within wiki-api
-
surrealdb_functions
procmacro for surrealdb functions (fn::*)
-
mixinx
mixin not only struct fields, but also impl funcs and traits
-
vpi_export_macro
proc-macro for vpi_export
-
ty-tag-macros
Proc macros for ty-tag
-
nxml-rs-macros
Procedural macros for the nxml-rs crate
-
proc-macro3
defines a macro that imports either from
proc_macroorproc-macro2depending on theproc-macro2feature flag -
builder_m4cro
derive macro to implement the builder pattern
-
notan_macro
set of utils as macros for Notan
-
rudi-macro
Macros for Rudi
-
ormx-macros
lightweight procedural macros bringing orm-like features to sqlx
-
fail_on_ci
Script to abort compilation if one of the known CI-Servers is detected
-
functions_ai
Function to string implementation for LLMs
-
jsonschema_code_generator
generating rust types from JSON schemas
-
rmin-macros
A minimal Rust lib for writting R extensions
-
renaissance
rich man cries like a crocodile
-
stylers_core
Scoped CSS implementation in Rust
-
actix-cloud-codegen
Proc macros for Actix Cloud
-
introspect-proc-macros
Procedural macros for
introspect -
dojo-macros
ORM for Rust
-
shallow-debug
A basic Debug derive macro that can be used on any type
-
inline-doc
Embed markdown/text files as documentation
-
studs-lib
Studs that provides macro implementations and utilities
-
xmlserde_derives
macros that help xmlserde serde the xml files
-
translator
A procedural macro which translates your repr-C structs into C++, Python and C# at compile time for helping write FFI libraries
-
linker-set-proc
Procedural macro for linker-set crate
-
partial-application-rs
A macro to transform functions into partially applicable structs
-
mutablex
A horrid macro for making mutables of X size
-
actix-default-responder
Procedural macro for generating default
Responderimplementation for a specific data type (ie. json, xml, etc). -
actix-handler-macro
Helper macros for using Actix. Generates handlers, actors and address traits.
-
r2r_macros
Minimal ros2 bindings
-
hifmt-macros
Format output without Rust code segment in binary to reduce the ultimate binary size
-
leptos_macro
view macro for the Leptos web framework
-
wasm_bindgen_cfg
wasm-bindgenthat can becfg’d -
bomboni_core
Internal part of Bomboni library
-
impl-from-into-similar
Implement Into to any struct to convert between structs sharing similar fields. Uses serde_json.
-
nu-derive-value
Macros implementation of #[derive(FromValue, IntoValue)]
-
bingen
Procedure macro for bringing a compile-time compiled assembly code as a binary slice
-
form-yew
a macro to help with forms in yew
-
many-macros
Procedural macros to support create MANY modules
-
thaw_macro
Shared Thaw internal macro
-
dep-inj-target
Stateless target creator of dep-inj
-
type-sig-proc-macro
type-sig: Internal crate that defines the procedural macro, don't use this directly
-
emboss_macros
Proc macro implementations for emboss
-
rrplug_proc
proc macros of rrplug
-
server_fn_macro_default
The default implementation of the server_fn macro without a context
-
polyerror
Macro to make errors easy and expressive
-
dioxus-class-macro
Dioxus class proc_macro
-
exhaust-macros
Proc-macro support for the 'exhaust' library
-
target-test-dir-support
Support for the
target-test-dirproc-macro crate -
accessors-rs
Derive macro generating an impl for accessing the fields of a struct
-
sw4rm-rs-generation
handle generation of rust models & apis from OpenAPI v2, v3, and v3.1 specs
-
ra_ap_salsa-macros
Procedural macros for the salsa crate
-
enum-filter
Filter to a specific enum variant from an iterator
-
hecs-macros
Procedural macro definitions for hecs
-
ouroboros_macro
Proc macro for ouroboros crate
-
env-smart
Proc macro to insert env vars into code
-
mcp-attr-macros
creating Model Context Protocol servers using declarative descriptions with attributes and types
-
metamorphose
Macros collection for converting Structure to Model, for a green-barrel project
-
sscanf_macro
Proc-Macros for the sscanf Crate. Not meant to be used as a standalone Crate
-
chatdbg_macros
Rust-specific (macro) support for ChatDBG
-
ruwren-macros
Proc-macros for ruwren
-
vtable-macro
Helper crate to generate ffi-friendly virtual tables
-
rempl-macros
creating html components directly in your source
-
serde_tuple_macros
Internal proc-macro crate for serde_tuple
-
pen-ffi-macro
FFI macro library for Pen programming language
-
smartdeploy-macros
Smartdeploy macros
-
optirustic-macros
A set of macros for the optirustic crate
-
vexide-macro
Proc macros for vexide
-
context_manager_macro
Process macro for context_manager crate
-
axsys-noun-macros
working with Noun data
-
polkavm-derive-impl-macro
The derive crate for PolkaVM guest programs (proc-macro)
-
daml-codegen
Daml GRPC Ledger API Code Generator
-
pfetch-extractor
proc-macro to extract pfetch logos at compile time
-
from_tuple
Derive structs from tuples
-
mvc_views
A procedural macro to append rendering blocks to Actix Web handler functions
-
alioth-macros
Proc macros for Alioth
-
standalone-quote
Fork of quote that allows disabling the proc-macro feature in proc-macro2 so as to remove the rustc dylib dependency
-
tracers-codegen
Contains the compile-time code generation logic which powers the
probeandtracersmacros.Do not use this crate directly; see "tracers" for more information -
deno-tower-lsp-macros
fork of https://crates.io/crates/tower-lsp macros, used in Deno. At the moment only floating patches.
-
macros-core
lightweight, and highly configurable library for quickly parsing macro input into custom objects
-
hydroflow_plus
Functional programming API for hydroflow
-
openharmony-ability-derive
Binding Rust application macro on Harmony with Ability
-
c2rs
C struct to Rust struct
-
enum-utility-macros
A macro to generate useful helpers for enums
-
bevy_startup_tree_macros
procedural macros for bevy_startup_tree
-
axum-routes-macros
Create an axum Router from an enum and resolve routes
-
rhaki-cw-plus-macro
Macro for rhaki-cw-utils
-
import-modules
based on require-all
-
dynasty-macros
Procedural macros for the Dynasty class system
-
ndjsonlogger
-
membrane_macro
A companion crate for
membrane -
aws-macros
Helper functions and types for AWS operations
-
flagger-macros
Enum flag generator proc macros
-
domcom-form-manager
A macro to simplify forms. Must be used with domcom
-
to_sql_condition
genreate sql condition proc macro
-
opentalk-types-common-macros
Macros for opentalk-types-common
-
restate-sdk-macros
Restate SDK for Rust macros
-
ijzer_macro
Macro for using IJzer in a rust project
-
to_phantom
Convert generics to PhantomData in proc macros
-
struct_morph
macro for morphing one struct into another
-
smile-marco
One contains many useful macros for generating common code
-
op-proc
proc macro for op
-
cpy-binder
when creating binds from Rust to C++ and Python
-
open-protocol-codec-proc-macro
Procedural macros for deriving encode/decode implementations for Atlas Copco/Torque Open Protocol
-
cfg_boost
Revamped syntax and macros to easily manage all #[cfg] parameters in one package. Compatible with stable toolchain and no dependencies. See README / Homepage for more details.
-
errgo
generate enum variants inline
-
bluejay-typegen-macro
Macros for
bluejay-typegen -
xoev-xwasser-derive
"XOEV XWasser XML Standard"
-
clone_from
Derive Clone including clone_from
-
tokio-pg-mapper-derive
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
struct_ext
A set of useful derive macros for structs
-
io_deser
Procedural macro crate for generating implementation of IoDeSer trait for structs
-
cute_custom_default
Derive macro for
Defaulttrait with customization -
bevy_ergo_plugin
Macros to make building bevy plugins more ergonomic
-
dialogue-core
the core of dialogue-macro
-
mlua-gen-macros
Generates code to easily use Rust's structs or enums in Lua with mlua
-
boa_macros
Macros for the Boa JavaScript engine
-
dynex
Inherit and derive object-unsafe traits for dynamic Rust
-
strong_id_macros
Macros for the strong_id crate
-
serenity-commands-macros
creating/parsing Serenity slash commands
-
blade-macros
Macros helpers for Blade users
-
bitmask-enum
A bitmask enum attribute macro
-
netsblox-extension-macro
Macros used by netsblox-extension-util
-
quickcheck_async
Runtime-agnostic attribute macros to use quickcheck with async tests
-
preinterpret
An intuitive toolkit to simplify code generation development
-
trait_deref
Macro that simulates inheritance in a trait
-
spring-macros
spring-rs Procedural Macros implementation
-
fieldset_macro
fieldset macro crate
-
syn_builder
Builder functions for
synstructures and enums to ease the generation of Rust code -
nidrs-macro
a nidrs macro
-
opt_args
Create macros for functions and structs with default values
-
rustfmt-config_proc_macro
A collection of procedural macros for rustfmt
-
wasm-typescript-definition
serde support for exporting Typescript definitions using wasm-bindgen
-
marlin-veryl-macro
🦀 No nonsense hardware testing in Rust 🛠️
-
aformat-macros
Internal proc-macro crate for aformat
-
dioxus-tw-components-macro
Macros used by dioxus-tw-components
-
derive-regex-proc-macro
proc macro implementation of derive_regex
-
trident-derive-accounts-snapshots
trident-accounts-snapshots
-
schematic_macros
Macros for the schematic crate
-
agb_sound_converter
converting wavs for use on the Game Boy Advance
-
inline-rust
A stupid macro that compiles and executes Rust and spits the output directly into your Rust code
-
hax-adt-into
adt_intoprocedural macro, allowing for mirroring data types with small variations -
x12-types-macros
Macros for x12-types
-
bubbly-bub-test
Interactive mode extension crate to Command Line Arguments Parser (https://crates.io/crates/clap) (derive macros helper crate)
-
const-addrs
A set of macros for creating networking types from a string literal
-
sapling-rewrite-macros
Proc macros to rewrite code used by Sapling
-
bevy_encase_derive
Bevy derive macro for encase
-
if-to-let-chain
Convert macros from the let_chains crate to if chains
-
nova-impl
nova crate
-
sqlparser_derive
Procedural (proc) macros for sqlparser
-
show-image-macros
macros for the show-image crate
-
swc_visit_macros
Visitor generator for stable rustc
-
include-wasm-rs
Builds a Rust WebAssembly module at compile time and returns the bytes
-
cali_derive
Contains the macro's used to simplify a Cali project's setup & testing
-
ergokv-macro
Easily store and retrieve data from TiKV with a derive
-
obfustring
Procedural macro that obfuscates string literals with RNG at compile time
-
nan-serve-publish-event
Tokio event publisher for nanoservices
-
actix_responder_macro
An attribute macro to transform a response struct to an actix responder
-
impl-template
A procedural macro for generating impl-blocks based on a simple template
-
asn1_codecs_derive
ASN.1 Codecs derive Macros
-
ollama-rs-macros
Procedural macros for ollama-rs
-
cob_sickle_macros
Macros for sickle_ui
-
asn1-codecs
ASN.1 Codecs for Rust Types representing ASN.1 Types
-
bevycheck
bevy error messages by proc-macro
-
getset2
derive macro, which is inspired by getset, is designed for generating the most basic getters and setters on struct fields
-
krpc-macro
RPC framework for service registration and discovery through API exposure, compatible with Dubbo3 protocol, intertunable with Java projects
-
route_match_macros
The route_match macro implementation
-
rust-ad-core
Rust Auto-Differentiation
-
chuot-macros
Procedural macros for the Chuột game engine
-
tryfrom-via-fromstr
Derive
TryFromby delegating to theFromStrimpl -
wasm-bindgen-macro
Definition of the
#[wasm_bindgen]attribute, an internal dependency -
procmeta-core
proc-macro helper
-
clia-redis-macros
A derive to store and retrieve JSON values in redis encoded using serde
-
ref_iter_macro
Macros for 'ref_iter'
-
macro_tools
Tools for writing procedural macroses
-
xso_proc
Macro implementation of #[derive(FromXml, AsXml)]
-
flag-bearer
Generic async semaphores
-
steam-vent-proto-build
Build steam-vent compatible protobuf bindings
-
sqlb-macros
Macros for sqlb. Not intended to be used directly.
-
car
std::array::{map, from_fn, try_from_fn} in const
-
approx-derive
Extends the approx crate by derive macros
-
derive-stack-queue
Derives for stack-queue
-
macro-gpt
proc macro that uses ChatGPT to generate rust code at compile-time based on a prompt, and a less simple one that can inject the results of prompts directly into your editor!
-
rmcp-macros
Rust SDK for Model Context Protocol macros library
-
mini-tokio-attr
macros for mini-tokio
-
diesel_enum_derive
Enum derive for [Postgres only] Varchar fields
-
fusen-procedural-macro
fusen-common
-
gtk-blueprint
Use Blueprint in Rust GTK applications
-
crokey-proc_macros
proc macros for the crokey crate
-
toml-cfg
A procedural macro for configuring constant values across crates
-
oxidate
Turns strings into a Rust AST
-
derive-redis-swapplex
Derives for redis-swapplex
-
celestia-grpc-macros
Helper crate for grpc_method macro for creating gRPC client, used by celestia-grpc
-
scryer-prolog
A modern Prolog implementation written mostly in Rust
-
tentacli-packet
Macro for implementing packet structures
-
libasm
adds inline assembly to stable rust
-
lure-macros
Shift left with Lure, a Rust crate that provides a macro for creating lazy Regex instances with compile-time validation, ensuring invalid patterns fail to compile
-
named-ctor
proc-macro to generate constructor functions with syntaxt similar to named params
-
mpst-seq-proc
macro for mpstthree
-
macroscope-utils
detail of the macroscope library
-
token_stream_flatten
Flattening iterator adaptor for token streams
-
xixixao/rust_to_metal_sl
ShaderToy clone in Rust, currently supporting MacOS
-
warcmutex
in Rust that provides an attribute macro for mods, structs and impls. Rewrite code using under the hood asynchronous reference (Arc) and asynchronous mutation (Mutex) control elements.
-
rustic-jsonrpc-macro
JSON-RPC 2.0 server library written in Rust
-
overfn
overloading system for functions with different arguments
-
bind_it
A macro that allows impl traits in let/static/const bindings until they actually stabilized
-
msft-service-macros
macros for service
-
gandiva_rust_udf_build
A basic shared library for gandiva rust udf
-
samevariant
Derive enum of same-variant pairs
-
derive2
An attribute macro that executes a function-like macro
-
kalosm-learning-macro
A macro to derive kalosm learning traits
-
toti
Expand macro N times for multiple generics
-
discriminant_hash_derive
Derive macro to implement Hash trait based on enum's discriminants only and ignore variant's fields
-
de_generics
generate 'de lifetimes for custom serde derive macros
-
workflow-html-macros
Workflow Macros for HTML Rendering
-
qualified_do_macro
Core macro implementation for qualified_do
-
TCFSMFTTTCS
Unsafe, yet fast finite state machine for counting :ty TokenTree clusters in any :ty TokenTree cluster sequence. It works for proc_macro2::TokenStreams too
-
actuate-macros
Macros for Actuate
-
bevy_state_macros
Macros for bevy_state
-
pulp-macro
Safe generic simd
-
enum-field-getter
A derive macro to create mutable and immutable getters for tuple/struct members of enum variants
-
struct-split-macro
Helper for struct-split crate
-
ezno-parser-visitable-derive
Derives 'Visitable' trait for Ezno AST
-
russenger_macro
Proc macro for creating new action on Russenger lib
-
assets_manager_macros
Procedural macros for assets_manager
-
dp_macro
procedural macro that implements memoization for dynamic programming
-
fixed-type-id-macros
Make your types have a fixed type id&stable type name with version support between different builds
-
p5doc
p5.js diagram within rustdoc
-
impl_here
A macro that helps impl method for foreign types
-
leptos-struct-table-macro
Macros for the leptos-struct-table crate
-
taurpc-macros
Macros for the taurpc crate
-
rust_arkitect
lightweight library for defining and validating architectural rules in Rust projects
-
trino-rust-client-macros
trino rust client macros
-
kstool-helper-generator
A macro help user create mpsc communications
-
factoryizer
Add factory/builder patterns automatically
-
rdxl_static
Static Site Generation Utilities for RDXL
-
logwise_proc
procmacro crate for logwise
-
proc-macro-error-attr
Attribute macro for proc-macro-error crate
-
der-oid-macro
Macro to encode DER oids at compile time
-
convert-chain
chain converter
-
hun-offsetof
C-like macros: offset_of and container_of
-
path_scan_macro
The macro implementation of path_scan
-
nipdf-macro
A macro for nipdf crate
-
tlns-google-oauth2-proc
A half-assed procedural macro that generates Scope enums and trait that converting the scopes back and fourth
-
more-convert-derive-internal
adds macros for various conversions
-
ferrite_model_gen
ChatGPT CLI
-
roadblk
Validator integration
-
rio-macros
Proc macros to help developing rio-rs applications
-
ranim-macros
macros for ranim
-
ra_ap_query-group-macro
A macro mimicking the
#[salsa::query_group]macro for migrating to new Salsa -
derive_display
A convenient attribute to derive
Displayimplementation from another trait implementation. Currently supportsToTokens. -
spacetimedb-bindings-macro
Easy support for interacting between SpacetimeDB and Rust
-
usdpl-build
Universal Steam Deck Plugin Library core
-
derive-env-url
Derives for env-url
-
futures-select-macro-preview
The
select!macro for waiting on multiple differentFutures at once and handling the first one to complete -
enum_data_proc
a proc-macro,Add bit operations and arithmetic operations to enum
-
rust_writer_proc
useful for editing a Rust file from Rust code
-
syrette_macros
Macros for Syrette, the convenient dependency injection framework
-
hollywood_macros
Macros for the Hollywood actor framework
-
stak-macro
Macros to integrate Stak Scheme
-
diesel-derive-pg
Derive ToSql and FromSql trait implementations for Postgres custom types
-
flyway-codegen
Flyway-rs project, Database change control,similar to flyway in Java
-
gorf-gen-core
Lambda calulcus backend library
-
derive_recursive
derive macro for recursive trait implementations
-
zang-macro
Rust language tokens translated to Uzbek
-
yew-struct-component-macro
Define Yew components using structs
-
yazi-codegen
Yazi codegen
-
yew-router-nested-macro
Contains macros used with yew-router
-
reflective
Hacky compile-time reflection
-
pareg_proc
contains proc macros for the pareg library
-
deprecate-until
Rust attribute to force deprecated item removal at a specified version
-
yuuka-macros
A helper library to generate complex and nested structures by a simple macro
-
wings_macro
WASM plugin system for Geese
-
muchin_model_state_derive
Derive macros for muchin model state
-
const-random-macro
procedural macro used by const-random
-
performances-testing
A performances testing library
-
error_spanned
Generates wrapper structs and macros around an enum implementing std::error::Error. Generated macros can be used to add line, file and span info to the enum's error. This is meant to be used inside proc macro libs.
-
templest
A procedural macro to manage temporary variables
-
auto-lsp-macros
Macros for
auto_lsp -
deluxe-core
Core traits and helpers for Deluxe procedural macro attribute parser
-
tera-template-macro
Proc Macro for tera-hot-reload crate
-
flexgen
A flexible, yet simple quote-based code generator for creating beautiful Rust code
-
renum
From and TryFrom trait derive with customization
-
fix-getters-utils
Utils for fix-getters
-
xtask-wasm-run-example
run-examplefeature of xtask-wasm -
ra-ap-rustc_index_macros
Automatically published version of the package
rustc_index_macrosin the rust-lang/rust repository from commit f08d5c01e69436891ff1c181385d0e078a8482ec The publishing script for this crate lives at:… -
luna-orm-macro
ORM based on sqlx
-
rtea-proc
Internal macro crate for rtea
-
s_test_fixture
or simple test fixture is a macro library to implement test fixture with no hassle
-
webgl-rc-macro
GLSL loading macro for webgl-rc
-
wasm-bindgen-macro-support
The part of the implementation of the
#[wasm_bindgen]attribute that is not in the shared backend crate -
oricalchum_derive
Procedural macros for oricalchum
-
synext
extension library for syn crate to help developers quickly develop derive macros
-
arrow-udf-macros
Procedural macros for generating Arrow functions
-
variant_enum
variant enum. generate enum variant. static dispatch.
-
moosicbox_lofty_attr
Macros for Lofty, modified for MoosicBox
-
zbus-lockstep-macros
Macros to keep types in lockstep with DBus XML definitions
-
napi-derive-ohos
N-API procedural macros
-
bevy_auto_plugin_nightly_proc_macros
proc macros for bevy_auto_plugin that require nightly rust
-
rust-analyzer-salsa-macros
Procedural macros for the salsa crate
-
struct-to-json-db-macro
macro for struct-to-json-db crate
-
implicit-trait
Add methods to foreign types with implicitly defined traits
-
neo4rs-macros
Macros used by neo4rs
-
pharia-skill-macros
Procedural macros for use within the
pharia-skillcrate -
yaah
AOC Helper
-
native_api_1c_core
Core library for Native API 1C
-
workflow-rpc-macros
Macros for the workflow-rpc crate
-
kcl-directory-test-macro
generating tests from a directory of kcl files
-
foundations-macros
Procedural macros used by foundations
-
enum-lexer-macro
A proc_macro lexer generator. using
enum-like syntax. -
roslibrust_codegen_macro
macro-based message generation for roslibrust
-
bind_syn
Syntax definition of let-binding shorthand utilized in crate bind
-
fixtures
Run tests against fixtures
-
css-rs-macro
A macro for writing your CSS next to your views
-
logfn
attribute macro for inserting logging code into your function
-
bmatcher-proc
bmatcher is a flexible and efficient binary pattern matching library designed to help you search and match binary data
-
fut-ret
parse the return type generated by async_trait in procedural macro
-
telety-impl
Common code for telety. Not intended for public use.
-
v_utils_macros
Macros for my utils crate
-
ergol_proc_macro
the proc macros for ergol, an async ORM for Rust
-
static_assert_generic
Static asserts involving const and type generics
-
grafana-plugin-sdk-macros
Convenience macros for the Grafana backend plugin SDK
-
enalang_macro
Exhaustingly Notorious Algorithms - macro support
-
reprfn
attribute macro for easyer define external functions
-
file_check_macro
A macro for checking the presence of a template file at compile time. E.g. for Tera templates
-
noshell-macros
noshell, a no_std argument parser and a shell for constrained systems
-
jintemplify_plugin_macro
jintemplify plugin proc-macro
-
kanu
ORM
-
maidenx_nn_macros
maidenx nn macros
-
discriminant-derive
Convert enum to integer type
-
commander-macros
used by commander-rust only. Please don't use it!
-
makepad-derive-widget
Makepad widget derive macros
-
mcp-core-macros
Macros library for mcp-core
-
url_query_string
procedural macro for generating methods to serialize structs into URL query strings. Provides seamless integration with serde and supports customizable serialization formats like camelCase and snake_case.
-
mongo-orm-macro
A proc macro for simplifying usage of mongo-orm
-
power-reqwest
a proc-macro for generate async http api client
-
machine
State machine utilities
-
qname-macro
Type for qualified names in XML - macro
-
turbine-proc
internal proc macros for turbine
-
query_macros
macros for query crate
-
async_static
A macro for declaring async lazily evaluated statics in Rust
-
sgxs-tools
working with the SGX stream format
-
wick-component-codegen
Code generator for wick components
-
export-type
Export Rust types to other languages
-
jetstream_wire_format_derive
Supporting proc-macro for the
p9crate -
dygma_focus_proc_macros
Dygma focus api, for use with dygma keyboards
-
repr_c_pub_struct
extracting
#[repr(C)] pub structures -
aargvark_proc_macros
Helper crate for aargvark
-
css-macros
MAcros to work with css files with stylist
-
rustato-proc-macros
Procedural macros for the Rustato state management library
-
synca
Write asynchronous code, and synca will create a synchronous version
-
orm_mysql_macro
A macro for mysql orm
-
lombok-macros
A collection of procedural macros for Lombok-like functionality in Rust
-
tarp
code coverage tool
-
scyllax-macros
Macros for scyllax
-
variadiz-macros
Procedural macros implementation of variadiz
-
pgx-macros
Proc Macros for 'pgx'
-
lending-iterator-proc_macros
Internal: proc-macro backend of ::lending_iterator
-
baroque
cuckoo
-
error-http
Procedural macro for associating error enums with HTTP codes
-
astree_macro
Easily build AST from Rust structures
-
irzha
Write Rust programs using Ukrainian language
-
cell_derive
A derive macro for quickly implementing
get_or_initandget_mutfunctions for structs that containOnceCellorOnceLockstructs -
caw_builder_proc_macros
A macro for generating builders
-
aoc-zen-runner-macros
Macros for aoc-zen-runner
-
notation_macro
Fun notation - DSL to create notation files
-
serde_syn
Use serde to parse Rust source code
-
r3bl_macro
Internal support for a proc-macro library for reading attributes into structs when implementing custom derives. Used by workspace in https://crates.io/crates/r3bl_rs_utils.
-
encase_derive_impl
Derive macro implementation for encase
-
err-handler
a non-intrusive error handling marco
-
surrealqlx-macros-impl
SurrealQLX macros implementation
-
gen_macro
GenUI plugin macro
-
sqly-macros
-
tea-macros
Procedural macros for the tevec
-
ord_by_key
convenient macro for implementing Ord trait with logic specified in an inline expression
-
pit-rust-host
Portal Interface Types
-
acton_test_macro
Testing utilities for Acton agents, providing tools to help in the testing and validation of agent behavior
-
string_macros
Small proc macro library for handling string literals
-
desert_macro
Binary serialization library for Rust (macros)
-
rig-tool-macro
-
rest-model-macro
macro for crate rest-model
-
mainstay-derive-accounts
Mainstay Derive macro for accounts
-
cgp-component-macro
Context-generic programming core component macros
-
micromegas-derive-transit
low overhead serialization, part of micromegas
-
macroex-extras
Additional "fun" extractors for macroex. Support crate for a certain in development UI crate.
-
include_wgsl
A tiny proc macro to include a WGSL file in your binary, and verify that it is valid at compile time
-
versionize_derive
Implements the Versionize derive proc macro
-
protobuf-convert
Macros for convenient serialization of Rust data structures into/from Protocol Buffers
-
libcrux-macros
Macros needed in libcrux
-
git-version-macro
Internal macro crate for git-version
-
sly_static_macros
macros for sly_static
-
ez_config
A lightweight and simple to use mapper from environment variables to config classes
-
rash_derive
rash derive crate
-
conf_from_env
Configurations and secrets defined in structs are automatically read from environment variables
-
struct-index
structure implement index trait
-
auto-import
Please do not use this
-
georm-macros
Macro support for Georm. Not intended to be used directly.
-
vercel_runtime_macro
Vercel Rust Function Runtime Macro
-
encrust-macros
Proc and derive macros for the encrust crate
-
bevy_atmosphere_macros
Proc macros for bevy_atmosphere
-
mcp-macros-fishcode2025
Macros for the Model Context Protocol SDK
-
wasmdev_macro
wasmdev macro implementation
-
cdk-ansible-macro
cdk-ansible is a tool to generate Ansible playbooks from Rust code
-
c_defines_to_enum
A procedural macro for generate enum from C defines statement
-
burned
Rust macros to embed files into your binary
-
dep-inj
easier dependency injection
-
despatma-visitor
Design Pattern Macro for visitor
-
woab-macros
Procedural macros for the WoAB crate
-
sgx_serialize_derive_internals
Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language
-
activity-macros
Macros for Discord activities in Rust
-
creusot-contracts-dummy
Dummy proc macros for creusot-contracts
-
sql_from_models-proc-macro
A helper crate for
models -
hipcheck-sdk-macros
Helper macros for the
hipcheck-sdkcrate -
aranya-policy-ifgen-macro
Proc macros for aranya-policy-ifgen
-
makepad-derive-live
Makepad platform live DSL derive macros
-
tonbo_macros
TonboRecord macro
-
derive_builder_core_fork_arti
Internal helper library for the derive_builder crate
-
agb_xm
converting XM tracker files for use with agb-tracker on the Game Boy Advance. You shouldn't use this package directly
-
secrets-manager-macro
Macro for using AWS Secrets Manager secrets in your application
-
kira_framework_proc
KiraFramework proc macro
-
rb-sys-test-helpers-macros
Macros for the rb-sys-test-helpers crate
-
sabry_procmacro_impl
Sabry proc-macro internals reusable outside of proc-macro context
-
caller_modpath
Get the module path of the caller in a proc_macro
-
tracel-xtask-macros
Macros for tracel-xtask crate
-
quickerr
A macro to define errors quickly, like
thiserrorbut terser and more opinionated -
ffi_trait
An attribute that makes an FFI-safe
dyn Trait -
cynic-parser-deser-macros
Macros for cynic-parser-deser
-
bullet
Supersonic Math
-
droid-wrap-macros
用于Rust的Android API的高级封装
-
serde-enum
Automaticly generates string serde implementation for enums
-
drylib-procs
Rust macro-library for Don't Repeating Yourself
-
rstml-component-macro
Macros for rstml-component
-
savvy-macro
Generate R-ready Rust functions by adding
#[savvy]macro -
proc-macro-rules-macros
Emulate macro-rules pattern matching in procedural macros
-
leptos_i18n_macro
Macros for the leptos_i18n crate
-
scaffolding-macros
A software development kit that provides the scaffolding macros for building applications and services
-
iocraft-macros
Macro implementations for the iocraft crate
-
untwine_macros
Declarative parsing with a BNF-like syntax - proc macro
-
log_time
sample code
-
literals
Literals for Rust
-
nidrs-valid-macro
a valid macro
-
enum-to-string-macros
EnumToStringderive macro which implements the methodsas_str()andas_dbg()to enums with no associated values -
kaptn-derive-extrametas
ExtraMetas Derive for the Kaptn Transfer-Hook Framework
-
test-shisho-datasource
Shisho Cloud Policy SDK
-
formality-macros
Macros used by a-mir-formality and formality-core
-
vk-shader-macros
Procedural macros for working with Vulkan shaders
-
simple-invoke-client-macro
An embeddable message queue system
-
padded-number-macros
Procedual macros to be used in the padded-number crate
-
azalea-registry-macros
Macros internally used in azalea-registry
-
rspack_napi_macros
rspack macros plugin
-
try_clone_derive
wich add a derive TryClone macro for the TryClone Trait of the fallible_allocation crate
-
colonbuilder
builder offers from_str method to build struct from colon separate string
-
rust-hdl-macros
Macro support for RustHDL
-
rasen-dsl
Wrapper for the Rasen compiler to write SPIR-V shaders in Rust
-
comlexr_macro
Dynamically build Command objects with conditional expressions
-
cadence_json_derive
Derive macros for serde_cadence
-
mvutils-proc-macro
Procedural macros for MVUtils
-
utoipauto
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
garde_derive
Derive macros for garde
-
typetrait
Helper macro to generate types for typestate programming
-
safina-macros
Procedural macro for the
safina-async-testpackage -
patum
Make enum conform to a given pattern
-
compiled-uuid
Parse UUIDs at compile time
-
askama_derive
Procedural macro package for Askama
-
prometheus-client-derive-text-encode
Auxiliary crate to derive text Encode trait from prometheus-client
-
fmt-derive-proc
A more robust and versatile derive macro for Debug and Display
-
studs-macros-lib
Studs that provides macro implementations and utilities
-
capacity_builder_macros
Macros for capacity_builder
-
micrortu_ie_representation_derive
SDK for MicroRTU
-
behavior
A macro checks like behavior in elixir
-
structre_proc_macros
Static-checked parsing of regexes into structs (helper crate)
-
stilts-macros
The macros that generate the templates for stilts
-
builder-rs
A procedural macro for generating builder patterns for Rust structs
-
ligen-core
Language Interface Generator Core
-
glissile
A macro for generating GLSL source code
-
moosicbox_async_service
MoosicBox async service package
-
typeof-literal
A macro that returns the type of any literal expression or composite of literals
-
multiconst_proc_macros
detail of multiconst
-
codesnip_attr
snippet bundle tool
-
sha1-macros
Macros for computing SHA1 hashes at compile-time
-
openwhisk_macro
Derive Macro for OpenWhisk Rust Client
-
socket_addr_macros
Check and parse SocketAddr at compile-time
-
const-field-offset-macro
Procedural macro to generate constant field offset from repr(c) struct
-
vapoursynth4-rs-macros
Proc macros for vapoursynth4-rs
-
const-serialize-macro
A macro to derive const serialize
-
manganis-macro
Ergonomic, automatic, cross crate asset collection and optimization
-
classic-bitfield
A bitfield enum with a classic feel
-
nougat-proc_macros
Internal: proc-macro backend of ::nougat
-
prest-db-macro
macro that derives Table trait to work with gluesql db
-
derive_constructor
Construct enums without naming them
-
html-to-string-macro
html to string macro powered by syn-rsx
-
match_box
boxand deref patterns in “match” for stable Rust. Now you can match throughBox,Rc, etc. -
svd_codegen
Generate Rust register maps (
structs) from SVD files -
epics_gen_macros
macros for deserializing xlsx tables and serializing them as EPICS PVs
-
serde-json-helpers
A collection of procedural macros compatible with stable Rust 2018 that simplify some common operations not covered by
serde_derive -
box_shorthand
Rust derive macro to create shorthand functions for initializing boxed enum variant values
-
smelter
Custom derive attribute that automatically derives builder methods
-
liberty-db
A fully defined liberty data structure, efficient parser & formatter
-
ron_asset_derive
a proc macro to help with asset dependencies
-
leptos-controls-macro
Leptos Controls Macro
-
blend-bindgen-rs
generated Blender's data structures
-
buns
Create simple code templates - basically macro_rules lite
-
fizyr-rpc-macros
procedural macros for the fizyr-rpc crate
-
bevy_render_macros
Derive implementations for bevy_render
-
kproc_pmacros
Support macros for kproc
-
yui
An attribute reader generator for Rust
-
rhine-schema-derive
Proc-macro crate for RHINE llm frame
-
RustPyNet
RustPyNet is a crate designed to help use python inside multiple threads for small-medium workloads like calling fast execution callbacks and small-medium operations from multiple places in an orchestrated manner…
-
rubedo-macros
Proc macros for Rubedo
-
pidl-rust
Rust support for pidl
-
fnck_sql_serde_macros
SerdeMacros for FnckSQL
-
colorthis
Meta macros that aid macro authors to create colors from a generalized syntax
-
unsafe_fn
macro to mark a function as unsafe without its body being unsafe
-
ffi_wrapper_nounwind
Automatically generate FFI wrappers that catch unwinding from FFI into Rust
-
fmtparse
Parse format!-like strings
-
static-map-macro
Macro to create a stack-alocated map
-
bitflags-attr-macros
Attribute macro implementation for bitflags-attr. Do not use directly, use the reexport in the
bitflagscrate. This allows for better compatibility across versions. -
syn_str
what syn is to proc_macro::TokenStream for proc_macro::TokenStream::to_string,quote! being format! with String::parse::<TokenStream>
-
json_schema_test_suite_test_case
Procedural Macro Attribute to run all the test cases described in JSON-Schema-Test-Suite
-
list-modules
A procedural macro for generating a list of string slices of the names of the modules inside a source code directory of a project
-
chalk-derive
A helper crate for use by chalk crates for
derivemacros -
nginx_derive
Helper crate for nginx-rust
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
ambient_editor_derive
A procedural macro to generate Ambient UI code for a struct or enum
-
enumify
macro that declares an
enum(and a bunch ofimpl Froms) based on a set of types -
bare_proc
A proc macro to generate Rust types from a BARE schema file
-
native_model_macro
A procedural macro for native_model
-
leptos_router_macro
Router utility macros for the Leptos web framework
-
def-mod
Simplifies module implementation routing and statically verifies exports
-
aranya-crypto-derive
Proc macros for aranya-crypto
-
farmfe_testing
Testing macro for farm
-
hashfn
A procedural macro to generate a hash representation of a function as a string slice
-
splat_attribs
macro that splatters attributes across multiple items
-
svgr-macro
A macro for generating SVG trees at compile time
-
deno_error_macro
Macro for writing Deno errors
-
autodefault
A proc macro that automatically inserts
..Default::default()into your struct literals -
aiscript-derived
AIScript derived crate
-
include_uri
Proc-macro to include URI as literals at build time
-
nuidl-lib
Code generation library for nuidl
-
leptosfmt-prettyplease
A fork of David Tolnay's prettyplease that adds the ability to format single expressions
-
include_absolute_path
Macro to returns absolute path of a specified file or directory
-
somedb-macros
database for storing data
-
my-ecs-macros
A procedural macro for my-ecs crate
-
codama-macros
Procedural macros for the Codama standard
-
surrealdb-extras-proc-macro
A
cargo generatetemplate for quick-starting a procedural macro crate -
diesel_filter_query
Procedural macros for Diesel filter
-
proto-json
convert to and from protobuf -> json easily
-
embed-licensing-core
Core implementation of embed-licensing
-
reshape_helper
Helper library for Reshape
-
name_of
expression for Rust
-
sourcegen
contains a procedural macro to work together with "sourcegen-cli" crate
-
sqlxmq_macros
Procedural macros for sqlxmq
-
cargo-fixture-macros
Macros for the cargo-fixture cargo extension
-
natrix_macros
Macros for natrix
-
hashed-type-def-core
hash based type identifier: hash code is computed on the basis of type definition
-
tamacro
-
elfo-macros
Macros for matching and deriving messages
-
nj-derive
procedure macro for node-bindgen
-
trident-derive-displayix
-
nonparallel-async
Rust macro for ensuring non-parallel execution of async functions
-
v_escape_codegen
Code generator package for v_escape
-
error_generator
Transform structs and enums into fully qualified errors using attributes
-
struct_to_string
proc-macro library to convert struct definitions to a string representation. An example use case would be for API documentation, and you want to present the Rust struct's for the API response on a webpage.
-
utility-macros-internals
utility-macros and utiliy-macros-derive common code
-
async-app-macros
ergonomic approach to implement applications spawning event loops
-
dioxus-core-macro
Core macro for Dioxus Virtual DOM
-
libatk-derive
Macro implementation for #[derive(CommandDescriptor)]
-
altaria-macros
Derive and proc macros for Altaria
-
preprocess-macro
Preprocesses a struct with built-in preprocessors
-
golem-rust-macro
Golem Rust tooling library that facilitates writing Golem backends in Rust
-
concat-idents-bruce0203
Allows concatenating multiple identifiers and using them everywhere
-
serde_avro_derive_macros
Derive avro schema for Rust structs for serde_avro_fast
-
fortuples
Procedural macros to generalize inherent and trait implementations over tuples
-
manor_macros
An ORM for MongoDB
-
pi_async_macro
A async file macros tools
-
dropshot_endpoint
macro used by dropshot consumers for registering handlers
-
mainstay-attribute-access-control
Mainstay attribute macro for instruction access control
-
poem-mcpserver-macros
Macros for poem-mcpserver
-
functional_trait
A macro that impls trait for Fns
-
predawn-macro-core
Core types and functions for macros in predawn
-
cosmic-macros
macros for thecosmicinitiative.io
-
bevy_ineffable_macros
Macros for the bevy_ineffable crate
-
rupring_macro
rupring macro
-
egui-probe-proc
Derive macro for egui-probe crate
-
krnl-macros
Macros for krnl
-
procmeta-proc
A derive-macro for procmeta-core
-
argley
Turn a struct into arguments for a
Command -
mod_plugins_macros
Reduce plugin boilerplate in the Bevy game engine
-
metamatch
A proc-macro for generating repetitive match arms
-
clone_into_derive
This crates generate clone macro for structs. It's quite convenient if you want that a struct copy to another struct which includes the struct fully.
-
derive-with
#[derive(With)]generates with-constructor for each field in struct -
intercom-common
See 'intercom'
-
derive-adhoc-macros
Macros that implement the derive_adhoc crate
-
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
okapi-operation
Procedural macro for generating OpenAPI operation specification (using okapi)
-
c3-lang-parser
C3 Lang
-
try_match_inner
The internal procedural macro of
try_match -
multiplatform_test
attribute macro to combine
#[test]and#[wasm_bindgen_test] -
safer_ffi-proc_macros
Procedural macro internals of
::safer_ffi -
goldboot-macros
Supporting macros for goldboot
-
utoipa-gen
Code generation implementation for utoipa
-
toml_config_derive
Rust macro to turn a Rust struct into a TOML config
-
bon-macros
proc-macro crate that is supposed to be a private implementation detail of the
boncrate -
sorm-macros
ORM (Object-Relational Mapping) built on SQLx
-
pub-fields
proc macro attribute that defaults all struct fields to public
-
marlin-verilog-macro
🦀 No nonsense hardware testing in Rust 🛠️
-
enumber
Provide useful impls on numerical enums
-
wesl-macros
Macros for the WESL rust compiler
-
iced_sessionlock_macros
Wayland extra shell lib
-
descord-macros
Macro implementation crate of descord
-
tailwag_macros
A collection of macros to support the tailwag crate
-
tailwag_orm_macros
A collection of macros supporting the tailwag_orm crate
-
user_doc
Attribute and derive procedural macros for generating user-facing documentation
-
leptos-struct-component-macro
Define Leptos components using structs
-
ntex-prost-derive
A Protocol Buffers implementation for the Rust Language
-
macrowind
Tailwind translater at compile time
-
inline-python-macros
Macros for the inline-python crate
-
jdefault_derive
Rust default derive
-
field_names
A proc-macro for exposing a struct's field names at runtime
-
ts-rs-macros
derive macro for ts-rs
-
enum-group
derive macro crate that helps enum types to group their variants
-
shorthand
A proc_macro to derive getter and setter for structs
-
hashmatch_macro
More efficient
static &strmatching when match #arm > 30 -
volatile-macro
Procedural macros for the volatile crate
-
ve-tos-generic
generic lib for volcengine offical tos rust sdk
-
interactive-clap-derive
Interactive mode extension crate to Command Line Arguments Parser (https://crates.io/crates/clap) (derive macros helper crate)
-
rstructor_derive
Derive macros for the rstructor library
-
artemis_codegen
Code generation for the artemis crate
-
dtor-proc-macro
proc-macro support for the dtor crate
-
compiler_cli_args
proc-macro that expands to the CLI args that were passed to rustc
-
sqlxx
Extension to sqlx
-
optional_struct_macro_impl
Helper crate implementing the proc_macro for the optional_struct crate
-
gluer-macros
Procedural macros for the gluer framework
-
smart-clone
Rust custom-derive macro for Clone with more control on the fields
-
hodoku
collection of macros to aid diagnostics during testing
-
kommand
Command-line arguments via function arguments
-
suanleme-macro
suanleme common module
-
small_ctor
A minimal, dependency free version of the ctor crate
-
rep
A small tool for representation/class invariants
-
wasm-bindgen-test-macro
Internal testing macro for wasm-bindgen
-
thruster-socketio-proc
The proc macros behind the thruster web framework
-
bevy_interleave_macros
macros for e2e packed to planar bind groups
-
token_stream2
A better TokenStream for procedural macros
-
qrcli
A QRCode cli tools, can encode and decode
-
derive-attribute-utils
derive-attribute
-
linera-witty-macros
Procedural macros for generation of WIT compatible host code from Rust code
-
include-flate-codegen
Macro codegen for the include-flate crate
-
fast_tuple
procedural macro library that provides an easy way to construct and annotate tuples
-
new-derive
Newderive macro -
anchor-syn-fix
Anchor syntax parsing and code generation tools
-
json_proc_macro
proc macro for parsing JSON-like syntax
-
substrait-expr-macros
helper macros for working with substrait expressions
-
rust_source_bundler
bundle local Rust library source files into a single file
-
simpl_actor_macros
tokio actors macros
-
enum-from-functions
A procedural macro that will create an enum with associated functions that each have a corresponding variant
-
default_variant
A proc-macro for specifying the variants or values to be used when deriving
Defaultin enums -
fsmentry-core
Finite State Machines with an entry API and data storage
-
futures-join-macro-preview
Definition of the
join!macro and thetry_join!macro -
flololoat
Mass Convert to floats
-
quote-data
A tokenization Library for Rust
-
overflow
Proc macros for changing the overflow behavior of math expressions
-
trait_info_gen
Procedural macros for obtaining Trait information at compile time
-
log_macro
Macro to print variable name and value only (stripped from release builds)
-
in_struct
An attribute-like procedural macro for defining structs for use in functions
-
realme_macros
A flexible and extensible configuration management library for Rust, designed to simplify the process of loading and managing configuration settings from various sources
-
server-function
A macro for easy RPC creation
-
as-method
Call function using the method syntax!
-
restep
useful REST API endpoint generator
-
macroific_macro
Proc macros for the macroific crate
-
nade-macro
Macros for nade
-
leptos-fluent-macros
Macros for leptos-fluent
-
dockerfile_builder_macros
Private macro implemenation for dockerfile_builder
-
rocal-macro
Macros for local-first-development driven web application framework
-
cxx-auto
Automatically generate cxx bindings
-
iat
hpc
-
to_table
for DomCom, add sort by field to struct
-
async_trait_proto
Async traits using nightly features
-
swc_config_macro
Macros to prevent mistakes
-
yew-component
macro to generate yew components from a single struct declaration
-
gh-workflow-macros
macros for gh-workflow
-
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.
-
specialized-dispatch
dispatching specialized versions of a function
-
crate_interface
way to define an interface (trait) in a crate, but can implement or use it in any crate
-
jni-toolbox-macro
proc macro to automate making JNI extern functions
-
leptos-routable-macro
Type-safe routing utility for Leptos with zero-string path generation
-
negative-proc_macros
Internal: proc-macro backend of ::negative
-
ai_function
Procedural Macro for creating text from a function to use in Large language Models
-
proc-debug-macro
Dump proc-macro output for efficient debugging
-
fusen-macro
RPC framework for service registration and discovery through API exposure, compatible with Dubbo3 protocol, intertunable with Java projects
-
bevy_registration_procedural_macros
Run code on the app from far away. Only the procedural macros are in this crate.
-
double_dot_macro_types
Misc types and functions required for the double_dot_macro ecosystem
-
chat_messages
lightweight Rust library for creating structured messages in chat systems, including HumanMessage, AiMessage, SystemMessage, and more. It supports easy extensibility through macros…
-
sort_by_derive
Derive macro SortBy and helper macros EnumAccessor and EnumSequence, deriving traits
Ord,PartialOrd,Eq,PartialEqandHashfor structs and enums that can’t automatically derive from those traits -
wasmedge-bindgen-macro
Pass string, vec and primitive types from host to webassembly
-
compile-time
Macros for getting compile time information
-
onionpack
Unpack your structs into DTOs, Entities and Schemas
-
mikros-macros
An optionated crate to help building multi-purpose applications
-
proc_qq_codegen
QQ client framework
-
cot_macros
web framework for lazy developers - macros
-
proc-state
Sustain global variables between individual proc-macro call
-
duktape-macros
duktape bindings macros
-
uniffi_macros
a multi-language bindings generator for rust (convenience macros)
-
for_ch
to flatten nested for-loop
-
generic_trait_alias
A proc-macro attribute which can be used to create custom type aliases for abstraction
-
mm_example_crate
part of macro_magic
-
rustavel_derive
Derive macros for the Ruskit web framework
-
dioxus-tw-components-sorttable-macro
Macros used by dioxus-tw-components
-
tuono_lib_macros
Superfast React fullstack framework
-
gandiva_rust_udf_macro
A basic library for gandiva rust udf macro
-
parse_api
parse api
-
rusty-bind-parser
Parses Rust module, generates Rust code with C ABI bindings and C/C++ header files and Swift gluecode
-
slang_struct
Macro that converts Slang style struct definitions into rust structs
-
rz-embed
implements a simple proc-macro for embedding directory trees in rust binaries
-
despatma-abstract-factory
Design Pattern Macro for abstract factory
-
usdt-attr-macro
Procedural macro for generating Rust macros for USDT probes
-
autoget
macro to generate getters for structs
-
kittycad-execution-plan-macros
Macros for working with KittyCAD execution plans
-
derive-attr-parser
Very simple parser for proc macro attributes
-
mini-internal
Derive macros for miniserde. Use the re-exports from the miniserde crate instead.
-
discriminant_ord_eq
DiscriminantOrdEq macro is designed to derive implementations of the Ord, PartialOrd, Hash, PartialEq, and Eq traits for enum types. These implementations are based solely on the enum's variant discriminants…
-
thiserror-impl-no-std
detail of the
thiserrorcrate -
samplify-rs
A procedural macro to generate sample data for Rust structs
-
fauxgen-macros
macro support package for fauxgen
-
const-random
compile time random number generation
-
cmd-proc-macro
Run some shell script when build the project, and yield the stdout as &[u8]
-
off-side
syntax (indent instead of braces, like in Python) to write Rust!
-
raxb-derive
Architecture for XML Binding
-
derive-masked
Adds #[derive(x)] macros for implementing the Debug and Display traits masking out sensitive fields
-
binary-serialize-derive
A small representation for objects in the Ezno checker, used for caching to make checking faster
-
ext-trait-proc_macros
Internal: proc-macro backend of ::ext_trait
-
macrotk
macro toolkit
-
wayland-raw-protocol-bindings
c like wayland bindings
-
stak-minifier-macro
Macros to minify Stak Scheme source codes
-
axum_error_macro
derive macro for your custom Error enum to generate quickly its status code and message
-
marlin-spade-macro
🦀 No nonsense hardware testing in Rust 🛠️
-
fievar
Proc macrs to generate functions that return static slices of struct field names or enum variant names
-
tensorflow-internal-macros
The package provides macros for internal usage in TensorFlow. No backwards compatibility guarantees are made.
-
aggregate_types
Aggregate attributes of structs for runtime
-
dyn_derive
Inherit and derive object-unsafe traits for dynamic Rust
-
askama-enum
Implement different askama templates for different enum variants
-
structbuilder_derive
Super simple macro to derive a builder trait for your struct
-
huber-procmacro
Internal package used by Huber
-
wars-macro
Wasm to Rust converter
-
hooks-macro-core
Compile-time, async hooks
-
maybe-async-cfg-tests
A tests for maybe-async-cfg
-
idewave_packet
Macro for implementing packet structures
-
wood_derive
autoderive for wood serialization
-
pigeon-macs
Generate recursive-descent & precedence climbing parsers. (macros)
-
oxi-macros
Proc macros for nvim-oxi
-
more-syn-types
parsing Rust Standard Library macros
-
ferris-extensions
Extension macros for Rust
-
makepad-derive-wasm-bridge
Makepad wasm bridge derive macros
-
cgp-async-macro
Context-generic programming async macros
-
defile-proc_macros
See https://docs.rs/defile
-
randsym
Generates unique identifiers for macros
-
agb_midi
converting MIDI files for use with agb-tracker on the Game Boy Advance. You shouldn't use this package directly
-
skynet_macro
Macros for Skynet
-
rimpiazza
A compile time procedural macro to replace keywords in a string
-
sixtyfps-macros
Macro helper for sixtyfps crate
-
azalea-protocol-macros
Macros internally used in azalea-protocol
-
auto_builder_derive
Macros for generating a 'safe' builder
-
dfir_datalog_core
Datalog implementation for DFIR
-
static_init_macro
Attribute macros for static_init crate
-
dep-expand
Expand cargo dependencies during build
-
macro_rules_attribute-proc_macro
Use declarative macros as proc_macro attributes or derives
-
gazelle
Helper macros for the gazelle_rust build file generator
-
copilot-rs-macro
SDK for interacting with chat models, providing easy-to-use functions and tools
-
rsciter_macro
rsciter macros implementation
-
o2o-macros
Macro definitions of 'o2o' crate
-
synom
Stripped-down Nom parser used by Syn
-
lazypoline-macros
Proc macros for the lazypoline-rs framework
-
elucify
SQL Database ORM
-
proc_macro_tools
Tools for writing procedural macroses
-
rusty-ast
that analyzes Rust code and visualizes its AST
-
cercis-rsx
rsx macro for cercis
-
qrus
A QRCode cli tools, can encode and decode
-
relib_export
relib is a framework for reloadable dynamic libraries
-
argos-macros
Argos's proc macros
-
mattro
A macro attribute parser
-
quote-alias
A helper macro for easily reusing static token streams
-
cogwheel-macro
Derive macros for the Cogwheel crate
-
namefn
Adds a macro to retrive the name of the current function
-
einsum-derive
Proc-macro based einsum implementation
-
deno-bindgen2-macro
Macros for the
deno_bindgen2crate -
file_env_const
macros for loading data from files or environment variables at compile time
-
rust_hdl_lib_macros
Macro support for RustHDL
-
traitify
A macro to turn an impl block into a trait
-
concat-strs-derive
Forked from Rebecca Turner <rbt@sent.as> 's "https://github.com/9999years/concat_strs". No more proc-macro-hack = "0.5", and updated to-date (20240916)
-
witchcraft-server-macros
Macro definitions used by witchcraft-server
-
reacty_yew
Generate Yew components from React component via Typescript type definitions
-
fnaop
lightweight and flexible Rust library designed to bring Aspect-Oriented Programming (AOP) to your Rust functions. By using fnaop, you can easily add pre and post function logic without…
-
sauron-macro
An html library for building client side webapps
-
bae
proc-macro attribute parser
-
portrait-codegen
Internal procedural macros for portrait
-
locenv-macros
A collection of macros to aid on module development for locenv
-
crate-_-name
macro to get the name of the current crate
-
event-driven-macro
Event Driven Message Handling
-
shrink-to-fit-macro
Derive macro for
shrink-to-fitcrate -
accessory
A configurable get/set/get_mut derive macro
-
derive_bounded
Builtin-macros workalike but with a way to specify bounds
-
jetstream_macros
Jetstream is a RPC framework for Rust, based on the 9P protocol and QUIC
-
pretty_derive
A procedural macro for pretty
-
testing_performance
A performances testing library
-
rustui_merge_macro
Macros for tailwind-fuse
-
supertrait-macros
Support macros for supertrait
-
percpu_macros
Macros to define and access a per-CPU data structure
-
thiserror-impl
detail of the
thiserrorcrate -
pear_codegen
A (codegen) pear is a fruit
-
sbs-api-macro
Macros for sbs-api crate
-
macro_state
A set of macros allowing storing and loading global state at compile-time within proc macros
-
cxx-async-macro
The macro for simple interoperability between C++ coroutines and asynchronous Rust
-
lsp_doc
Embed markdown/text files into Rust documentation attributes for LSP hover/preview
-
ector-macros
Ector is an open source async, no-alloc actor framework for embedded devices
-
apidoc-proc
Apidoc proc
-
assert-tokenstreams-eq
Compares tokenstreams by applying rustfmt and using pretty_assertions to visualize differences
-
enum_const_value
Providing const values for enums. Unit and enums with associated types are supported. Each variant gets a unique sequential value.
-
test-shisho-gql-derive
Shisho Cloud Policy SDK
-
fsmentry-macros
Finite State Machines with an entry API and data storage
-
bevy_asset_macros
Derive implementations for bevy_asset
-
elm_rusty
Auto generate Rust models to Elm models
-
byte-strings-proc_macros
Internal: proc-macro backend of ::byte_strings
-
farmfe_macro_cache_item
Macro to create a farm cache item
-
uniffi-macros-alicorn
An Alicorn bindings generator for Rust (convenience macros)
-
esp32_test_macro
macro that adds to test result message to end of the test functions
-
tree-sitter-parsers
Preinstallation of tree-sitter parsers of multiple languages for Rust projects
-
ra_ap_proc-macro-srv-cli
A standalone binary for the
proc-macro-srvcrate of rust-analyzer -
a653rs_macros
Macros implementation for a653rs
-
devault
A more flexible alternative to deriving Default
-
serde-versions-derive
An attribute macro for adding a version byte when serializing a struct via Serde. Also allows deseraializing while removing version byte.
-
potato-macro
A very simple and high performance http library
-
structopt-derive
Parse command line argument by defining a struct, derive crate
-
named_params
Fast, simple named parameters for Rust functions
-
ssttt
More Syn Syntax Tree Traversal Trait
-
sigmut-macros
a state management framework designed to be used as a foundation for UI frameworks
-
lockjaw_processor
proc_macro processor for lockjaw
-
resterror-derive
handle REST errors, with a derive macro to generate the error type. It also provides a compatibility layer with actix-web.
-
tabled_derive
Derive macros which is used by tabled crate
-
syn_util
helper APIs for procedural macros
-
tailwag_macro_exports
A collection of macros to support the tailwag crate
-
sync_docs
This proc macro allows injecting documentation from prost generated Rust file into custom defined sdk types (s2-sdk-rust in this case)
-
sub-struct
remove specified fields from a struct to create a new struct
-
unstyled_macro
Unstyled is just another library which allows to write scoped CSS styles in Rust
-
usdt-macro
Procedural macro for generating Rust macros for USDT probes
-
const-dispatch-proc_macros
Internal: proc-macro backend of ::const_dispatch
-
flowmacro
Definition of a 'flow' attribute macro to help write implementations
-
testing_macros
General purpose testing macros
-
turf_macros
Macros used by turf
-
proc-macro-error-attr2
Attribute macro for the proc-macro-error2 crate
-
macro_functions
functions for quickly parsing syn structures
-
bintex
Create bitfield LaTeX diagrams with the use of the deku library
-
denumic
Creating enum-based runtime dispatched traits
-
azure-functions-shared
Implementations shared between the azure-functions-codegen and azure-functions crates
-
discord_typed_interactions_lib
suppose you're working with discord slash commands and you want statically typed request types
-
bit-by-bit
Convenient proc-macro for defining structs with bitfields
-
proc_strarray
Create const u8 array from str or byte str literal
-
quokka-macros
A new framework for building old-school fullstack web applications
-
typeshare-annotation
The annotation used to mark types for typeshare
-
get_fields
procedural macro that generates an array of the field names of a named struct
-
fully_pub
Macro that makes multiple items or fields public at once
-
auto_curry
Procedural macro to automatically curry functions
-
derive-from-one
Automatically generates
Fromimpls so you don’t have to -
mass-cfg-attr
A way to mass toggle cfg-attr on attributes
-
progenitor-macro
An OpenAPI client generator - macros
-
ctor-used-linker
__attribute__((constructor)) for Rust
-
syner
A procedural macro to generate a parser for attributes from a struct
-
safe-vk-macros
optional library with macros for safe-vk
-
typst-wasm-macros
Typst WASM tools
-
strunemix_macros
Macro used by Strunemix to derive traits for structs
-
pinocchio-log-macro
Macro for pinocchio log utility
-
azalea-buf-macros
#[derive(AzBuf)]
-
deriving_via_macros
DerivingViaMacros
-
utoipauto-macro
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
impl-for
Macros to impl for multiple types
-
extension-fn
No boilerplate code for extension function definitions
-
syscall_macro
macros for syscalls in x86_64
-
quote-use-macros
Support
usein procmacros hygienically -
sin
Sin aims to be an alternative to the proc-macro2/syn ecosystem geared towards developer UX and custom syntax parsing
-
auto-trait
macro to generate trait implementation for wrapper types
-
syn-codegen
Syntax tree describing Syn's syntax tree
-
tree_sitter_grep_proc_macros
(proc-macros used internally by tree-sitter-grep)
-
mevy_ui
bevy_ui macro, that adds a CSS-like syntax!
-
db_code_macro
Generate Db code
-
v8_derive_macros
Derive macros for Rusty v8
-
devela_macros
procedural macros for devela
-
mendes-macros
Macros for mendes web toolkit
-
anyhow_trace
Macro which adds source location as context to anyhow errors
-
enum_from_variant
macro to generate From<T> trait implementations for enum variants, simplifying error conversions and enum mapping
-
erased-generic-trait
Macros for generating trait objects from traits with generic methods
-
derive_base_message
A procedural macro for generating base message structures
-
errorset
ErrorSet library
-
mu-sdk-macros
Mu SDK macros
-
bevy-butler-proc-macro
Procedural macro definitions for bevy-butler
-
enutil_macros
General Enum Utility Macros
-
quirky_binder_codegen
Quirky Binder Codegen
-
safe_attr
An attribute #[safe] to mark functions, allowing the ommission of unsafe
-
alphabet_match_macro
Alphabet match procedural macro
-
display_enum
Implement Display For the Enumeration
-
langen_macro
create programming languages
-
ctor_bare_macros
Macros for registering constructor functions for Rust under no_std
-
elapsed-printer
Very simple macro for printing time elapsed to execute a function
-
sahne
DI library via implementing trait with trait
-
rbitpack
For packing booleans in variables using bitwise operations
-
hoax
procedural macro crate that "hides" any string literal in a plain sight
-
recorder
Generate data-only structs with utilities easily
-
datafile-test
Generate test codes for data-file (JSON, YAML)
-
derive_state_machine_future
Custom derive implementation for the
state_machine_futurecrate. Use that crate instead of this one directly. -
syn-unnamed-struct
Extends syn expressions and meta structs with unnamed structs and meta lists
-
arcdps_codegen
Macros for arcdps
-
quote2-macros
An alternative lightweight version of quote
-
witgen_macro_helper
Macros helpers for witgen which is a library to help you generate wit definitions in a wit file for WebAssembly
-
rsx-rosetta
Autofomatter for Dioxus RSX
-
qubit-macros
Macros to accompany
qubit -
structout
A proc-macro for generating structs from a common definition
-
hydroperfox-smodel-proc
Semantic modeling for Rust: procedural macros
-
xml2gpui_macros
Helper macros to convert XML attributes to GPUI attributes
-
rcss-core
RCSS - (core) contain parser functionality
-
cypher_derive
A flexible and intuitive query builder for Neo4j and Cypher
-
workflow-core-macros
Macros for the workflow-core crate
-
rusty_json_serialization
procedural macros for automated JSON serialization in Rust
-
lattices_macro
Procedural macros for the
latticescrate -
pagetop-macros
Una colección de macros que mejoran la experiencia de desarrollo con PageTop
-
bitflag-attr-macros
Attribute macro implementation for bitflags-attr. Do not use directly, use the reexport in the
bitflagscrate. This allows for better compatibility across versions. -
basicmethod
Add constructor, get and set method using derive macro
-
depends_derives
Ergonomic, performant, incremental computation between arbitrary types
-
swift-bridge-macro
Powers swift-bridge module code generation
-
polling-async-trait
A proc macro that creates async methods based on polling methods for your trait
-
bevy_fn_plugin
Create Bevy plugins from functions
-
dioxus-motion-transitions-macro
Page transition support for dioxus-motion
-
unc-abi-client
generate Rust clients for Utility smart contracts
-
zirv-macros
A collection of useful macros for everyday programming
-
apistos-gen
Actix-web OpenAPI v3.0 documentation generator
-
impl_index
Macro for deriving the Index trait
-
jlrs-macros
contains the custom derives offered by jlrs
-
non_structural_derive_macro
nonstructural derives for auto traits
-
build-it
A derive-macro for simple builder-pattern generation
-
ecsact_rust_codegen
Ecsact rust code generator
-
e173_ts
TypeScript generation macros for E1.73 Support library
-
axum-resp-result-macro
Help Struct For Axum Response
-
decay_type
Macro for decaying Rust types to their simplest value type form
-
ormlite-macro
An ORM for people who love SQL. Use the
ormlitecrate, not this one. -
waynest-macros
Macros for waynest
-
count-tys
Function-like procedural macro that accepts a comma-delimited :ty TokenTree sequence and returns their count as a constant usize
-
axum_guard
A set of attribute macros for protecting Axum URI resources
-
rstml-to-string-macro
html to string macro powered by rstml
-
peepmatic-macro
Macros for peepmatic
-
include-bytes-plus
Improved include_bytes! allowing to reinterpret input differently
-
proc-macro-type-name
Convert Rust field names (snake case) to type names (pascal case) using proc_macro2 identifiers
-
proc-macro-crate-name-test
testing to see whether CARGO_PKG_NAME is populated correctly when proc macro crate is re-exported
-
fbthrift_codegen_includer_proc_macro
Workaround for https://github.com/rust-lang/rfcs/issues/752
-
actix_error_proc_macros
Procedural macros for the actix_error_proc package
-
py_fstr
A macro for making Python like fstrings
-
sqlx-utils-macro
working with SQLx in a structured and efficient way, both when developing and running
-
typify-macro
typify macro implementation
-
rocket_codegen
Procedural macros for the Rocket web framework
-
ligen-macro
Ligen (Language Interface Generator) is an extensible automatic binding generator ecosystem
-
ralik
ALIKe language
-
derive-collect-docs
Collect documentation from Rust structs using a
CollectDocsderive macro -
quote-doctest
doctest generator for quote
-
cgp-field-macro
Context-generic programming field macros
-
annotation-rs
Compile-time annotation parser for rust
-
awsl-syn
AWSL parser for rust macro
-
json_schema_test_suite
Procedural Macro Attribute to run all the test cases described in JSON-Schema-Test-Suite
-
mm_example_crate2
part of macro_magic
-
ifc_rs_verify_derive
A proc-macro crate for the ifc crate
-
typespec_macros
Procedural macros for client libraries built on typespec
-
mdmodels-macro
A procedural macro for generating models from a markdown data model
-
forr
a compile time for loop for code generation
-
ruic
Load Qt Designer .ui files into Rust code at compile time
-
py-rs-macros
derive macro for py-rs
-
onlytypes
creating types that can only be created by a certain function
-
conerror_macro
macro that automatically adds context to errors
-
iroha-internal
Internal functions, struct for Iroha
-
azalea-inventory-macros
Internal macros for azalea-inventory
-
splat_derive
providing a Splat derive macro, which generates a splat method for the struct deriving it
-
packetrs-impl
Macro-based struct serialization/deserialization
-
enum2str
derive macro that creates a Display impl for enums. This is useful for strongly typing composable sets of strings
-
synthez-core
Internal implementations of
synthezcrate -
enumerate
An attribute macro that, given a trait and its implementers, generates an enum that can be used instead of a trait object, avoiding dynamic dispatch
-
wasm_macro
Collections of useful macros for wasm
-
stronghold-derive
Proc macros and derives for Stronghold
-
pegcel-macros
A PEG parser generator for Syn
-
indexed_db_futures_macros_internal
Internal macros for the
indexed_db_futurescrate -
derive-asset-container
Derive AssetManager trait
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
declare_impl
proc macro for the error_set crate
-
autoclone
macro to clone variables before passing them into a
moveclosure or async block -
derive-error
Derive macro for Error using macros 1.1
-
edn-derive
Edn (De)Serialization derive macros
-
arcon_codegen
Code generation for Arcon
-
rdf-derive
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
symbol-ty-macro
A procedural macro for generating symbols as type-level strings
-
git-const
Proc macro to provide properties of git repo
-
wasmbind-js-file-macro
Provide a macro to generate JavaScript bindings from an external JS file
-
devise_codegen
devising derives and other procedural macros
-
capnp_conv_macros
attribute macros that implement capnp read/write traits
-
error_mancer_macros
proc macro for error_mancer
-
diesel-crud-codegen
-
smodel-proc
Symbol semantic modeling for Rust: procedural macros
-
func_
Proc macro to add function name constant within body of function
-
match_any_trait
match expressions for any trait
-
rustc-ap-rustc_macros
Automatically published version of the package
rustc_macrosin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
ctor-proc-macro
proc-macro support for the ctor crate
-
nvim-oxi-macros
Proc macros for nvim-oxi
-
instruct-macros
are a collection of simple macros that we're using in Instructor-AI to generate json schema from Serde Objects
-
polars-row-derive
Macro to help convert an interator of structs into a DataFrame
-
tokio_with_wasm_proc
Mimicking tokio functionalities on web browsers
-
scopegraphs-macros
A well-documented port of scopegraphs to Rust
-
frenv_macro
Macros 0.1 implementation of #[derive(FromEnv)]
-
cercis-component
component macro for cercis
-
fancy_constructor
Derive a highly configurable constructor for your struct
-
bevy_gizmos_macros
Derive implementations for bevy_gizmos
-
rust-typed
Get the types of a struct
-
deluxe-macros
Derive macros for Deluxe procedural macro attribute parser
-
docify_macros
Support macros for docify
-
documented-macros
Derive and attribute macros for
documented -
oasgen-macro
Dependency of oasgen. Generates OpenAPI 3.0 spec based on Rust code. Works with actix-web, but architected to easily extend to other frameworks (or no framework).
-
better-default-derive
A better Default macro
-
kittycad-modeling-cmds-macros
Macros for defining KittyCAD modeling commands
-
err-as-you-go
easy inline error types
-
enum2contract
no_std compatible rust derive macro that lets users specify contracts for pub/sub style messaging using strongly typed rust enums. Conversion methods for JSON and binary are created for the generated payloads
-
redis-macros-derive-bincode
Derive macros to serialize/deserialize structures with bincode to store in redis
-
overloading
A POC crate that utilizes
Fn*traits to implement partial overloading -
rocket_db_pools_codegen
Procedural macros for rocket_db_pools
-
predawn-macro
Macros for predawn
-
ts-rs-macros-serde-json
derive macro for ts-rs
-
templr_macros
Procedural macros for templr
-
sixtyfps-corelib-macros
Helper macro for sixtyfps-corelib
-
hydroflow_macro
Macro for using Hydroflow's Surface Syntax
-
derive-box-dyn
Proc macro to convert struct to Box<dyn T>
-
prest-serde-derive-fork
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
mock-syn
Mock / wrap syn structs and enums overiding specific fields
-
alkahest-proc
Procedural macros for 'alkahest-proc' crate
-
union_type
A proc macro to introduce union type into rust
-
cascading-wasm-language
Compiled web language based on CSS syntax
-
syn-graphs
graph description language parsers using syn
-
more-di-macros
Macro implementation of #[injectable(Trait)]
-
ruskit_macros
Procedural macros for the Ruskit web framework
-
paste
Macros for all your token pasting needs
-
macro_magic_core_macros
Support macros for macro_magic_core
-
enum-str-derive
serialize/deserialize enums into/from a string
-
visa-rs-proc
procedural macros used in visa-rs
-
string_enum
String based enum
-
afmt
Basic data structure parsing from strings
-
tantivy-macro
derive tantivy schema api
-
cpp_synmap
Sourcemap and full crate parsing support for
cpp_syn -
skip-if-macros
Attribute macro to skip running a function that produces files
-
diplomat
FFI generation macro
-
input-sys
Bindgen generated unsafe libinput wrapper
-
halo2derive
Derive macros for halo2curves fields
-
variadics_macro
Procedural macros for the
variadicscrate -
sea-strum
macros for working with enums and strings
-
stylish-macros
Internal implementation details of
stylish-core -
serde_derive_state
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
embed_it_macros
The macros for [
embed_it] -
fieldx_plus_macros
Heler macros for fieldx_plus crate
-
chassis-proc-macros
Procedural Macros for chassis crate
-
swc_ecma_quote_macros
Quasi quotation system for ecmascript
-
manyhow-macros
Macro for manyhow
-
perfect-derive
prototype of the proposed perfect_derive macro
-
constany_stage_one
Convert any function to constant
-
rs-derive
A procedural macro library containing useful derive macros
-
native-proc
Procedural macro for parsing prost-build structs and generating local matching types
-
tidos_macro
Procedural macros for the Tidos component framework
-
rwf-macros
Macros for the Rust Web Framework
-
nb-field-names
generate class methods of returning field names of structs
-
himark
For those who crave more ergonomic marker traits
-
cdrs-tokio-helpers-derive
Derive CDRS helper traits
-
pyo3_special_method_derive_macro
Automatically derive Python dunder methods for your Rust code
-
bigquery-functions-types-macros
proc macros to define BigQuery function types
-
literateink-wasm
LiterateInk crates
-
dwind-macros
Macros used by the dwind crate for applying dominator classes to components using a custom language
-
derive-combine
A macro for combining multiple structs into one
-
random_struct_layout
The custom attributes to randomize struct members layout
-
reactive_stores_macro
Stores for holding deeply-nested reactive state while maintaining fine-grained reactive tracking
-
derive-all
Derive macro that derives all macros possible
-
octokit-rs
Octokit RS is a lib with the up-to-date Github types
-
pdl-derive
PDL's derive macro
-
serialize_derive
derive for #[derive(Serialize)] and #[derive(Deserialize)]
-
quoth-macros
support macros for quoth
-
cali_cli
Cali's codegen and cli application
-
stringify-ident-proc-macro
Replacement for the stringify! macro for use in const functions
-
include_display_mode_tex
embedding TeX formulae in documentation
-
wide-str
Proc macro for compile-time UTF-16 string literals
-
rscx-macros
proc macros for the rscx crate
-
macro-string-eval
Part of test suite for macro-string crate
-
dfir_macro
Macro for using Hydro's Data Flow Intermediate Representation (DFIR)
-
better-bae
proc-macro attribute parser
-
fieldx_derive_support
Derive proc macros for fieldx_derive crate
-
sycamore-state-macros
sycamore-state proc macro implementation
-
odata_client_codegen
Strongly-typed OData client code generation
-
rkyv_derive_test
Derive macro for rkyv
-
env_vars_explorer
Enumerates and prints environment variables available at compile-time
-
impartial-ord
Derives a quicker PartialOrd for types that already implement Ord
-
fused_error
working with composable errors
-
konst_proc_macros
detail of the
konstcrate -
varianteq
Derive the equality of enum variants ignoring fields
-
serde-clap-deserialize
Proc macro for setting serde/clap defaults
-
samotop-async-trait
Type erasure for async trait methods
-
autoerror
Automatically generate error handling traits
-
ops-derive
Derive macros for std::ops
-
doc-cfg
#[doc_cfg(..)] helper attribute
-
stageleft_macro
Helper macros for the stageleft crate
-
rust-sitter-macro
Procedural macros for Rust Sitter