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