-
strum
macros for working with enums and strings
-
proc-macro-crate
Replacement for crate (macro_rules keyword) in proc-macros
-
synstructure
Helper methods and macros for custom derives
-
litrs
Parse and inspect Rust literals (i.e. tokens in the Rust programming language representing fixed values). Particularly useful for proc macros, but can also be used outside of a proc-macro context.
-
proc-macro2
A substitute implementation of the compiler’s
proc_macro
API to decouple token-based libraries from the procedural macro use case -
unicode-ident
Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31
-
quote
Quasi-quoting macro quote!(...)
-
syn
Parser for Rust source code
-
macrotest
Test harness for macro expansion
-
paste
Macros for all your token pasting needs
-
expander
Expands proc macro output to a file, to enable easier debugging
-
proc-macro-error2
Almost drop-in replacement to panics in proc-macros
-
macro_magic
Allows the exporting and importing of the tokens of items across module, file, and crate boundaries
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
linkme
Safe cross-platform linker shenanigans
-
derive_utils
A procedural macro helper for easily writing derive macros for enums
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
delegate
Method delegation with less boilerplate
-
r2r
Easy to use, runtime-agnostic, async rust bindings for ROS2
-
serde_tokenstream
A serde deserializer for proc_macro::TokenStreams
-
venial
A very small syn
-
attribute-derive
Clap like parsing for attributes in proc-macros
-
proc-macro-warning
Emit warnings from inside proc macros
-
unicode-id-start
Determine whether characters have the ID_Start or ID_Continue properties according to Unicode Standard Annex #31
-
ctor
__attribute__((constructor)) for Rust
-
derive-new
#[derive(new)]
implements simple constructor functions for structs and enums -
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
-
enum-as-inner
A proc-macro for deriving inner field accessor functions on enums
-
derive-getters
boilerplate getters generator
-
proc-macro2-diagnostics
Diagnostics for proc-macro2
-
getset
we're ready to go! A procedural macro for generating the most basic getters and setters on fields
-
maybe-async
A procedure macro to unify SYNC and ASYNC implementation
-
structmeta
Parse Rust's attribute arguments by defining a struct
-
ra_ap_proc-macro-srv-cli
A standalone binary for the
proc-macro-srv
crate of rust-analyzer -
rustfmt-wrapper
wrapper around rustfmt for use by code generators
-
utoipauto
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
pyo3-stub-gen
Stub file (*.pyi) generator for PyO3
-
dynasm
A plugin for assembling code at runtime. Combined with the runtime crate dynasmrt it can be used to write JIT compilers easily.
-
databake
Trait that lets structs represent themselves as (const) Rust expressions
-
specr-transpile
Converts Specr lang code to Rust
-
k9
rust testing library
-
pmutil
Utils for proc-macro
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
terrars
Terraform in Rust
-
macro_railroad
generate syntax diagrams for Rust macros
-
asn1-compiler
Compiler for compiling ASN.1 specs to Rust, with PER Codec support and derive macros for PER Codecs
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
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
-
tryexpand
Test harness for macro expansion
-
parse-variants
Derive the syn::parse::Parse trait for enumerations and use it to comfortably parse a variant of the enumeration
-
docify
allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
proc_macro_roids
Traits and functions to make writing proc macros more ergonomic
-
scryer-prolog
A modern Prolog implementation written mostly in Rust
-
unsynn
Proc-macro parsing made easy
-
ambassador
Trait implementation delegation via procedural macros
-
bitmask-enum
A bitmask enum attribute macro
-
supply-chain-trust-example-crate-000001
Parser for Rust source code
-
derive_setters
Rust macro to automatically generates setter methods for a struct's fields
-
rusteron-code-gen
Code generator for aeron c bindings
-
clap_derive
Parse command line argument by defining a struct, derive crate
-
deluxe
Procedural macro attribute parser
-
derive-adhoc
An ergonomic way to write derive() macros
-
syn-mid
Providing the features between "full" and "derive" of syn
-
function_name
macro that expands to the name of the annotated function
-
uniffi_meta
-
impl-tools
Helper macros: autoimpl
-
proc-macro-rules
Emulate macro-rules pattern matching in procedural macros
-
fv-template
Field-value based string templating
-
stability
Rust API stability attributes for the rest of us
-
messageforge
lightweight Rust library for creating structured messages in chat systems, including HumanMessage, AiMessage, SystemMessage, and more. It supports easy extensibility through macros…
-
is-macro
Derive methods for using custom enums like Option / Result
-
bon-cli
Dev tool for working with the
bon
crate -
frunk_proc_macro_helpers
Common internal functions for frunk's proc macros
-
prost-derive
Generate encoding and decoding implementations for Prost annotated types
-
percpu
Define and access per-CPU data structures
-
maybe-async-cfg
A procedure macro to unify sync and async implementations depending on the features of your crate
-
cargo-hax
The high assurance translation toolchain
-
do-with-in
A template language for Rust metaprogramming using partial staging
-
pearlite-syn
A syn parser for the Pearlite specification language
-
sample-test
Sampling strategies and machinery for testing arbitrary data
-
template-quote
A new-fasioned quote! macro implementation with pretty template-engine like syntax
-
quote-use
Support
use
in procmacros hygienically -
dbg-pls
Syntax aware pretty-printing debugging
-
dioxus-rsx
Core functionality for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences
-
dsl_auto_type
Automatically expand query fragment types for factoring as functions
-
int-enum
A derive macro for conversion between integer and enum types
-
syn-helpers
Framework for building derive macros
-
r3bl_core
Helper crate for r3bl_tui and r3bl_tuify crates. Used by workspace in https://github.com/r3bl-org/r3bl-open-core
-
const-random
compile time random number generation
-
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.
-
format-bytes
A macro to format bytestrings
-
quote2
An alternative lightweight version of quote
-
r2a
that provides a typesafe way to convert ROS 2 messages into Apache Arrow format
-
malloc_size_of_derive
Firefox memory reporting, not intended for external use
-
rustifact
A seamless bridge between a build script and the main crate
-
form
A small script to move inline modules into the proper directory structure
-
test-generator
Rust Test generator: enumerating entries according to file-system pattern and generating a test function for each entry
-
chalk-derive
A helper crate for use by chalk crates for
derive
macros -
unique-type-id
A unique id proc-macro generator for types
-
macroific
Proc macro development utilities
-
swift-bridge-ir
Holds the data structures and logic for bridge module parsing and code generation
-
vercel_runtime_router
Vercel Rust Function Runtime Router
-
rem-utils
Extraction Maestro
-
napi-derive-backend
Codegen backend for napi procedural macro
-
ra_ap_hir_def
RPC Api for the
proc-macro-srv
crate of rust-analyzer -
eiffel
language inspired guard clauses with Rust macros
-
rustfmt_if_chain
An if_chain-aware rustfmt (kind of)
-
as_derive_utils
private derive utilities used by abi_stable and structural
-
napi_sym
proc macro for writing N-API symbols
-
github-languages
All GitHub's supported languages
-
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.
-
makepad-micro-proc-macro
Makepad micro proc macro util lib
-
glib-macros
Rust bindings for the GLib library, proc macros crate
-
gix-trace
provide minimal
tracing
support that can be turned off to zero cost -
workflow-macro-tools
Macro utility functions used by the
workflow-rs
framework -
jacklog
Easy way to get logging the way Jack always wants anyway
-
wasmtime-versioned-export-macros
Macros for defining versioned exports in Wasmtime
-
curve25519-dalek-derive
curve25519-dalek Derives
-
genemichaels
Makes your code formatty
-
spl-discriminator-syn
Token parsing and generating library for the
spl-discriminator
library -
argp
Derive-based argument parser optimized for code size
-
rand_derive2
Generate customizable random types with the rand crate
-
quasiquote
quote compatible quasiquote macro with support for interpolating expressions
-
actix-multipart-derive
Multipart form derive macro for Actix Web
-
futures-macro
The futures-rs procedural macro implementations
-
simpl_cache
caching tools
-
supply-chain-trust-example-crate-000036
Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31
-
test_each_file
Generates a test for each file in a specified directory
-
napi-derive-backend-ohos
Codegen backend for napi-harmony procedural macro
-
symbols
Proc-macro utility to populate enums from database data
-
myn
Minimalist Rust syntax parsing for procedural macros
-
supply-chain-trust-example-crate-000004
Quasi-quoting macro quote!(...)
-
twust
Static checker for tailwindcss class names in rust for rust
-
swc_eq_ignore_macros
Macros for EqIgnoreSpan and TypeEq
-
derive_deref
Adds
#[derive(Deref)]
and#[derive(DerefMut)]
-
strum_macros
macros for working with enums and strings
-
tokenstream2-tmpl
Runtime TokenStream interpolation for Rust macros
-
better_default
The std Default derive, but it allows to constomize the default fields values and has some upgrades
-
derive-deftly
An ergonomic way to write derive() macros
-
contracts-try
Design-by-contract attributes
-
native-windows-derive
A very light and simple rust GUI library
-
vba_extract
extract a vbaProject.bin binary from an Excel xlsm macro file for insertion into an rust_xlsxwriter file
-
necessist-backends
-
proc-macro-utils
low-level utilities on proc-macro and proc-macro2 types
-
rusty-bind-parser
Parses Rust module, generates Rust code with C ABI bindings and C/C++ header files and Swift gluecode
-
vtable_gen
A C++-ABI VTable Generator for Rust
-
cfg_eval
#[cfg_eval]
in stable Rust 🙃 -
re_types_builder
Generates code for Rerun's SDKs from flatbuffers definitions
-
extendable-data
A set of rust macros that allows you to specify data that can be "extended" or inherited from
-
json_proc
proc macro for parsing JSON-like syntax
-
reflect
The "but I thought Rust doesn't have reflection?" memorial brand new way of defining procedural macros
-
penum
Make enum conform to a given pattern
-
sea-bae
proc-macro attribute parser
-
proc-debug
Dump proc-macro output for efficient debugging
-
scopegraphs-regular-expressions
A well-documented port of scopegraphs to Rust
-
impl-trait-for-tuples
Attribute macro to implement a trait for tuples
-
firmware-controller
Controller to decouple interactions between components in a no_std environment
-
positional
author/parse positional files
-
call2-for-syn
Apply parser functions to proc-macro2 token streams
-
command-rpc
cli crate and api for replacing rpc
-
pit-rust-generator
Portal Interface Types
-
safe-proc-macro2
A fork of
proc_macro2
crate with unsafe code removed -
synthez
Steroids for
syn
,quote
andproc-macro2
crates -
yewlish-fetch
A macro for generating Yew fetch API bindings
-
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.
-
dupit
copy or clone a value
-
mantra-rust-macros
macros to create requirement traces and coverage logs for the
mantra
framework -
from-attr
that makes it easy to parse attributes
-
deno_ops
Proc macro for writing Deno Ops
-
lombokrs
lightweight Rust macro library. It is the simple implementation of lombok Java in Rust.
-
drylib
Rust macro-library for Don't Repeating Yourself
-
serde_default
Generate a Default impl using serde attributes
-
extruct
proc-macro library that provides tools for listing named struct fields and implementing conversion from a larger struct containing fields with same names
-
default-struct-builder
Generates builder methods of every field of a struct
-
include_proc_macro
shorthand for including proc-macro source files in the module tree for external tooling like IDEs or other similar purposes
-
rust2antd
Generate Ant Design table from Rust struct
-
async-generic
Write code that can be both async and synchronous without duplicating it
-
ocaml-build
OCaml code generation
-
dict_derive
Derive macros for some PyO3 traits to convert python dicts into rust structs
-
checked-rs-macro-impl
procedural macros for checked-rs. This crate is not intended to be used directly.
-
macro-dep-test
testing version resolution for associated macros
-
contracts
Design-by-contract attributes
-
stilts-lang
The parser for stilts
-
db-set-macros
A derive for some ORM functions utilising SQLX
-
proc_macro2_helper
Various utility code to extract data that can be used with proc macro2
-
stageleft
Type-safe staged programming for Rust
-
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
-
assert_type_match
Statically assert that a type matches another type
-
machine-check-machine
Machine crate for the formal verification tool machine-check
-
cargo-cabal
that helps you to turn in one command a Rust crate into a Haskell Cabal library
-
pax-language-server
Language Server for Pax Language
-
savvy-bindgen
Parse Rust functions, and generate C and R code
-
command_attr
Procedural macros for command creation for the Serenity library
-
jsonrpc-derive
High level, typed wrapper for
jsonrpc-core
-
defamed
Default, positional and named parameters
-
fieldx_aux
Various types and tools useful for fieldx crates and, potentially, to users of fieldx
-
aws-dynamo-derive
Helper crate for aws-sdk-dynamodb
-
function-wrapper
Rust attribute macro library that makes it easy to wrap functions in code that runs before and / or after a function executes
-
derive-syn-parse
Derive macro for
syn::parse::Parse
-
tnj-air
TNJ Assembly Intermediate Representation (AIR)
-
opimps
attribute macros to assist with overloading operators for borrowed and owned data
-
no-panic
Attribute macro to require that the compiler prove a function can't ever panic
-
fn-decorator
contains macros for implementing wrapper functions around member or static functions
-
reflected
Something like reflection
-
flamer
a procedural macro to insert
flame::start_guard(_)
calls -
proc-quote
A procedural macro implementation of quote!
-
micro_games_macros
macros to make it easier to build complex systems with Bevy
-
winter-maybe-async
sync/async macro for winterfell
-
tailwag_macro_logic
The logic for A collection of macros to support the tailwag crate
-
doc_consts
get doc comments on fields as runtime constants
-
attr-parser-fn
parse attribute procedual macros in functional way
-
surreal_derive_plus
Query builder for surrealdb
-
metrics-derive
Proc macro for automatically describing and initializing metrics
-
juniper_codegen
Code generation for
juniper
crate -
syn-prelude
prelude traits and helpers for enhancing 'syn'/'proc-macro2' lib
-
pack_bools
Attribute macro to pack all boolean fields of a struct into a bitfield
-
cssparser-macros
Procedural macros for cssparser
-
common-error-build
High performance universal error code management for Rust in Rust
-
embed-licensing
Embed licensing information of dependencies to comply with free software licenses
-
opendp_tooling
Tooling for proc-macros and code generation
-
expand-mod
Expand
mod module_name;
in.rs
files and combine the module tree consisting of multiple files into a single file -
frc42_macros
Filecoin FRC-0042 calling convention procedural macros
-
opentalk-proc-macro-fields-helper
Helper function for working with fields in proc macros, used in OpenTalk crates
-
dioxus-rsx-rosetta
Autofomatter for Dioxus RSX
-
ab-code-gen
Functions to generate boilerplate code for objects implementing the 'Actor' pattern. Used by the abcgen crate.
-
macroific_attr_parse
Attribute parsing utilities for the macroific crate
-
unit-enum
A procedural macro for deriving ordinal methods in unit-like enums for Rust
-
moosicbox_env_utils
MoosicBox env utilities package
-
EasyAlgolia
EasyAlgolia is a Rust crate designed for utilizing the Algolia admin client. It simplifies the process of updating and inserting documents into Algolia's search index.
-
trace
A procedural macro for tracing the execution of functions
-
kira_qqbot
KiraFramework proc macro
-
ct-python
Execute Python code at compile time to generate Rust code
-
modus_ponens
develop forward chaining inference engines
-
gradio_macro
A macro for generating Gradio interfaces
-
typed-i18n-support
Support crate for the derive macro for typed-i18n
-
property
Generate several common methods for structs automatically
-
timrs_macro_utils
Macro helpers for Tim.rs
-
swimos_macro_utilities
SwimOS Macro Utilites
-
stageleft_tool
Helper macros for the stageleft crate
-
needs_env_var
Skip compilation if environment variable is missing
-
sunbeam-ir
Sunbeams intermediary types used to parse and generate CSS
-
place_macro
Macros you wish you had while you were writing your non-proc macro
-
maidenx_macro_utils
MaidenX Macro Utils
-
ra_ap_proc_macro_api
RPC Api for the
proc-macro-srv
crate of rust-analyzer -
crud-api-endpoint
CLI generator for your API. Enpoint description
-
timelang
A DSL (Domain Specific Language) and grammar for parsing and rendering human-readable date/time and duration values
-
chur
A wrapper around tonic-build which adds dependencies
-
flexpect
Attribute macro that falls back to #[allow] if #[expect] is not supported
-
validated_struct
Easily generate nested structures with getters and predicated setters
-
structstruck
Nested struct and enum definitions
-
apidoc-expand
Apidoc expand
-
serde_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
bitflag-attr
A macro to generate bitflags structures from C-like enums
-
aksr
derive macro designed to automatically generate getter and setter methods for both named and tuple structs
-
synsert
A primitive for writing structural search and replace programs for rust
-
typed-fields
A collection of macros that generate newtypes
-
makepad-widgets
Makepad widgets
-
mpst-seq
DEPRECIATED: A library with macro for mpstthree
-
pesticide
ORM for CC based on pest
-
windows-interface
The interface macro for the windows crate
-
dmacro
define C-like debug trace macro: enter!() and leave!()
-
rstml-control-flow
Custom nodes with control flow implementation for rstml. Usefull when you need to implement If, For, etc.
-
syn-file-expand
load full source code of multi-file crates
-
machine-check-bitmask-switch
Bitmask switch crate for the formal verification tool machine-check
-
telety
Access type information across crates and modules in your proc macros
-
stak-macro-util
Macro utilities for Stak Scheme
-
macro-field-utils
work with darling fields
-
std-reset
Many reworked implementations from the standard library, as well as new solutions for easy coding
-
ssa-rust
SSA to Rust converter
-
instance_code
Turn instances into source code
-
upgrayedd
Ergonomic function interposition in Rust
-
randstruct
implements a subset of the features of the GCC randomize_layout plugin
-
mosaic-derive
proc-macro for the mosaic crate
-
type_pipe
Curry types
-
aranya-policy-ifgen-build
Code generator for aranya-policy-ifgen
-
znap-syn
Collection of utilities for parsing and code generation that power znap-macros
-
fusen-derive-macro
fusen-common
-
hydroflow_lang
Hydroflow's Surface Syntax implementation
-
proc-macro-assertions
Easily create asserts on proc macro inputs
-
macrors
custom macro library in Rust
-
swc_visit_macros
Visitor generator for stable rustc
-
ragkit_convex_macros
Macros to help make Convex in Rust nice
-
gensym
Creates unique identifiers for macros using procedural macros
-
diesel_as_jsonb
Use your structs as Jsonb with diesel and PG
-
packed_struct_codegen
implements the code generation for the packed_struct library
-
grappler
function hooking through proc-macros
-
prometheus-static-metric
Static metric helper utilities for rust-prometheus
-
macro_types
easier to create procedural macros
-
derive_more_preview
Adds #[derive(x)] macros for more traits
-
vodca
Reduce boilerplate when writing DDD codes
-
enum_inject
Implement inject For the Enumeration
-
quic-rpc-macros
quic-rpc库的高级封装
-
schema
Access the schema for a Rust item
-
sgxs-tools
working with the SGX stream format
-
cast_checks_convert
-
serde_keyed_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
simple-invoke-client-macro
An embeddable message queue system
-
chandeliers-san
AST definition and static analysis procedures of Candle
-
timrs_hkt_macro
Rust Higher-Kinded Types emulation procedural macros
-
clap_config
Automatically merge CLI args, environment variables, config files, and default values in clap apps
-
EnumBitFlags
EnumBitFlags is an implementation of flags support for enums
-
serde_nested_with
Use serde attributes on nested fields
-
sneks
macros for naming enum variants
-
simpleml_macro
A macro for placing SimpleML content directly into Rust source code
-
noop_proc_macro
No-op proc_macro, literally does nothing
-
derive-elves
Writing inclusive derive macros is tedious, this creates provides helper functions that make it easier
-
mainstay-syn
Mainstay syntax parsing and code generation tools
-
variadics_please
Implement things as if rust had variadics
-
fn-error-context
An attribute macro to add context to errors from a function
-
axum_grants
A set of attribute macros for protecting Axum URI resources
-
clappos
flagless version of Clap that uses argument position for assignment with zero dependencies
-
code-product
macro producing multiple expansions
-
atri_plugin
AtriPlugin
-
jni_fn
JNI-compatible method signature generator
-
eagle
creating RPC protocols
-
safe-quote
A fork of
quote
crate that addsforbid(unsafe_code)
and depends onsafe-proc-macro2
instead ofproc-macro2
-
just-convert
Easy conversion of structures
-
hax-lib-macros-types
Hax-internal types
-
rawkit-proc-macros
Procedural macros for Rawkit
-
cargo-test-macro
Helper proc-macro for Cargo's testsuite
-
zoo-endpoint
Macro used by zoo consumers for registering handlers. This wraps dropshot’s
Endpoint
and adds some extra functionality for tracing. -
structured-map
generating structured maps with a set of known keys
-
rglw_codegen_utils
Root project for all the utilities that rustyglware offers to the community
-
struct-index
structure implement index trait
-
newtyperef
generate custom newtype reference types
-
tauri-ipc-macros
IPC bindings for using Tauri with a Rust Frontend (e.g. leptos)
-
map-enum
This package introduces a procedural macro for generating typed enums
-
syn_derive
Derive macros for
syn::Parse
andquote::ToTokens
-
compile-time
Macros for getting compile time information
-
apidoc-attr
Apidoc attr
-
actix_async_handler
Support for async syntax for Actix
-
axum-error-handler
error handler for axum
-
after-test
A procedural macro that allows you to run a clean up function after each test from a test module
-
dynex
Inherit and derive object-unsafe traits for dynamic Rust
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
ceasar_macro
A proc macro for evaluating ascii alphabetic character ciphers
-
duchess-reflect
Internal component of duchess crate
-
aws-sdk-compile-checks-macro
Macros that add compile time checks to the AWS SDKs
-
io-excel
package that wraps around Calamine and rust_xlsxwriter, allowing for simple Excel read and write operations through procedural macros
-
inttype-enum
Converts an [
enum
] into an [inttype
], and try to convert it back -
diesel-json-derive
Macro crate implementing the proc macro for diesel-json-derive
-
racc
port of Berkeley YACC to Rust, and allows you to write grammar definitions directly in Rust source code
-
variantly
Derive helper methods for enum variants that are familiar from
std::option::Option
&std::result::Result
such asunwrap_or
orand_then
-
easyfix-messages-gen
Easy FIX (Financial Information Exchange) toolset - messages generator
-
derive-into-owned
Custom derives to help with types containing Cow fields
-
c-like-concat
macro that works just like C's ##
-
predawn-schema-macro
Macros for predawn-schema
-
gandiva_rust_udf_build
A basic shared library for gandiva rust udf
-
enum_macros
A collection of useful macros to make working with enums easier
-
syn-impersonated
Parser for Rust source code
-
jaffi
Support for the jaffi code generator
-
rust-oop
use macro to implement inheritance
-
ferment
Syntax tree morphing of FFI-compatible stuff
-
set_builder
A procedural macro to create Iterators over a set defined by Haskell-inspired set-builder notation
-
substruct
A proc-macro to create subsets of structs
-
wgsl_ln
Experimental crate for writing wgsl in rust!
-
arc-trait
Automagically implement any trait for Arc<T>
-
lucidity
A distributed orchestrator platform for Rust
-
triton-constraint-builder
Emits efficient code from Triton VM's AIR
-
proclet
Proc macros made easy
-
custom_attrs
that allows you to configure values specific to each variants of an enum
-
proc-macro-faithful-display
A Display implementation for proc-macro types more faithful to the input stream
-
autogen
set of macros that allows you to automatically apply generics to impl blocks
-
spread_macros
Macros around an extended spread syntax
-
to_query
Structure to HTTP_GET/SQL Query Parameters
-
a0
generate structs and their values from external data
-
rem-borrower
Permission repairer for Rusty Extraction Maestro
-
compiletime-regex
proc macro for compile time regex
-
ambient_package_macro_common
Common implementation of a proc-macro that generates boilerplate from an
ambient.toml
-
wd_macro
wd macro for rust
-
rkyv-with
Third-party derive macro for rkyv's *With traits
-
ifmt
Inline expression interpolation for Rust
-
into-jsvalue-derive
derive into-jsvalue for enum return values in async wasm_bindgen functions
-
clap_main
provide a #[clap_main] macro to automatically parse and pass args to your main function
-
str-match
Format pattern like str match macro
-
bool_to_bitflags
compact multiple bools into a single bitflags field automatically with getters and setters
-
polkavm-derive-impl
The derive crate for PolkaVM guest programs (implementation)
-
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…
-
unzip-n
Procedural macro to generate
unzip
for iterators over n-sized tuples -
procout
Output a proc macro's TokenStream to a file
-
despatma-lib
Common tokens for Despatma
-
extpat
A procedural macro for implement extractor pattern
-
tokio-wrap
run asynchronous code within synchronous functions
-
fire
fire implementation for rust
-
crabstructor
constructor generator for named structures
-
unroll
An attribute-like procedural macro for unrolling for loops
-
validator_struct
ergonomic addition to the validator crate
-
membrane_types
A companion crate for
membrane
-
macro_optim
procedural macro crate for optimizing and simplifying various expressions at compile time
-
Boot-Banner
An elegant banner library that enhances project launches with eye-catching terminal displays and helpful assistance
-
iter_all_proc
Iterate all enum vases
-
relm-gen-widget
relm-attributes and relm-derive
-
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.
-
tuple_for_each
macros and methods to iterate over the fields of a tuple struct
-
xladd-derive
macro that helps write Excel UDF functions in Rust
-
zerocopy-derive
Custom derive for traits from the zerocopy crate
-
impl-tools-lib
Helper macros: autoimpl
-
watt-non-static-runtime
Runtime for executing Rust procedural macros compiled as WebAssembly
-
chat_messages
lightweight Rust library for creating structured messages in chat systems, including HumanMessage, AiMessage, SystemMessage, and more. It supports easy extensibility through macros…
-
complex-enum-macros
Convert enums with non-unit variants to privitives
-
address-literal
Procedural macro for converting Address(H160) literals to Address(H160) at compile time
-
small_derive_deref
Derive the Deref and DerefMut traits
-
katexit
Insert KaTeX autorender script into rustdoc
-
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.
-
kona-common-proc
Proc macro extension for the
kona-common
crate -
macro-wasmer-universal-test
Universal test macro for wasmer-test
-
montycat_serialization_derive
A derive trait for custom rmp serialization/deserialization
-
bflib
a BrainFuck-to-Rust transpiler using Rust proc macro
-
winit-main
Abstract away winit's event-loop inversion of control
-
ffi_trait
An attribute that makes an FFI-safe
dyn Trait
-
roadblk-expand
Validator proc-macro expand impl
-
concat-mulidents
concatenating multiple identifiers
-
enum_desc
A set of column-derived macros is provided to add descriptive information to enumerations and translate enumeration codes
-
rbac-macro
rbca-macro
-
derive_util
tools for derive macros
-
unsafe_target_feature
A more convenient #[target_feature] replacement
-
wasm-minimal-protocol
Typst plugin helper macro library
-
tlkit-expand
Tool kit
-
bevy_caravan
A function-like proc macro designed for making expressing Bevy's query.get statements easier
-
bolt-utils
Bolt utils
-
sparkles-macro
Macro crate for sparkles
-
url-macro
A compile-time URL validation macro. Parses and checks URLs at compile-time, converting valid URLs into
url::Url
objects. Provides early error detection for malformed URLs. -
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
kstool-helper-generator
A macro help user create mpsc communications
-
new-derive
New
derive macro -
tailwag_forms_macro_logic
The logic for a suite of macros supporting the tailwag_forms crate
-
getter-methods
Derive macro to create getter / accessor methods
-
reprfn
attribute macro for easyer define external functions
-
dfa-regex
Match regular expressions using a corresponding DFA
-
roop
attributes to simulate inheritance in Rust
-
derive-masked
Adds #[derive(x)] macros for implementing the Debug and Display traits masking out sensitive fields
-
namedarg
main package
-
dummy_tmp_fork
Macros implementation of #[derive(Dummy)]
-
local-impl
A proc macro for creating extension traits
-
casey
Case transforming macros for ident tokens
-
lombok-rs
Lombok port for Rust
-
indexed_db_futures_macros_internal
Internal macros for the
indexed_db_futures
crate -
af_bevy_plugin_macro
Automates generation of bevy plugins boilerplate
-
approx-derive
Extends the approx crate by derive macros
-
windows-implement
The implement macro for the windows crate
-
neli-proc-macros
Procedural macros for neli
-
global-id-creator-macro
A procedural macro library for generating constants
-
deno-proc-macro-rules
Deno fork of proc-macro-rules. Emulate macro-rules pattern matching in procedural macros
-
qsync
Generate react-query hooks for your rust backend (see https://github.com/Wulf/create-rust-app)
-
console-log-rs
replaces console.log in a rust module with println!
-
chur-build
A wrapper around tonic-build which adds dependencies
-
auto-rust
automatically generate Rust code using LLMs at compilation time
-
mlua_proc_macro
used to convert structs into lua tables with mlua
-
gettext-macros
A few proc-macros to help internationalizing Rust applications
-
smart-serde-default
An annotation to implement #[serde(default)] and Default
-
time_this
two macros to quickly time functions for debugging purposes
-
rs-macro-di
Rust dependency injection by macro
-
http-error-derive
Create an enum with error message and http code
-
asm_unroll
unrolled for-loops within inline asm
-
async_refactor
automated async code refactoring in Rust
-
conseq
Macro to conditionally repeat a piece of code in a sequence
-
yew-alt-html
Alternative macro for building Html in Yew
-
smart-clone
Rust custom-derive macro for Clone with more control on the fields
-
yew-lmth
A macro crate for writing HTML-like syntax for Yew application, inspired by Sycamore and Dioxus
-
intercom-common
See 'intercom'
-
mlua-bridge
Generate UserData implementations for mlua
-
test-attr
Custom test attributes for convenience
-
string_macros
Small proc macro library for handling string literals
-
derive_dumb
Derive
Dumb
generates a structure in which all fields are public. Original structure can be converted using function calldumb
. -
string_cache_codegen
A codegen library for string-cache, developed as part of the Servo project
-
find-crate
Find the crate name from the current Cargo.toml
-
kolbold_macros
memory and time metrics collection
-
diesel-enum-sqltype
derive macro for FromSql and ToSql traits for postgres enums
-
supply-chain-trust-example-crate-000003
A substitute implementation of the compiler’s
proc_macro
API to decouple token-based libraries from the procedural macro use case -
ormlitex-attr
See
ormlitex
-
backtrait_error
Errors with backtraces
-
enso-macro-utils
writing macros
-
awesome-glib
Bunch of macros to make a life of gtk/glib user easier
-
script-macro
Write proc-macros inline with other source code
-
sh
Macro for easily running commands
-
vermouth
a new kind of parser for procedural macros
-
ext_format
A small, yet powerful, Rust crate for string interpolation
-
fnck_sql_serde_macros
SerdeMacros for FnckSQL
-
band_proc_macro
Support library for band
-
cxx_linker
A procedural macro for linking Rust functions with C++ using Itanium name mangling
-
file_enum_macro
Macros to generate an enum with a variant for each file in a project subdirectory. Extremely sloppy for now.
-
execute_evcxr
execution of evcxr-supported syntax via building and executing a binary crate
-
genemichaels-lib
Makes your code formatty, the library
-
pest_tree
Convert output from pest parser into statically typed trees
-
u-num-it
typenum macro for matching types from a given range
-
default_fields
derive macro that adds a default getter function for each struct field
-
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)
-
small_iter_fields
get an iterator, or get the length, or convert to a hashmap from an enum
-
openssl-macros
Internal macros used by the openssl crate
-
derive_display
A convenient attribute to derive
Display
implementation from another trait implementation. Currently supportsToTokens
. -
do-with-in-base
A template language for Rust metaprogramming using partial staging
-
sahne
DI library via implementing trait with trait
-
sourcegen-cli
In-place Rust source generator CLI utility
-
double-dyn
Macro for implementing functions with multiple dynamic argument dispatch
-
enum_stream_codegen
A parser generator. This package handles code generation for the
enum_stream
macro.” -
notation_dsl
Fun notation - DSL to create notation files
-
cgp-component-macro-lib
Context-generic programming core component macros implemented as a library
-
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.
-
future_gadget_laboratory
time travel experiments
-
debugger_test
proc macro for writing tests that launch a debugger and run commands while verifying the output
-
json_typegen_shared
Codegen from JSON samples. Not intended to be used directly. See repository for the intended crates.
-
struct_derive
automatically apply function on certain type of struct
-
vmi-macros
Procedural macros for VMI
-
convert_by_name
Derive From and Into for structs and enums based on field and variant names
-
tiaojian-macro
conditional compile proc-macro
-
css-modules
CSS Modules with a macro for convenience
-
crdts_derive
CRDTs proc_macro
-
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…
-
shimkit-macros
Macros for shimskit
-
fimi_magic
Procedural macros for fimi-rs (generic file migration framework)
-
mono-macro
Force monomorphizing on functions with
share-generics
to minimalize binary size -
vitasdk-sys-build-util
Internal build utilities for raw bindings to vitasdk
-
doc-chunks
Clusters of doc comments and dev comments as coherent view
-
confused
treat scary functions with the respect they deserve
-
struct-box
Securely encrypt any serializable struct / enum
-
fill-array
macro allowing to fill arrays with an expression
-
clippy-tracing
add, remove and check for
tracing::instrument
in large projects where it is infeasible to manually add it to thousands of functions -
multihash-derive
Proc macro for deriving custom multihash tables
-
swx
general purpose development
-
teenygame-macro
Macros for teenygame (implementation detail)
-
fort
Proc macro attributes for Bastion runtime
-
gnostr-lib-proc-macros
Proc macros for the gnostr-lib crate
-
proc-macro-error
Almost drop-in replacement to panics in proc-macros
-
ambient_project_macro_common
Common implementation of a proc-macro that generates boilerplate from an
ambient.toml
-
rem-controller
Non-local control flow repairer for Rusty Extraction Maestro
-
derive_builder_core
Internal helper library for the derive_builder crate
-
attribution
A declarative custom attribute parsing framework
-
callback-trait
Implement trait for Fn so that functions that accept traits as parameters can directly receive Fn parameters
-
amplify_syn
Amplifying syn capabilities: helper functions for creating proc macro libraries
-
portrait-framework
Framework for implementing portrait fillers
-
cmfy-macros
A CLI companion app for Comfy UI
-
machine_uuids
retrieve a machines UUID
-
structdump
Dump structure to source code
-
frunk_utils_derives
Derives for frunk traits
-
net-literals
Literals for IP/socket addresses
-
pfetch-logo-parser
A parser for pfetch logos
-
const-currying
A procedural macro for speeding up your function using currying
-
enum-display-derive
Display trait's custom derive for simple enums
-
himark
For those who crave more ergonomic marker traits
-
auto-trait
macro to generate trait implementation for wrapper types
-
lcrt
help writing leetcode solutions in rust
-
tonbo_macro
TonboRecord macro
-
catalytic_macro
Macros for the ORM for Scylla, fully compatible with Apache Cassandra™
-
ijzer_lib
IJzer. Provides tools for tensors, parsing syntax tree of the IJ language and transpiling it to rust code.
-
dustr
Generate dart code based on a rust ffishim
-
constructivist
Simplify the construction of structured data
-
mwt
proc macros for generating mut and non-mut methods without duplicating code
-
wasm_bindgen_cfg
wasm-bindgen
that can becfg
’d -
jsonrpsee-proc-macros
Procedueral macros for jsonrpsee
-
temp
A procedural macro to manage temporary variables
-
cdefines
A proc macro that translates c #define constants to rust consts
-
negative-proc_macros
Internal: proc-macro backend of ::negative
-
pyo3_macro
macro crate builds PyO3-compatible Rust
protobuf
andgRPC
structures. So you can easily expose your generated protobuf code as Pythin binding through PyO3. Features Macro… -
smile-marco
One contains many useful macros for generating common code
-
scout-utils
Macro utilities for the Scout project
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
syn-rsx
syn-powered parser for JSX-like TokenStreams
-
onionpack
Unpack your structs into DTOs, Entities and Schemas
-
r18-trans-support
r18 translation support
-
taos-macros
TDengine connector internal macros
-
c_struct_layout
enforcing stable, C-compatible data layouts in Rust
-
errgo
generate enum variants inline
-
caravel_export_poc
Caravel Module Wrapper
-
pidl-rust
Rust support for pidl
-
appinfo
Macro to derive appinfo at compile time using cargo compile-time env vars and
clap-rs
-
tauri-types
Type generating macros for Tauri apps
-
introspect-core
containing the core functionality used for
introspect
and supporting crates -
context_attr
Attribute macro to add context to all errors a function produces
-
xenosphere-macro
A macro function for handling Xenosphere framework
-
nuidl
The nucom IDL compiler
-
from_form
TryFrom impl HashMap<String,String> -> Struct
-
chandeliers-syn
Syntax of the Lustre language, to be parsed by procedural macros
-
error-enum
Provide a easy way to define an enum that represents errors with error codes, document comments and several other functionalities
-
bloom-rsx
A JSX-like syntax for bloom
-
error-http
Procedural macro for associating error enums with HTTP codes
-
tylift
Lift enum variants to the type-level
-
option_ord
configure ordering on 1+T with the 1 either smallest or largest, explicit vs derive default
-
include-wasm-rs
Builds a Rust WebAssembly module at compile time and returns the bytes
-
swc_ecma_transforms_macros
Macros for swc_ecma_transforms
-
deriving_via
DerivingVia
-
is-plutus-data-derive
Derive macro for IsPlutusData
-
razy-importer-macros
Proc macros for razy-importer
-
playout
DSL for creating Vulkan pipeline layout and descriptor set layout
-
chandeliers-lus
Procedural macros for the Chandeliers project, implementing a deep embedding of Lustre in Rust
-
bevy_derive
derive implementations for Bevy Engine
-
easify
Development tools. Includes various helper functions and proc-macros to simplify your code and boost your development
-
python-ast
compiling Python to Rust
-
enum_from_derive
Implement From For the Enumeration
-
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…
-
simple_cache_core
caching tools
-
uniffi_checksum_derive
a multi-language bindings generator for rust (checksum custom derive)
-
pit-rust-host
Portal Interface Types
-
invoke_impl
Proc macro to generate functions that can invoke all identical functions or methods inside impl blocks
-
win_etw_macros
Enables apps to report events to Event Tracing for Windows (ETW)
-
inherit
derive macro
-
opt_args
Create macros for functions and structs with default values
-
tlayuda
A derive procedural macro for structs that adds a static method that generates instances of the struct with minimal configuration
-
named-array
A procedural macro for accessing struct fields as an array
-
tupl-macros
Macros used by the tupl crate
-
const-addrs
A set of macros for creating networking types from a string literal
-
bevy_commandify
A macro for creating bevy commands
-
kanu
ORM
-
i18n-format
proc-macro to allow gettext! and xgettext to work together
-
entropy-macro
Macros library for ENTROPY<rust>
-
obfustr-macros
proc macros for [
obfustr
] -
proc-macro-generator-wrapper
An proc-macro wtapper crate for demonstrating a regression
-
farmfe_macro_plugin
macro for farm plugins
-
general-structs
General-structures - this library allows you to create structures with common fields, and those that are different can be specified individually
-
devise_core
devising derives and other procedural macros
-
subimpl
A procedural macro that generates all the implementations of a type for a struct containing a field of that type
-
aionbot-macros
Rust-based high concurrency cross platform bot runtime
-
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.
-
rbitpack
For packing booleans in variables using bitwise operations
-
rate-limit-core
companion crate to
rate-limit-macro
with primary purpose to provide tests -
derive-sql-common
Common functions supporting
derive-sql
and associated crates -
err-handler
a non-intrusive error handling marco
-
rvv-asm
Procedure macro to encode RISC-V V extension (rvv) instructions
-
prpc-build
Build prpc from protobuf definitions
-
ez-jsonrpc-macros
JSON-RPC 2.0 made easy!
-
dotenvy_macro
A macro for compile time dotenv inspection
-
include-crypt-bytes
Rust macro to embed encrypted files in compiled binary
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
dervy
Auto-derivation for entity types in domain-driven design
-
guard_macros
Convenient Rust guard macros
-
game_start_macro
A macro for starting a game
-
test-group
Organize tests into groups with macros for filtering in nextest
-
postfix-macros
Postfix macros on stable Rust, today
-
yaserde_derive
Serialization and deserialization macros
-
cronitor
Make cron jobs but SIMPLER
-
type-utilities-rs
Type utilities in Rust
-
inherent-pub
Mark methods in
impl Trait for Type
blocks inherent to the type -
proxygen-macros
proc-macros for proxygen
-
argentum_game_coordinate_system_macros
Argentum: Coordinate System Macros
-
hydroflow_plus
Functional programming API for hydroflow
-
hsr-codegen
Build fast HTTP APIs fast, with Rust + OpenAPI
-
cmd-macro
makes std::process::Command simple to use
-
usdt-impl
Main implementation crate for the USDT package
-
sully_peg
Proc macro for PEG generation
-
darkfi-derive-internal
Internal crate for serialization derive macros
-
functions_ai
Function to string implementation for LLMs
-
static-graph
Generate static parallel computation graph from DSL at compile time
-
lombok
port for Rust
-
serde_derive_default
Derive Default using serde field level annotations
-
macro_railroad_annotation
Easily embed macro_railroad images in your docs using this attribute macro!
-
z3d
Z3 DSL interface for Rust
-
proc_strarray
Create const u8 array from str literal
-
timrs_pipe_macro
Procedural macro providing Elixir-style pipe operators for function composition
-
conjure-macros
Macros exposed by conjure-http. Do not consume directly.
-
mapstruct-derive-lib
A derive macro for mapstruct
-
variant_enum
variant enum. generate enum variant. static dispatch.
-
r2r_msg_gen
Internal dependency to the r2r crate
-
gtk-properties-macro
Experimental property declaration macro for gtk-rs
-
diesel_derives_extra
Automatically derive some simple CRUD methods for your Diesel models
-
xbinser-macros
binary structure transporation, macros to generate encode and decode tools
-
deserter
Procedural macros to initialize Rust structs from JavaScript-like object syntax
-
shared-tokio-runtime-macros
Shared tokio runtime macros
-
dioxus-check
Checks Dioxus RSX files for issues
-
elfo-macros-impl
Macros for matching and deriving messages, implementation internals
-
in_struct
An attribute-like procedural macro for defining structs for use in functions
-
napi-derive
N-API procedural macros
-
kproc-parser
minimal procedural macros parser that produce a convenient AST by including only the necessary code
-
core_extensions_proc_macros
detail of the
core_extensions
crate -
machine_uuid
retrieve a machines UUID
-
box-self
Easy way to duplicate a new function with self: Box<Self> signature
-
sqlx-macros
Macros for SQLx, the rust SQL toolkit. Not intended to be used directly.
-
mlua_derive
Procedural macros for the mlua crate
-
static_table_derive
Procedural macros for investments crate
-
canadensis_macro
A procedural macro that generates Rust data types and serialization code from inline and/or external Cyphal DSDL files
-
js-macros
Quickly prototype procedural macros using JavaScript or TypeScript!
-
small_read_only
A macro to implement getters on a struct
-
concat-arrays
A macro for concatenating fixed-size arrays
-
gsettings-macro
Macro for typesafe GSettings key access
-
leptos_macro
view macro for the Leptos web framework
-
async-trait-static
async fn in trait for no_std
-
mutablex
A horrid macro for making mutables of X size
-
erased-generic-trait
Macros for generating trait objects from traits with generic methods
-
typemarker
Procedural macro for easily creating multiple linked marker types
-
yui
An attribute reader generator for Rust
-
function-frame
Procedural macro to wrap any function outputs within a text frame
-
adversary-macros
Procedural macros for the adversary crate
-
rogger
Logging macros for Rinrin.rs
-
toti
Expand macro N times for multiple generics
-
forsyde-io-generator
Code generation component for traits and others of the Rust ForSyDe IO supporting library
-
progenitor-impl
An OpenAPI client generator - core implementation
-
bevy_surreal_macros
Macros for the bevy_surreal crate
-
parsegen
A parser generator implemented as a proc macro
-
bare_proc
A proc macro to generate Rust types from a BARE schema file
-
fastsim-proc-macros
Procedural macros for FASTSim
-
defmt-macros
defmt macros
-
sleigh2macro
Macro used to transpile Ghidra code into rust
-
const_field_count
procedural macro to derive a constant function for counting the number of fields in a struct
-
proc-macro-kwargs
Keyword argument parsing for function-like proc-macros
-
extendr-macros
Generate bindings from R to Rust
-
axum_guard
A set of attribute macros for protecting Axum URI resources
-
include-repo
implements the 'include_repo!' macro for easy AGPL compliance! Include a tarball as a const in your code!
-
sort_by_derive
Derive macro SortBy and helper macros EnumAccessor and EnumSequence, deriving traits
Ord
,PartialOrd
,Eq
,PartialEq
andHash
for structs and enums that can’t automatically derive from those traits -
message_macro_derive
A macro to generate/parse binary representation of messages
-
unsafe-access
macros for skipping bounds checks via get_unchecked(..)
-
runtime-struct-field-names-as-array
procedural macro that generates an array of the field names of a named struct
-
kittycad-modeling-cmds-macros-impl
Macros for defining KittyCAD modeling commands
-
wayrs-scanner
Generates code for wayrs-client from xml files
-
crux_macros
Macros for use with crux_core
-
code-product-lib
macro producing multiple expansions
-
utoipa_auto_discovery
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
denumic
Creating enum-based runtime dispatched traits
-
codegen-libc
A codegen tool for extracting libc cfg
-
color-hex
Procedural macro for converting hexadecimal strings to an RGB or RGBA byte array at compile time
-
macro-visit
Function like proc-macro visitor for build.rs
-
basicmethod
Add constructor, get and set method using derive macro
-
depends_core
Ergonomic, performant, incremental computation between arbitrary types
-
krk
The shuttle cli helper for (js like experience)
-
indirect-once
One-time resolvable runtime indirection in the style of glibc's ifunc
-
wrapcenum-derive
Derive macro for nvml-wrapper, not for general use
-
enumber
Provide useful impls on numerical enums
-
redpen-shim
A proc-macro attribute provider that allows crates to annotate their code with redpen lints without breaking their build
-
markup-proc-macro
A blazing fast, type-safe template engine for Rust
-
rash_derive
rash derive crate
-
wasmtime-c-api-macros
Support macros for
wasmtime-c-api
-
mrml-common-macros
Common macros for the MRML crate
-
neon-frame-macro
Macros to simplify writing Neon apps
-
subenum
A proc-macro to create subsets of enums, that can be converted to and from
-
include_absolute_path
Macro to returns absolute path of a specified file or directory
-
prost-validate-derive-core
the prost-validate derive implementation
-
suanleme-macro
suanleme common module
-
cfg-vis
A macro to support
#[cfg()]
on visibility -
functional_macro
A functional macro for Rust
-
wasm-bindgen-macro-support
The part of the implementation of the
#[wasm_bindgen]
attribute that is not in the shared backend crate -
inkwell_internals
Internal macro crate for inkwell
-
power-protobuf
a proc-macro for embedding protobuf inside rust code
-
cbor-macro
Macros for entering CBOR in diagnostic notation (EDN) or pretty printed format
-
cgp-field-macro-lib
Context-generic programming field macros as a library
-
prolangkit_macros
Macros for prolangkit
-
git_rev
Procedural macros for including git revision hashes in code
-
simple_function_logger
function logger
-
jj-lib-proc-macros
Proc macros for the jj-lib crate
-
o2o-impl
'o2o' crate
-
prost-dto-core
Data transfer object conversion macros for prost
-
macropol
Ergonomic string literal interpolation in macro definitions
-
variants-struct
A derive macro to convert enums into a struct where the variants are members
-
edgedb-derive
Derive macros for EdgeDB database client
-
tarantool-proc
Tarantool proc macros
-
sails-macros
Procedural macros for the Sails framework
-
intuicio-derive
Procedural macro module for Intuicio scripting platform
-
callback_fn
callback functions
-
syn-file-expand-cli
CLI tool to read full source code of multi-file crates and output it to stdout
-
uucore_procs
uutils ~ 'uucore' proc-macros
-
quote-alias
A helper macro for easily reusing static token streams
-
const-field-offset-macro
Procedural macro to generate constant field offset from repr(c) struct
-
instability
Rust API stability attributes for the rest of us. A fork of the
stability
crate. -
typify-impl
typify backend implementation
-
wit-bindgen-rust-macro
Procedural macro paired with the
wit-bindgen
crate -
derive-docs
generating documentation from Rust derive macros
-
curried
currying function to be used in normal && generic && map case, with procedural macro
-
mockers_macros
Compiler plugin for 'mockers' mocking library
-
fully_pub
Macro that makes multiple items or fields public at once
-
cargo-toml-macros
Convinient macros for pulling fields from your Cargo.toml. Prettier than std::env
-
smtlib-build-util
The build utils for building the smtlib family of crates
-
trust-me-2
A convenient macro to tell the Rust compiler that you know better and to leave you alone regarding unsafe code
-
from-to-repr
Derives TryFrom and From implementations for the representation type of a Rust enumeration
-
tinyklv-common
Common attributes
tinyklv
crate -
fail_on_ci
Script to abort compilation if one of the known CI-Servers is detected
-
spez
Macro to specialize on the type of an expression
-
nj-derive
procedure macro for node-bindgen
-
small_ctor
A minimal, dependency free version of the ctor crate
-
brainfuck_macros
A compiler plugin that converts brainfuck code into Rust at compile time, letting your BF programs be optimised by LLVM to super-fast native code
-
leptos-mview-core
Main implementation of leptos-mview
-
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…
-
testtesttest2
test
-
optbuilder
A optional builder derive macro for helping with big constructors with mostly optional parameters
-
utility-types
proc-macro to realize several utility types of TypeScript
-
wgpu-pp
C-style preprocessor for WGSL using proc macros
-
rust-i18n-macro
Macro for rust-i18n crate
-
justerror
Extension to
thiserror
that helps reduce the amount of handwriting -
server-function
A macro for easy RPC creation
-
rust_minify
minify rust code
-
cmd_lib_macros
Common rust commandline macros and utils, to write shell script like tasks easily
-
enalang_macro
Exhaustingly Notorious Algorithms - macro support
-
tao-macros
Proc macros for tao
-
fsm-macro
A statically checked finite state machine written in rust
-
actix-web-codegen
Routing and runtime macros for Actix Web
-
for-else
Python-esque for-else construct for Rust
-
volatile-macro
Procedural macros for the volatile crate
-
cbit
A proc-macro to use callback-based iterators with
for
-loop syntax and functionality -
structout
A proc-macro for generating structs from a common definition
-
derive-error
Derive macro for Error using macros 1.1
-
join_impl
join!
macro -
bevy_derive_commands
A macro for creating bevy Commands methods
-
env-smart
Proc macro to insert env vars into code
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
agb_macros
Macro for declaring the entry point for a game using the agb library
-
tcp-struct-macros
Macros for tcp-struct
-
foundations-macros
Procedural macros used by foundations
-
sub-struct
remove specified fields from a struct to create a new struct
-
c-closures-build
Generates C/C++ FFI compatible
*Closure
structures from rust closures, useful for cross language functional programming -
pgrx-macros
Proc Macros for 'pgrx'
-
wasmer-derive
Wasmer derive macros
-
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
-
derive-ocaml
Custom derive and procedural macros for easy FFI with ocaml on top of the ocaml crate
-
ene_kafka_derive
Derive macros used for Ene Kafka
-
bae
proc-macro attribute parser
-
maikklein/unreal-api-derive
Rust integration for Unreal Engine 5
-
polars-row-derive
Macro to help convert an interator of structs into a DataFrame
-
buffered
Implement SOA for independently buffered streams
-
merge-cfg
Merge or cover config based on priorities
-
struct_layout
Customize your struct layout with this one weird trick
-
aors
Useful rs tools for Advent of Code
-
stidgen
Strongly Typed ID types macro
-
insert-only-set
A procedural macro to generate insert-only sets from enums
-
rustler_codegen
Compiler plugin for Rustler
-
quote_into
Easily & efficiently generate code by quoting it in a macro
-
dynimp-macros
extended version of razy-importer-macros
-
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…
-
light-macros
Macros used in Light Protocol on-chain programs
-
swc_trace_macro
Proc macro for performance trace of swc
-
debug-span
Visualize proc-macro2 spans for debugging and assertions
-
faster-pest-generator
proc-macro for faster-pest
-
iconify
Proc-macros for generating icons from the Iconify API
-
esp-hal-procmacros
Procedural macros for esp-hal
-
thiserror-impl-no-std
detail of the
thiserror
crate -
scx_stats_derive
Derive macro for scx_stats
-
wedpr_l_macros
WeDPR shared macros
-
milkyway-std-derive
Procedural macro for milkyway-sdk
-
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
-
sdf-macros
SDF macros
-
fortuples
Procedural macros to generalize inherent and trait implementations over tuples
-
ra_ap_proc_macro_srv
Proc-macro server for rust-analyzer
-
vts
Macro to generate boiler plate to define new types with associated constraints
-
trace2
A proc macro for tracing the execution of functions, similar to trace crate, but thread safe and use log
-
envhead
build environment variable names using a static prefix. Works great with the popular clap crate.
-
constable
const lookup table generation
-
brain_fuck
BrainFuck compiler in Rust procedural macro metaprogramming
-
inertia-macros
attribute macros to assist with overloading operators for borrowed and owned data
-
prql-compiler-macros
Macros for PRQL compilation at build time
-
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
-
toml-cfg
A procedural macro for configuring constant values across crates
-
bomboni_core
Internal part of Bomboni library
-
gadget-blueprint-proc-macro
Procedural macros for writing Tangle blueprints
-
feature-gate
macro for feature-gating modules and types
-
sw4rm-rs-generation
handle generation of rust models & apis from OpenAPI v2, v3, and v3.1 specs
-
regexp2rust_macro
regexp(ecma262) to rust code macro
-
renum
From and TryFrom trait derive with customization
-
teloxide-macros
The teloxide's procedural macros
-
jetstream_wire_format_derive
Supporting proc-macro for the
p9
crate -
burned
Rust macros to embed files into your binary
-
pest-ast
Derive to convert from pest parse tree to typed syntax tree
-
proptest-attr-macro
Procedural attribute macro for writing proptest tests
-
fixed_width_derive
Derive trait for use with the fixed_width crate
-
const-random-macro
procedural macro used by const-random
-
to_sql_condition
genreate sql condition proc macro
-
metamorphose
Macros collection for converting Structure to Model, for a green-barrel project
-
macro-compose
trying to simplify and organize proc-macros
-
narrative-macros
Procedural macros for the narrative crate
-
same_enum
Generates
From
trait implementations for enums with the same unit variants -
envtime
Runtime and compile time environment resolution for Rust
-
derive-from-one
Automatically generates
From
impls so you don’t have to -
introspect-proc-macros
Procedural macros for
introspect
-
bintex
Create bitfield LaTeX diagrams with the use of the deku library
-
near-self-update-proc
Near contract update helper procedural macro
-
creusot-contracts-proc
Proc macro crate for creusot-contracts
-
disjoint_impls
Support for mutually disjoint impls
-
mass-cfg-attr
A way to mass toggle cfg-attr on attributes
-
specialized-dispatch
dispatching specialized versions of a function
-
aidecomment
that can get the OpenAPI operation summary and description from doc comments and provide them to aide
-
cypher_derive
A flexible and intuitive query builder for Neo4j and Cypher
-
autoload
macro,single scan load ioc aop
-
croc-look
expand macros and watch them in real time
-
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…
-
mutself
Create self-modifying executables
-
table-enum-core
You are probably looking for the table-enum crate, which wraps this crate and is much more ergonomic to use
-
tokio-actor
Macro based Asynchronous Actor System
-
include_cstr
Macro for building static CStr reference from file content
-
from-num
Attribute macro #[from_num(...)]
-
maelstrom-macro
Macros for Maelstrom internal usage
-
mser_macro
-
constime
Zig's comptime for Rust with zero dependencies. Mostly something to play around with until more stuff is const fn.
-
stateful_macro_rules
Generate macro_rules macros that have states
-
derive_step
A derive macro for the unstable Step trait
-
trigraph
macro for your rust code
-
gandiva_rust_udf_shared
A basic shared library for gandiva rust udf
-
s_test_fixture
or simple test fixture is a macro library to implement test fixture with no hassle
-
ts-rs-macros
derive macro for ts-rs
-
dojo-macros
ORM for Rust
-
macroscope
makes writing proc macros a breeze
-
proc-macro-type-name
Convert Rust field names (snake case) to type names (pascal case) using proc_macro2 identifiers
-
include_dir_macros
The procedural macro used by include_dir
-
ferrotype
An opinionated wrapper for insta.rs
-
proc-macro-id
Identity procedural macro
-
derive-discriminant
A derive macro for enum discriminants
-
recursive-proc-macro-impl
Procedural macros for the recursive crate
-
smarterr-macro
Smart error handling library
-
reactive_stores_macro
Stores for holding deeply-nested reactive state while maintaining fine-grained reactive tracking
-
const_env_impl--value
Configure const and static items by environment variables
-
is-tree-macro
Everything is a tree
-
rxing-one-d-proc-derive
proc macros to simplify the development of one-d barcode symbologies in rxing (https://github.com/rxing-core/rxing)
-
on_your_marks
Getters and Setters for Rust
-
fix-hidden-lifetime-bug-proc_macros
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
sickle_macros
Macros for sickle_ui
-
cain
Procedural macro to transform sequential branches into nested branches
-
html-macro
html macro
-
bytes-lit
Create byte slices from literal integers
-
raxb-derive
Architecture for XML Binding
-
ascent_macro
ascent macros
-
lock_order
macro for helping produce a deterministic lock ordering to prevent deadlocks
-
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
-
getters2
Generate getters, mutable getters, setters, and copy accessors for structs and enums
-
struct_morph
macro for morphing one struct into another
-
pipewire-wrapper-macro-impl
Attribute and prop macroses implementations for pipewire-wrapper crate
-
disintegrate-macros
Disintegrate macros. Not for direct use. Refer to the
disintegrate
crate for details. -
clown
approximation of capture-by-closure lambdas
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
auto-import
Please do not use this
-
xml2gpui_macros
Helper macros to convert XML attributes to GPUI attributes
-
de_generics
generate 'de lifetimes for custom serde derive macros
-
surrealdb_functions
procmacro for surrealdb functions (fn::*)
-
tower-lsp-macros
Internal procedural macros for tower-lsp
-
klvm-derive
Derive macros for implementing KLVM traits
-
safe_attr
An attribute #[safe] to mark functions, allowing the ommission of unsafe
-
elapsed-printer
Very simple macro for printing time elapsed to execute a function
-
tco
A macro for transforming a tail-calling recursive function to eliminate recursion
-
saturating_arithmetic
Proc macro #[saturateit] to rewrite operators into their saturating equivalents
-
lofty_attr
Macros for Lofty
-
leftwm-macros
A window manager for Adventurers
-
rsfk
that provides inline brainfuck execution as macros
-
sh-builtin-bash
Procedural macro and bindings for creating bash builtins
-
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…
-
translator
A procedural macro which translates your repr-C structs into C++, Python and C# at compile time for helping write FFI libraries
-
fantasy-cpu-emulator
Fantasy CPU Emulator
-
activity-vocabulary-derive
Code generator for Activity Streams 2.0
-
quote-data-helpers
Internal functions, struct for quote-it
-
xls_table_derive
Procedural macros for investments crate
-
expansion
expant the native libs
-
lazy-regex-proc_macros
proc macros for the lazy_regex crate
-
papyrus_proc_macros
Procedural macros for the Papyrus node
-
hitrace-macro
Convienience macros for instrumenting code with hitrace
-
tl-proto-proc
A collection of traits for working with TL serialization/deserialization
-
bevy_utils_proc_macros
Bevy Utils Proc Macros
-
include_gif
procedural macro that packs a gif image into a byte representation
-
wolfram-library-link-macros
Procedural macros used by wolfram-library-link
-
relm-derive-common
Common derive implementation internally used by relm crates
-
butane_codegen
Macros for Butane. Do not use this crate directly -- use the butane crate.
-
delegate-trait-impl
Delegate trait implementations
-
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…
-
bluejay-typegen-macro
Macros for
bluejay-typegen
-
pretty_derive
A procedural macro for pretty
-
pixel-game-lib-macros
Procedural macros for pixel-game-lib
-
as_warp_reply
Macro to implement the warp reply trait on custom structs
-
primitive-enum-derive
macros for get primitive enum from complex
-
studs-lib
Studs that provides macro implementations and utilities
-
coreum-std-derive
Procedural macro for osmosis-std
-
zips
Macros for wrapping up a bunch of Option<T>'s/Result<T, E>'s into a single Option<(T [, T...])>
-
rem-repairer
Lifetime repairer for Rusty Extraction Maestro
-
ks-placeholder
A macro help user create pesudo source file
-
gix-macros
Proc-macro utilities for gix
-
classic-bitfield
A bitfield enum with a classic feel
-
axum_error_macro
derive macro for your custom Error enum to generate quickly its status code and message
-
golem-rust-macro
Golem Rust tooling library that facilitates writing Golem backends in Rust
-
nject-macro
Zero cost dependency injection macros
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
const_gen_proc_macro
Create proc macro that adds compile time functionality for the creation of constants
-
ergokv-macro
Easily store and retrieve data from TiKV with a derive
-
tensorflow-internal-macros
The package provides macros for internal usage in TensorFlow. No backwards compatibility guarantees are made.
-
doctest-file
Procedural macro that sources doctests from dedicated files into Rustdoc documentation with support for hiding lines
-
dialogue-core
the core of dialogue-macro
-
workflow_macro
Derive Macro for Workflow-Aurras
-
neon-macros
Procedural macros supporting Neon
-
actix-handler-macro
Helper macros for using Actix. Generates handlers, actors and address traits.
-
color-print-proc-macro
package color-print
-
reduct-macros
Macros crate for ReductStore
-
thirtyfour-querier-derive
#[derive(Querier)] macro for thirtyfour WebDriver library
-
git-ref-format-macro
Macros for the git-ref-format crate
-
qroc
Perl for procedural macros
-
steel-derive
Derive macros for use within steel
-
hdv_derive
proc_macro_derive
for hdv -
machine
State machine utilities
-
hclua-macro
hclua macro
-
tera-template-macro
Proc Macro for tera-hot-reload crate
-
remoc_macro
Procedural macros for Remoc
-
oricalchum_derive
Procedural macros for oricalchum
-
try-from-map
A derive macro for converting a HashMap<String, String> into a struct
-
prost-serde-derive
Derive macro for serializing/deserializing structs generated by Prost with Serde
-
auto_impl_trait
auto impl trait by provide trait file
-
cmd-proc-macro
Run some shell script when build the project, and yield the stdout as &[u8]
-
prove
struct
-
nut_self
Makes your code nut
-
dremoc-macro
Procedural macros for dremoc
-
type-id-derive-impl
-
janetrs_macros
Attribute macros for JanetRS
-
logfn
attribute macro for inserting logging code into your function
-
utoipauto-core
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
traitify
A macro to turn an impl block into a trait
-
gcp_client
Experimantal GCP client
-
origami-macros
Macros for origami-engine
-
gll-macros
Macros used with the gll crate
-
typeshare-core
The code generator used by Typeshare's command line tool
-
enutil
General Enum Utility Macros
-
ngyn_macros
Modular backend framework for web applications
-
instant-xml-macros
Procedural macros for instant-xml
-
equator-macro
Composable assertion library
-
altrios-proc-macros
ALTRIOS procedural macros
-
limousine_derive
Proc macros for building hybrid index data structures
-
pio-proc
proc-macro for assembling PIO code in a Rust program at compile time
-
bitlight-core-derive
providing derive macros for the Bitlight core
-
captcha_oxide_core
Dependencies for captcha_oxide and captcha_oxide_macros
-
dunge_macros
Procmacro for the dunge library
-
async-backtrace-attributes
Procedural macros for the
async-backtrace
crate -
preserves-schema-macros
Preserves Schema code generation macros for Rust
-
tigerbeetle-unofficial-sys
Native bindings to the tigerbeetle library
-
e-macros
macro definition that can handle Json and C data
-
size_of_const_macro
Macro for generating the constant of a type's size
-
pzmacro
general macro; demo: https://github.com/FaceWaller/pzmacro
-
spooky-season
👻 SPOOKY! 👻🎃👻
-
lex_derive
Some derive macros for creating a lexer
-
kalosm-parse-macro
A macro to derive kalosm parsing traits
-
sqlparser_derive
proc macro for sqlparser
-
multiversion-macros
multiversion
-
shuttle-codegen
Proc-macro code generator for the shuttle.rs service
-
wd_log
A practical log crate for rust
-
rquickjs-macro
Procedural macros for rquickjs
-
arouse
Arouse is
-
match_any_trait
match expressions for any trait
-
ntree-macros
Complementary proc macros for ntree-rs
-
moosicbox_lofty_attr
Macros for Lofty, modified for MoosicBox
-
prometheus-client-derive-encode
Auxiliary crate to derive Encode trait from prometheus-client
-
macroific_core
Shared functionality for macroific & macroific_macro
-
reginleif-macro
The core library of nolauncher
-
substrait-expr-funcgen
automatically generating code from Substrait YAML files
-
all-the-same
A procedural macro that copy-pastes match arms for new type variant enums
-
celery-codegen
Macros for rusty-celery
-
equalia
Automatically implement PartialEq for your structs
-
file_check_macro
A macro for checking the presence of a template file at compile time. E.g. for Tera templates
-
midi2_proc
Internal procedural macro crate. Only intended for use with midi2
-
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
-
ni-fpga-macros
Macros to be used with the ni-fpga crate
-
egui-probe-proc
Derive macro for egui-probe crate
-
tentacli-packet
Macro for implementing packet structures
-
tui-helper-proc-macro
Macros for widgetui
-
prqlc-macros
Macros for PRQL compilation at build time
-
diesel_enum_derive
Enum derive for [Postgres only] Varchar fields
-
linera-witty-macros
Procedural macros for generation of WIT compatible host code from Rust code
-
lvbitfile2rust
Generate Rust register maps (
struct
s) from lvbitx files - in the spirit of svd2rust -
derive-deftly-macros
Macros that implement the derive_deftly crate
-
algorithm-macro
about algorithm data structure, now has ttl with lru/lru-k/lfu/arc and slab/rbtree/roaring_bitmap/timer_wheelss, 关于算法常用的数据结构
-
sled_driver_macros
Procedural macros for use the in the sled crate
-
timeout-macro
modio-logger Dbus service
-
java_asm_macro
Java bytecode reader & writer in rust
-
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.
-
ndk-macro
Helper macros for android ndk
-
try-let
Proc macro for a basic try-let form
-
cocoa-purity
macro collection
-
fuel-indexer-macro-utils
Fuel Indexer Macro Utils
-
paperclip-macros
Macros for paperclip OpenAPI tooling library
-
derive_hub
A proc-macro for a simple actor framework
-
strand-derive
derive macro for a strand in rope
-
multi-eq
Macros for creating custom equality trait derives
-
test-impl
A macro for use in testing, to run a test on multiple trait implementations
-
raffl-macro
Rust Asynchronous FFI Library - A library for writing asynchronous callback-friendly FFI
-
replace_ident_in_expr
Replaces target ident with given ident in an expr
-
derive_constructor
Construct enums without naming them
-
hun-offsetof
C-like macros: offset_of and container_of
-
rerust
Reactive programming with dataflow semantics
-
rs-derive
A procedural macro library containing useful derive macros
-
const_panic_proc_macros
detail of the
const_panic
crate -
ext-crud-derive
Derive macros for ext-crud-rs
-
redis-macros-derive-bincode
Derive macros to serialize/deserialize structures with bincode to store in redis
-
recorder
Generate data-only structs with utilities easily
-
girolle_macro
A nameko macro proc-macro to generate a Nameko Function
-
neovide-derive
Derive macros for the Neovide gui
-
xshell-macros
Private implementation detail of xshell crate
-
require_lifetimes
A proc-macro to force rust authors to write lifetimes in function signatures
-
proc-caesar
Procedural macro to break Rust IDEs
-
bevy_atmosphere_macros
Proc macros for bevy_atmosphere
-
aoc-auto
Automatically imports your solutions to Advent of Code challenges for easy running
-
derive_pb
derive macro for proto
-
enum_to_string
Generate a serialized string using the display trait easily
-
bevy_startup_tree_macros_core
core of bevy_startup_tree_macros
-
quick-impl
procedural macro auto-generating common methods on enums and structs
-
openai-macros
macros for the openai-utils crate
-
bounded-integer-macro
Proc macro for
bounded-integer
. Do not use directly. -
ouroboros_macro
Proc macro for ouroboros crate
-
smodel-proc
Symbol semantic modeling for Rust: procedural macros
-
devela_macros
procedural macros for devela
-
sdi
Rust statically resolved dependency injection lib
-
xtask-wasm-run-example
run-example
feature of xtask-wasm -
i-slint-core-macros
Helper macro for i-slint-core
-
destructure
Automation of Destructure Pattern
-
derive_everything
#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] everything if possible
-
iced_layershell_macros
Wayland extra shell lib
-
err-derive
Derive macro for
std::error::Error
-
avr-device-macros
Attribute macros for re-export in
avr-device
-
ok_macros
The standard library that's ok
-
instruct-macros
are a collection of simple macros that we're using in Instructor-AI to generate json schema from Serde Objects
-
field_macro
pmc get_name macro
-
traitlit
exposes an atribute for implementing traits for integer and float types
-
ruzhda
Rust programming, in Bulgarian
-
struct_baker
enable ergonomic creation of compile time parsers
-
impl-opaque-macro
Macro for declaring complex struct and initializer
-
include_optional
Option-returning versions of include_X macros
-
packet_derive
Derive implementation for packet_enum
-
cloneable_dyn
Macros to make structs and enums clonable that use dyn Objects
-
psl-codegen
Generate native Rust code from Mozilla's Public Suffix List
-
v_utils_macros
Macros for my utils crate
-
serenity-commands-macros
creating/parsing Serenity slash commands
-
ai_functions
Procedural macro for creating text from a function for use in Large Language Models
-
micrortu_ie_representation_derive
SDK for MicroRTU
-
rupring_macro
rupring macro
-
flipperzero-test-macros
Procedural macros for flipperzero-test
-
commonware-macros
Augment the development of primitives with procedural macros
-
test-trace-macros
Supporting procedural macro crate for test-trace
-
syn-dissect-closure
Analyze syn ExprClosure body
-
derive_merge
A derive macro to partially update a named struct
-
dmntk-macros
DMNTK | Procedural and derive macros
-
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.
-
miniserde-enum
Derive macros for miniserde on enums
-
tagrs
Rust test tagging
-
usdpl-build
Universal Steam Deck Plugin Library core
-
servify_macro
Procedural macros for use with Servify
-
functional_trait
A macro that impls trait for Fns
-
pagetop-macros
A collection of procedural macros that boost PageTop development
-
enumcapsulate-macros
Procedural macros for 'enumcapsulate' crate
-
variadiz-macros
Procedural macros implementation of variadiz
-
casco
CSS-like parser for procedural macros
-
native_model_macro
A procedural macro for native_model
-
pavex_macros
Procedural macros for the Pavex framwork
-
quickerr
A macro to define errors quickly, like
thiserror
but terser and more opinionated -
better
rustcoed make better
-
trait_info_gen
Procedural macros for obtaining Trait information at compile time
-
polyhorn-ui
Shared API contract for multi-platform Polyhorn UI
-
actix-json-responder
A procedural macro to reduce json response boilerplate on actix projects
-
overloading
A POC crate that utilizes
Fn*
traits to implement partial overloading -
goldboot-macros
Supporting macros for goldboot
-
rstml-component-macro
Macros for rstml-component
-
mozilla-central-workspace-hack
Workspace hack for mozilla-central
-
rustpython-derive-impl
Rust language extensions and macros specific to rustpython
-
kexplain
Derive explanations for functions by 'showing the work' for things like math
-
rust-ad-core
Rust Auto-Differentiation
-
dep-inj-target
Stateless target creator of dep-inj
-
tantivy-macro
derive tantivy schema api
-
http-request-derive-macros
Use derive to create HTTP requests
-
hpl-toolkit-macro-platform-gate
HPL macro for defining an platform-gate
-
cpy-binder
when creating binds from Rust to C++ and Python
-
optional_struct_macro_impl
Helper crate implementing the proc_macro for the optional_struct crate
-
derive-env-url
Derives for env-url
-
jsonrpc-utils-macros
Proc-macros for jsonrpc-utils
-
elicit_macro
SmartPointer-like structure for polymorphism
-
default-args
zero-cost default arguments in rust
-
phper-macros
The proc-macros for phper crate
-
pacaptr-macros
several macros used in pacaptr
-
bracer
Macros to help write ARM assembly
-
specs-derive
Custom derive macro for Specs components
-
default2
Default implementation using macros
-
tt-equal
The macro
tt_equal
acts as a predicate for whether two token trees are equal -
panic_discard
A proc-macro that discards panics that happen within a function
-
cameleon-impl-macros
used by other cameleon crates implementation
-
semx_entry
为对应架构定义汇编入口以及异常入口
-
polyhal-macro
macros for polyhal
-
indextree-macros
Macros for indextree
-
ruva-macro
Event Driven TEvent Handling
-
tlns-google-oauth2-proc
A half-assed procedural macro that generates Scope enums and trait that converting the scopes back and fourth
-
nanosql_macros
Tiny, strongly-typed data mapper for SQLite (procedural macros)
-
embed-rust
A macro that allows to embed a Rust executable
-
bevy_ergo_plugin
Macros to make building bevy plugins more ergonomic
-
parquet_derive
Derive macros for the Rust implementation of Apache Parquet
-
unity_native_proc_macro
The derive macros for the unity_native library
-
leafwing_input_manager_macros
Macros for the
leafwing-input-manager
crate -
dapr-macros
Dapr Rust SDK (Macros)
-
cmd-impl
-
schematic_macros
Macros for the schematic crate
-
semx_bst
对应硬件板级定义
-
rotate-enum
macro that implements prev() and next() methods to an enum
-
rustlings-macros
A macros crate intended to be used only by Rustlings
-
primwrap
Derive operation traits for primitive wrapper structs
-
restep
useful REST API endpoint generator
-
witchcraft-server-macros
Macro definitions used by witchcraft-server
-
lox-derive
Derive macros for the Lox ecosystem
-
import-modules
based on require-all
-
rp235x-hal-macros
Macros used by rp235x-hal
-
unsafe_fn_body
Wrap the function body in an unsafe block using attribute macros
-
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.
-
compilation-guard
Force compilation to fail when certain condition is met
-
server_fn_macro_default
The default implementation of the server_fn macro without a context
-
moosicbox_async_service
MoosicBox async service package
-
hecs-macros
Procedural macro definitions for hecs
-
grass-macro
Procedual Macros for GRASS
-
ir_arcane
personal mcaro library, not for public use(yet)
-
mirams-proc-macros
Menhera.org Internet Resources Assignment Management System (proc-macros)
-
crepe
Datalog in Rust as a procedural macro
-
units-relation
A procedural macro to be used with the library Rs-Measures to define relations among units of measurement
-
exemplar_proc_macro
Proc macros for the exemplar crate
-
proclet-utils
proclet
-
forward_goto
bringing gotos to Rust
-
builder-rs
A procedural macro for generating builder patterns for Rust structs
-
fn-bnf-macro
Proc macro for fn-bnf
-
tonbo_marco
TonboRecord marco
-
autd3-traits
Wav Modulation for AUTD
-
krpc-macro
RPC framework for service registration and discovery through API exposure, compatible with Dubbo3 protocol, intertunable with Java projects
-
humblegen
An experimental code-generator in the vain of protobuf, but a little more humble
-
leon-macros
Proc macros for crate leon
-
macro-ob
a macro to inline rot13 to confuse IDEs
-
linker-set-proc
Procedural macro for linker-set crate
-
zephyr-macros
Macros for the zephyr sdk
-
cpclib-macros
cpclib macros related to z80 assembling
-
tracers-macros
Macros which generate tracers and the code that fires the tracers. See the 'tracers' crate for further instructions
-
nodarium_macros
Procedural macros for the nodarium crate
-
mydb_macros
mydb proc macros
-
nano_parser_gen_macro
A parser generator inspired by yacc (procedural macro)
-
fred-macros
Procedural macros for the
fred
Redis client -
thaw_macro
Shared Thaw internal macro
-
pupactor_macro
Macros for pupactor
-
kanidmd_lib_macros
Kanidm Server Library Support Macros
-
sbs-api-macro
Macros for sbs-api crate
-
maiden_macro_utils
Maiden Macro Utils
-
owo-code
OwO Code owo! pwogwam owo in ur nyative wanguage owo!
-
wings_macro
WASM plugin system for Geese
-
either_trait_macro
An attribute-like macro to implement traits for Either
-
binrw_derive
Derive macro for binrw
-
netdb_auth_macro_derive
Netdb Auth validation for rocket
-
clone_from
Derive Clone including clone_from
-
fieldset_macro
fieldset macro crate
-
jsonschema_code_generator
generating rust types from JSON schemas
-
zbus-lockstep-macros
Macros to keep types in lockstep with DBus XML definitions
-
workflow-html-macros
Workflow Macros for HTML Rendering
-
yara-x-macros
Procedural macros used by the yara-x crate
-
dynamodb-helper
Macro that creates a struct for interacting with AWS DynamoDB
-
volo-build
Compile thrift and protobuf idls into rust code at compile-time
-
accio
Retrieves code blocks distributed to multiple sites
-
spirv-std-macros
Macros for spirv-std
-
lexopt_derive
Derive macros for lexopt
-
rust_hdl_private_macros
Macro support for RustHDL
-
derive-extras
Adds a number of useful extra
#[derive(...)]
macros -
thisslime-core
Error utilities for slimebot
-
tosho-macros
A macro library for tosho-mango
-
opt2doc_derive
Derive macro for opt2doc
-
pinned-init-macro
Proc macros for the pinned-init crate
-
autophagy
AOT compiler for Rust
-
cercis-rsx
rsx macro for cercis
-
pegcel-macros
A PEG parser generator for Syn
-
enumorph
Derive macro to generate
TryFrom
andFrom
implementations for converting between newtype enum variants and their wrapped values -
polywrap_schemafy_lib
Generates serializable Rust types from a json schema
-
telexide_proc_macros
macros for subscribing to events in telexide
-
rcstruct
Generate transparent
Struct(Rc<RefCell<Struct>>)
newtypes -
senax-macros
Senax macros
-
sonic_spin
Reads ::() as a general postfix operator
-
diesel_sqltype_enum_pg
Diesel automatic derivation of
FromSql
andToSql
for enums withSqlType
generated bydiesel
and takingToString
andFromStr
as base. Postgres binding only -
python-mod
A macro library for including a Python module in Rust. At this point, very imcomplete.
-
binary-serialize-derive
A small representation for objects in the Ezno checker, used for caching to make checking faster
-
docify_macros_clone
Support macros for docify
-
halo2derive
Derive macros for halo2curves fields
-
fn_overloads
Create functions with varying arguments and return types. Please don't use this.
-
ah-macro
工具宏
-
http_query_params
A small package to it easy to create http query params
-
disarray-macros
Disarray macros
-
binmarshal-macros
Derive and helper macros for binmarshal
-
hashfn
A procedural macro to generate a hash representation of a function as a string slice
-
frunk-enum-derive
Derive macros to implement the frunk::LabelledGeneric trait on enums
-
poise_macros
Internal macro implementation crate of poise
-
quickcheck_macros
A macro attribute for quickcheck
-
ngeom-macros
Internal proc-macro crate for ngeom
-
astree_macro
Easily build AST from Rust structures
-
fiberplane-pdk-macros
Macros for the Fiberplane PDK
-
raffia_macro
Macros for Raffia
-
stry-attrouter
A attribute based router for various Rust web servers
-
sorted_locks_derive
Macro to aquire
std::syn::RwLock
orstd::syn::Mutex
locks with consistent order to prevent deadlock -
irox-derive-helpers
Helper traits & functions for the proc_macro crate to aid in writing less complex derive macros
-
rustic-jsonrpc-macro
JSON-RPC 2.0 server library written in Rust
-
subtle-ng-derive
Derive macros for subtle-ng traits
-
hs-hackathon-macros
Macro support crate for Helsing's Rust Nation hackathon
-
structre_proc_macros
Static-checked parsing of regexes into structs (helper crate)
-
dynisland-macro
Procedural macros for dynisland-core
-
strsermac
macro for strser crate
-
bobo-oop
a part of bobo library about oop
-
derive-all
Derive macro that derives all macros possible
-
wurst
Webby UI Rust abstraction
-
yolo_keyword
Adds the yolo keyword
-
go-pmacro
some proc-macros for the goscript project
-
form-yew
a macro to help with forms in yew
-
yew-attrs-macro
Dynamic attributes for Yew
-
templing
Minimal templating engine
-
assets_manager_macros
Procedural macros for assets_manager
-
power-protobuf-lib
lib for protobuf!
-
aj_macro
Derive Macro for aj
-
resx_derives
Derive macros for Resx
-
unimock_macros
Procedural macros used by unimock
-
hai_macros
Essential macros for Hai
-
cxx-qt-macro
A set of macros for Qt/C++ interop in Rust
-
syndicate-macros
Support macros for programming with the Syndicated Actor model and Dataspaces
-
serde_dhall_typegen
Automatically generate Rust structs and enums from Dhall types
-
unsafe_fn
macro to mark a function as unsafe without its body being unsafe
-
macroex-extras
Additional "fun" extractors for macroex. Support crate for a certain in development UI crate.
-
error_generator
Transform structs and enums into fully qualified errors using attributes
-
pretty_panic_proc_macro
proc-macro for pretty_panic
-
radiation-macros
Macroses to derive traits for radiation crate
-
groom_macros
Macros for groom - a thin wrapper around actix for making code-first strictly-typed HTTP APIs
-
goglob-common
Internal library used by goglob, not for public use
-
include-utils-macro
Internal proc macro for the
include-utils
crate -
derive_recursive
derive macro for recursive trait implementations
-
asar-snes-proc-macros
Procedural macros for asar-snes
-
cpreprocess
Procedural macro that runs a C preprocessor on the input
-
kfghdfghdfkgh_js_macros
internal crate
-
rotext_internal_macros
internal macros used by rotext
-
bogdan_hello_macro_derive
adds the method hello_macro that generates a greeting based on the name of the struct
-
proc-state
Sustain global variables between individual proc-macro call
-
jsm
Jay's stupid macros
-
alrulab-macros
Alrulab Macros
-
miette-derive
Derive macros for miette. Like
thiserror
for Diagnostics. -
endian-writer-derive
Procedural Macros for endian-writer crate
-
varianteq
Derive the equality of enum variants ignoring fields
-
cargo-fixture-macros
Macros for the cargo-fixture cargo extension
-
version_macro
rust cargo build binary with git version and build time
-
lambda-router-macros
Macros for use within lambda-router crate
-
rust_observer_trace_macro
Trace macro dependency for rust observer
-
cubing_macros
Features from
cubing.js
in Rust -
rio-proc-macros
Rio proc macros
-
krnl-macros
Macros for krnl
-
pyo3-prost
protobuf structs in Python
-
portaldi-macros
Macros for portaldi
-
pmhelp
A WIP library to assist in the creation of procedural macros
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
notan_macro
set of utils as macros for Notan
-
matrix-sdk-test-macros
Helper macros to write tests for the Matrix SDK
-
magnus-macros
Derive and proc macros for magnus
-
worker-macros
Macros to support the
worker
crate and remove FFI boilerplate / conversion from user code -
saa-macros-proto
Procedural macros for saa-schema
-
edifact-types-macros
Macros for edifact-types
-
geoip2-codegen
geoip2 macros
-
shopify_function_macro
Macros for the
shopify_function
crate -
target-test-dir-support
Support for the
target-test-dir
proc-macro crate -
mf1-macros
Macros for the mf1 crate
-
flawless-macros
Macros for flawless
-
puff_bench_macro
Benchmark macros
-
stateroom-wasm-macro
A macro for building a Stateroom service as a WebAssembly module
-
frunk_proc_macros
Proc macros for Frunk
-
mashin_macro
Proc macro for writing mashin resources
-
ops-derive
Derive macros for std::ops
-
lazy-re
lazy reverse engineers
-
current_semver
Get the current semver type from the environment
-
chorus-macros
Macros for the chorus crate
-
autoget
macro to generate getters for structs
-
lucamoller_dust_macro
Macros for the Dust web framework
-
batadase-macros
batadase is an incredible LMDB wrapper
-
heapsz-derive
Procedural macros for
heapsz
-
modelfox_macro
ModelFox makes it easy for programmers to train, deploy, and monitor machine learning models
-
extend1
Alternative to
Extend::extend_one
that is stable and does not require#![feature(extend_one)]
-
arcdps_codegen
Macros for arcdps
-
proto-json
convert to and from protobuf -> json easily
-
wasmedge-macro
The procedural macros for WasmEdge Rust bindings
-
dummy
Macros implementation of #[derive(Dummy)]
-
iocraft-macros
Macro implementations for the iocraft crate
-
orangutan_macro
Flask-like super simple and lightweight web server framework for rust
-
cps
Assists in the creation of readable and maintainable macro_rules! macros
-
print_each_line
It prints each line and execution time during execution. You can utilize it as a super simple profiler.
-
cyclonedx-bom-macros
Procedural macros used internally by the
cyclonedx-bom
crate -
ezno-parser-visitable-derive
Derives 'Visitable' trait for Ezno AST
-
ephemeral-rollups-sdk-attribute-commit
-
picodata-plugin-proc-macro
Procedural macros for picodata-plugin crate
-
bit_roles_macros
Granular role management based on bit flags
-
test-shisho-datasource
Shisho Cloud Policy SDK
-
document_validator_core
Required dependencies for document_validator and document_validator_macros
-
renaissance
rich man cries like a crocodile
-
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.
-
a2lmacros
macros in support of the a2lfile crate
-
mysql-connector-macros
Macros for the mysql-connector crate
-
leptos-struct-table-macro
Macros for the leptos-struct-table crate
-
airgl
down into the white wind flow’rs
-
safer-ffi-gen-macro
Proc macro implementation for safer-ffi-gen
-
address-cmp
An attribute for address comparison
-
c_macros
A bunch of macros useful for interfacing with C code
-
leptos_i18n_macro
Macros for the leptos_i18n crate
-
bang_notation
!-notation for Rust
-
edn-derive
Edn (De)Serialization derive macros
-
sorm-macros
ORM (Object-Relational Mapping) built on SQLx
-
pathogen_macros
Macros for the Pathogen crate
-
udf-macros
UDF procedural macros implementation
-
rlp-derive
Derive macro for #[derive(RlpEncodable, RlpDecodable)]
-
actix_responder_macro
An attribute macro to transform a response struct to an actix responder
-
c2rust-macros
Procedural macro support crate for C2Rust
-
roslibrust_codegen_macro
macro-based message generation for roslibrust
-
scrapelect-filter-proc-macro
proc-macros for making scrapelect Filters
-
dynamic_services_derive
A dynamic services injection framework implemented as macros
-
typewit_proc_macros
detail of typewit
-
trident-derive-accounts-snapshots
trident-accounts-snapshots
-
aargvark_proc_macros
Helper crate for aargvark
-
singleton-attr-proc-macro
singleton procedural attribute and derive macro (internal implementation)
-
proc-bitfield-macros
The supporting proc-macro library for the proc-bitfield crate
-
mddd-std
small framework for DDD init sysmem and CLI interface. Sub crate with std tools. Use "mddd" crate
-
named_params
Fast, simple named parameters for Rust functions
-
kvx_macros
Macros for kvx: an abstraction layer over various key-value store backends
-
spanr
proc-macro authors to visualize the spans on generated code
-
tailwag_macros
A collection of macros to support the tailwag crate
-
derive-box-dyn
Proc macro to convert struct to Box<dyn T>
-
thiserror-impl
detail of the
thiserror
crate -
rrplug_proc
proc macros of rrplug
-
secrets-manager-macro
Macro for using AWS Secrets Manager secrets in your application
-
natural-derive
Proc macros for naturally deriving basic trait impls for new types
-
restate-sdk-macros
Restate SDK for Rust macros
-
delve
number of macros that make working with enums and strings more convenient
-
gset
A procedural macro for generating the most basic getters and setters on fields
-
testing_macros
General purpose testing macros
-
partial-application-rs
A macro to transform functions into partially applicable structs
-
hydroflow_datalog_core
Datalog implementation for Hydroflow
-
race-proc-macro
RACE Protocol proc macros
-
thruster-proc
The proc macros behind the thruster web framework
-
tiny-rsx
A fast and minimal syn RSX (JSX in Rust) parser
-
erg_proc_macros
proc macros for Erg
-
cosmic-macros-primitive
Some primitive macros needed to jump start cosmic-space
-
peg-macros
Procedural macros for rust-peg. To use rust-peg, see the
peg
crate. -
pit-rust-guest
Portal Interface Types
-
mantra-rust-procm
Defines procedural macros used by
mantra-rust-macros
-
sql_tool_macros
这个库用于存储宏
-
hollywood_macros
Macros for the Hollywood actor framework
-
orbital
Automation of boiler-templates generated by CakePattern
-
cifg-diag-attr
An attribute for adding a railroad diagram to the cifg macro_rules doc comments. Intended for use by the cifg crate only
-
openwhisk_macro
Derive Macro for OpenWhisk Rust Client
-
to_phantom
Convert generics to PhantomData in proc macros
-
ruwren-macros
Proc-macros for ruwren
-
discriminant_hash_derive
Derive macro to implement Hash trait based on enum's discriminants only and ignore variant's fields
-
manganis-macro
Ergonomic, automatic, cross crate asset collection and optimization
-
c_defines_to_enum
A procedural macro for generate enum from C defines statement
-
add-macro-impl-into
trait 'Into<T>'
-
tea-macros
Procedural macros for the tevec
-
rudi-macro
Macros for Rudi
-
structbuilder_derive
Super simple macro to derive a builder trait for your struct
-
pear_codegen
A (codegen) pear is a fruit
-
truck-derivers
Derive macros generating an impl of the geometric traits
-
xso_proc
Macro implementation of #[derive(FromXml, AsXml)]
-
fut-ret
parse the return type generated by async_trait in procedural macro
-
json_schema_test_suite_test_case
Procedural Macro Attribute to run all the test cases described in JSON-Schema-Test-Suite
-
tuplez-macros
Procedural macros implementation of tuplez
-
json_schema_test_suite
Procedural Macro Attribute to run all the test cases described in JSON-Schema-Test-Suite
-
domcom-form-manager
A macro to simplify forms. Must be used with domcom
-
more-di-macros
Macro implementation of #[injectable(Trait)]
-
literify
Stringifies tokens inside token stream
-
catchr
A testing framework inspired by Catch for C++
-
prometheus-client-derive-text-encode
Auxiliary crate to derive text Encode trait from prometheus-client
-
test-fuzz-macro
-
baroque
cuckoo
-
embed-licensing-core
Core implementation of embed-licensing
-
iffy
proc macro for simulating the ternary operator from C-like languages
-
unstyled_macro
Unstyled is just another library which allows to write scoped CSS styles in Rust
-
frunk_derives
contains the custom derivations for certain traits in Frunk
-
structified_enum
Marcos to structify unit-like enum with discriminants
-
futures-select-macro-preview
The
select!
macro for waiting on multiple differentFuture
s at once and handling the first one to complete -
foundationdb-macros
Macro definitions used to maintain the FoundationDB's crate
-
sqlxx
Extension to sqlx
-
hill_vacuum_proc_macros
Procedural macros of the HillVacuum main library
-
dot-parser-macros
contains companion proc macros for the dot_parser crate
-
ixc_schema_macros
Interchain SDK Schema Macros
-
tri_macros
local crates are a pain in the ass
-
egui_struct_macros
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
spacetimedb-bindings-macro
Easy support for interacting between SpacetimeDB and Rust
-
get_files_macro
macro that can resolve a directory's file names before compile-time
-
java-bindgen-macro
Java Bindgen | Macro
-
compose_spec_macros
Procedural macros for use in the compose_spec crate
-
exhaust-macros
Proc-macro support for the 'exhaust' library
-
surrealdb-extras-proc-macro
A
cargo generate
template for quick-starting a procedural macro crate -
verilog-arc
proc macro based code generation backend for OpenVAF
-
struct-arithmetic
Trait to derive basic arithmetic operations for your structs
-
actix-default-responder
Procedural macro for generating default
Responder
implementation for a specific data type (ie. json, xml, etc). -
ri-utils
Ut
-
bon-macros
proc-macro crate that is supposed to be a private implementation detail of the
bon
crate -
auto_ref
Replace &T to impl AsRef<T>
-
grafana-plugin-sdk-macros
Convenience macros for the Grafana backend plugin SDK
-
serde_avro_derive_macros
Derive avro schema for Rust structs for serde_avro_fast
-
round_view_derive
Procedural macros to generate methods r2_view, r3_view and r4_view
-
evento-macro
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
memory-serve-macros
Macro for memory-serve
-
axum-starter-macro
A help crate for simplify the code of starting axum server
-
rocketmq-macros
Unofficial Rust implementation of Apache RocketMQ
-
blackboxmc_proc
Procedrual macros for the BlackboxMC crates
-
woab-macros
Procedural macros for the WoAB crate
-
despatma-dependency-container
Design Pattern Macro for dependency container
-
c2rs
C struct to Rust struct
-
bingen
Procedure macro for bringing a compile-time compiled assembly code as a binary slice
-
include_uri
Proc-macro to include URI as literals at build time
-
xoev-xwasser-derive
"XOEV XWasser XML Standard"
-
ref-mut-n
Defines a nested mutable reference
-
deep_causality_macros
Procedural macros that generate constructurs and getters
-
lvgl-codegen
Code generation based on LVGL source code
-
sub-model
a proc marco for easy generate sub models
-
uri_path_router
A proc-macro crate that generates flattened enums for routing
-
ambient_editor_derive
A procedural macro to generate Ambient UI code for a struct or enum
-
decolor
Asynchronous runtime abstractions for implicit function decoloring
-
quork-proc
The proc macros for quork (not intended for independant use)
-
native_db_macro
A procedural macro for native_db
-
cercis-component
component macro for cercis
-
around
execute code around a function
-
native-json-macro
Native JSON for Rust
-
turf_macros
Macros used by turf
-
syrette_macros
Macros for Syrette, the convenient dependency injection framework
-
fieldname-access
Derive macro for safe struct field access by their names in runtime
-
swc_ecma_codegen_macros
Macros for swc_ecma_codegen
-
log-attributes
A set of function log attributes, that make logging function in- and outputs a charm
-
oss_derive
aliyun-oss-client 's macro
-
locenv
aid on module development for locenv
-
defaults
A better
Default
derive macro -
kitty_table_proc_macro
Proc macro crate for Kitty Table
-
reacty_yew
Generate Yew components from React component via Typescript type definitions
-
cutlass
Macro based library to take the boilerplate out of configuration handling
-
nu-derive-value
Macros implementation of #[derive(FromValue, IntoValue)]
-
culpa-macros
Internal implementation details of
culpa
-
sycamore-state-macros
sycamore-state proc macro implementation
-
lower
desugar math where the compiler wont
-
strdesermac
macro for strdeser crate
-
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
-
debug_code
The util to remove code when not debug build
-
elm_rusty
Auto generate Rust models to Elm models
-
derive-redis-swapplex
Derives for redis-swapplex
-
enum-utils
A set of useful proc macros for enums
-
serde-json-helpers
A collection of procedural macros compatible with stable Rust 2018 that simplify some common operations not covered by
serde_derive
-
dont-expand
Dummy macros to shadow macros to avoid expansion in cargo expand
-
nutt-web-macro
Procedural macro for nutt-web framework
-
enumify
macro that declares an
enum
(and a bunch ofimpl From
s) based on a set of types -
pisserror_macros
The internal implemenation of
pisserror
-
ffishim
behind ffishim_derive
-
nop-macros
Procedural macros to do nothing, allowing attributes to be used as metadata
-
git-version-macro
Internal macro crate for git-version
-
mixinx
mixin not only struct fields, but also impl funcs and traits
-
tryfrom-via-fromstr
Derive
TryFrom
by delegating to theFromStr
impl -
struct_auto_from
auto generating conversion methods between structs
-
utility-macros-internals
utility-macros and utiliy-macros-derive common code
-
hax-lib-macros
Hax-specific proc-macros for Rust programs
-
bincode_macro
Add macros to bincode to make it easier to use
-
snax
JSX-like syntax for proc macro authors
-
derive-deref-rs
derive macro library used to easily defined the Derive and DrerfMut trait of the core library
-
impl-template
A procedural macro for generating impl-blocks based on a simple template
-
sqlxmq_macros
Procedural macros for sqlxmq
-
stylish-macros
Internal implementation details of
stylish-core
-
pax-macro
Macros for Pax, used both for parser codegen and for showing Pax where to attach to Rust code
-
replisdk-experimental-proc
Procedural macros crate for replisdk-experimental
-
wasm-bindgen-macro
Definition of the
#[wasm_bindgen]
attribute, an internal dependency -
procmeta-proc
A derive-macro for procmeta-core
-
axum-routes-macros
Create an axum Router from an enum and resolve routes
-
discretionary_engine_macros
macros for discretionary_engine
-
alkahest-proc
Procedural macros for 'alkahest-proc' crate
-
treesitter_kind_collector
collect kind names from node-types.json of treesitter
-
html-to-string-macro
html to string macro powered by syn-rsx
-
lit-mod
collection of procedural macros for working with string literals
-
synext
extension library for syn crate to help developers quickly develop derive macros
-
better-macro
better versions of common macros like println
-
cfg_attrs
An alternative to #[cfg_attr(...)] that is easier to use with doc comments
-
sigmut-macros
a state management framework designed to be used as a foundation for UI frameworks
-
p5doc
p5.js diagram within rustdoc
-
diman_unit_system
Internal procedural macros for diman
-
clickhouse-derive
A macro for deriving clickhouse::Row
-
charify
proc macro to turn its token input into a char, similar to the built-in stringify! macro
-
builder_m4cro
derive macro to implement the builder pattern
-
vptr-macros
Procedural macros for the
vptr
crate -
mongodb-internal-macros
Internal macros for the mongodb crate
-
rzhavchina
Rust programming, in Russian
-
dyn_derive
Inherit and derive object-unsafe traits for dynamic Rust
-
makepad-derive-live
Makepad platform live DSL derive macros
-
agb_xm
converting XM tracker files for use with agb-tracker on the Game Boy Advance. You shouldn't use this package directly
-
lib3d6
Potentially my personal utility library, for now a test
-
enum-utility-macros
A macro to generate useful helpers for enums
-
derive_typst_intoval
Derive typst::IntoValue for structs
-
bitwise_boolean
macro to generate bitwise boolean getters and setters for a struct with u8 field storing up to 8 flags
-
spring-macros
rust microservice framework
-
gadget-context-derive
Procedural macros for deriving Context Extension traits from
gadget-sdk
-
solders-macros
A collection of attribute macros to reduce boilerplate in the solders project
-
tamasfe-macro-utils
Proc-macro utilities, intended for personal use
-
bevy_encase_derive
Bevy derive macro for encase
-
transmute-tools
Proc macros and traits to assist with safely creating transmutable data structures
-
dep-inj
easier dependency injection
-
fpr-cli-derives
that allows one to write cli tools quickly. (derive macros)
-
tailwind_fuse_macro
Macros for tailwind-fuse
-
telety-impl
Common code for telety. Not intended for public use.
-
replisdk-proc
Procedural macros crate for replisdk
-
memoeyes
Procedural macros for automatic memoization
-
dlopen2_derive
Derive macros for the dlopen2 crate
-
tauri-store-macros
Persistent stores for Tauri
-
minus-one
A proc-macro crate to subtract one from a number
-
convert-chain
chain converter
-
nemo157/embrio-async
-
macrotk
macro toolkit
-
build-info-proc
Part of the build-info crate: This crate provides the proc-macros
-
azalea-registry-macros
Macros internally used in azalea-registry
-
non_structural_derive_macro
nonstructural derives for auto traits
-
macro-ruby
Execute ruby code at compile time trough mruby
-
msg_channel_macro
message channel
-
compiler_cli_args
proc-macro that expands to the CLI args that were passed to rustc
-
named-ctor
proc-macro to generate constructor functions with syntaxt similar to named params
-
confique-macro
Macro crate for 'confique'. Do not use directly! Semver not guaranteed!
-
astmaker
Build Abstract Syntax Trees and tree-walking models quickly in Rust
-
leptos-controls-macro
Leptos Controls Macro
-
xcfg-derive
configuration file parser for Rust
-
macro_magic_core
Core implementation behind macro_magic
-
derive-collect-docs
Collect documentation from Rust structs using a
CollectDocs
derive macro -
quote-impersonated
Quasi-quoting macro quote!(...)
-
webgl-rc-macro
GLSL loading macro for webgl-rc
-
memoize-inner
Helper crate for memoize
-
query_macros
macros for query crate
-
surql-definition-macros
procedural macro for generating SurrealDB table and field definitions
-
polling-async-trait
A proc macro that creates async methods based on polling methods for your trait
-
try_match_inner
The internal procedural macro of
try_match
-
idewave_packet
Macro for implementing packet structures
-
gtk-blueprint
Use Blueprint in Rust GTK applications
-
crate_interface
way to define an interface (trait) in a crate, but can implement or use it in any crate
-
azalea-buf-macros
#[derive(McBuf)]
-
axum-codec-macros
Procedural macros for axum-codec
-
dioxus-rsx-hotreload
CLI Configuration for dioxus-cli
-
enum-methods
Generates methods for each enum variant
-
derive-stack-queue
Derives for stack-queue
-
shower
get string of code block
-
extends-rs
rust extends impl a macro attr
-
actix-web-codegen-const-routes
Routing and runtime macros for Actix Web with support for const routes
-
sqlx-macros-oldapi
Macros for SQLx, the rust SQL toolkit. Not intended to be used directly.
-
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.
-
nuidl-lib
Code generation library for nuidl
-
termal_proc
fancy colored cli using ansi codes
-
sqlx-type-macro
Proc macros for sqlx-type
-
napi-derive-ohos
N-API procedural macros
-
wasmbus-macros
derive macros for wasmbus-rpc
-
ez_config
A lightweight and simple to use mapper from environment variables to config classes
-
a653rs_macros
Macros implementation for a653rs
-
macro-rules-rt
Transforms text or TokenStream using Rust's macro_rules syntax
-
comprehensive_macros
A harness for creating consistently-shaped servers will less boilerplate
-
mini-tokio-attr
macros for mini-tokio
-
tree_sitter_grep_proc_macros
(proc-macros used internally by tree-sitter-grep)
-
car
std::array::{map, from_fn, try_from_fn} in const
-
discriminant-macro
Better
Discriminant
and enum operations -
splat_derive
providing a Splat derive macro, which generates a splat method for the struct deriving it
-
byteme
Converts a struct into Vec<u8> and back. The conversion is Big Endian by default.
-
lark_bot_sdk_macros
rust lark bot sdk macros
-
rapid-web-codegen
Codegen utilities for the rapid framework
-
kittycad-execution-plan-macros
Macros for working with KittyCAD execution plans
-
enum-fields
Quickly access shared enum fields in Rust
-
semx_bsp
对应硬件板级定义
-
maybe-async-cfg-tests
A tests for maybe-async-cfg
-
derive-combine
A macro for combining multiple structs into one
-
better-bae
proc-macro attribute parser
-
easy_proc
Helper macros for making proc macros
-
trapeze-macros
Macros for trapeze
-
kira_framework_proc
KiraFramework proc macro
-
ezno-ast-generator
Quasi-quoted constant compiled TS definitions for Ezno AST
-
custom_debug_derive
Derive Debug with a custom format per field
-
mmtk-macros
MMTk macros provides procedural macros used by mmtk-core
-
hpl-toolkit-attribute-account-schemas-ix-injector
HPL attribute macro for defining a compressed account schema
-
fav_derive
Derive macros for fav
-
macros-utils
macros crate
-
ai-write
Macro inserting ChatGPT responses into rust code at compile-time
-
rocket_db_pools_codegen
Procedural macros for rocket_db_pools
-
prosa-macros
ProSA macros
-
spanned_error_message
Pretty error messages with spans outside of proc macros
-
cxx-auto
Automatically generate cxx bindings
-
rustfmt-config_proc_macro
A collection of procedural macros for rustfmt
-
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).
-
antlion
Handy way to evaluate at compile-time any Rust expression
-
open-metrics-client-derive-text-encode
Auxiliary crate to derive text Encode trait from open-metrics-client
-
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
-
nestruct
that provides macros to easily flatten or nest structs and enums in your code
-
tabled_derive
Derive macros which is used by tabled crate
-
bigquery-functions-types-macros
proc macros to define BigQuery function types
-
yew-router-macro
Contains macros used with yew-router
-
macro_functions
functions for quickly parsing syn structures
-
vercel_runtime_macro
Vercel Rust Function Runtime Macro
-
lattices_macro
Procedural macros for the
lattices
crate -
try_clone_derive
wich add a derive TryClone macro for the TryClone Trait of the fallible_allocation crate
-
libcnb-proc-macros
Procedural macros used within libcnb.rs
-
fusen-procedural-macro
fusen-common
-
cli-settings-derive
Manage CLI settings with configuration file(s) and command line parsing, using serde and clap
-
stringify-attr
Attribute macros for stringifying
-
garde_derive
Derive macros for garde
-
taurpc-macros
Macros for the taurpc crate
-
externcfn-attr
macro_rules for define correct extern 'C' functions with an normal syntax
-
anyhow_trace
Macro which adds source location as context to anyhow errors
-
rusty_json_serialization
procedural macros for automated JSON serialization in Rust
-
defmt-test-macros
defmt-test macros
-
typeshare-annotation
The annotation used to mark types for typeshare
-
jintemplify_plugin_macro
jintemplify plugin proc-macro
-
boa_macros
Macros for the Boa JavaScript engine
-
trident-derive-fuzz-test-executor
-
literal-enum
Convert an [
enum
] to a [literal
], and try to convert it back -
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.
-
kittycad-modeling-cmds-macros
Macros for defining KittyCAD modeling commands
-
sscanf_macro
Proc-Macros for the sscanf Crate. Not meant to be used as a standalone Crate
-
kameo_macros
Fault-tolerant Async Actors Built on Tokio macros
-
stilts-macros
The macros that generate the templates for stilts
-
enum-mapping-macro
Maps enum variants to numbers and viceversa
-
syncify
macro for writing async functions once and getting both the async version and a sync version that strips all async function modifiers and all .await suffixes
-
proto
proto
allows you to define Protocol Buffers using Rust code to reuse Rust’s type system and ecosystem -
ferrite_model_gen
ChatGPT CLI
-
zang-macro
Rust language tokens translated to Uzbek
-
aggregate_types
Aggregate attributes of structs for runtime
-
proc_macro_tools
Tools for writing procedural macroses
-
doc-search-dsl-macro
A procedural macro for implementing a document search domain-specific language
-
synom
Stripped-down Nom parser used by Syn
-
bevycheck
bevy error messages by proc-macro
-
templr_macros
Procedural macros for templr
-
impl_index
Macro for deriving the Index trait
-
typeof-literal
A macro that returns the type of any literal expression or composite of literals
-
sky-derive
Macros for the Skytable client driver
-
wick-component-codegen
Code generator for wick components
-
discriminant_hash_eq
DiscriminantHashEq macro is designed to derive implementations of the Hash, PartialEq, and Eq traits for enum types. These implementations are based solely on the enum's variant discriminants…
-
typify-macro
typify macro implementation
-
structs-from-excel
that adds a procedural macro that unravels structs via a given, purpose-formatted Excel spreadsheet
-
behavior
A macro checks like behavior in elixir
-
ucc
Universal compiler invocator for heterogeneous CPU/GPU computation applications
-
maomi-dom-macro
Strict and Performant Web Application Programming
-
atmosphere-macros
Macro crate of atmosphere
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
derive-adhoc-macros
Macros that implement the derive_adhoc crate
-
ntex-prost-derive
A Protocol Buffers implementation for the Rust Language
-
pgx-macros
Proc Macros for 'pgx'
-
templest
A procedural macro to manage temporary variables
-
foxglove_derive
A derive macro for a Foxglove trait
-
syn-pub-items
Parser for Rust source code (patched for pub items)
-
utoipa-gen
Code generation implementation for utoipa
-
css-macros
MAcros to work with css files with stylist
-
name_of
expression for Rust
-
ascent_base
support library for the ascent package
-
token_stream_flatten
Flattening iterator adaptor for token streams
-
evcxr_ssg_macro
A macro for calling a function in wasm and passing serializable rust values to it
-
awf-help
Actix web flask use proc macros
-
fmtparse
Parse format!-like strings
-
cell_derive
A derive macro for quickly implementing
get_or_init
andget_mut
functions for structs that containOnceCell
orOnceLock
structs -
scyllax-macros-core
Core macro impl for scyllax
-
spatialos-macro
Procmacro crate used to expand SpatialOS component and types created with spatialos-codegen
-
struct-to-json-db-macro
macro for struct-to-json-db crate
-
cgp-component-macro
Context-generic programming core component macros
-
pm-lexer
sample lexer using the proc-macro crate, to be used in the pomelo testings
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
chatdbg_macros
Rust-specific (macro) support for ChatDBG
-
vexide-macro
Proc macros for vexide
-
build-deps
Rust build-script dependencies generator for data/IDL files
-
db_code_macro
Generate Db code
-
jump-kun-macros
jump-kun. Parses jump-kun config file and creates fucntions.
-
reqwest-scraper-macros
Web scraping integration with reqwest
-
clippy-tracing-attributes
add, remove and check for
tracing::instrument
in large projects where it is infeasible to manually add it to thousands of functions -
meilisearch-index-setting-macro
Helper tool to generate settings of a Meilisearch index
-
htmlm-macro
html macro with no dependencies
-
auto_builder_derive
Macros for generating a 'safe' builder
-
invoke-witc
rust macros invokes witc
-
samotop-async-trait
Type erasure for async trait methods
-
inline-rust
A stupid macro that compiles and executes Rust and spits the output directly into your Rust code
-
turbo-crates
A set of useful crates (WIP)
-
ord_by_key
convenient macro for implementing Ord trait with logic specified in an inline expression
-
safina-macros
Procedural macro for the
safina-async-test
package -
faux_macros
Implementations for #[create], #[methods], when!
-
ext-trait-proc_macros
Internal: proc-macro backend of ::ext_trait
-
fievar
Proc macrs to generate functions that return static slices of struct field names or enum variant names
-
mvutils-proc-macro
Procedural macros for MVUtils
-
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.
-
rust-analyzer-salsa-macros
Procedural macros for the salsa crate
-
absolution
‘Freedom from
syn
’. A lightweight Rust lexer designed for use in bang-style proc macros. -
ferment-macro
Macros for boilerplate
-
add-macro-impl-from
trait 'From<T>'
-
valence_entity
Minecraft entities for Valence
-
axum-resp-result-macro
Help Struct For Axum Response
-
extism-convert-macros
Macros to remove boilerplate with Extism
-
better-default-derive
A better Default macro
-
pfetch-extractor
proc-macro to extract pfetch logos at compile time
-
ra-ap-rustc_macros
Automatically published version of the package
rustc_macros
in the rust-lang/rust repository from commit 89ab6559cc10ee3b24c4aef2f62b716f682cb926 The publishing script for this crate lives at:… -
leptos-fluent-macros
Macros for leptos-fluent
-
enum_for_matches
enum_for_matches
is a procedural macro that runs a match arm for each enum variant passed into it regardless of type -
flowmacro
Definition of a 'flow' attribute macro to help write implementations
-
ecsact_rust_codegen
Ecsact rust code generator
-
jni-toolbox-macro
proc macro to automate making JNI extern functions
-
nom-rule
A procedural macro for writing nom parsers using a grammar-like DSL
-
yew-component
macro to generate yew components from a single struct declaration
-
synca
Write asynchronous code, and synca will create a synchronous version
-
dropshot_endpoint
macro used by dropshot consumers for registering handlers
-
css-rs-macro
A macro for writing your CSS next to your views
-
diesel_filter_query
Procedural macros for Diesel filter
-
yui_internal
Internal functions, struct for derive in Yui
-
wasmdev_macro
wasmdev macro implementation
-
enum_const_value
Providing const values for enums. Unit and enums with associated types are supported. Each variant gets a unique sequential value.
-
cvars
Configuration variables - a simple and ergonomic way to store and edit configuration at runtime
-
enum_stringify
Macro to generate string conversion functions for enums
-
cw-orch-from-interface-derive
Macro for generating From implementation for cw-orch interfaces of copied types
-
unconst
Macro to unconst const/fn/enum/struct/trait/impl/type items
-
opengl-registry-macros
Macros utilizing the OpenGL API and Extension Registry
-
iced_sessionlock_macros
Wayland extra shell lib
-
shipyard_proc
providing attribute macro to Shipyard
-
tracers-codegen
Contains the compile-time code generation logic which powers the
probe
andtracers
macros.Do not use this crate directly; see "tracers" for more information
-
cosmic-macros
macros for thecosmicinitiative.io
-
procmeta-core
proc-macro helper
-
crate-_-name
macro to get the name of the current crate
-
veil-macros
Veil procedural macros
-
enum-from-functions
A procedural macro that will create an enum with associated functions that each have a corresponding variant
-
jlrs-macros
contains the custom derives offered by jlrs
-
generating-proc-macro-crate
An example proc-macro crate for demonstrating a regression
-
chuot-macros
Procedural macros for the Chuột game engine
-
scyllax-macros
Macros for scyllax
-
frclib-structure-macros
A derive macro for implementing the FrcStruct trait on structs
-
farmfe_macro_cache_item
Macro to create a farm cache item
-
libasm
adds inline assembly to stable rust
-
get_fields
procedural macro that generates an array of the field names of a named struct
-
patum
Make enum conform to a given pattern
-
predawn-macro-core
Core types and functions for macros in predawn
-
uniffi_macros
a multi-language bindings generator for rust (convenience macros)
-
extra_args
Rust macro to pass implicit args to functions (use with care)
-
hidmystr
Hide string at compile time and treat variable value as original at runtime
-
sly_static_macros
macros for sly_static
-
wasmedge-bindgen-macro
Pass string, vec and primitive types from host to webassembly
-
getset2
Getset, we're ready to go! A procedural macro for generating the most basic getters and setters on fields
-
from-attr-core
from-attr core type
-
melior-macro
Internal macros for Melior
-
srcfiles
Extract source files for a Rust crate
-
capnp_conv_macros
attribute macros that implement capnp read/write traits
-
uringy-macros
Procedural macros for the uringy crate
-
macroquad_macro
Proc macro for macroquad
-
swipl-macros
Macro crate for swipl-rs
-
do-with-in-internal-macros
A template language for Rust metaprogramming using partial staging
-
tiny-web-macro
macro library for automatically connecting a web engine to the web project
-
preprocess-macro
Preprocesses a struct with built-in preprocessors
-
hippotat-macros
Asinine HTTP-over-IP, proc-macros
-
macroscope-utils
detail of the macroscope library
-
rust_source_bundler
bundle local Rust library source files into a single file
-
bfieldcodec_derive
Derive macro for BFieldCodec
-
rsciter_macro
rsciter macros implementation
-
aide-macros
Macros for the Aide library
-
hydroperfox-smodel-proc
Semantic modeling for Rust: procedural macros
-
string_enum
String based enum
-
native-proc
Procedural macro for parsing prost-build structs and generating local matching types
-
syn_str
what syn is to proc_macro::TokenStream for proc_macro::TokenStream::to_string,quote! being format! with String::parse::<TokenStream>
-
saphir_macro
Macro generation for http server framework
-
versionize_derive
Implements the Versionize derive proc macro
-
ifc_rs_verify_derive
A proc-macro crate for the ifc crate
-
simple_cache_macros
caching tools
-
proc-macro-rules-macros
Emulate macro-rules pattern matching in procedural macros
-
comprehension
Iterator comprehension in Rust
-
crc-fast-gen
A proc-macro generating SIMD/table/loop CRC algorithms
-
derive_base_message
A procedural macro for generating base message structures
-
assert2-macros
procedural macros for assert2
-
derive-attr-parser
Very simple parser for proc macro attributes
-
display_enum
Implement Display For the Enumeration
-
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!
-
blade-macros
Macros helpers for Blade users
-
builders
Rust macros for building structs
-
enum2map
A small macro to convert enums with associated data into a HashMap
-
getset-macro
A procedural macro that simplifies the creation of getter, setter and constructor methods for fields in your Rust structs
-
serde-clap-deserialize
Proc macro for setting serde/clap defaults
-
shumai-config-impl
A benchmark framework that empowers efficient and correct multi-thread benchmarks
-
wedpr_ffi_macros
WeDPR ffi shared macros
-
diesel-crud-codegen
-
kalosm-learning-macro
A macro to derive kalosm learning traits
-
impl-new-derive
Derive macro for implementing the
new
method for structs -
volmark
Debugging and other macros for my Hornvale project
-
builder_option_derive
A macro to generate builder class for a struct
-
esso
Jest style tests in RUST
-
struct_db_macro
A procedural macro for struct_db
-
unpat
Unboxing the pattern with easy syntax
-
agb_midi
converting MIDI files for use with agb-tracker on the Game Boy Advance. You shouldn't use this package directly
-
primitive_enum
Little utility for dealing with enums no extra data in variants
-
static_assert_generic
Static asserts involving const and type generics
-
test-r-macro
Test framework for Rust (macros)
-
interactive-clap-derive
Interactive mode extension crate to Command Line Arguments Parser (https://crates.io/crates/clap) (derive macros helper crate)
-
elfo-macros
Macros for matching and deriving messages
-
err-as-you-go
easy inline error types
-
postgres-json-derive
Derive macro for implementing ToSql and FromSql for a struct
-
include-flate-codegen
Macro codegen for the include-flate crate
-
enum_helpers
Adds functions like is_, as_, as_mut_ and into_ to enums
-
ctor-used-linker
__attribute__((constructor)) for Rust
-
fusen-macro
RPC framework for service registration and discovery through API exposure, compatible with Dubbo3 protocol, intertunable with Java projects
-
rstml-to-string-macro
html to string macro powered by rstml
-
basic-text-literals
Basic Text string literal macro for basic-text
-
deno-tower-lsp-macros
Fork of https://crates.io/crates/tower-lsp-macros, used in Deno
-
simd-json-derive-int
procmacros for simd-json-derive
-
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)
-
hifmt-macros
Format output without Rust code segment in binary to reduce the ultimate binary size
-
esp32_test_macro
macro that adds to test result message to end of the test functions
-
securefmt
Drop-in replacement for the Debug derive macro that hides fields marked as sensitive
-
cl-format-macros
Proc macro for cl-format
-
studs-macros-lib
Studs that provides macro implementations and utilities
-
autodefault
A proc macro that automatically inserts
..Default::default()
into your struct literals -
checksum_dir
generate checksums of directories at compile time
-
arrow-udf-macros
Procedural macros for generating Arrow functions
-
composint-macro
Space efficient structs using otherwise useless bits
-
crokey-proc_macros
proc macros for the crokey crate
-
pascal_ident_to_string
A macro to convert an identifier to a string literal in pascal case
-
colonbuilder
builder offers from_str method to build struct from colon separate string
-
rust-typed
Get the types of a struct
-
wasm-typescript-definition
serde support for exporting Typescript definitions using wasm-bindgen
-
rcss-core
RCSS - (core) contain parser functionality
-
random_struct_layout
The custom attributes to randomize struct members layout
-
oxide-macros
Main entrypoint macro for AVRoxide
-
uniform-array-derive
A derive macro for turning uniform types into slices
-
hashed-type-def-procmacro
Proc-macro generator for a hash based type identifier: hash code is computed on the basis of type definition
-
maiden_nn_macros
Maiden NN Macros
-
dao-dao-macros
A package macros for deriving DAO module interfaces
-
stak-macro
Macros to integrate Stak Scheme
-
percpu_macros
Macros to define and access a per-CPU data structure
-
api-forge-macro
A proc macro for constructing Request structs
-
progenitor-macro
An OpenAPI client generator - macros
-
hpl-compression-macro-merkle-tree-utils
HPL macro for defining an platform-gate
-
binf_macros
that adds utilities for dealing with binary flags
-
aya-ebpf-macros
Proc macros used by aya-ebpf
-
futures-join-macro-preview
Definition of the
join!
macro and thetry_join!
macro -
extism-pdk-derive
Helper package for the Extism Plug-in Development Kit (PDK) for Rust
-
documented-macros
Derive and attribute macros for
documented
-
cache-this-proc-macro
Proc macro implementation for simple caching of expression using the file system
-
pam-macros
Macros for the pam crate
-
xmlserde_derives
macros that help xmlserde serde the xml files
-
flololoat
Mass Convert to floats
-
proc-macro2-fallback
Only the non-libproc_macro-based codepath of the proc-macro2 crate
-
xitca-codegen
proc macro for xitca
-
pyo3_special_method_derive_macro
Automatically derive Python dunder methods for your Rust code
-
rglw_codegen
Root project for all the utilities that rustyglware offers to the community
-
match_type
Match on the type of an expression at compile time
-
code_gene_macro
code generation macros
-
efbuilder
A procedural macro for generating efficient builders
-
elm_to_view
A macro for parsing elm_markup to leptos view
-
generic_trait_alias
A proc-macro attribute which can be used to create custom type aliases for abstraction
-
netxbuilder
netx builder assembly
-
fbthrift_codegen_includer_proc_macro
Workaround for https://github.com/rust-lang/rfcs/issues/752
-
nested_enum_utils
Macros to provide conversions for nested enums
-
creusot-contracts-dummy
Dummy proc macros for creusot-contracts
-
nougat-proc_macros
Internal: proc-macro backend of ::nougat
-
yew-router-nested-macro
Contains macros used with yew-router
-
wasm-bindgen-struct
Macro to make declaring
wasm-bindgen
imports much easier -
ai_function
Procedural Macro for creating text from a function to use in Large language Models
-
proc_qq_codegen
QQ client framework
-
usdt-attr-macro
Procedural macro for generating Rust macros for USDT probes
-
ffi_rpc_macro
Proc macros for ffi_rpc
-
starbase_macros
Macros for the starbase framework
-
test-shisho-gql-derive
Shisho Cloud Policy SDK
-
wars-macro
Wasm to Rust converter
-
devise_codegen
devising derives and other procedural macros
-
derive-with
#[derive(With)]
generates with-constructor for each field in struct -
cute_custom_default
Derive macro for
Default
trait with customization -
bevy_render_macros
Derive implementations for bevy_render
-
syn_builder
Builder functions for
syn
structures and enums to ease the generation of Rust code -
sourcegen
contains a procedural macro to work together with "sourcegen-cli" crate
-
beady
A macro for writing tests in a Behaviour Driven (BD) style
-
my-ast
AST definition like general programming languages and S-expression macros
-
edgedb-query-derive
that provide a bunch of attribute macros that help to build EdgeDB query using edgedb-tokio crate
-
enum-filter
Filter to a specific enum variant from an iterator
-
extendable-enums
A set of rust macros that allows you to specify data that can be "extended" or inherited from
-
cast_checks_macro
-
extension-fn
No boilerplate code for extension function definitions
-
quickcheck_async
Runtime-agnostic attribute macros to use quickcheck with async tests
-
flatfish
A macro to write Fully Qualified Syntax without nesting turbofishes
-
fauxgen-macros
macro support package for fauxgen
-
rings-derive
Helper macros for rings node implementation
-
easy_proc_macro
Rust's last proc-macro crate
-
shallow-debug
A basic Debug derive macro that can be used on any type
-
auto_curry
Procedural macro to automatically curry functions
-
irrefutable
Procedural macro to convert a refutable let expression to an irrefutable
-
impl-for
Macros to impl for multiple types
-
makepad-derive-widget
Makepad widget derive macros
-
trakt-macros
Procedural macros for the trakt-rs crate
-
derive_bounded
Builtin-macros workalike but with a way to specify bounds
-
env-extract
Extracts environment variables into Strings or Enums
-
rdxl_static
Static Site Generation Utilities for RDXL
-
specit
Spec "it" for Rust testing
-
diesel-selectable-macro
A derivable
Serialize
macro that selects precise fields -
depends_derives
Ergonomic, performant, incremental computation between arbitrary types
-
byte-strings-proc_macros
Internal: proc-macro backend of ::byte_strings
-
bevy_trait
Macros for creating Traits in Bevy
-
rocket_sync_db_pools_codegen
Procedural macros for rocket_sync_db_pools
-
standard-dist
Derivable random distributions for types
-
cdrs-tokio-helpers-derive
Derive CDRS helper traits
-
ra-ap-rustc_index_macros
Automatically published version of the package
rustc_index_macros
in the rust-lang/rust repository from commit 89ab6559cc10ee3b24c4aef2f62b716f682cb926 The publishing script for this crate lives at:… -
gandiva_rust_udf_macro
A basic library for gandiva rust udf macro
-
dora-operator-api-macros
Rust API Macros for Dora Operator
-
ra_ap_salsa-macros
Procedural macros for the salsa crate
-
hyprland-macros
Macros used in hyprland-rs
-
near-async-derive
contains derive macros for near-async
-
swc_config_macro
Macros to prevent mistakes
-
mock_derive
An easy to setup, rich mocking library for the Rust programming language
-
axum_thiserror
procedural macro for custom error handling in web applications, enabling the association of specific HTTP status codes with error types
-
derive_state_machine_future
Custom derive implementation for the
state_machine_future
crate. Use that crate instead of this one directly. -
match-by-hash
Match statement, but for any value and with a hash function
-
union_type
A proc macro to introduce union type into rust
-
scopegraphs-macros
A well-documented port of scopegraphs to Rust
-
ace_it
Macro to automate wrapping types into enums
-
rocket_codegen
Procedural macros for the Rocket web framework
-
ralik
ALIKe language
-
drylib-procs
Rust macro-library for Don't Repeating Yourself
-
impl-from-into-similar
Implement Into to any struct to convert between structs sharing similar fields. Uses serde_json.
-
test-log-macros
Supporting procedural macro crate for test-log
-
sauron-macro
An html library for building client side webapps
-
onlytypes
creating types that can only be created by a certain function
-
jsony_macros
proc-macro crate for jsony
-
include-crypt-bytes-cipher
Rust macro to embed encrypted files in compiled binary
-
ffi_wrapper_nounwind
Automatically generate FFI wrappers that catch unwinding from FFI into Rust
-
unrust-proc-macro
The unrust proc macro crate
-
struct_ext
A set of useful derive macros for structs
-
simpl_actor_macros
tokio actors macros
-
unprolix
Boilerplate generator for constructors, getters and setters with derive macros
-
symbols-models
Proc-macro utility to populate enums from database data (shared traits)
-
iroha-internal
Internal functions, struct for Iroha
-
serde_syn
Use serde to parse Rust source code
-
derive_codec_sv2
Derive macro for Sv2 binary format serializer and deserializer
-
to_and_fro
Proc macro for generating implimentations of Display and FromStr for Enum Variants
-
irzha
Write Rust programs using Ukrainian language
-
display_json
Procedural macros for implementing Display, Debug and FromStr for (de)serializing json strings
-
from_variant
Automatically derive From impls for enums
-
warnings-macro
A macro for defining warnings
-
fixed-size
Attribute macro to replace variable length types with fixed length types in struct definitions. Useful for overriding String when using prost.
-
oxi-macros
Proc macros for nvim-oxi
-
proc-macro-error-attr2
Attribute macro for the proc-macro-error2 crate
-
azalea-protocol-macros
Macros internally used in azalea-protocol
-
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.
-
duktape-macros
duktape bindings macros
-
native_api_1c_core
Core library for Native API 1C
-
hpl-toolkit-macro-account-schemas-instruction
HPL macro for defining a instruction to get account schema values
-
despatma-visitor
Design Pattern Macro for visitor
-
parse_api
parse api
-
wiwiwiwiwi
proc macros for wiwi, a library, of, Stuff™ (do not rely on this crate directly)
-
static-map-macro
Macro to create a stack-alocated map
-
serde_flat_path
A macro for expanding long structure chains within serde
-
netsblox-extension-macro
Macros used by netsblox-extension-util
-
clickrs
Simplified CLIs for Rust via procedural macros (Python's click, for Rust)
-
syn-path
macro to declare a syn::Path at compile time
-
ez_jni_macros
macros for the ez_jni crate
-
serde-validate-macro
A procedural macro that validates the deserialization of a struct
-
lending-iterator-proc_macros
Internal: proc-macro backend of ::lending_iterator
-
attribute-derive-macro
Clap for proc macro attributes
-
ctjs
compile time javascript as a rust proc macro
-
pareg_core
contains the implementation for the pareg library
-
smarty-rust-proc-macro
The official client macro for creating Smarty APIs for Rust
-
rglw_orm_codegen
Rustyglware orm based on sqlx library
-
lachs_derive
Derive macro for creating a lexer
-
starlane-primitive-macros
Some primitive macros needed to jump start starlane
-
thruster-socketio-proc
The proc macros behind the thruster web framework
-
workflow-wasm-macros
Macros for workflow-wasm
-
async_trait_proto
Async traits using nightly features
-
mattro
A macro attribute parser
-
masala
Automatic curry. Yum!
-
spaik-proc-macros
Procedural macros for SPAIK
-
clone_with
procedural macro to clone a struct with some fields changed
-
errorset
ErrorSet library
-
mini-internal
Derive macros for miniserde. Use the re-exports from the miniserde crate instead.
-
pen-ffi-macro
FFI macro library for Pen programming language
-
fast_tuple
procedural macro library that provides an easy way to construct and annotate tuples
-
wood_derive
autoderive for wood serialization
-
for_ch
to flatten nested for-loop
-
r-lombok-macros
r-lombok is a rust macros that automatically plugs into your editor and build tools
-
box_shorthand
Rust derive macro to create shorthand functions for initializing boxed enum variant values
-
cushy-macros
Macros for the Cushy GUI framework
-
staged-builder
A proc macro which generates staged builders for types
-
oxidate
Turns strings into a Rust AST
-
tokio-postgres-macros
work with the
tokio-postgres
crate -
mpst-seq-proc
macro for mpstthree
-
fmt-derive-proc
A more robust and versatile derive macro for Debug and Display
-
aranya-crypto-derive
Proc macros for aranya-crypto
-
objr_procmacro
procmacro crate for objr
-
py_fstr
A macro for making Python like fstrings
-
azalea-block-macros
Proc macros used by azalea-block
-
permafrost
Write. Macros. Everywhere.
-
derive_struct_fields_macro
way to work with struct fields programmatically
-
toursql
a derive macro for gluesql
-
bevy_fn_plugin
Create Bevy plugins from functions
-
maomi-macro
Strict and Performant Web Application Programming
-
savvy-macro
Generate R-ready Rust functions by adding
#[savvy]
macro -
logwise_proc
procmacro crate for logwise
-
stronghold-derive
Proc macros and derives for Stronghold
-
derive-redis-json
A derive to store and retrieve JSON values in redis encoded using serde
-
from_tuple
Derive structs from tuples
-
puball
Public all the field in your struct
-
safer_ffi-proc_macros
Procedural macro internals of
::safer_ffi
-
smelter
Custom derive attribute that automatically derives builder methods
-
implicit-trait
Add methods to foreign types with implicitly defined traits
-
to_table
for DomCom, add sort by field to struct
-
ezjsonrpc
JSONRPC 2.0 server/client with proc_macro helpers
-
arma-rs-proc
proc macros for arma-rs
-
bind_it
A macro that allows impl traits in let/static/const bindings until they actually stabilized
-
macro-v
Attribute macro for making the visibility of the
macro_rules!
macro the same as other items -
suitest_macros
suitest macros
-
hoax
procedural macro crate that "hides" any string literal in a plain sight
-
protobuf-convert
Macros for convenient serialization of Rust data structures into/from Protocol Buffers
-
summer-boot-macro
summer boot macro
-
safe-regex-macro
Macro for the safe-regex package
-
tfhe-versionable-derive
set of proc macro for easier implementation of the tfhe-versionable traits
-
serialize_derive
derive for #[derive(Serialize)] and #[derive(Deserialize)]
-
error-window
proc macro that will make your main function output errors as dialog boxes as well as errors to the console
-
rwf-macros
Macros for the Rust Web Framework
-
rust_hls_macro_lib
Helper functions for rust_hls and rust_hls_macro
-
meowtonin-impl
Proc macros for meowtonin, a fully featured Rust wrapper around byondapi
-
macros-core
lightweight, and highly configurable library for quickly parsing macro input into custom objects
-
dbn-macros
Proc macros for dbn crate
-
devault
A more flexible alternative to deriving Default
-
crypt_guard_proc
CryptGuardProc is the proc macro crate related to CryptGuardLib, which is a comprehensive Rust library designed for strong encryption and decryption, incorporating post-quantum cryptography…
-
swift-bridge-macro
Powers swift-bridge module code generation
-
steam-vent-proto-build
Build steam-vent compatible protobuf bindings
-
native_api_1c_macro
Macro library for Native API 1C
-
serialize_display_adapter_macro_derive
Automatically impl Display for struct that implementated serde::Serialize
-
mendes-macros
Macros for mendes web toolkit
-
reflexive
Handy way to evaluate at compile-time any Rust expression
-
turingarena-iospec
specify I/O format and automate validation, parser generation, and more. Part of TuringArena: tools to create programming challenges.
-
quickstart-lib-rust
Just for testing
-
function-compose-proc-macros
lib to allow composition of sync and async rust functions
-
utoipauto-macro
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
serde_tuple_macros
De/serialize structs with named fields as array of values
-
odata_client_codegen
Strongly-typed OData client code generation
-
count-tys
Function-like procedural macro that accepts a comma-delimited :ty TokenTree sequence and returns their count as a constant usize
-
yaah
AOC Helper
-
samevariant
Derive enum of same-variant pairs
-
async_auto_traits
Assert and mask auto traits in
async fn
return types -
vhdl_lang_macros
VHDL Language Frontend - Macros
-
yuuka-macros
A helper library to generate complex and nested structures by a simple macro
-
nginx_derive
Helper crate for nginx-rust
-
default_variant
A proc-macro for specifying the variants or values to be used when deriving
Default
in enums -
type_utils
Generate types based on existing types
-
anchor-syn-fix
Anchor syntax parsing and code generation tools
-
repr_c_pub_struct
extracting
#[repr(C)] pub struct
ures -
counting-macros
Stateful numeric incrementing macros
-
defile-proc_macros
See https://docs.rs/defile
-
inline-python-macros
Macros for the inline-python crate
-
aranya-policy-ifgen-macro
Proc macros for aranya-policy-ifgen
-
proc-macro2-impersonated
A substitute implementation of the compiler’s
proc_macro
API -
askama-enum
Implement different askama templates for different enum variants
-
colorthis
Meta macros that aid macro authors to create colors from a generalized syntax
-
ssttt
More Syn Syntax Tree Traversal Trait
-
rscx-macros
proc macros for the rscx crate
-
vararg
macro for creating variadic functions
-
xparse-macros
A parser combinator that is fully statically dispatched and supports both sync & async parsing
-
i-build
bui
-
add-macro-impl-display
trait 'Display'
-
serde_derive_state
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
unrest_tmp_syn
don't use
-
match_bytes
A language extension for matching byte patterns in slices of bytes
-
litcrypt2
Let's encrypt your string statically during compile time
-
skynet_macro
Macros for Skynet
-
hax-adt-into
adt_into
procedural macro, allowing for mirroring data types with small variations -
ferris-extensions
Extension macros for Rust
-
conf_from_env
Configurations and secrets defined in structs are automatically read from environment variables
-
stak-minifier-macro
Macros to minify Stak Scheme source codes
-
fn-fixture-lib
Internal library for fn-fixture
-
nb-field-names
generate class methods of returning field names of structs
-
arg_ripper
A proc macro for pulling local variables out of functions as arguments
-
test-context-macros
Macro crate for test-context
-
derive-enum-all-values
A procedural derive macro which exposes a method named
all_values
that returns all defined values as a compile-time static -
castle_schema_parser
Castle Schema Parser
-
azalea-inventory-macros
Internal macros for azalea-inventory
-
bevy_state_macros_official
Bevy ECS Macros
-
perfect-derive
prototype of the proposed perfect_derive macro
-
r2r_macros
Minimal ros2 bindings
-
enum_data_proc
a proc-macro,Add bit operations and arithmetic operations to enum
-
teloxide_tests_macros
Proc macros for teloxide_tests
-
usdt-macro
Procedural macro for generating Rust macros for USDT probes
-
dygma_focus_proc_macros
Dygma Focus API, proc macros
-
sha1-macros
Macros for computing SHA1 hashes at compile-time
-
field_names
A proc-macro for exposing a struct's field names at runtime
-
syner
A procedural macro to generate a parser for attributes from a struct
-
stageleft_macro
Helper macros for the stageleft crate
-
fieldx_derive_support
Derive proc macros for fieldx_derive crate
-
flarch_macro
Arch-dependant macros
-
bevy_asset_macros
Derive implementations for bevy_asset
-
makepad-derive-wasm-bridge
Makepad wasm bridge derive macros
-
drylib-proc-macros
Rust macro-library for Don't Repeating Yourself
-
double_dot_macro_types
Misc types and functions required for the double_dot_macro ecosystem
-
arbitrary-model-tests
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
despatma-abstract-factory
Design Pattern Macro for abstract factory
-
acton_test_macro
Testing utilities for Acton agents, providing tools to help in the testing and validation of agent behavior
-
rempl-macros
creating html components directly in your source
-
clip_derive
helpers to derive clip_core traits
-
wattle-proc
proc
-
wasm-bindgen-test-macro
Internal testing macro for wasm-bindgen
-
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.
-
syn-codegen
Syntax tree describing Syn's syntax tree
-
ambient_element_component
Helper procedural macro for the Ambient runtime that converts a function to an
ElementComponent
, allowing for more concise definitions of components -
xflags-macros
Private implementation details of xflags
-
winrt_gen
Code generation for the winrt crate
-
dyn_safe-proc_macros
::dyn_safe
’s internal crate -
cgp-field-macro
Context-generic programming field macros
-
tailwag_macro_exports
A collection of macros to support the tailwag crate
-
c3-lang-parser
C3 Lang
-
kvapi-macros-internals
Under-the-hood TokenStream parsing for the
kvapi
crate -
token_stream2
A better TokenStream for procedural macros
-
der-oid-macro
Macro to encode DER oids at compile time
-
sir-macro
Helper crate for
sir
. Do not use directly. -
duchess-macro
Internal component of duchess crate
-
err-gen
Error-generation macro for hierarchical actor design
-
make_fields
Tiny derive macro to work with fields inspired by lens's makeFields
-
wrapping_proc_macro
A proc macro for cleaner wrapping arithmetic
-
sea-strum
macros for working with enums and strings
-
easy-pin
Using Pin made easy
-
extest
Extra utilities for your tests
-
accessors-rs
Derive macro generating an impl for accessing the fields of a struct
-
aws-macros
Helper functions and types for AWS operations
-
aigen_macros
Procedural macros for testing
-
multiplatform_test
attribute macro to combine
#[test]
and#[wasm_bindgen_test]
-
test-ignore-if-utils
Build utils for the
test-ignore-if
crate -
parcelona_macros_derive
parcelona internal macro crate
-
adtest
better test generation
-
sing_util
Internal functions and types for sing_rs
-
workflow-rpc-macros
Macros for the workflow-rpc crate
-
tracel-xtask-macros
Macros for tracel-xtask crate
-
inarybay
Graph-based binary format (de)serializer generator
-
config-gen-macro-impl
A helper crate containing the macro implementation for config-generator
-
versuch
Procedural macro polyfill for Ok-wrapping functions
-
off-side
syntax (indent instead of braces, like in Python) to write Rust!
-
lexa-syn
Utilitaires pour la crate syn (proc-macro)
-
obfustring
Procedural macro that obfuscates string literals with RNG at compile time
-
enum2str
derive macro that creates a Display impl for enums. This is useful for strongly typing composable sets of strings.
-
nonparallelex
Rust macro for ensuring non-parallel execution of functions, extended Fork of
nonparallel
-
file_env_const
macros for loading data from files or environment variables at compile time
-
serde-versions-derive
An attribute macro for adding a version byte when serializing a struct via Serde. Also allows deseraializing while removing version byte.
-
macro_rules_attribute-proc_macro
Use declarative macros as proc_macro attributes or derives
-
lexgen
A fully-featured lexer generator implemented as a proc macro
-
decay_type
Macro for decaying Rust types to their simplest value type form
-
pi_async_macro
A async file macros tools
-
def-mod
Simplifies module implementation routing and statically verifies exports
-
roadblk-proc
Validator proc-macro
-
nacos-macro
Nacos's proc macros
-
proc-macro-error-attr
Attribute macro for proc-macro-error crate
-
cgp-async-macro
Context-generic programming async macros
-
nys
A declarative parer generator library
-
bevy_ecs_markers_macros
Proc Macros for Bevy ECS Markers
-
enum-str-derive
serialize/deserialize enums into/from a string
-
chassis-proc-macros
Procedural Macros for chassis crate
-
syn_util
helper APIs for procedural macros
-
arcon_codegen
Code generation for Arcon
-
derive_builder_core_fork_arti
Internal helper library for the derive_builder crate
-
casespaetzle-macro
This package introduces a procedural macro for the crate 'casespaetzle'
-
typetrait
Helper macro to generate types for typestate programming
-
sweet_macros
macro crate for sweet
-
socket_addr_macros
Check and parse SocketAddr at compile-time
-
async-blocking-bridger
A way to write a blocking client and async client without repeating yourself
-
proc-debug-macro
Dump proc-macro output for efficient debugging
-
mock-syn
Mock / wrap syn structs and enums overiding specific fields
-
proflogger_proc
Implements a macro to enable automatic function profiling. Should be used with proflogger.
-
test-span-macro
macro to do snapshot tests on tracing spans, usint test-span
-
aranya-policy-derive
Proc macros for generating Aranya Policy Langauge FFIs
-
telety-macro
Proc macros for telety. Not intended for public use.
-
quote2-macros
An alternative lightweight version of quote
-
optional-default
Helper macro to allow specifying default values for only some of a struct's fields
-
bevy_gizmos_macros
Derive implementations for bevy_gizmos
-
derive_display_from_debug
A trivial Rust macro to derive the Display trait for any type with the Debug trait
-
predawn-macro
Macros for predawn
-
macro_state
A set of macros allowing storing and loading global state at compile-time within proc macros
-
untwine_macros
Declarative parsing with a BNF-like syntax - proc macro
-
s2p
helper create to convert list of struct to polars dataframe
-
fake_serialize
macro for implementing dummy implementations of the traits serde::Serialize and serde::Deserialize
-
hooks-macro-core
Compile-time, async hooks
-
macroific_macro
Proc macros for the macroific crate
-
hackfn
Fake implementation of
std::ops::Fn
for user-defined data types -
more-syn-types
parsing Rust Standard Library macros
-
dioxus-core-macro
Core macro for Dioxus Virtual DOM
-
hipcheck-macros
Helper macros for the
hipcheck
crate -
docify_macros
Support macros for docify
-
bevy_state_macros
Macros for bevy_state
-
syn-unnamed-struct
Extends syn expressions and meta structs with unnamed structs and meta lists
-
partial-enum
proc-macro generating partially inhabited enums
-
nvim-oxi-macros
Proc macros for nvim-oxi
-
syn-graphs
graph description language parsers using syn
-
quote-doctest
doctest generator for quote
-
laps_macros
Macros for crate
laps
-
nullable_struct
A derive macro that makes it easy to create nullable versions of structs
-
proc_macro_helper
Procedural macros helper
-
synthez-core
Internal implementations of
synthez
crate -
workflow-task-macros
Macros for the workflow-task crate
-
quote-use-macros
Support
use
in procmacros hygienically -
embedded-test-macros
proc-macros for the embedded-test crate
-
stringify-ident-proc-macro
Replacement for the stringify! macro for use in const functions
-
serde-enum
Automaticly generates string serde implementation for enums
-
snafu-cli-debug
Derive a debug implementation on snafu errors that prints pretty CLI output
-
apidoc-proc
Apidoc proc
-
func_
Proc macro to add function name constant within body of function
-
comptime
Compile-time code execution (i.e. lightweight proc-macro)
-
awsl-syn
AWSL parser for rust macro
-
fixtures
Run tests against fixtures
-
envar
macro to read environment variables at compile time
-
my_proc_macro
proc macro
-
rimpiazza
A compile time procedural macro to replace keywords in a string
-
oberst_proc
A type-safe command parser and dispatcher inspired by Brigadier and written in Rust
-
sin
Sin aims to be an alternative to the proc-macro2/syn ecosystem geared towards developer UX and custom syntax parsing
-
moisture
Rust-based parsing library intended for use with procedural macros!
-
nonparallel-async
Rust macro for ensuring non-parallel execution of async functions
-
bit-by-bit
Convenient proc-macro for defining structs with bitfields
-
count-macro
macro to perform compile time counting
-
sigo_macro_derive
helper derives for sigo
-
cascading-wasm-language
Compiled web language based on CSS syntax
-
biscuit-quote
macros for compile time datalog parsing for Biscuit authorization tokens
-
goglob-proc-macro-tests
Internal library used for testing goglob, not for public use
-
optional_struct_macro
Helper crate implementing the proc_macro for the optional_struct crate
-
d2-stampede-macros
Procedural macros for d2-stampede
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
rweb-macros
web server framework for rust
-
swc_ecma_quote_macros
Quasi quotation system for ecmascript
-
workflow-core-macros
Macros for the workflow-core crate
-
forr
a compile time for loop for code generation
-
peggen-macs
Generate recursive-descent & precedence climbing parsers. (macros)
-
proc-macro-crate-name-test
testing to see whether CARGO_PKG_NAME is populated correctly when proc macro crate is re-exported
-
include_wgsl
A tiny proc macro to include a WGSL file in your binary, and verify that it is valid at compile time
-
incdir
Compile-time including of directories
-
from-attr-macro
Macros for from-attr
-
maud_macros
Compile-time HTML templates
-
autoerror
Automatically generate error handling traits
-
swc_plugin_macro
Macro support for authoring plugin's transform fn
-
div-int-procmacro
Proc macro implementation for the div-int crate
-
uller_macro
Macro-crate for uller
-
syn-serde
serialize and deserialize Syn syntax trees
-
from-enum
derive proc macro for deriving From on enums
-
gluer-macros
Procedural macros for the gluer framework
-
rustc-ap-rustc_macros
Automatically published version of the package
rustc_macros
in the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
compiled-uuid
Parse UUIDs at compile time
-
fieldx_plus_macros
Heler macros for fieldx_plus crate
-
rcss-macro
RCSS - (macro) implementation of proc macros
-
as-method
Call function using the method syntax!
-
static-noise
generation static noise at compile time
-
desugar
Allow for Desugaring of various Rust constructs
-
git-const
Proc macro to provide properties of git repo
-
config_parser_derive
A proc-macro for implementing ConfigParser trait of config_parser library
-
json_proc_macro
proc macro for parsing JSON-like syntax
-
persistent-structs
A Macro that generate helper functions to make non-mutable structs nicer to use
-
mquote
Quasi-quoting library aimed on better readability and usability
-
manyhow-macros
Macro for manyhow