-
proc-macro-error
Almost drop-in replacement to panics in proc-macros
-
syn
Parser for Rust source code
-
quote
Quasi-quoting macro quote!(…)
-
derive_more
Adds #[derive(x)] macros for more traits
-
proc-macro-crate
Replacement for crate (macro_rules keyword) in proc-macros
-
proc-macro2
A substitute implementation of the compiler’s
proc_macroAPI to decouple token-based libraries from the procedural macro use case -
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
strum_macros
Helpful macros for working with enums and strings
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
derive_utils
A procedural macro helper for easily writing derive macros for enums
-
darling
A proc-macro library for reading attributes into structs when implementing custom derives
-
paste
Macros for all your token pasting needs
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
maybe-async
A procedure macro to unify SYNC and ASYNC implementation
-
com_macros_support
Support library for COM crate macros
-
dynasm
A plugin for assembling code at runtime. Combined with the runtime crate dynasmrt it can be used to write JIT compilers easily.
-
quickcheck_macros
A macro attribute for quickcheck
-
getset
Getset, we’re ready to go! A procedural macro for generating the most basic getters and setters on fields
-
fltk-derive
Rust bindings for the FLTK GUI library
-
solana-sdk-macro
Solana SDK Macro
-
serde_repr
Derive Serialize and Deserialize that delegates to the underlying repr of a C-like enum
-
napi-derive
N-API procedural macros
-
gluon_codegen
Code generation macros for the gluon programming language
-
glib-macros
Rust bindings for the GLib library, proc macros crate
-
tabled_derive
Derive macros which is used by tabled crate
-
miette-derive
Derive macros for miette. Like
thiserrorfor Diagnostics. -
cmd_lib_macros
Common rust commandline macros and utils, to write shell script like tasks easily
-
serde_tokenstream
A serde deserializer for proc-macro TokenStreams
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
proc-quote
A procedural macro implementation of quote!
-
proc-macro-error-attr
Attribute macro for proc-macro-error crate
-
casper-node-macros
A macro to create reactor implementations for the casper-node
-
juniper_codegen
Internal custom derive trait for Juniper GraphQL
-
rkyv_derive
Derive macro for rkyv
-
inline-python
Inline Python code directly in your Rust code
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
cstr
Macro for building static CStr reference
-
contracts
Design-by-contract attributes
-
indoc
Indented document literals
-
graphql_query_derive
Utility crate for graphql_client
-
strum
Helpful macros for working with enums and strings
-
hdf5-derive
Derive macro for HDF5 structs and enums
-
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.
-
clap_derive
Parse command line argument by defining a struct, derive crate
-
protocol-derive
Easy protocol definitions
-
snafu-derive
An ergonomic error handling library
-
defmt-macros
defmt macros
-
syn-mid
Providing the features between “full” and “derive” of syn
-
jsonrpc-derive
High level, typed wrapper for
jsonrpc-core -
is-macro
Easily create methods for to use yout custom enum like Option / Result
-
soa_derive_internal
Internal implementation crate for soa-derive
-
derive-new
#[derive(new)]implements simple constructor functions for structs and enums -
assert2-macros
procedural macros for assert2
-
core_extensions_proc_macros
Implementation detail of the
core_extensionscrate -
ouroboros_macro
Proc macro for ouroboros crate
-
binread_derive
Derive macro for binread
-
uniffi_macros
a multi-language bindings generator for rust (convenience macros)
-
yaserde_derive
Serialization and deserialization macros
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
schemars_derive
Macros for #[derive(JsonSchema)], for use with schemars
-
const-random
Provides compile time random number generation
-
ts-rs-macros
derive macro for ts-rs
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
rhai_codegen
Procedural macros support package for Rhai, a scripting language and engine for Rust
-
vtable-macro
Helper crate to generate ffi-friendly virtual tables
-
fix-hidden-lifetime-bug-proc_macros
Proc-macro to write an automatic fix for the “hidden lifetime in impl Trait” issue
-
ramhorns-derive
Experimental Mustache-like templating engine
-
multihash-derive
Proc macro for deriving custom multihash tables
-
cameleon-impl-macros
Utilities used by other cameleon crates implementation
-
sauron-node-macro
An html library for building client side webapps
-
usdt-macro
Procedural macro for generating Rust macros for USDT probes
-
native-windows-derive
A very light and simple rust GUI library
-
gotham_restful_derive
Derive macros for gotham_restful
-
enum-as-inner
A proc-macro for deriving inner field accessor functions on enums
-
include_dir_impl
Implementation crate for include_dir
-
opaque_typedef
Supports defining opaque typedefs
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
call2-for-syn
Apply parser functions to proc-macro2 token streams
-
moveit
A library for safe, in-place construction of Rust (and C++!) objects
-
const-field-offset-macro
Procedural macro to generate constant field offset from repr(c) struct
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
static_table_derive
Procedural macros for investments crate
-
ndk-macro
Helper macros for android ndk
-
wasm-bindgen-test-macro
Internal testing macro for wasm-bindgen
-
salsa-macros
Procedural macros for the salsa crate
-
swc_visit_macros
Visitor generator for stable rustc
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
impl-trait-for-tuples
Attribute macro to implement a trait for tuples
-
cynic-proc-macros
Procedural macro crate for cynic - a GraphQL query builder & data mapper for Rust
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
redbpf-macros
Procedural macros for redbpf
-
rustbus_derive
derive proc-macros for the rustbus crate
-
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.
-
parquet_derive
Derive macros for the Rust implementation of Apache Parquet
-
frame-support-procedural
Proc macro of Support code for the runtime
-
markup-proc-macro
A blazing fast, type-safe template engine for Rust
-
structmeta
Parse Rust’s attribute arguments by defining a struct
-
v_escape_derive
Procedural macro package for v_escape
-
mlua_derive
Procedural macros for the mlua crate
-
bolero-generator-derive
value generator for testing and fuzzing
-
moore-derive
Procedural macros for the moore compiler framework
-
conrod_derive
A crate providing procedural macros for the conrod library
-
autograph_derive
Procedural macro crate for autograph
-
faux_macros
Implementations for #[create], #[methods], when!
-
sea-strum
Helpful macros for working with enums and strings
-
pgx-macros
Proc Macros for ‘pgx’
-
bit-struct
Define structs which have fields which are assigned to individual bits, not bytes
-
aquamarine-demo-crate
A demo crate for aquamarine – the mermaid.js integration for rustdoc
-
derive-getters
Simple boilerplate getters generator
-
derive-into-owned
Custom derives to help with types containing Cow fields
-
serde_derive_internals
AST representation used by Serde derive macros. Unstable.
-
rash_derive
rash derive crate
-
ct-python
Execute Python code at compile time to generate Rust code
-
futures-macro
The futures-rs procedural macro implementations
-
tylift
Lift enum variants to the type-level
-
simple_parse_derive
A derive macro that implements the simple_parse traits
-
sqlxmq_macros
Procedural macros for sqlxmq
-
crevice-derive
Derive crate for the ‘crevice’ crate
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
proc_macro_roids
Traits and functions to make writing proc macros more ergonomic
-
cargho
Derive-based argument parser optimized for being up to date in crates.io
-
fstrings-proc-macro
Python3 fstring interpolation in Rust
-
enumset_derive
An internal helper crate for enumset. Not public API.
-
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.
-
jomini_derive
Serde macros implementation of
#[derive(JominiDeserialize)] -
clapi
A framework for create command-line applications
-
maud_macros
Compile-time HTML templates
-
gc_derive
Garbage collector derive plugin for rust-gc
-
actix-web-codegen
Routing and runtime macros for Actix Web
-
data-encoding-macro-internal
Internal library for data-encoding-macro
-
gltf-derive
Internal macros for the gltf crate
-
rand_derive2
Generate customizable random types with the rand crate
-
saphir_macro
Macro generation for http server framework
-
bitwrap_derive
macro for bitwrap
-
libcnb-proc-macros
Procedural macros used within libcnb.rs
-
qmetaobject_impl
Custom derive for the qmetaobject crate
-
crepe
Datalog in Rust as a procedural macro
-
bae
A Rust proc-macro attribute parser
-
ckb-fixed-hash-macros
Provide several proc-macros to construct const fixed-sized hashes
-
deltoid-derive
Derive macro that generates code to calculate and apply deltas to structs and enums
-
struct-arithmetic
Provides a Trait to derive basic arithmetic operations for your structs
-
askama_derive
Procedural macro package for Askama
-
ruma-identifiers-macros
Procedural macros for creating Matrix identifiers
-
drone-core-macros
Procedural macros for drone-core
-
libafl_derive
Derive proc-macro crate for LibAFL
-
djin-protocol-derive
A for of protocol, for aoe-djin
-
enum-iterator-derive
Procedural macro to iterate over the variants of a field-less enum
-
ff_derive
Procedural macro library used to build custom prime field implementations
-
frunk_proc_macros_impl
Proc macros inernal implementations for Frunk
-
defmt-test-macros
defmt-test macros
-
easy-xml-derive
The macros for easy-xml
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
janetrs_macros
Attribute macros for JanetRS
-
phf_macros
Macros to generate types in the phf crate
-
dict_derive
Derive macros for some PyO3 traits to convert python dicts into rust structs
-
tangram_macro
Make predictions with a Tangram model from your Rust app. Learn more at https://www.tangram.dev/.
-
datasize_derive
Derive macros for the
datasizecrate -
rustfmt-config_proc_macro
A collection of procedural macros for rustfmt
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
relm-derive
Custom derive required by the relm crate
-
serde_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
procout
Output a proc macro’s TokenStream to a file
-
deku_derive
bit level serialization/deserialization proc-macro for structs
-
ext-php-rs-derive
Derive macros for ext-php-rs
-
nj-derive
procedure macro for node-bindgen
-
tls_codec_derive
Derive macros for the tls_codec trait
-
zerocopy-derive
Custom derive for traits from the zerocopy crate
-
palette_derive
Automatically implement traits from the palette crate
-
chalk-derive
A helper crate for use by chalk crates for
derivemacros -
tetsy-scale-codec-derive
Serialization and deserialization derive macro for Tetsy SCALE Codec
-
bitmask-enum
A bitmask enum attribute macro
-
below_derive
Proc macros for below
-
pen-ffi-macro
FFI macro library for Pen programming language
-
proto-vulcan-macros
Internal macro library for proto-vulcan
-
argh_derive
Derive-based argument parsing optimized for code size
-
metamorphose
Macros collection for converting Structure to Model, for a mango-orm project
-
sewup-derive
Macros implementation for SewUp
-
hobo_derive
hobo is a Rust frontend framework
-
rune-macros
Helper macros for Rune
-
tower-lsp-macros
Internal procedural macros for tower-lsp
-
fn-error-context
An attribute macro to add context to errors from a function
-
gramatika-macro
Proc macros for Gramatika
-
diesel_filter_query
Procedural macros for Diesel filter
-
opimps
A simple library of attribute macros to assist with overloading operators for borrowed and owned data
-
dioxus-core-macro
Core macro for Dioxus Virtual DOM
-
sawp-flags-derive
SAWP BitFlags Handling and Storage Derive Macro
-
rlink-derive
High performance Stream Processing Framework
-
lspower-macros
Internal procedural macros for lspower
-
kube-derive
Custom derives for the kube kubernetes crates
-
inkwell_internals
Internal macro crate for inkwell
-
gc-arena-derive
proc-macro support for gc-arena
-
der-oid-macro
Macro to encode DER oids at compile time
-
arma-rs-proc
proc macros for arma-rs
-
html-macro
html macro
-
datatest-derive
Procmacro for the datatest crate
-
xladd-derive
A simple macro that helps write Excel UDF functions in Rust
-
prometheus-static-metric
Static metric helper utilities for rust-prometheus
-
bitwrap_derive_extra
macro for bitwrap
-
macroquad_macro
Proc macro for macroquad
-
mockers_macros
Compiler plugin for ‘mockers’ mocking library
-
narui_macros
proc macros of the narui gui framework
-
enum-display-derive
Display trait’s custom derive for simple enums
-
fates_macro
Helper macro for Fates crate. See https://crates.io/crates/fates
-
rquickjs-macro
Procedural macros for rquickjs
-
pinwheel_macro
Build web applications with Rust
-
git-testament-derive
Record git working tree status when compiling your crate - inner procedural macro
-
static_init_macro
Attribute macros for static_init crate
-
swift-bridge-macro
Powers swift-bridge module code generation
-
syn-rsx
syn-powered parser for JSX-like TokenStreams
-
jenner-macro
Macro implementations for jenner
-
bitbuffer_derive
Reading bit sequences from a byte slice
-
slog-extlog-derive
Custom derive code for slog-extlog
-
config_parser_derive
A proc-macro for implementing ConfigParser trait of config_parser library
-
bevycheck
Helpful bevy error messages by proc-macro
-
rustpython-derive
Rust language extensions and macros specific to rustpython
-
neli-proc-macros
Procedural macros for neli
-
dodo-derive
Dodo persistence library derives
-
cenum
A rust derive macro for C-style primitive enums
-
aragog-macros
Macros for Aragog Crate
-
fncmd-impl
This crate shouldn’t be used directly. Check fncmd.
-
influxdb_derive
Private implementation detail of the influxdb crate
-
com_macros
COM crate macros
-
command_attr
Procedural macros for command creation for the Serenity library
-
generic-bytes-derive
A macro for derivation of SizedBytes, a trait for conversion to and from an array of bytes with a type-level size
-
oauth1-request-derive
A derive macro for
oauth1_request::Requesttrait -
sixtyfps-macros
Macro helper for sixtyfps crate
-
bitfield-derive
This crate provides derive to generate struct with bitfield access
-
cdrs-tokio-helpers-derive
Derive CDRS helper traits
-
wasmtime-rust-macro
Macro support crate for wasmtime-rust
-
spirv-std-macros
Macros for spirv-std
-
jsonrpsee-proc-macros
Procedueral macros for jsonrpsee
-
refinery-macros
This crate should not be used directly, it is internaly related to Refinery
-
derive_setters
Rust macro to automatically generates setter methods for a struct’s fields
-
property
Generate several common methods for structs automatically
-
autocorrect-derive
proc-marcro-derive for autocorrect
-
peg-macros
Procedural macros for rust-peg. To use rust-peg, see the
pegcrate. -
unroll
An attribute-like procedural macro for unrolling for loops
-
serde_derive_state
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
tuirealm_derive
Derive macro which automatically implements the MockComponent trait
-
i18n-macro
A simple compile time i18n implementation in Rust
-
harmony_derive
Proc macros for harmony_rust_sdk. Not meant to be publicly used.
-
tlua-derive
Picolua derive macro definitions
-
ff-uint_derive
Library for building and interfacing with fixed-sized integers and finite fields
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
dionysos-derives
derive crate for dionysos: Scanner for various IoCs
-
minitrace-macro
Attribute procedural macro for minitrace-rust
-
tracing-rc-derive
Attribute macros for tracing-rc
-
tch-tensor-like-derive
Derive macro implemenations used by tch-tensor-like crate
-
yew-interop-macro
macros for the yew-interop crate
-
partial_ref_derive
Derives for partial_ref
-
treeflection_derive
#[derive(Node)] macro for the Treeflection library
-
rustler_codegen
Compiler plugin for Rustler
-
gdnative-derive
The Godot game engine’s gdnative derive and procedural macros
-
struct-merge-codegen
Proc macro codegen crate for merge-struct
-
restcrab_macros
Macros for the restcrab crate
-
bolt-proto-derive
Procedural macros for bolt-proto
-
scale_documentation_parser
a proc macro to parse the structured SCALE documentation into Rust datastructures
-
error_generator
Transform structs and enums into fully qualified errors using attributes
-
toql_derive
Library with derive for toql
-
scanf
Parse text inputs (inverse of print! and format!)
-
sanitizer_macros
Derive macro for the sanitizer crate
-
memoize-inner
Helper crate for memoize
-
inet2_derive
Derivation macros for Internet2-based crates
-
yui_derive
Internal derive and proc macro for Yui
-
sql_db_mapper_derive
Derives used by code generated by sql_db_mapper
-
abomonation_derive
A custom derive plugin for abomonation
-
elrond-wasm-derive
Elrond WebAssembly smart contract API procedural macros
-
xls_table_derive
Procedural macros for investments crate
-
dynomite-derive
Derives AWS DynamoDB dynomite types from native Rust struct types
-
vectrix-macro
A macro for composing matrices
-
versionize_derive
Implements the Versionize derive proc macro
-
sudo_plugin
Macros to easily write custom sudo plugins
-
hotg-rune-proc-block-macros
Procedural macros for the rune-proc-block crate
-
krator-derive
Derive macros for the Krator crate
-
elephantry-derive
Macro implementation of #[derive(Entity)]
-
set_slice
A macro for assigning values to slices
-
safe-proc-macro2
A substitute implementation of the compiler’s
proc_macroAPI to decouple token-based libraries from the procedural macro use case -
unique-type-id
A unique id proc-macro generator for types
-
doku-derive
A framework for building documentation (internal macro)
-
enumscribe_derive
Derive macros for converting between enums and strings
-
mpesa_derive
MpesaSecuritytrait derive macro crate -
mock_derive
An easy to setup, rich mocking library for the Rust programming language
-
magic_static_macro
Proc macro for magic_static
-
flexpiler_derive
Derive macro project for main crate ‘flexpiler’
-
gxi-macros
collection of macros for gxi-rs
-
static-pubkey
macro used for compile-time parsing of public key strings into byte arrays for near 0-cost static public keys
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
finny_derive
Procedural macros crate for the main finite state machine crate, finny
-
enum_cycling_derive
Small macro for working with enums
-
typesets-macro
The derive macros for typesets
-
rust-cef-derive
Macros to derive the ToCef trait implementation for any struct as well as macros to annotate members to map to various CEF headers or key-value pairs. This enables having a structured…
-
rbatis-macro-driver
rbatis macro driver 高性能Rust orM框架 宏系统支持
-
oso-derive
macros for oso, an open source policy engine for authorization that’s embedded in your application
-
sval_derive
Custom derive for sval
-
swc_ecma_codegen_macros
Macros for swc_ecma_codegen
-
sawp-ffi-derive
Generate cbindgen compatible member accessors for structs and enums
-
wchar-impl
Internal implementation of wchar
-
remoc_macro
Procedural macros for Remoc
-
delegate
Method delegation with less boilerplate
-
lazy-regex-proc_macros
proc macros for the lazy_regex crate
-
async-stream-impl
proc macros for async-stream crate
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
glsl-layout-derive
Custom derive for
glsl-layoutcrate -
libipld-cbor-derive
ipld cbor codec proc macro
-
shumai-config-impl
A benchmark framework that empowers efficient and correct multi-thread benchmarks
-
decent-synquote-alternative
An 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…
-
genesis-impl
proc macro crate for genesis
-
flow_impl_derive
Definition of a derive macro for FlowImpl
-
mpst-seq-proc
A library with macro for mpstthree
-
irzha
Write Rust programs using Ukrainian language
-
maomi-macro
A rust wasm framework for building pages with components (helper macros)
-
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
bitregions-impl
implementation for the bitregions crate
-
s_test_fixture
s_test_fixture or simple test fixture is a macro library to implement test fixture with no hassle
-
proconio-derive
Procedural macros for proconio
-
drone-cortexm-macros
Procedural macros for drone-cortexm
-
ocaml-derive
OCaml procedural macros
-
inline-proc
Inline procedural macros
-
starship_module_config_derive
The minimal, blazing-fast, and infinitely customizable prompt for any shell! ☄🌌️
-
include-flate-codegen
Macro codegen for the include-flate crate
-
easy-jsonrpc-mw
Convert a trait definition into a jsonrpc api
-
inertia-macros
A simple library of attribute macros to assist with overloading operators for borrowed and owned data
-
cuda_std_macros
Macros for cuda_std
-
shoulda_macro
derive macro for test assertions
-
creator-derive
Mobile Game Framework
-
tamasfe-macro-utils
Proc-macro utilities, intended for personal use
-
git-version-macro
Internal macro crate for git-version
-
rustfmt-wrapper
Library wrapper around rustfmt for use by code generators
-
dcc-lsystem-derive
Macro implementation of #[derive(TurtleContainer)]
-
derive-env-url
Derives for env-url
-
find-crate
Find the crate name from the current Cargo.toml
-
canonical_derive
The automatic derivation of Canon for structs, and enums
-
reflect
The “but I thought Rust doesn’t have reflection?” memorial brand new way of defining procedural macros
-
futures-select-macro-preview
The
select!macro for waiting on multiple differentFutures at once and handling the first one to complete -
derive_state_machine_future
Custom derive implementation for the
state_machine_futurecrate. Use that crate instead of this one directly. -
js-macros
Quickly prototype procedural macros using JavaScript or TypeScript!
-
rdxl_static
Static Site Generation Utilities for RDXL
-
lv2-core-derive
Procedural macros for lv2-core
-
rustc-ap-rustc_macros
Automatically published version of the package
rustc_macrosin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
rkyv_dyn_derive
Macros for rkyv_dyn
-
oxide-macros
Main entrypoint macro for AVRoxide
-
neon-macros
Procedural macros supporting Neon
-
macro-ruby
Execute ruby code at compile time trough mruby
-
gotham_formdata_derive
Implementation detail of gotham_formdata
-
enum_const_value
Providing const values for enums. Unit and enums with associated types are supported. Each variant gets a unique sequential value.
-
thruster-proc
The proc macros behind the thruster web framework
-
packer_derive
Derives for the packer crate
-
canadensis_derive_register_block
Derive macro for
canadensis::register::RegisterBlock -
fortify_derive
Derive macros for fortify
-
tskit-derive
procedural macros for tskit-rust
-
rsexp-derive
Derive macro for S-expression conversion
-
gtmpl_derive
Derive for gtmpl_value
-
shaku_derive
Code generation for the shaku dependency injection framework
-
sp-multihash-derive
Proc macro for deriving custom sp-multihash tables
-
clickrs_proc_macro
Simplified CLIs for Rust via procedural macros (Python’s click, for Rust). The procedural macro crate.
-
macropol
Ergonomic string literal interpolation in macro definitions
-
ref-cast-impl
Derive implementation for ref_cast::RefCast
-
butcher_proc_macro
Procedural macros for butcher
-
pipederive
Proc macros for data integration app using pipebase framework
-
hecs-macros
Procedural macro definitions for hecs
-
add_getters_setters
Makes it much easier to add getters and setters for fields of structures. Done by simply just adding some attributes to the struct and fields
-
giftwrap
Wrap and unwrap your types the stylish way
-
slices
Convert string literals to static unsigned integer slices in compile time
-
diff_derive
A derive macro for implementing Diff on the diff-struct crate
-
proc_macro2_helper
Various utility code to extract data that can be used with proc macro2
-
constduck-procmacro
Macro implementation of #[derive(ConstDuck)]
-
holium-macro-support
Support crate for the procedural macro for the Holium Rust SDK
-
fff_derive
Procedural macro library used to build custom prime field implementations
-
sscanf_macro
Proc-Macros for the sscanf Crate. Not meant to be used as a standalone Crate
-
proxy-enum
Emulate dynamic dispatch and sealed classes using a proxy enum, which defers all method calls to its variants
-
bitbar-derive
Proc-macros for the bitbar crate
-
celery-codegen
Macros for rusty-celery
-
usdt-attr-macro
Procedural macro for generating Rust macros for USDT probes
-
test-fuzz-macro
test-fuzz-macro
-
err-per-field-derive
Derived macro for err-per-field crate
-
compiled-uuid
Parse UUIDs at compile time
-
libtor-derive
Internal #[derive] macros for libtor
-
rs-odbc_derive
Proc macros for rs-odbc crate
-
substrate-subxt-proc-macro
Derive calls, events, storage and tests for interacting Substrate modules with substrate-subxt
-
gmod-macros
Proc macros for gmod-rs
-
css-modules
CSS Modules with a macro for convenience
-
gettext-macros
A few proc-macros to help internationalizing Rust applications
-
dukt-macros
duktape bindings macros
-
clone_cell_derive
Proc macro for clone_cell
-
crayfish-macros
Crayfish macros
-
enum-flags
EnumFlags is a csharp like enum flags implementation
-
default-args
zero-cost default arguments in rust
-
iced_focus_derive
A proc-macro to derive a focus chain for Iced applications
-
nitroglycerin_derive
derive(Attributes, Get, Query) for nitroglycerin/dynamodb
-
scan-rules
This crate provides some macros for quickly parsing values out of text. Roughly speaking, it does the inverse of the print!/format! macros; or, in other words, a similar job to scanf from C.
-
securefmt
Drop-in replacement for the Debug derive macro that hides fields marked as sensitive
-
partial-borrow-macros
proc-macros for partial-borrow
-
win_etw_macros
Enables apps to report events to Event Tracing for Windows (ETW)
-
ed-derive
Derive macros for the ed crate
-
netlify_lambda_attributes
Lambda macro attributes
-
gdnative-impl-proc-macros
Internal dependency of the gdnative bindings
-
a2lmacros
provides macros in support of the a2lfile crate
-
typify-macro
typify macro implementation
-
plex
A syntax extension for writing lexers and parsers
-
shred-derive
Custom derive for shred
-
elapsed-printer
Very simple macro for printing time elapsed to execute a function
-
better-bae
A Rust proc-macro attribute parser
-
prometheus-metric-storage-derive
Implementation details for prometheus-metric-storage
-
consulrs_derive
A derive macro for implementing query options for Consul endpoints
-
devise_core
A library for devising derives and other procedural macros
-
autd3-traits
Wav Modulation for AUTD
-
trace
A procedural macro for tracing the execution of functions
-
pokeapi-macro
Attribute macro for
pokeapi-modelstructs -
byteme
Converts a struct into Vec and back. The conversion is Big Endian by default.
-
wasmbus-macros
derive macros for wasmbus-rpc
-
openapi_type_derive
Implementation detail of the openapi_type crate
-
windows_macros
Macros for the windows crate
-
muta-apm-derive
Muta tracing procedural macros
-
diesel_derives
You should not use this crate directly, it is internal to Diesel
-
fixed_width_derive
Derive trait for use with the fixed_width crate
-
frame-support-procedural-tools
Proc macro helpers for procedural macros
-
mattro
A macro attribute parser
-
const-random-macro
Provides the procedural macro used by const-random
-
cmd_lib_core
Common rust commandline macros and utils, to write shell script like tasks easily
-
diesel_derives_extra
Automatically derive some simple CRUD methods for your Diesel models
-
edn-derive
Edn (De)Serialization derive macros
-
stidgen
Strongly Typed ID types macro
-
autoincrement_derive
Derive macros for
autoincrementcrate -
mun_codegen_macros
Macros used by mun code generation
-
bingen
Procedure macro for bringing a compile-time compiled assembly code as a binary slice
-
npyz-derive
#[derive(…)]s for reading structured arrays in NPY files
-
gostd_derive
proc_macro_derive library for gostd
-
plctag-derive
macros for
plctag -
tuix_derive
Derive macros for tuix
-
rvv-asm
Procedure macro to encode RISC-V V extension (rvv) instructions
-
rust-i18n-macro
Macro for rust-i18n crate
-
derive_rich
Helps you to create richful function for your structs
-
iota-rs
A rust macro for other Go refuges who miss const blocks and iota
-
bolt-client-macros
Procedural macros for bolt-client
-
wasmedge-bindgen-macro
Pass string, vec and primitive types from host to webassembly
-
napi-derive-backend
Codegen backend for napi procedural macro
-
x86test-macro
Procedural macro plugin for x86test
-
clean-macro-docs
Hide internal rules when documenting
macro_rules!macros -
gumdrop_derive
custom derive support for gumdrop
-
ebml-iterable-specification-derive
Provides macros for implementing
EbmlSpecificationfor theebml-iterablecrate -
rbatis_sql_macro
rbatis sql macro system
-
build-info-proc
Part of the build-info crate: This crate provides the proc-macros
-
machine
State machine utilities
-
synthez
Steroids for
syn,quoteandproc-macro2crates -
rabbithole-derive
The macro system helping users to model the relationship of their data
-
sunfish_macro
Web Application Build Tool
-
pmacro_ruly
macros for ruly
-
fort
Proc macro attributes for Bastion runtime
-
leetcode_test
Some useful macros and definition for exercising in leetcode
-
reformation_derive
reformation derive crate
-
ctjs
compile time javascript as a rust proc macro
-
u256-literal
Procedural macro for converting u256 literals to U256 at compile time
-
aliri_braid_impl
Implementation macros for the
aliri_braidcrate -
enso-macro-utils
Utilities for writing macros
-
static-reflect-derive
Procedural derive for static-reflect
-
actix-json-responder
A procedural macro to reduce json response boilerplate on actix projects
-
tonic_include_protos
A helper proc-macro to include all protobuf files generated by tonic_build
-
bytify
Convenience macro for generating continuous byte arrays from arbitrary sequences of literals
-
tokio-pg-mapper-derive
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
evmc-declare
Bindings to EVMC (VM declare macro)
-
trackable_derive
Custom derive for
trackablecrate -
topo-macro
procedural macros for the topo crate
-
ast2str
A crate for pretty-printing ASTs and other recursive data structures
-
c2rs
C struct to Rust struct
-
structmap-derive
Proc derive macro for structmap crate
-
ssbh_write_derive
ssbh_write derive macro
-
nongoose-derive
Macros implementation of #[derive(Schema)]
-
rusty-peg
A macro for defining PEG parsers
-
for_ch
to flatten nested for-loop
-
dummy
Macros implementation of #[derive(Dummy)]
-
struct2vec_derive
Rust structure to slice
-
ublox_derive
Utility macros for the ublox crate
-
extendr-macros
Generate bindings from R to Rust
-
autoproto-derive
Derive macros for
autoproto -
identifier_derive
Derive macros for identifier
-
discord_typed_interactions_proc_macro
suppose you’re working with discord slash commands and you want statically typed request types
-
lazylink-macro
Convert extern fn to libdl call
-
pam-macros
Macros for the pam crate
-
solid-derive
Macros for the
solidcrate. Not intended to be used directly. -
ptah_derive
Derive macro for Rust’s implementation of Ptah, Poplar’s message-passing format
-
json_schema_test_suite
Procedural Macro Attribute to run all the test cases described in JSON-Schema-Test-Suite
-
syndicate-macros
Support macros for programming with the Syndicated Actor model and Dataspaces
-
async-injector-derive
A derive to help construct dependent values in async-injector
-
dyn_struct_derive
Derive macros for the
dyn_structcrate -
wood_derive
autoderive for wood serialization
-
macro_railroad
A library to generate syntax diagrams for Rust macros
-
rep_derive
A small tool for representation/class invariants
-
jrsonnet-gc-derive
Garbage collector derive plugin for rust-gc
-
generate-derive
Provides derive functionality for the
generatecrate -
swipl-macros
Macro crate for swipl-rs
-
helper
A library provided some useful proc macros for Rust
-
rust-hdl-macros
Macro support for RustHDL
-
optbuilder
A optional builder derive macro for helping with big constructors with mostly optional parameters
-
cute_custom_default
Derive macro for
Defaulttrait with customization -
proptest-attr-macro
Procedural attribute macro for writing proptest tests
-
recap-derive
Derives FromStr impl for types which are then deserialized using recap
-
const_panic_proc_macros
Implementation detail of the
const_paniccrate -
pomelo-impl
Implementation details for pomelo, not to be used directly
-
autowired-derive
Autowired project derive macro support
-
penrose_proc
proc-macros for the Penrose tiling window manager library
-
tree_hash_derive
Procedural derive macros to accompany the tree_hash crate
-
pcd-rs-derive
Derive macros for pcd-rs crate
-
crabler_derive
Derive macro for crabler library
-
dipa-derive
The derive macro for the dipa crate
-
msgpack-schema-impl
Implementation detail of the msgpack-schema crate
-
stable-step-derive
An implementation of Step for stable rust (derive macros)
-
dropshot_endpoint
macro used by dropshot consumers for registering handlers
-
ra_ap_proc_macro_srv
TBD
-
gvariant-macro
Proc macros for the gvariant crate
-
arel_macro
arel macros
-
ev3dev-lang-rust-derive
Derive macros for ev3dev_lang_rust
-
binary_macros_impl
Procedural macro implementations for decoding base64-like encodings in string literals to [u8] literals
-
nanoserde-derive
Fork of makepad-tinyserde derive without any external dependencies
-
include_dir_macros
The procedural macro used by include_dir
-
lain_derive
Derive macros for usage with lain
-
ferric-macros
A Probablistic Programming Language with a declarative syntax for random variables
-
fuels-abigen-macro
Fuel Rust SDK marcros to generate types from ABI
-
packtool-macro
In memory packing made easy: procedural macro definitions
-
peppi-derive
Support crate for peppi
-
laby_macros
HTML transformation macros for laby
-
tealr_derive
The derive macro for tealr
-
otopr-derive
Obvious Rust Protobuf Library - Derive Macros
-
activitystreams-derive
Derive macros for activitystreams
-
ya-runtime-sdk-derive
Macro implementation of #[derive(RuntimeDef)]
-
bytecheck_derive
Derive macro for bytecheck
-
saturating_arithmetic
Proc macro #[saturateit] to rewrite operators into their saturating equivalents
-
srpc-macro
contains srpc’s macros
-
abscissa_derive
Custom derive support for the abscissa application microframework
-
mp4ameta_proc
Procedural macros to generate common accessors for the mp4ameta crate
-
notation_macro
Fun notation - DSL to create notation files
-
paperclip-macros
Macros for paperclip OpenAPI tooling library
-
bash_builtins_macro
Macros for the bash-builtins crate
-
eventmill_derive
Derive macros for convient implementation of some traits of the
eventmillcrate -
every_variant_macro
To be used with all variant, contains the derive macro
-
rustorm_codegen
code gen provides macro for generating code on data access objects on table metadata
-
poem_openapi_validator_derive
poem openapi validator
-
rdxl_internals
RDXL Internals
-
tractor-macros
Proc macros for
tractor -
lexgen_util
Runtime library for lexers generated by lexgen
-
const-gen-derive
A derive macro for the const-gen crate
-
extra_args
Rust macro to pass implicit args to functions (use with care)
-
asn1_derive
#[derive] support for asn1
-
noop_proc_macro
No-op proc_macro, literally does nothing
-
nameless-clap_derive
Parse command line argument by defining a struct, derive crate
-
sully_peg
Proc macro for PEG generation
-
parst_derive
derive macros for parst
-
tokio_env_macro
Procedural macros for tokio_env
-
actix-proc-macros
Proc macros, to be re-exported by
actix-helper-macros -
tco
A macro for transforming a tail-calling recursive function to eliminate recursion
-
merfolk_frontend_derive
A
Frontendfor merfolk using derive macros -
postgres-derive
An internal crate used by postgres-types
-
ketos_derive
Derive traits for Ketos scripting language
-
asteracea_proc-macro-definitions
Proc macro definitions for Asteracea. They are unlikely to work correctly unless used through the asteracea crate.
-
starlark_derive
Derive helpers for the starlark package
-
docbot-derive
Derive macros for docbot
-
bunt-macros
Helper crate for
bunt. Please see the docs ofbuntfor more information. Do not use this crate directly, API stability is not guaranteed! -
concat-arrays
A macro for concatenating fixed-size arrays
-
struct-field-names-as-array
Provides a procedural macro that generates an array of the field names of a named struct
-
pyo3-prost
Use Rust protobuf structs in Python
-
structout
A proc-macro for generating structs from a common definition
-
inject-macro
Experimental IOC library for Rust, procedural macros
-
uniui_gui_macro
Macroses for uniui_gui crate. Please refer to uniui_gui crate for full documentation
-
variant_counter_derived
Rust’s Enum variant counter
-
c2rust-macros
Procedural macro support crate for C2Rust
-
strong-xml-derive
Derive marco of strong-xml
-
fizyr-rpc-macros
procedural macros for the fizyr-rpc crate
-
std140-macros
Procedural macros for the std140 crate
-
runestick-macros
Runescript, a generic stack-based virtual machine for Rust
-
agpu-macro
agpu derive macros
-
automate-derive
Derive macros for the automate library
-
cdefines
A proc macro that translates c #define constants to rust consts
-
gf256-macros
Proc-macros for the gf256 crate
-
miniserde-enum
Derive macros for miniserde on enums
-
predicate-macros
Easy to implement predicate crate traits
-
variants-struct
A derive macro to convert enums into a struct where the variants are members
-
finte-derive
#[derive(IntEnum)] support for finte
-
bitaccess_macros
bitaccess macro implementations (use
bitaccessinstead of this) -
result-like-derive
derive macros for result-like
-
quickjs_regex_derive
quickjs libregexp
-
ethers-derive-eip712
Custom derive macro for EIP-712 typed data
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
rdxl
Macros and Component System for HTML Templating
-
arr_macro_impl
Private impl crate for arr_macro
-
try_match_inner
The internal procedural macro of
try_match -
make_tuple_traits
a proc_macro for making a bunch of traits for tuples up to a fixed size
-
dmv_derive
Defines the
Dmvderive macro -
sc-chain-spec-derive
Macros to derive chain spec extension traits implementation
-
grafana-plugin-sdk-macros
Convenience macros for the Grafana backend plugin SDK
-
intertrait-macros
Macros for intertrait crate, which allows for direct casting between trait objects
-
bevy_proto_derive
Derive macro for use with bevy_proto
-
stronghold-derive
Proc macros and derives for Stronghold
-
retryable-proc_macros
Automatic function retry macro
-
druid-derive
derive impls for druid, a Rust UI toolkit
-
woab-macros
Procedural macros for the WoAB crate
-
kommandozeilen_argumente_derive
derive-Macros für das kommandozeilen_argumente crate
-
efmt_derive
Internal proc macros for efmt crate
-
ioctl-gen
Simple macros for generating ioctl numbers
-
ddd_dapr_derive
Derive macros for convient implementation of some traits of the
ddd_daprcrate -
edgedb-derive
Derive macros for EdgeDB database client
-
pdf_derive
helper for pdf-rs
-
package_info_derive
Derive macro for exposing Cargo Package Information to Rust code
-
gxi-derive
derive macros for gxi-rs
-
stdweb-internal-test-macro
Internal crate of the
stdwebcrate -
build_cfg_macros
Proc macros for build_cfg
-
nacos-rs-sdk-macro
THIS PROJECT IS SUPPORTER FOR NACOS-RS-SDK
-
actix-handler-macro
Helper macros for using Actix. Generates handlers, actors and address traits.
-
next-gen_proc-macro
Safe generators on stable Rust
-
into_query_derive
Provides a derive macro for IntoQuery
-
load-dotenv
This is a small procedural macro to load your .env file at compile time
-
binrw_derive
Derive macro for binrw
-
ff-derive-num
Procedural macro library to add the Num trait to Field implementations for ff
-
rweb-macros
Yet another web server framework for rust
-
rebound-proc
Proc macros associated with the rebound crate
-
cssparser-macros
Procedural macros for cssparser
-
foreignc_derive
Creates methods for deriving ffi abis. Made as a part of the foreignc crate
-
safe-quote
Quasi-quoting macro quote!(…)
-
ergol_proc_macro
the proc macros for ergol, an async ORM for Rust
-
flaggy-codegen
proc-macro code generation for flaggy
-
better-bae-macros
A Rust proc-macro attribute parser
-
teloxide-macros
The teloxide’s procedural macros
-
targets
Some helpers to get you started with declarative programming in Rust
-
sqlb-macros
Macros for sqlb. Not intended to be used directly.
-
teloc_macros
Macros for teloc framework
-
rust-ad-macros
Rust Auto-Differentiation
-
flamer
a procedural macro to insert
flame::start_guard(_)calls -
advancedresearch-nano_ecs
A bare-bones macro-based Entity-Component-System
-
migrations_macros
Codegeneration macros for diesels embedded migrations
-
better-macro
This crate provides better versions of common macros like println
-
red_asn1_derive
macros for red_asn1
-
fbthrift_codegen_includer_proc_macro
Helps include generated thrift structures
-
quit_macros
Procedural macros used by crate quit
-
debug2-derive
Derive macro for debug2
-
phper-macros
The proc-macros for phper crate
-
sc2-proc-macro
Procedural macros for rust-sc2 API
-
emv-qrcps-derive
Derive macros for emv-qrcos crate
-
bitbag_derive
Derive macros for the bitbag crate
-
err-derive
Derive macro for
std::error::Error -
mazzaroth-rs-derive
Mazzaroth Rust library derivation macros
-
scale_impl_generator
a proc macro to generate a large percentage of all impls on SCALE crypto primitives
-
tokenstream2-tmpl
Runtime TokenStream interpolation for Rust macros
-
attribution
A declarative custom attribute parsing framework
-
asn1_der_derive
This crate contains a procedural macro to implement
derivefor myasn1_dercrate -
igri_derive
Derive macro for
igri -
nb-blocking-util
Utility proc macro for removing all async/await from a function
-
sudograph-generate
Procedural macro for Sudograph
-
kg-diag-derive
Macro implementation for #[derive(Detail)]
-
spatialos-macro
Procmacro crate used to expand SpatialOS component and types created with spatialos-codegen
-
rocket_okapi_codegen_fork
Macros supporting rocket_okapi forked from rocket_okapi_codegen_fork
-
resrap_proc_macro
Macros for resrap
-
bevy_ecs_macros
Bevy ECS Macros
-
asn1_codecs_derive
ASN.1 Codecs derive Macros
-
adorn
A plugin to provide python-style decorators in Rust
-
yewtil-macro
Macros to be re-exported from the yewtil crate
-
cbor_enhanced_derive_protocol
Derive macro implementation for cbor_enhanced
-
sfsm-proc
Macros to generate state machines for sfsm
-
peepmatic-macro
Macros for peepmatic
-
cffi-impl
Safe* C FFI interface generator - macro
-
binver_derive
derive for binver
-
clippy-mini-macro-test
A macro to test clippy’s procedural macro checks
-
emacs-macros
Proc macros for emacs modules
-
cstr-macros
Procedural macros for cstr
-
dacquiri_derive
Derive macro support for dacquiri
-
shorthand
A proc_macro to derive getter and setter for structs
-
db-derive-impl
Derive proc-macro for db-derive
-
observer_attribute
Observer Attributes
-
charify
A simple proc macro to turn its token input into a char, similar to the built-in stringify! macro
-
limelight-derive
Derive macro for limelight
-
linq
Language Integrated Query in Rust
-
dhall_proc_macros
Macros for dhall
-
repr_c_pub_struct
A library for extracting
#[repr(C)] pub structures -
asterix-derive
proc-macro convenience with the deku library, for updating ASTERIX FSPECs
-
type-change
Convert between different types of the same field name
-
rlp-derive
Derive macro for #[derive(RlpEncodable, RlpDecodable)]
-
postgres_query_macro
Write and execute SQL queries with ease
-
field_names
A proc-macro for exposing a struct’s field names at runtime
-
docopt_macros
Docopt macro for command line argument parsing
-
jni_fn
JNI-compatible method signature generator
-
rbxm-proc
Internal proc macros for the
rbxmcrate -
lerp_derive
Generic linear interpolation and extrapolation, automatically implemented for a variety of numeric types
-
zisvalidator_derive
Derive macro for zisvalidator
-
klickhouse_derive
proc-macro crate for klickhouse
-
agui_macros
The macro utilities of agui
-
async-proto-derive
Proc-macros for the async-proto crate
-
macrotk
The Rust macro toolkit
-
rsmnl-derive
procedural macro for rsmnl
-
try-catch
A simple proc-macro that enables try-catch for Rust with automatic downcasting of error types
-
sea-strum_macros
Helpful macros for working with enums and strings
-
alipay_derive
alipay-rs macro
-
env_derive
env_derive is macro of env_rs
-
function-frame
Procedural macro to wrap any function outputs within a text frame
-
color-print-proc-macro
Implementation for the package color-print
-
vertigo-macro
Virtual DOM library for Rust - macros for html and fetch
-
typed-sql-derive
Macro implementation for typed-sql
-
xops_macros
procedural macro implementations for xops
-
fixed_typemap_macros
Internals for the fixed_typemap crate
-
fieldmask_derive
derive macros for the fieldmask crate
-
casey
Case transforming macros for ident tokens
-
rsrl_derive
Macros for RSRL
-
adminix_macro
macro for adminix
-
ts3_derive
Derive macro for ts3 crate
-
defunctionalize-proc-macro
Defunctionalization as a proc-macro over modules
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
z3d
Z3 DSL interface for Rust
-
fehler-macros
Macros des Fehlers
-
no-panic
Attribute macro to require that the compiler prove a function can’t ever panic
-
c-like-concat
simple macro that works just like C’s ##
-
zerogc-derive
Procedural derive for zerogc’s garbage collection
-
ifmt-impl
Implementation detail of the ifmt crate
-
ormx-macros
lightweight procedural macros bringing orm-like features to sqlx
-
cherry-derive
An asynchronous ORM, support MySQL, PostgreSQL, SQLite and SQL Server
-
qualia_derive
Derive macros for Qualia
-
holium-macro
Procedural macro for the Holium Rust SDK
-
syn_util
helper APIs for procedural macros
-
address-cmp
An attribute for address comparison
-
expression_format_impl
macros implementation for crate expression_format
-
specs_declaration
A simple macro to effectively create SPECS systems
-
fast-map-derive
Maplike using match
-
argio-macro
A macro to convert function input and output to stdio
-
zoet-macro
Implementation detail for
#[zoet]macro -
parse-variants
Derive the syn::parse::Parse trait for enumerations and use it to comfortably parse a variant of the enumeration
-
proc-macro-hack-impl
Procedural functionlike!() macros using only Macros 1.1
-
evmap-derive
Derive macro for evmap::ShallowCopy
-
dims_derive
Derive macros for Generating Systems of Units
-
aper_derive
Synchronized state machines over WebSockets
-
open-metrics-client-derive-text-encode
Auxiliary crate to derive text Encode trait from open-metrics-client
-
pacaptr-macros
Implementation of several macros used in pacaptr
-
fixed-macro-impl
Proc-macro implementation for the
fixed-macrocrate -
ord_by_key
Provides a convenient macro for implementing Ord trait with logic specified in an inline expression
-
c2rust-bitfields-derive
C-compatible struct bitfield derive implementation used in the C2Rust project
-
scpi_derive
SCPI/IEEE488.2 parser support library
-
jsonrpc_client_macro
Internal proc-macro crate for
jsonrpc_client -
tl-proto-proc
A collection of traits for working with TL serialization/deserialization
-
elfo-macros
Macros for matching and deriving messages
-
net-literals
Literals for IP/socket addresses
-
enum_to_enum_derive
Derive macro implementation for enum_to_enum. enum_to_enum derives possibly effectful conversions between enums.
-
ergo-pin
Ergonomic stack pinning
-
coi-derive
coi-derive provides procedural macros for coi
-
hirpdag_derive
Procedural macro for generating hirpdag boilerplate. See hirpdag crate.
-
jump-kun-macros
A crate for jump-kun. Parses jump-kun config file and creates fucntions.
-
winit-main-proc
Proc macros for winit-main
-
toml-cfg
A procedural macro for configuring constant values across crates
-
percy-css-macro
A macro for writing your CSS next to your views
-
canadensis_macro
A procedural macro that generates Rust data types and serialization code from inline and/or external AVCAN DSDL files
-
paw-attributes
Proc Macro attributes for the Paw crate
-
partial-application-rs
A macro to transform functions into partially applicable structs
-
quartz_nbt_macros
This crate contains the function-like procedural macro which parses quartz_nbt’s compact compound format
-
assets_manager_macros
Procedural macros for assets_manager
-
relational_types_procmacro
Procmacro to help create relations between objects
-
sszb_derive
Procedural derive macros to accompany the sszb crate
-
xml-schema-derive
Structure generator from XSD source file
-
microserde-derive
Derive macros for microserde. Use the re-exports from the microserde crate instead.
-
sanitizeable_derive
derive structs without certain fields
-
inline-rust
A stupid macro that compiles and executes Rust and spits the output directly into your Rust code
-
sppparse_derive
Derive macro for Sppparse
-
comprehension
Iterator comprehension in Rust
-
makero
A
macro_rules!macro to aid in the creation of complexmacro_rules!macros -
defaults
A better
Defaultderive macro -
unquote
A reverse quote macro… that is: A macro to parse input from a ParseStream according to a given pattern.
-
packable-derive
Derive macro for the
packablecrate -
pg_mapper
derive
TryFrom<tokio_postgres::Row> -
test-span-macro
macro to do snapshot tests on tracing spans, usint test-span
-
optargs-macro
Macros for the optargs crate
-
microtype-macro
Proc macro for generating microtypes
-
variantly
Derive helper methods for enum variants that are familiar from
std::option::Option&std::result::Resultsuch asunwrap_ororand_then -
unsafe-storage
Maintain invariants in macros without modules
-
cain
Procedural macro to transform sequential branches into nested branches
-
flag-mast-derive
Ergonomic Rust bit flags
-
de-ref
DErive deREF
-
enum-lexer
A proc_macro lexer generator. using
enum-like syntax. -
prae_macro
A proc macro for the
praecrate. Should not be used directly. -
suricata-derive
Derive macros for Suricata
-
hrpc-proc-macro
Proc macros for hRPC
-
penguin-config-derive
See penguin-config
-
macroscope-macro
An implementation detail of the macroscope library
-
actori_derive
Actor framework for Rust
-
replman_derive
An opinionated REPL framework
-
into-attr-derive
The macros helping to convert the structure into graphviz dot attrivute
-
auto-add-lifetimes-to-impl
Automatically add lifetimes to impl given the trait, structure or any arguments have lifetime arguments. Mainly for use in macros
-
fuzzy-pickles-derive
Procedural macros for fuzzy-pickles
-
custom_debug_derive
Derive Debug with a custom format per field
-
bl602-macros
Macros for BL602 IoT SDK
-
constrainer
An attempt to bring CAD concepts of constraints to variables in order to significantly reduce redundant instructions
-
pijul-macros
Macros used to write libpijul
-
ntex-macros
ntex proc macros
-
alkahest-proc
Procedural macros for ‘alkahest-proc’ crate
-
from_variants_impl
Internal helper crate for from_variants crate
-
lemmy_apub_lib_derive
A link aggregator for the fediverse
-
mocktopus_macros
Mocktopus procedural macros
-
point-derive
Proc macro to help with struct to ts point conversion
-
decorators
A macro for generating decorator methods
-
default-boxed-derive
Custom derive for default-boxed
-
descriptor_derive
A simple to use struct descriptor, derive crate
-
tlayuda
A derive procedural macro for structs that adds a static method that generates instances of the struct with minimal configuration
-
metriki-macros
Macros for metriki
-
sm-ext-derive
Procedural macro package for sm-ext helpers
-
packed_struct_codegen
This crate implements the code generation for the packed_struct library
-
simavr-section-macro
Internal implementation details of the simavr-section crate
-
atomecs-derive
Derive macros for atomecs
-
coil_proc_macro
This library should not be used directly, it is re-exported through coil
-
rtea-proc
Internal macro crate for rtea
-
malloc_size_of_derive
Crate for Firefox memory reporting, not intended for external use
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
fstrings-rust-proc-macro
Python3 fstring interpolation in Rust
-
lucene_query_builder_rs_derive
This crate is used internally by lucene_query_builder
-
muta-codec-derive
Muta fixed codec derive procedural macros
-
fail_on_ci
Script to abort compilation if one of the known CI-Servers is detected
-
telegraf_derive
Derive macros for the telegraf-rust library
-
quote_precise
A quote implementation that preserves meaningful span locations
-
pocket_prover-derive
Derive procedural macros for
pocket_prover -
configr_derive
The dead easy way to use config files in your project
-
reql-macros
Macros for the reql crate
-
convert_by_name
Derive From and Into for structs and enums based on field and variant names
-
rocket-config-codegen
Procedural macros for the rocket-config library
-
indoc-impl
Indented document literals
-
ptr_meta_derive
Macros for ptr_meta
-
buffering_nocopy_macro
A proc-macro crate for buffering
-
validated_struct_macros
Macros for validated_struct
-
derive-aktor
Create actors in rust with a derive macro
-
join_export
Exports of the
join!,join_async!,join_spawn!,join_async_spawn!,async_spawn!macros which are reexported byjoincrate -
dont-expand
Dummy macros to shadow macros to avoid expansion in cargo expand
-
loupe-derive
Profiling tool for Rust, see the
loupecrate -
attributes
Procedural macros for command creation with rusty-interaction
-
sqlx-model-macros
sqlx model macro
-
clickhouse-derive
A macro for deriving clickhouse::Row
-
scraper-macros
Macros implementation of #[derive(Scraper)]
-
best_macros
This crate was created for optimize coding in RUST
-
from_value_derive
Implement impl Form<CustomStruct> for serde_json::Value
-
rocket_sync_db_pools_codegen
Procedural macros for rocket_sync_db_pools
-
ssz_rs_derive
utility crate for deriving simple serialize implementations
-
byewlma-macros
Macros for
byewlma -
endiannezz_derive
Addition to endiannezz crate that allows derive(Io)
-
rustacuda_derive
Custom Derive Macro for RustaCUDA
-
solana-sdk-macro-frozen-abi
Solana SDK Macro frozen abi
-
typetrait
Helper macro to generate types for typestate programming
-
sqlstate-macros
Procedural macros for sqlstate
-
entity_noop_macros
Macro library that provides noop macros for entity re-exports
-
near-units-macro
Macro for parsing strings literals of NEAR units
-
logfn
provides the logfn attribute macro for inserting logging code into your function
-
sixtyfps-corelib-macros
Helper macro for sixtyfps-corelib
-
pio-proc
proc-macro for assembling PIO code in a Rust program at compile time
-
panda-re-macros
Macros needed for the
panda-relibrary -
rg3d-core-derive
Proc-macro for the Visit trait
-
ceres-derive
derive macros for ceres
-
huber-procmacro
Interal package used by Huber
-
try-let
Proc macro for a basic try-let form
-
drop_struct_macro_derive
A derive macro to free (drop) memory for structs that are used in the FFI
-
accel-derive
Procedual macro for writing GPGPU kernel
-
gll-macros
Macros used with the gll crate
-
func_trace
A procedural macro for tracing the execution of functions
-
wasmyon-macro-support
Provides macro support for the main wasmyon crate
-
rlua-builders-derive
Derive helpers for struct/enum for rlua
-
arctk-proc
Procedural macro support library for the ARCTK crate
-
modus_ponens_derive
Library to develop forward chaining inference engines
-
mjb_gc_derive
Derive macro for mbartlett21’s mjb_gc crate
-
ethercat-derive
Automatic deriving of traits in the ethercat-plc crate
-
pm-lexer
This is a sample lexer using the proc-macro crate, to be used in the pomelo testings
-
turbolift_macros
macros for turbolift
-
rkyv_typename_derive
Derive macro for rkyv_typename
-
rtlola-macros
Procedural macros for more convenient handling of HirModes in the rtlola_hir crate
-
either_trait_macro
An attribute-like macro to implement traits for Either
-
structsy-derive
Structsy single file struct database persistent derive implementation
-
verilated-module
A procedural macro for replacing verilated marked up structs with include of generated code
-
compile_ops
Compile time operations to not affect your performance and constness with ecuations you can encode
-
nodex-macros
nodex macros
-
formy_derive
Derive macro implementation for ‘formy’
-
procmac
modulo de agregados mac
-
cell-map-macro
Macros for the cell-map crate
-
aversion-macros
macros to support the aversion crate
-
influxdb2-structmap-derive
Proc derive macro for structmap crate
-
pin-init-internal
Internal implementation details of crate
pin_init -
embarkstudios/spirv-std-macros
Macros for spirv-std
-
simple_calculator_deliver
deliver library for simple_calculator_cmd
-
wayk_proto_derive
derive macros for Encode and Decode traits from wayk_proto
-
view_macro
a macro for constructing views
-
is-same-derive
Derive proc macro for the is-same crate
-
inherent-pub
Mark methods in
impl Trait for Typeblocks inherent to the type -
derive-system
Rust implementation of https://github.com/stuartsierra/component
-
flatk-derive
Derive macros for deriving traits for flatk
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
weblog-proc-macro
weblog is a crate that defines a set of macros for calling
console.log()and other members of the browser’s console API when targeting Wasm -
log-attributes
A set of function log attributes, that make logging function in- and outputs a charm
-
indirect-once-derive
One-time resolvable runtime indirection in the style of glibc’s ifunc
-
alacritty_config_derive
Failure resistant deserialization derive
-
actix_responder_macro
An attribute macro to transform a response struct to an actix responder
-
new-home-application-macro
Provides a derive macro for the Method in the new-home-application framework
-
physx-macros
Utility macros used internally by the physx crate
-
yew-component
A simple macro to generate yew components from a single struct declaration
-
lock_order
Utility macro for helping produce a deterministic lock ordering to prevent deadlocks
-
bma-benchmark-proc
Procedure macros for bma-benchmark
-
alloc_counter_macro
The #[no_alloc] macro for the alloc_counter crate
-
asn1-rs-impl
Implementation details for the
asn1-rscrate -
postfix-macros-impl
Proc macro crate for postfix-macros
-
jmespath-macros
Statically compiles JMESPath expressions
-
typename_derive
Derive plugin for the typename crate
-
wrapcenum-derive
Derive macro for nvml-wrapper, not for general use
-
lpu-macros
Macros used for lego-powered-up
-
deq_macros
Deq macros
-
confql-proc-macro
Procedural macro for creating GraphQL server from yaml file trees and a schema
-
cdds_derive
Derive macros for cyclonedds-rs
-
from_variant
Automatically derive From impls for enums
-
membrane_macro
A companion crate for
membrane -
if_empty_derive
Proc macro to generate if_empty for types that have is_empty implemented
-
sqlx-models-proc-macro
A helper crate for
sqlx-models -
stdf-record-derive
Procedural macros supporting the
stdfcrate -
segsource-derive
Derive implementations for
segsource. You should usesegsourceinstead. -
diesel_as_jsonb
Use your structs as Jsonb with diesel and PG
-
bitstream_reader_derive
Reading bit sequences from a byte slice
-
tttr-toolbox-proc-macros
Proc macros for ttt-toolbox
-
headers-derive
derive(Header)
-
iterator_item_macros
proc macros for the iterator_item crate
-
ed2-derive
Derive macros for the ed2 crate
-
checked_expr
a procedural macro for making writing checked_* chains more ergonomic
-
jet-proto-proc-macros
A library of proc macros for helping with writing solana programs
-
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
alt_serde_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
enum-methods
Generates methods for each enum variant
-
easy_proc_macro
Rust’s last proc-macro crate
-
gcmodule_derive
Generate code to implement Trace trait on structures
-
lovm2_internals
a lightweight virtual machine with a focus on simplicity and extendability
-
ligen-c-macro
C binding generator
-
opaque_typedef_macros
Supports defining opaque typedefs
-
arg-derive
Derive for arg crate
-
displaythis-impl
Implementation detail of the
displaythiscrate -
pl-lens-derive
Provides procedural
derivemacros that are used in conjuction with thepl-lenscrate -
hecs-component-provider-macros
Internal code for an extension to the hecs ECS library. Use https://crates.io/crates/hecs-component-provider in your code.
-
forward_goto
Crate bringing gotos to Rust
-
netxbuilder
netx builder assembly
-
yatt_orm_derive
Yet Another Task Tracker
-
extends-rs
rust extends impl a macro attr
-
entrance_derive
A crate which provides derive macros for the crate entrance
-
zeronet_sign_derive
ZeroNet content signing
-
polyhorn-ui-macros
Procedural macros for Polyhorn UI that turn a CSS-like specification into style structs
-
vk-shader-macros-impl
Implementation detail of vk-shader-macros
-
masala
Automatic curry. Yum!
-
ext-trait-proc_macros
Internal: proc-macro backend of ::ext_trait
-
katexit
Insert KaTeX autorender script into rustdoc
-
boolenum
Derive From and Into for your boolean enums
-
ops-derive
Derive macros for std::ops
-
safe-regex-macro
Macro for the safe-regex package
-
deranged-macros
Ranged integers
-
serde-versions-derive
An attribute macro for adding a version byte when serializing a struct via Serde. Also allows deseraializing while removing version byte.
-
df_rocket_okapi_codegen
Macros supporting rocket_okapi, used in DF Storyteller project
-
const-default-derive
#[derive(ConstDefault)]
-
lexpr-macros
Internal crate implementing macros exposed by the
lexprcrate -
mutview
Derive macro for zordon crate
-
rustpub-macro
macros for the rustpub crate
-
finite_repr_derive
Proc Macro for the finite_repr crate
-
syn-helpers
Framework for building derive macros
-
binreader-macros
Proc macros used by/for binreader
-
redis-lua-macro
Macro component of Redis Lua scripting helper
-
rayon-join-macro
A convenience n-nary macro around
rayon::join() -
everyday_macros
This crate 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.
-
auxtools-impl
procedural macros for use with the auxtools crate
-
embedded-error-chain-macros
Procedural macros of the
embedded-error-chaincrate -
ambassador
Trait implementation delegation via procedural macros
-
pmhelp
A WIP library to assist in the creation of procedural macros
-
zhi_enum_derive
derive macros to easily use enum
-
mathml-macros
Macros for mathml-rs
-
msfs_derive
This crate provides macros for MSFS
-
amper_mac
proc macro crate of amper crate
-
nommy_derive
derive(Parse)
-
transmute-tools
Proc macros and traits to assist with safely creating transmutable data structures
-
derive_jface
Java Native Interface to rust Native Objects (derive)
-
aleo-std-timed
A profiler to conveniently time function executions
-
qtpl-macros
Macro component of qtpl. Use qtpl instead of this package directly.
-
xflags-macros
Private implementation details of xflags
-
toql_query_macro
Library with query macro for Toql
-
machine_uuid
A library to retrieve a machines UUID
-
unicode_names2_macros
Support macros for
unicode_names2 -
zone_cfg_derive
Rust bindings for Zone management (proc macro generation helper)
-
macro_io
Rust package that contains procedural macros to do IO during compile time
-
pegtastic-macros
Procedural macros for pegtastic. To use pegtastic, see the
pegtasticcrate. -
xaynet-macros
Macros for internal use in
xaynet-server -
macro-compose
macro-compose is a library trying to simplify and organize proc-macros
-
ansi-colors-macro
A proc-macro for creating ANSI colored strings at compile time
-
update-sync_derive
Derive macros for
update-sync. DO NOT CONSUME DIRECTLY -
bonfida-macros
Bonfida-utils macros
-
oapi_derive
Derive macro for OApi
-
small_ctor
A minimal, dependency free version of the ctor crate
-
carbide_derive
A crate providing procedural macros for the carbide library
-
witgen_macro
Macros for witgen which is a library to help you generate wit definitions in a wit file for WebAssembly
-
tracers-macros-hack
Do not reference this crate directly; see the “tracers” crate for further instructions. This crate contains the actual
proc-macro=truecrate which implements the probing macros. Because the… -
mouscache_derive
A utility crate implement trait to store object either in redis or in memory
-
column_store_proc_macros
Procedural macros for crate column_store
-
remote-trait-object-macro
Macro that expands a Rust trait to a remote-trait-object service
-
savory-derive
Custom derive support for savory crates
-
nova-macro
Implementation for nova crate
-
sierra-proc
Procedural macros for ‘sierra’ crate
-
min_max_macros
Macros for nicer min()/max()
-
cust_derive
Macros for cust
-
ggplot-derive
derive(Merge) for GGPlot
-
thisctx_impl
Macro implementation of the
thisctxcrate -
cutlass
Macro based library to take the boilerplate out of configuration handling
-
apply_pub
A Rust syntax extension for applying the
pubvisibility modifer to many items at once -
prusto-macros
prusto macros
-
actix-signal-derive
Derive macro implementation for actix-signal
-
windows_winmd_macros
Macro helpers for the windows_winmd crate
-
rust_hawktracer_proc_macro
helper crate for hawktracer profiling library
-
uni_components_macro
Macroses for uni_components crate
-
pathsep
a small macro to enable easy path construction in other macro calls
-
deltastruct_proc
The proc-macro backend for the crate Deltastruct
-
ffi-convert-derive
Macros implementations of CReprOf, AsRust, CDrop traits from ffi-convert
-
ever-macro
Helper macro for
ever, which prints the build information with minimal boilerplate -
funtime
A proc-macro helper to time Rust functions
-
devault
A more flexible alternative to deriving Default
-
display-as-proc-macro
A helper crate for display-as-template
-
aide-macros
Macros for the Aide library
-
lamedh_attributes
Lambda macro attributes
-
trans-derive
Serialization protocol for inter-language communication (derive macros)
-
const-table
Associate struct-typed constants with enum variants
-
const_internals
Internal macros for the constant crate. Not for external use!
-
discrab_codegen
proc macros for Discrab (a discord bot wrapper)
-
megenginelite-derive
A safe megenginelite wrapper in Rust
-
tiny-rpc-macros
Proc-macros for tiny-rpc
-
jnix
High-level extensions to help with the usage of JNI in Rust code
-
ogma-macros
Ogma DSL builder libs
-
trans-schema-derive
Generating trans code from Rust into other languages (derive macros)
-
destruct-derive
Destruct structs and enums for simpler combinator implementation
-
derive_pod
Implement the Pod trait safely with a derive macro
-
bit-by-bit
Convenient proc-macro for defining structs with bitfields
-
templing
Minimal templating engine
-
derive-collect-docs
Collect documentation from Rust structs using a
CollectDocsderive macro -
lv2-urid-derive
Procedural macros for lv2-urid
-
get-random-const
Simple compile-time random generator
-
peek-poke-derive
Derive macro for peek-poke
-
autodefault
A proc macro that automatically inserts
..Default::default()into your struct literals -
from_tuple
Derive structs from tuples
-
awesome-glib
Bunch of macros to make a life of gtk/glib user easier
-
ff_derive-zeroize
Procedural macro library used to build custom prime field implementations
-
neo-mime-macro
mime procedural macros
-
const_num_bigint_derive
const bigint
-
pbni-codegen
PBNI for Rust Codegen
-
mauzi_macros
Helper crate for ‘mauzi’. Use ‘mauzi’ directly please.
-
amethyst_derive
Amethyst derive
-
big_enum_set_derive
An internal helper crate for big_enum_set. Not public API.
-
sea-orm-rocket-codegen
Procedural macros for sea_orm_rocket
-
tracing-forest-macros
Macros for tracing-forest
-
orga-macros
Macros for the orga crate
-
ebpf-kern-macros
Kernel space macros for libbpf
-
extprim_literals_macros
Internal crate to support
extprim_literals. You typically don’t need this crate directly. -
cassandra_macro_derive
Macros 1.1 implementation of #[derive(Cassandra)]
-
mod_expand
Macro to expand a module namespace over an expression
-
canrun_codegen
Procedural macros used by the Canrun crate
-
crayfish-trace-macros
Crayfish trace macros
-
overloadf_derive
unlock function overloading for rust
-
norpc-macros
Code generator for norpc
-
structscan_derive
Macro implementation of #[derive(UserSubmittable)]
-
col_proc_macros
A bunch of procedural macros for declare collections of various kinds from their contents as fast as possible
-
include-repo
This crate implements the ‘include_repo!’ macro for easy AGPL compliance! Include a tarball as a const in your code!
-
capsule-macros
Capsule procedural macros
-
cmd_lib_cf_macros
Common rust commandline macros and utils, to write shell script like tasks easily
-
inherent
Make trait methods callable without the trait in scope
-
abistr-macros
proc macro implementations for abistr
-
lrpc-macros
lrpc’s proc macros
-
fast-rustc-ap-rustc_macros
Automatically published version of the package
rustc_macrosin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
futures-join-macro-preview
Definition of the
join!macro and thetry_join!macro -
ni-fpga-macros
Macros to be used with the ni-fpga crate
-
foreign-types-macros
An internal crate used by foreign-types
-
rusty_v8_helper_derive
A rust derive macro for rusty_v8_helper
-
rustify_derive
A derive macro for implementing an Endpoint for rustify
-
geobacter-runtime-amd-macros
Geobacter AMDGPU specific derive macros
-
hobo_css_macros
hobo is a Rust frontend framework
-
typed-qb-procmacro
Procmacros for typed-qb
-
eagre-asn1
A asn1 library, currently only supporting DER
-
proc-macro-kwargs-derive
Procedural derive for proc-macro-kwargs
-
libvmm_macros
Virtual Machine Monitor macros
-
cuach-derive
A HTML template system for Rust
-
automato
a crate to generate state machines enforced at compile time
-
controlled-option-macros
Procedural macros for the controlled-option crate
-
machinery-macros
Macro utilities for the
machineryandmachinery-apicrates -
show-image-macros
macros for the show-image crate
-
unitval-derive
Provide values for unit enum variants
-
derive_constructor
Construct enums without naming them
-
err-gen
Error-generation macro for hierarchical actor design
-
portus_export
Procedural macro for use with portus, CCP congestion control algorithms
-
convert-js-macros
macros for convert-js
-
newt_proc_macros
Proc macros for newt-rs
-
smol-potat-macro
Proc macro for smol runtime
-
mendes-macros
Macros for mendes web toolkit
-
scanfmt_macros
Procedural macro for scanfmt
-
notation_dsl
Fun notation - DSL to create notation files
-
rubber_duck_macro
The proc macros for the rubber-duck crate (macros for building named-arg functions)
-
structmeta-derive
derive macro for structmeta crate
-
oxlex-derive
Derive component for oxlex
-
const_env--value
Configure const and static items by environment variables
-
structype_derive
A derive macro crate that lets you view an allowed type’s fields and will let you over-ride it
-
shipyard_proc
Crate providing attribute macro to Shipyard
-
mdbx-proc
mdbx proc macro
-
steam-language-gen-derive
Implementation detail of
steam-language-gencrate -
simd_helpers
Helpers to write more compact simd code
-
grb-macro
Procedural macros for the grb crate
-
configurs_derive
Macro implementations for configurs, the configuration loader for Rust apps
-
cargho_derive
Derive-based argument parser optimized for being up to date in crates.io
-
aeiou-macros
Algebraic effects derive macro
-
gluon-salsa-macros
Procedural macros for the salsa crate
-
fbinit_macros
Provides macros for fbinit crate
-
shredder_derive
Backing derives for the shredder library
-
aoc_macros
helper macros for AoC
-
bart_derive
#[derive(BartDisplay)] implementation for supporting the bart package
-
bitpatterns-proc-macro
Procedural macros used by the bitpatterns crate
-
syn-pub-items
Parser for Rust source code (patched for pub items)
-
argser-macros
Provides the Macros for the Argser-Crate
-
node_api_macro
Write Node.js native addons with Node-API in Rust
-
error_spanned_derive
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.
-
genco-derive
Quote macro for the even simpler code generation for Rust
-
watt
Runtime for executing Rust procedural macros compiled as WebAssembly
-
polygraph-macro
A multiple-interconnected graph library or in-memory relational database (proc-macro implementation)
-
ppc750cl-macros
Procedural macros for powerpc750cl
-
display_json_derive
Procedural macros for implementing Display and Debug with serde_json::to_string and serde_json::to_string_pretty
-
sp-version-proc-macro
Macro for defining a runtime version
-
crossbundle-derive
Cross-Platform Rust Toolkit for Games 🏹
-
inline-python-macros
Macros for the inline-python crate
-
geoip2-codegen
geoip2 macros
-
async_static
A macro for declaring async lazily evaluated statics in Rust
-
worker-macros
Macros to support the
workercrate and remove FFI boilerplate / conversion from user code -
simd-json-derive-int
procmacros for simd-json-derive
-
validated_struct
Easily generate nested structures with getters and predicated setters
-
syn-impersonated
Parser for Rust source code
-
pgc-derive
Garbage collector derive plugin for pgc
-
roxido_macro
Macros to support the roxido crate
-
bencher-macro
A benchmark library
-
outer_attribute
A library providiving
OuterAttributethat implementssyn::parse::Parsetrait -
format-bytes-macros
Macros for the format-bytes crate
-
dyn-clonable-impl
Attribute wrapper for dyn-clone
-
address-literal
Procedural macro for converting Address(H160) literals to Address(H160) at compile time
-
memoise
Simple memoization library for rust
-
arctk-attr
Attribute macro support library for the ARCTK crate
-
verify-macros
Procedural macros for the Verify library
-
aqua_parse_macro
The macro used in ‘aqua_parse’
-
trace2
A proc macro for tracing the execution of functions, similar to trace crate, but thread safe and use log
-
uptown_funk_macro
Helper macro for the uptown_funk crate
-
discriminant_hash_derive
Derive macro to implement Hash trait based on enum’s discriminants only and ignore variant’s fields
-
rocketjson_macro
Crate for working with Json and Rocket
-
duktape-macros
duktape bindings macros
-
command-macros-plugin
Implementation crate for command-macros
-
mockalloc-macros
Procedural macro attribute for the mockalloc crate
-
starchart-derive
Derive macros used by the starchart crate
-
lockjaw_processor
proc_macro processor for lockjaw
-
char-lex-macro
Create easy enum based lexers
-
clapi_macros
Macros for clapi
-
standalone-quote
Fork of quote that allows disabling the proc-macro feature in proc-macro2 so as to remove the rustc dylib dependency
-
mwt
proc macros for generating mut and non-mut methods without duplicating code
-
structdoc-derive
Extract structure and documentation from structs (derive support)
-
embeddir
A macro for embedding all files in a directory into the executable
-
rclrust-msg-gen
TODO
-
ffi-gen-macro
ffi-gen macro
-
pallet-contracts-proc-macro
Procedural macros used in pallet_contracts
-
zipkin-macros
Macros for use with
zipkin -
mux-stream-macros
Internals of mux-stream
-
mark_tuple_traits
a proc_macro for marking tuples of length up to 32 with a single marker trait to bypass the ‘fundamental’ feature
-
tetsy-util-mem-derive
Tetsy Common Crate for Memory Reporting
-
swarm-bot-packets-macro
Packet macros for swarm bot
-
derive-ocaml
Custom derive and procedural macros for easy FFI with ocaml on top of the ocaml crate
-
count-tys
Function-like procedural macro that accepts a comma-delimited :ty TokenTree sequence and returns their count as a constant usize
-
arcon_macros
Macros for Arcon
-
partialdebug-derive
macros for partialdebug
-
meshx-derive
Derive macros for meshx
-
urid-derive
Procedural macros for urid
-
iffy
proc macro for simulating the ternary operator from C-like languages
-
act-zero-macro
Procedural macros for act-zero
-
include_wgsl
A tiny proc macro to include a WGSL file in your binary, and verify that it is valid at compile time
-
dill-impl
Implementation details of the dill DI library
-
quix-derive
Derive macro for generation quix::ProcessDispatch
-
ltv_derive_impl
Internal crate for ltv_derive
-
iterate-proc-macro
Support crate for
iterate -
toql_role_expr_macro
Library with role expression macro for Toql
-
looking-glass-derive
looking-glass is a reflection & type-erasure library for Rust
-
derive_display_from_debug
A trivial Rust macro to derive the Display trait for any type with the Debug trait
-
macrotk-derive
macrotk core derive macros
-
holium-backend
Backend crate for the Holium Rust SDK procedural macro
-
tonic_catch_proc
catch any tonic await error convert into Status
-
ctjs_macros
compile time javascript as a rust proc macro
-
pinwheel_elements_macro
Build web applications with Rust
-
specit
Spec “it” for Rust testing
-
algoliasearch
Algolia client
-
xdr-rs-serialize-derive
XDR object serialization for Rust
-
cenum-derive
A rust derive macro for C-style primitive enums
-
named_constants
Procedural macro makes enums behave like named constants in languages like C/C++ or C#
-
unique-type-id-derive
A unique id proc-macro generator for types
-
quartz_commands_macros
This crate contains the function-like procedural macro which parses quartz_commands’s custom syntax
-
syn_str
This library is what syn is to proc_macro::TokenStream for proc_macro::TokenStream::to_string,quote! being format! with String::parse::
-
safe_attr
An attribute #[safe] to mark functions, allowing the ommission of unsafe
-
casco
CSS-like parser for procedural macros
-
azul-peek-poke-derive
Derive macro for peek-poke
-
enum_default
enum_default provides an EnumDefault derive macro that provides a std::Default implementation for Enums by using the first value or specifying a #[default] attribute
-
ligen-macro
Language Interface Generator Core
-
frunk-enum-derive
Derive macros to implement the frunk::LabelledGeneric trait on enums
-
stateroom-wasm-macro
A macro for building a Stateroom service as a WebAssembly module
-
qt_macros
Macros for Qt
-
illicit-macro
procedural macros for the illicit crate
-
html-to-string-macro
simple html to string macro powered by syn-rsx
-
rutenspitz_macro
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
hashmap_derive
A proc_macro to derive the FromMap trait
-
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
mini-internal
Derive macros for miniserde. Use the re-exports from the miniserde crate instead.
-
lombok
Lombok port for Rust
-
enum_pipeline_derive
Provides derive macros for enum_pipeline
-
ast2str-derive
A crate for pretty-printing ASTs and other recursive data structures
-
hoax
Simple procedural macro crate that “hides” any string literal in a plain sight
-
serde-diff-derive
Derives serde_diff::SerdeDiff
-
nop-json-derive
Helper crate for internal use in nop-json
-
atomig-macro
Defines procedural macros for the crate
atomig. Please see the main crate. -
serde-enum-str
Serialize and deserialize enum string
-
qu-derive
internal part of qu crate
-
bytes-cast-derive
Safely re-interpreting &[u8] bytes as custom structs without copying, for efficiently reading structured binary data. Procedural macro for compile-time soundness checking.
-
derive_codec_sv2
Derive macro for Sv2 binary format serializer and deserializer
-
yade
Yet Another Derive Error
-
typic-derive
Type-safe transmutations between layout-compatible types
-
skidscan-macros
Proc macros for skidscan
-
col_proc_macros_impl
The implementation crate of macros marked with the proc-macro-hack derive macro
-
rokol_derive
Derive crate for Rokol
-
smelter
Custom derive attribute that automatically derives builder methods
-
derive-syn-parse
Derive macro for
syn::parse::Parse -
tojson_macros
A simple syntax extension generates default ToJson impl
-
fluvio-test-derive
Procedure macro to run async fn as test
-
bigml_derive
Internal
derivesupport for unofficial BigML client bindings -
asn_codecs_derive
ASN.1 Codecs derive Macros
-
elastic_derive
Compile-time code generation for Elasticsearch type implementations
-
rosrust_codegen
Message generation for rosrust
-
ux-macro
Backend agnostic GUI framework
-
dtd-macro
A DTD file parser
-
proc-caesar
Procedural macro to break Rust IDEs
-
winspawn-macro
Proc macros for building winspawn
-
telexide_fork_proc_macros
(fork) macros for subscribing to events in telexide
-
proc_macro_test
Enable switching between std::sync, tokio::sync and loom::sync
-
thruster-socketio-proc
The proc macros behind the thruster web framework
-
keypath-proc-macros
proc macros for the keypath crate
-
struct_layout
Customize your struct layout with this one weird trick
-
clap_derive-v3
Parse command line argument by defining a struct, derive crate
-
starlark_module
Derive helpers for the starlark package
-
watt-non-static-runtime
Runtime for executing Rust procedural macros compiled as WebAssembly
-
syn-codegen
Syntax tree describing Syn’s syntax tree
-
pl-lens-macros
Temporary crate used to implement the
lens!procedural macro -
rust-ad-core-macros
Rust Auto-Differentiation
-
easy-jsonrpc
Convert a trait definition into a jsonrpc api
-
gxi_macro
proc-macro for writing gxi components
-
def-mod
Simplifies module implementation routing and statically verifies exports
-
prometheus-client-derive-text-encode
Auxiliary crate to derive text Encode trait from prometheus-client
-
router-xiaobei-macro
抄袭的router-rs
-
defunctionalize
Defunctionalization as a proc-macro over modules
-
jsonrpc-v2-macros
Proc macros for jsonrpc-v2
-
enum-lexer-macro
A proc_macro lexer generator. using
enum-like syntax. -
bevy_fallible_derive
Proc macro crate for bevy_fallible
-
verify_macro
An attribute that automatically instruments code with logical type bounds
-
absolution
‘Freedom from
syn’. A lightweight Rust lexer designed for use in bang-style proc macros. -
tari_comms_rpc_macros
RPC service proc macro
-
real_c_string
Generate string parseable in compiled binary
-
fourcc
Syntax extension to generate FourCCs (four-character code)
-
type_hash_macros
Internal macro definitions. They may not work properly if not used via the type_hash crate.
-
standalone-syn
Fork of syn that turns of the proc-macro feature in proc-macro2 and standalone-quote so as to remove the rustc dylib dependency
-
winrt_gen_macros
Macro helpers for the winrt_gen crate
-
include-flate-codegen-exports
Macro codegen for the include-flate crate
-
oasis-amqp-macros
Helper macros for AMQP 1.0 type definitions
-
catinator_macros
proc macros for catinator
-
imm_gc_derive
Derive macro for mbartlett21’s imm_gc crate
-
proc-macro-kwargs
Keyword argument parsing for function-like proc-macros
-
cmd-derive
Macros for the cmd-macro crate
-
pear_codegen
A (codegen) pear is a fruit
-
retrofit_codegen
proc macro crate for retrofit
-
kobold_macros
Macros for the kobold framework
-
cardparse_derive
Fixed width text format parsing to structs
-
erl_nif_macro
Write Erlang and Elixir NIFs in Rust
-
requestty-macro
The
questionsmacro forrequestty -
drone-cortex-m-macros
Procedural macros for drone-cortex-m
-
jlrs-derive
jlrs-derive contains the custom derives offered by jlrs
-
yooper_derive
macros for yooper
-
relm-derive-state
Custom derive required by the relm-state crate
-
optional-fields-serde-macro
Macro for optional-field crate serde integration
-
enum_to_u8_slice_derive
A simple fork of enum_to_str_derive (by @DCjanus), convert enum to u8 slice ref
-
olympia_derive
Olympia is a gameboy emulator and toolkit, intended to run as a native or web assembly application targeting a cycle count accurate emulation. olympia_derive provides a couple of proc…
-
please-clap
Pattern-match against Clap subcommands and arguments
-
models-proc-macro
A helper crate for
models -
tonic-rpc-macro
Core macro for tonic-rpc
-
iroha-derive
Internal derive for Iroha
-
qualify-derive
Simple utility for wrapping derive macros that do not qualify paths properly
-
serde-semver-derive
Derive macro for serde-compatible version checker
-
suspend_fn
macro for implicit await
-
spez-macros
proc_macro crate for spez
-
toql_fields_macro
Library with fields macro for Toql
-
synthez-core
Internal implementations of
synthezcrate -
deluge-rpc-macro
Procedural macros used by the deluge-rpc crate
-
weechat-macro
Procedural macros for the weechat crate
-
decent-serde-json-derive-alternative
A derive proc-macro for the FromJson and ToJson traits defined by the decent-serde-json-alternative crate. It compiles quickly but is not as robust or flexible as the serde_derive proc-macro. Sometimes it is enough.
-
box_shorthand
Rust derive macro to create shorthand functions for initializing boxed enum variant values
-
fyrox-core-derive
Proc-macro for the Visit trait
-
tappet-derive
Implementation detail of the
tappetcrate -
rp1-macros
Macros for RP1
-
unrest_tmp_syn
don’t use
-
from_bytes_derive
create from_bytes() and packed_size() to read binary data into structs
-
diff-enum
A macro library to help defining enum variants by their differences
-
windows_gen_macros
Macro helpers for the windows_gen crate
-
vizz_derive
Derive macro for the Visualize trait
-
python_comm_macros
proc macros for python_comm
-
spa-server-derive
spa-server derive macro
-
actors-macros
Macro crate for Riker actor framework
-
nonparallel
Rust macro for ensuring non-parallel execution of functions
-
finiteelement_macros
A library to create procedural macros that define types implementing FiniteElement
-
readonly
Struct fields that are made read-only accessible to other modules
-
aoc-runner-derive
Codegen for aoc-runner & others
-
mockiato-codegen
Internally used by mockiato for code generation. This crate should never be used directly
-
darpi-code-gen
code generation for the web api framework darpi
-
vertigo-html-macro
Html2Vertigo conversion macro
-
binwrite_derive
Derive macro for binwrite
-
ffishim_derive
Procedural macros for generating ffi-compatible stubs
-
allochronic-util-macros
Private utility macro crate for allochronic and khonsulabs
-
polling-async-trait
A proc macro that creates async methods based on polling methods for your trait
-
jnix-macros
Companion crate to jnix that provides proc-macros for interfacing JNI with Rust
-
rotate-enum
A simple macro that implements prev() and next() methods to an enum
-
nifpga-type-macro
helper macro for nifpga datatype
-
enumn
Convert number to enum
-
cornetto
#[cornetto(manage my config)]
-
byte-strings-proc_macros
Internal: proc-macro backend of ::byte_strings
-
artemis-codegen-proc-macro
Proc macros for the artemis crate
-
binserde_derive
derive implementation for binserde
-
sylt-macro
Proc-macros for developing the sylt programming language
-
comptime
Compile-time code execution (i.e. lightweight proc-macro)
-
smd_macro
A crate for the smd! macro
-
rdxl_static_macros
Macros for RDXL Static Site Generation
-
chekov_macros
CQRS/ES Framework macros
-
medea-macro
Internal macros and codegen for Medea media server project
-
debug_stub_derive
A drop-in replacement for
#[derive(Debug)]that supports replacement values for members which do not implementfmt::Debug. -
mockers_derive
Macro 1.1 implementation for ‘mockers’ mocking library
-
comn-pms
proc macros used in comn
-
async_fn-proc_macros
Collection of helper annotations and macros for concise and yet explicit
async fnsignatures -
ligen-cmake-macro
CMake project generator
-
subplotlib-derive
macros for constructing subplotlib based test suites, typically generated by
subplot codegen -
async-reply-derive
Derive macros for
async-replymessages -
synom
Stripped-down Nom parser used by Syn
-
merfolk_frontend_derive_macros
derive macros for merfolk_frontend_derive
-
distill-serde-importable-derive
Proc macro for SerdeImportables in
distill -
kaitai-macros
Macros for kaitai
-
ra_ap_proc_macro_api
TBD
-
dync-derive
Attribute macros for producing
dynccompatible traits -
ast2str-lib
A crate for pretty-printing ASTs and other recursive data structures
-
parenthesized_c
A library that allows to parse
(C)attribute tokens in#[repr(C)] -
xshell-macros
Private implementation detail of xshell crate
-
scrappy_do_codegen
Macros used by scrappy-do
-
clouseau_macros
Internal dependency of clouseau
-
spanr
A tool for proc-macro authors to visualize the spans on generated code
-
swc_ecma_transforms_macros
Macros for swc_ecma_transforms
-
rnet-macros
Macros for rnet
-
fake_serialize
A rust macro for implementing dummy implementations of the traits serde::Serialize and serde::Deserialize
-
safer_ffi-proc_macro
Procedural macro internals of
::safer_ffi -
macrotk-core
macrotk core types and functions
-
arbitrary-model-tests
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
async-trait-static
async fn in trait for no_std
-
cstr-enum-derive
Derive macros for the cstr-enum crate
-
macroscope
Macroscope makes writing proc macros a breeze
-
samotop-async-trait
Type erasure for async trait methods
-
toql_paths_macro
Library with paths macro for Toql
-
rusteval-derive
macros for rusteval
-
type-layout-derive
Derive macro implementation for type-layout crate
-
wasm-rpc-macros
Expose rust functions as WASM RPC interfaces
-
subxt-macro
Generate types and helpers for interacting with Substrate runtimes
-
proc-test-catalog
Proc macros for test catalog collection, see test-catalog for details
-
mxml
Mixin Markup Language
-
suspend_fn_proc_macro
helper macro for suspend_fn
-
compile-time-run-macro
implementation crate for compile-time-run
-
web-glitz-macros
Procedural macros for the web-glitz crate
-
proper
Derives for converting primitives to and from simple enums and newtype structs
-
union_type
A proc macro to introduce union type into rust
-
stringify-attr
Attribute macros for stringifying
-
xylem-codegen
Codegen backend for xylem
-
drone-riscv-macros
Procedural macros for drone-riscv
-
gs11n_derive
A varint serialization framework for game developing
-
canary-macro
contains canary’s macros
-
serde_int_map_derive
Deriviation of serde Serialize and Deserialize for maps indexed by integers
-
rocket_codegen
Procedural macros for the Rocket web framework
-
enum-variants-strings-derive
Derive macro for converting instances of enums to and from strs using variant names
-
paste-impl
Implementation detail of the
pastecrate -
tensorflow_proto_derive
Procedural macros for tensorflow_proto
-
automod
Pull in every source file in a directory as a module
-
devise_codegen
A library for devising derives and other procedural macros
-
enumber
Provide useful impls on numerical enums
-
auto-trait
Simple macro to generate trait implementation for wrapper types
-
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
-
reign_derive
Opinionated Fullstack Web Framework in Rust
-
inventory-impl
Implementation of macros for the
inventorycrate -
serde_syn
Use serde to parse Rust source code
-
attribution-macros
The macros used by the attribution crate
-
remain
Compile-time checks that an enum, struct, or match is written in sorted order
-
tower-web-macros
Macros for tower-web
-
rhythmc_macros
The compiler macros for rhythmc
-
proc-quote-impl
A procedural macro implementation of quote!
-
robespierre-fw-macros
robespierre - framework macros
-
seq-macro
Macro to repeat sequentially indexed copies of a fragment of code
-
rifgen_attr
To be used only with rifgen
-
structmapper-codegen
A library to help you generate code that mapped one struct to another
-
swc_css_codegen_macros
Internal macro for the css code generator
-
toql_enum_derive
Library with enum derive for toql
-
static-map-macro
Macro to create a stack-alocated map
-
test-impl
A macro for use in testing, to run a test on multiple trait implementations
-
cpp_synmap
Sourcemap and full crate parsing support for
cpp_syn -
golang-type-decl-macro
Golang Type Decl Macro
-
unrest_tmp_synom
don’t use
-
derive_from_as
Traits to Read and write types that implement serde Serialize and deserialize to files
-
sonic_serde_macros
Macros used in sonic_serde_object
-
napi-rs-derive
N-API procedural macros
-
static-reflect-derive-internals
The internal implementation of procedural derive for
static-reflect -
smol-potat-derive
Proc macro for smol runtime