-
syn
Parser for Rust source code
-
proc-macro-error
Almost drop-in replacement to panics in proc-macros
-
quote
Quasi-quoting macro quote!(…)
-
derive_more
Adds #[derive(x)] macros for more traits
-
synstructure
Helper methods and macros for custom derives
-
proc-macro-crate
Replacement for crate (macro_rules keyword) in proc-macros
-
ctor
attribute((constructor)) for Rust
-
proc-macro2
A substitute implementation of the compiler’s
proc_macroAPI to decouple token-based libraries from the procedural macro use case -
strum_macros
Helpful macros for working with enums and strings
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
derive_builder_core
Internal helper library for the derive_builder crate
-
darling
A proc-macro library for reading attributes into structs when implementing custom derives
-
derive_utils
A procedural macro helper for easily writing derive macros for enums
-
delegate
Method delegation with less boilerplate
-
sqlx-macros
Macros for SQLx, the rust SQL toolkit. Not intended to be used directly.
-
indoc
Indented document literals
-
enum-as-inner
A proc-macro for deriving inner field accessor functions on enums
-
serde_tokenstream
A serde deserializer for proc-macro TokenStreams
-
miette-derive
Derive macros for miette. Like
thiserrorfor Diagnostics. -
fltk-derive
Rust bindings for the FLTK GUI library
-
relm-derive
Custom derive required by the relm crate
-
dynasm
A plugin for assembling code at runtime. Combined with the runtime crate dynasmrt it can be used to write JIT compilers easily.
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
napi-derive
N-API procedural macros
-
maybe-async
A procedure macro to unify SYNC and ASYNC implementation
-
serde_repr
Derive Serialize and Deserialize that delegates to the underlying repr of a C-like enum
-
glib-macros
Rust bindings for the GLib library, proc macros crate
-
rkyv_derive
Derive macro for rkyv
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
safe-quote
A fork of
quotecrate that addsforbid(unsafe_code)and depends onsafe-proc-macro2instead ofproc-macro2 -
derive-new
#[derive(new)]implements simple constructor functions for structs and enums -
casper-node-macros
A macro to create reactor implementations for the casper-node
-
proc-macro-error-attr
Attribute macro for proc-macro-error crate
-
quickcheck_macros
A macro attribute for quickcheck
-
expander
Expands proc macro output to a file, to enable easier debugging
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
juniper_codegen
Internal custom derive trait for Juniper GraphQL
-
tabled_derive
Derive macros which is used by tabled crate
-
schemars_derive
Macros for #[derive(JsonSchema)], for use with schemars
-
cmd_lib_macros
Common rust commandline macros and utils, to write shell script like tasks easily
-
native-windows-derive
A very light and simple rust GUI library
-
contracts
Design-by-contract attributes
-
ts-rs-macros
derive macro for ts-rs
-
cstr
Macro for building static CStr reference
-
com_macros_support
Support library for COM crate macros
-
is-macro
Easily create methods for to use yout custom enum like Option / Result
-
soa_derive_internal
Internal implementation crate for soa-derive
-
defmt-macros
defmt macros
-
argh_derive
Derive-based argument parsing optimized for code size
-
swc_visit_macros
Visitor generator for stable rustc
-
ouroboros_macro
Proc macro for ouroboros crate
-
hdf5-derive
Derive macro for HDF5 structs and enums
-
safe-proc-macro2
A fork of
proc_macro2crate with unsafe code removed -
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.
-
prost-derive
A Protocol Buffers implementation for the Rust Language
-
gluon_codegen
Code generation macros for the gluon programming language
-
prometheus-static-metric
Static metric helper utilities for rust-prometheus
-
fix-hidden-lifetime-bug-proc_macros
Proc-macro to write an automatic fix for the “hidden lifetime in impl Trait” issue
-
gltf-derive
Internal macros for the gltf crate
-
strum
Helpful macros for working with enums and strings
-
utoipa-gen
Code generation implementation for utoipa
-
futures-macro
The futures-rs procedural macro implementations
-
faux_macros
Implementations for #[create], #[methods], when!
-
multihash-derive
Proc macro for deriving custom multihash tables
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
snafu-derive
An ergonomic error handling library
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
getset
Getset, we’re ready to go! A procedural macro for generating the most basic getters and setters on fields
-
paste
Macros for all your token pasting needs
-
worker-macros
Macros to support the
workercrate and remove FFI boilerplate / conversion from user code -
protocol-derive
Easy protocol definitions
-
usdt-macro
Procedural macro for generating Rust macros for USDT probes
-
wasm-bindgen-macro
Definition of the
#[wasm_bindgen]attribute, an internal dependency -
mlua_derive
Procedural macros for the mlua crate
-
bit-struct
Define structs which have fields which are assigned to individual bits, not bytes
-
assert2-macros
procedural macros for assert2
-
cameleon-impl-macros
Utilities used by other cameleon crates implementation
-
cynic-codegen
Codegen for cynic - a GraphQL query builder & data mapper for Rust
-
yaserde_derive
Serialization and deserialization macros
-
crepe
Datalog in Rust as a procedural macro
-
moveit
A library for safe, in-place construction of Rust (and C++!) objects
-
peg-macros
Procedural macros for rust-peg. To use rust-peg, see the
pegcrate. -
vtable-macro
Helper crate to generate ffi-friendly virtual tables
-
rhai_codegen
Procedural macros support package for Rhai, a scripting language and engine for Rust
-
core_extensions_proc_macros
Implementation detail of the
core_extensionscrate -
structmeta
Parse Rust’s attribute arguments by defining a struct
-
gdnative-impl-proc-macros
Internal dependency of the gdnative bindings
-
amplify_syn
Amplifying syn capabilities: helper functions for creating proc macro libraries
-
clap_derive
Parse command line argument by defining a struct, derive crate
-
jsonrpc-derive
High level, typed wrapper for
jsonrpc-core -
serde_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
conrod_derive
A crate providing procedural macros for the conrod library
-
neli-proc-macros
Procedural macros for neli
-
redbpf-macros
Procedural macros for redbpf
-
parquet_derive
Derive macros for the Rust implementation of Apache Parquet
-
sqlxmq_macros
Procedural macros for sqlxmq
-
neon-macros
Procedural macros supporting Neon
-
qmetaobject_impl
Custom derive for the qmetaobject crate
-
ramhorns-derive
Experimental Mustache-like templating engine
-
sauron-node-macro
An html library for building client side webapps
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
napi-derive-backend
Codegen backend for napi procedural macro
-
gotham_restful_derive
Derive macros for gotham_restful
-
libcnb-proc-macros
Procedural macros used within libcnb.rs
-
nom-rule
A procedural macro for defining nom combinators in simple DSL
-
proc_macro_roids
Traits and functions to make writing proc macros more ergonomic
-
slog-extlog-derive
Custom derive code for slog-extlog
-
include_dir_impl
Implementation crate for include_dir
-
bolero-generator-derive
value generator for testing and fuzzing
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
tensorflow-internal-macros
The package provides macros for internal usage in TensorFlow. No backwards compatibility guarantees are made.
-
const-random
Provides compile time random number generation
-
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.
-
oso-derive
macros for oso, an open source policy engine for authorization that’s embedded in your application
-
moore-derive
Procedural macros for the moore compiler framework
-
paperclip-macros
Macros for paperclip OpenAPI tooling library
-
wasm-bindgen-test-macro
Internal testing macro for wasm-bindgen
-
derive-getters
Simple boilerplate getters generator
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
sixtyfps-corelib-macros
Helper macro for sixtyfps-corelib
-
binread_derive
Derive macro for binread
-
markup-proc-macro
A blazing fast, type-safe template engine for Rust
-
ct-python
Execute Python code at compile time to generate Rust code
-
crevice-derive
Derive crate for the ‘crevice’ crate
-
swift-bridge-macro
Powers swift-bridge module code generation
-
bpaf_derive
Derive macros for bpaf Command Line Argument Parser
-
venial
A very small syn
-
v_escape_derive
Procedural macro package for v_escape
-
migrations_macros
Codegeneration macros for diesels embedded migrations
-
yew-router-macro
Contains macros used with yew-router
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
static_table_derive
Procedural macros for investments crate
-
aquamarine-demo-crate
A demo crate for aquamarine – the mermaid.js integration for rustdoc
-
derive-into-owned
Custom derives to help with types containing Cow fields
-
fawkes-crypto_derive
zk-SNARK circuit building framework
-
tower-lsp-macros
Internal procedural macros for tower-lsp
-
rustfmt-wrapper
Library wrapper around rustfmt for use by code generators
-
datatest-derive
Procmacro for the datatest crate
-
gettext-macros
A few proc-macros to help internationalizing Rust applications
-
metamorphose
Macros collection for converting Structure to Model, for a mango-orm project
-
clapi
A framework for create command-line applications
-
pgx-macros
Proc Macros for ‘pgx’
-
build-info-proc
Part of the build-info crate: This crate provides the proc-macros
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
rand_derive2
Generate customizable random types with the rand crate
-
jsonrpsee-proc-macros
Procedueral macros for jsonrpsee
-
asn1-rs-derive
Derive macros for the
asn1-rscrate -
actix-web-codegen
Routing and runtime macros for Actix Web
-
rash_derive
rash derive crate
-
derive_builder_core_fork_arti
Internal helper library for the derive_builder crate
-
opaque_typedef
Supports defining opaque typedefs
-
ambassador
Trait implementation delegation via procedural macros
-
symbols
Proc-macro utility to populate enums from database data
-
phf_macros
Macros to generate types in the phf crate
-
fstrings-proc-macro
Python3 fstring interpolation in Rust
-
ext-php-rs-derive
Derive macros for ext-php-rs
-
ascent_macro
implementation of ascent macros
-
syn-mid
Providing the features between “full” and “derive” of syn
-
proc-quote
A procedural macro implementation of quote!
-
enum-iterator-derive
Procedural macro to derive Sequence
-
unimock_macros
Procedural macros used by unimock
-
pen-ffi-macro
FFI macro library for Pen programming language
-
spirv-std-macros
Macros for spirv-std
-
struct-arithmetic
Provides a Trait to derive basic arithmetic operations for your structs
-
ckb-occupied-capacity-macros
TODO(doc): @keroro520 crate description
-
arma-rs-proc
proc macros for arma-rs
-
tlua-derive
Tlua derive macro definitions
-
a2lmacros
provides macros in support of the a2lfile crate
-
html-macro
html macro
-
dioxus-core-macro
Core macro for Dioxus Virtual DOM
-
celery-codegen
Macros for rusty-celery
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
fixed_width_derive
Derive trait for use with the fixed_width crate
-
maybe-async-cfg
A procedure macro to unify sync and async implementations depending on the features of your crate
-
syn-rsx
syn-powered parser for JSX-like TokenStreams
-
ff_derive
Procedural macro library used to build custom prime field implementations
-
askama_derive
Procedural macro package for Askama
-
tylift
Lift enum variants to the type-level
-
hard-xml
Strong typed xml, based on xmlparser
-
gvariant-macro
Proc macros for the gvariant crate
-
libafl_derive
Derive proc-macro crate for LibAFL
-
abscissa_derive
Custom derive support for the abscissa application microframework
-
rustbus_derive
derive proc-macros for the rustbus crate
-
dropshot_endpoint
macro used by dropshot consumers for registering handlers
-
diesel_derives
You should not use this crate directly, it is internal to Diesel
-
zerocopy-derive
Custom derive for traits from the zerocopy crate
-
sea-strum
Helpful macros for working with enums and strings
-
checked_decimal_macro_core
A package for macro used in
checked_decimal_macro -
frunk_derives
frunk_derives contains the custom derivations for certain traits in Frunk
-
bitwrap_derive_extra
macro for bitwrap
-
rquickjs-macro
Procedural macros for rquickjs
-
easy-xml-derive
The macros for easy-xml
-
deku_derive
bit level serialization/deserialization proc-macro for structs
-
shank_macro
Provides macros used to annotate Solana Rust programs in order to extract an IDL with the shank CLI
-
extendr-macros
Generate bindings from R to Rust
-
salsa-macros
Procedural macros for the salsa crate
-
chalk-derive
A helper crate for use by chalk crates for
derivemacros -
trace
A procedural macro for tracing the execution of functions
-
syn-file-expand
Library to load full source code of multi-file crates
-
rune-macros
Helper macros for Rune
-
libipld-cbor-derive
ipld cbor codec proc macro
-
below_derive
Proc macros for below
-
procout
Output a proc macro’s TokenStream to a file
-
rocket_sync_db_pools_codegen
Procedural macros for rocket_sync_db_pools
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
psl-codegen
Generate native Rust code from Mozilla’s Public Suffix List
-
stronghold-derive
Proc macros and derives for Stronghold
-
cdbc-macro
Rust Coroutine Database Driver Connectivity
-
kube-derive
Custom derives for the kube kubernetes crates
-
hirpdag_derive
Procedural macro for generating hirpdag boilerplate. See hirpdag crate.
-
gumdrop_derive
custom derive support for gumdrop
-
bitwrap_derive
macro for bitwrap
-
kommandozeilen_argumente_derive
derive-Macros für das kommandozeilen_argumente crate
-
arrow2_convert_derive
Proc macros for arrow2_convert
-
mockers_macros
Compiler plugin for ‘mockers’ mocking library
-
thiserror-impl-no-std
Implementation detail of the
thiserrorcrate -
jomini_derive
Serde macros implementation of
#[derive(JominiDeserialize)] -
rustfmt-config_proc_macro
A collection of procedural macros for rustfmt
-
enumset_derive
An internal helper crate for enumset. Not public API.
-
jenner-macro
Macro implementations for jenner
-
win_etw_macros
Enables apps to report events to Event Tracing for Windows (ETW)
-
proto-vulcan-macros
Internal macro library for proto-vulcan
-
as_derive_utils
private derive utilities used by abi_stable and structural
-
maud_macros
Compile-time HTML templates
-
autograph_derive
Procedural macro crate for autograph
-
ocaml-derive
OCaml procedural macros
-
wolfram-library-link-macros
Procedural macros used by wolfram-library-link
-
tls_codec_derive
Derive macros for the tls_codec trait
-
display_json
Procedural macros for implementing Display, Debug and FromStr for (de)serializing json strings
-
mybatis-macro
mybatis macro driver
-
datasize_derive
Derive macros for the
datasizecrate -
dummy
Macros implementation of #[derive(Dummy)]
-
openapi_type_derive
Implementation detail of the openapi_type crate
-
asn1-compiler
ASN.1 Compiler in Rust
-
diesel_filter_query
Procedural macros for Diesel filter
-
asn1_derive
#[derive] support for asn1
-
impl-trait-for-tuples
Attribute macro to implement a trait for tuples
-
deltoid-derive
Derive macro that generates code to calculate and apply deltas to structs and enums
-
hobo_derive
hobo is a Rust frontend framework
-
macroquad_macro
Proc macro for macroquad
-
nj-derive
procedure macro for node-bindgen
-
inet2_derive
Derivation macros for Internet2-based crates
-
defmt-test-macros
defmt-test macros
-
dbg-pls-derive
derive(Debug)
-
inter-struct-codegen
Proc macro codegen crate for merge-struct
-
git-testament-derive
Record git working tree status when compiling your crate - inner procedural macro
-
show-image-macros
macros for the show-image crate
-
pam-macros
Macros for the pam crate
-
bevycheck
Helpful bevy error messages by proc-macro
-
arr_macro
Initialize arrays with ease!
-
attribute-derive
Clap for proc macro attributes
-
static_init_macro
Attribute macros for static_init crate
-
suborbital-macro
Macro for setting up a Runnable
-
oauth1-request-derive
A derive macro for
oauth1_request::Requesttrait -
pacaptr-macros
Implementation of several macros used in pacaptr
-
fates_macro
Helper macro for Fates crate. See https://crates.io/crates/fates
-
c2rust-macros
Procedural macro support crate for C2Rust
-
janetrs_macros
Attribute macros for JanetRS
-
rustpython-derive
Rust language extensions and macros specific to rustpython
-
xladd-derive
A simple macro that helps write Excel UDF functions in Rust
-
minitrace-macro
Attribute procedural macro for minitrace-rust
-
ormx-macros
lightweight procedural macros bringing orm-like features to sqlx
-
aptos-crypto-derive
Custom derives for
aptos-crypto -
vectrix-macro
A macro for composing matrices
-
ndk-macro
Helper macros for android ndk
-
macropol
Ergonomic string literal interpolation in macro definitions
-
double-dyn
Macro for implementing functions with multiple dynamic argument dispatch
-
arcon_macros
Macros for Arcon
-
bin-layout-derive
This library used to serialize and deserialize data in binary format
-
cynic-proc-macros
Procedural macro crate for cynic - a GraphQL query builder & data mapper for Rust
-
cdrs-tokio-helpers-derive
Derive CDRS helper traits
-
frame-support-procedural
Proc macro of Support code for the runtime
-
mwt
proc macros for generating mut and non-mut methods without duplicating code
-
derive-syn-parse
Derive macro for
syn::parse::Parse -
command_attr
Procedural macros for command creation for the Serenity library
-
cenum
A rust derive macro for C-style primitive enums
-
tarantool-proc
Tarantool proc macros
-
wasmbus-macros
derive macros for wasmbus-rpc
-
unroll
An attribute-like procedural macro for unrolling for loops
-
cssparser-macros
Procedural macros for cssparser
-
static-pubkey
macro used for compile-time parsing of public key strings into byte arrays for near 0-cost static public keys
-
gc_derive
Garbage collector derive plugin for rust-gc
-
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.
-
watt
Runtime for executing Rust procedural macros compiled as WebAssembly
-
impl-tools
Helper macros: autoimpl
-
gsettings-macro
Macro for typesafe GSettings key access
-
der-oid-macro
Macro to encode DER oids at compile time
-
dict_derive
Derive macros for some PyO3 traits to convert python dicts into rust structs
-
inline-python
Inline Python code directly in your Rust code
-
wasmbox-macro
Macro implementation for wasmbox
-
gf256-macros
Proc-macros for the gf256 crate
-
magic_static_macro
Proc macro for magic_static
-
bitregions-impl
implementation for the bitregions crate
-
polymesh-primitives-derive
Derive impls for Polymesh Primitives
-
sewup-derive
Macros implementation for SewUp
-
sqlxinsert
Sqlx derive macro for simpler inserts
-
bevy_ecs_macros
Bevy ECS Macros
-
entrait_macros
Procedural macros reexported by entrait
-
reformation_derive
reformation derive crate
-
mpst-seq-proc
A library with macro for mpstthree
-
teloxide-macros
The teloxide’s procedural macros
-
refinery-macros
This crate should not be used directly, it is internaly related to Refinery
-
treeflection_derive
#[derive(Node)] macro for the Treeflection library
-
memoize-inner
Helper crate for memoize
-
harmony_derive
Proc macros for harmony_rust_sdk. Not meant to be publicly used.
-
invoke_impl
Proc macro to generate functions that can invoke all identical functions or methods inside impl blocks
-
kproc_macros
Useful proc macros
-
lazy-regex-proc_macros
proc macros for the lazy_regex crate
-
better-bae
A Rust proc-macro attribute parser
-
saphir_macro
Macro generation for http server framework
-
macro_state
A set of macros allowing storing and loading global state at compile-time within proc macros
-
econf-derive
Load environment variables into your struct members in one shot
-
pomelo-impl
Implementation details for pomelo, not to be used directly
-
tch-tensor-like-derive
Derive macro implemenations used by tch-tensor-like crate
-
telegraf_derive
Derive macros for the telegraf-rust library
-
cassandra_macro_derive
Macros 1.1 implementation of #[derive(Cassandra)]
-
djin-protocol-derive
A for of protocol, for aoe-djin
-
result-like-derive
derive macros for result-like
-
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…
-
toy-arms_derive
A derive macro crate for toy-arms
-
lombok
Lombok port for Rust
-
palette_derive
Automatically implement traits from the palette crate
-
rkyv_typename_derive
Derive macro for rkyv_typename
-
cust_derive
Macros for cust
-
function_name-proc-macro
macro that expands to the name of the annotated function
-
proc-macro2-diagnostics
Diagnostics for proc-macro2
-
deno_ops
Proc macro for writing Deno Ops
-
roxido_macro
Macros to support the roxido crate
-
sqlx-type-macro
Proc macros for sqlx-type
-
typify-macro
typify macro implementation
-
jrsonnet-gcmodule-derive
Generate code to implement Trace trait on structures
-
dhall_proc_macros
Macros for dhall
-
sscanf_macro
Proc-Macros for the sscanf Crate. Not meant to be used as a standalone Crate
-
cargho
Derive-based argument parser optimized for being up to date in crates.io
-
proconio-derive
Procedural macros for proconio
-
into_query_derive
Provides a derive macro for IntoQuery
-
remoc_macro
Procedural macros for Remoc
-
try_match_inner
The internal procedural macro of
try_match -
autd3-traits
Wav Modulation for AUTD
-
enum-flags
EnumFlags is a csharp like enum flags implementation
-
gramatika-macro
Proc macros for Gramatika
-
canadensis_derive_register_block
Derive macro for
canadensis::register::RegisterBlock -
scanf
Parse text inputs (inverse of print! and format!)
-
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
-
simple_parse_derive
A derive macro that implements the simple_parse traits
-
shipyard_proc
Crate providing attribute macro to Shipyard
-
packable-derive
Derive macro for the
packablecrate -
easy-jsonrpc-mw
Convert a trait definition into a jsonrpc api
-
wasm-bus-macros
WebAssembly Bus Macros
-
bae
A Rust proc-macro attribute parser
-
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
-
aquatic_toml_config_derive
Serialize toml with comments
-
dynomite-derive
Derives AWS DynamoDB dynomite types from native Rust struct types
-
s_test_fixture
s_test_fixture or simple test fixture is a macro library to implement test fixture with no hassle
-
sawp-flags-derive
SAWP BitFlags Handling and Storage Derive Macro
-
display-as-proc-macro
A helper crate for display-as-template
-
elephantry-derive
Macro implementation of #[derive(Entity)]
-
debug2-derive
Derive macro for debug2
-
usdt-attr-macro
Procedural macro for generating Rust macros for USDT probes
-
bitfield-derive
This crate provides derive to generate struct with bitfield access
-
agpu-macro
agpu derive macros
-
gc-arena-derive
proc-macro support for gc-arena
-
hotg-rune-proc-block-macros
Procedural macros for the rune-proc-block crate
-
shoulda_macro
derive macro for test assertions
-
steam-language-gen-derive
Implementation detail of
steam-language-gencrate -
dioxus-table-macro
Make data-driven table rendering easy with Dioxus - macro crate
-
set_slice
A macro for assigning values to slices
-
qsk-macros
Remapping DSL macro to make qsk remapping more concise
-
pinwheel_macro
Build web applications with Rust
-
elfo-macros
Macros for matching and deriving messages
-
const-field-offset-macro
Procedural macro to generate constant field offset from repr(c) struct
-
pub-sub-client-derive
Macros for pub-sub-client
-
enum-display-derive
Display trait’s custom derive for simple enums
-
ferric-macros
A Probablistic Programming Language with a declarative syntax for random variables
-
rdxl_static
Static Site Generation Utilities for RDXL
-
gxi-macros
collection of macros for gxi-rs
-
config_parser_derive
A proc-macro for implementing ConfigParser trait of config_parser library
-
sanitizer_macros
Derive macro for the sanitizer crate
-
decorators
A macro for generating decorator methods
-
test-fuzz-macro
-
yew-interop-macro
macros for the yew-interop crate
-
cdefines
A proc macro that translates c #define constants to rust consts
-
strong-xml-derive
Derive marco of strong-xml
-
pdf_derive
helper for pdf-rs
-
async-stream-impl
proc macros for async-stream crate
-
bdk-testutils-macros
Supporting testing macros for
bdk -
pokeapi-macro
Attribute macros for
pokeapi-model -
dotenv_codegen_implementation
A
dotenvimplementation for Rust -
evmc-declare
Bindings to EVMC (VM declare macro)
-
aliri_braid_impl
Implementation macros for the
aliri_braidcrate -
swc_ecma_transforms_macros
Macros for swc_ecma_transforms
-
matrix-sdk-test-macros
Helper macros to write tests for the Matrix SDK
-
castflip_derive
Derive macros for castflip
-
nova-macro
Implementation for nova crate
-
mendes-macros
Macros for mendes web toolkit
-
serde_derive_state
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
u256-literal
Procedural macro for converting u256 literals to U256 at compile time
-
sh-inline
Macros to run inline shell (bash) script
-
foreign-types-macros
An internal crate used by foreign-types
-
binrw_derive
Derive macro for binrw
-
securefmt
Drop-in replacement for the Debug derive macro that hides fields marked as sensitive
-
derive_deref
Adds
#[derive(Deref)]and#[derive(DerefMut)] -
macro-ruby
Execute ruby code at compile time trough mruby
-
dodo-derive
Dodo persistence library derives
-
wood_derive
autoderive for wood serialization
-
js-macros
Quickly prototype procedural macros using JavaScript or TypeScript!
-
r3bl_rs_utils_macro
Internal support for a proc-macro library for reading attributes into structs when implementing custom derives. Use https://crates.io/crates/r3bl_rs_utils in your code.
-
dcc-lsystem-derive
Macro implementation of #[derive(TurtleContainer)]
-
derive_state_machine_future
Custom derive implementation for the
state_machine_futurecrate. Use that crate instead of this one directly. -
thiserror-impl
Implementation detail of the
thiserrorcrate -
css-modules
CSS Modules with a macro for convenience
-
bitbuffer_derive
Reading bit sequences from a byte slice
-
mun_codegen_macros
Macros used by mun code generation
-
aptos-log-derive
Aptos structured log type macros
-
prometheus-metric-storage-derive
Implementation details for prometheus-metric-storage
-
dionysos-derives
derive crate for dionysos: Scanner for various IoCs
-
sql_db_mapper_derive
Derives used by code generated by sql_db_mapper
-
magnus-macros
Derive and proc macros for magnus
-
narui_macros
proc macros of the narui gui framework
-
xls_table_derive
Procedural macros for investments crate
-
diff_derive
A derive macro for implementing Diff on the diff-struct crate
-
genesis-impl
proc macro crate for genesis
-
bolt-proto-derive
Procedural macros for bolt-proto
-
glsl-layout-derive
Custom derive for
glsl-layoutcrate -
creator-derive
Mobile Game Framework
-
proc_macro2_helper
Various utility code to extract data that can be used with proc macro2
-
oxide-macros
Main entrypoint macro for AVRoxide
-
named-tup-derive
A helper macro crate for the named-tup crate
-
thruster-proc
The proc macros behind the thruster web framework
-
fehler-macros
Macros des Fehlers
-
hecs-macros
Procedural macro definitions for hecs
-
tracing-rc-derive
Attribute macros for tracing-rc
-
fortify_derive
Derive macros for fortify
-
rust-i18n-macro
Macro for rust-i18n crate
-
capsule-macros
Capsule procedural macros
-
inkwell_internals
Internal macro crate for inkwell
-
bitbar-derive
Proc-macros for the bitbar crate
-
partial_ref_derive
Derives for partial_ref
-
prusto-macros
prusto macros
-
packer_derive
Derives for the packer crate
-
toql_derive
Library with derive for toql
-
plctag-derive
macros for
plctag -
tokio-actor
Macro based Asynchronous Actor System
-
ra_ap_proc_macro_srv
TBD
-
flow_impl_derive
Definition of a derive macro for FlowImpl
-
rsexp-derive
Derive macro for S-expression conversion
-
rweb-macros
Yet another web server framework for rust
-
flexpiler_derive
Derive macro project for main crate ‘flexpiler’
-
toml-cfg
A procedural macro for configuring constant values across crates
-
scoundrel-macro
An engine for working with ASCII roguelikes. This is just the macro package, use
scoundrelinstead! -
phper-macros
The proc-macros for phper crate
-
summer-boot-macro
summer boot macro
-
pipederive
Proc macros for data integration app using pipebase framework
-
intertrait-macros
Macros for intertrait crate, which allows for direct casting between trait objects
-
serde_derive_internals
AST representation used by Serde derive macros. Unstable.
-
crabbake
Trait that lets structs represent themselves as (const) Rust expressions
-
lemmy_apub_lib_derive
A link aggregator for the fediverse
-
identity-diff-derive
Derive procedural macro for the identity-diff crate
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
scpi_derive
SCPI/IEEE488.2 parser support library
-
finny_derive
Procedural macros crate for the main finite state machine crate, finny
-
fyrox-core-derive
Proc-macro for the Visit trait
-
krator-derive
Derive macros for the Krator crate
-
near-sdk-witgen
Macros needed to generate wit for near rust sdk
-
wasmtime-rust-macro
Macro support crate for wasmtime-rust
-
stdweb-internal-test-macro
Internal crate of the
stdwebcrate -
restcrab_macros
Macros for the restcrab crate
-
struct-field-names-as-array
Provides a procedural macro that generates an array of the field names of a named struct
-
dough
Internal macros for the bagel crate
-
zoet-macro
Implementation detail for
#[zoet]macro -
i18n-macro
A simple compile time i18n implementation in Rust
-
jump-kun-macros
A crate for jump-kun. Parses jump-kun config file and creates fucntions.
-
com_macros
COM crate macros
-
struct2vec_derive
Rust structure to slice
-
lexgen_util
Runtime library for lexers generated by lexgen
-
fp-bindgen-macros
Macros for fp-bindgen
-
tamasfe-macro-utils
Proc-macro utilities, intended for personal use
-
reflect
The “but I thought Rust doesn’t have reflection?” memorial brand new way of defining procedural macros
-
enum_const_value
Providing const values for enums. Unit and enums with associated types are supported. Each variant gets a unique sequential value.
-
scale_documentation_parser
a proc macro to parse the structured SCALE documentation into Rust datastructures
-
gmod-macros
Proc macros for gmod-rs
-
ublox_derive
Utility macros for the ublox crate
-
typename_derive
Derive plugin for the typename crate
-
lv2-core-derive
Procedural macros for lv2-core
-
data-encoding-macro-internal
Internal library for data-encoding-macro
-
influxdb_derive
Private implementation detail of the influxdb crate
-
holium-backend
Backend crate for the Holium Rust SDK procedural macro
-
anthill-di-derive
Derive extension for anthill-di
-
autocorrect-derive
proc-marcro-derive for autocorrect
-
yui_internal
Internal functions, struct for derive in Yui
-
cyfs-base-derive
Rust cyfs-base-derive package
-
rvv-asm
Procedure macro to encode RISC-V V extension (rvv) instructions
-
sqlb-macros
Macros for sqlb. Not intended to be used directly.
-
frunk_proc_macros_impl
Proc macros inernal implementations for Frunk
-
byteme
Converts a struct into Vec and back. The conversion is Big Endian by default.
-
pmacro_ruly
macros for ruly
-
join_export
Exports of the
join!,join_async!,join_spawn!,join_async_spawn!,async_spawn!macros which are reexported byjoincrate -
openwhisk_macro
Derive Macro for OpenWhisk Rust Client
-
tealr_derive
The derive macro for tealr
-
netlify_lambda_attributes
Lambda macro attributes
-
enum_cycling_derive
Small macro for working with enums
-
grafana-plugin-sdk-macros
Convenience macros for the Grafana backend plugin SDK
-
mpesa_derive
MpesaSecuritytrait derive macro crate -
awmpde_derive
awmpde used for deriving multipart request for actix web 3
-
db_ip_macros
Macros for db_ip
-
derive-env-url
Derives for env-url
-
minicdn_macros
Static files, compressed for efficiency (macros crate)
-
dotenvy_codegen_impl
Internal implementation for dotenvy_codegen
-
agui_macros
The macro utilities of agui
-
cpclib-macros
cpclib macros related to z80 assembling
-
symbols-models
Proc-macro utility to populate enums from database data (shared traits)
-
rust-hdl-macros
Macro support for RustHDL
-
cain
Procedural macro to transform sequential branches into nested branches
-
assert-parse-register-assert-macro
The util macro for ‘assert-parse’
-
qualia_derive
Derive macros for Qualia
-
mmtk-macros
MMTk macros provides procedural macros used by mmtk-core
-
specs-derive
Custom derive macro for Specs components
-
ff-derive-num
Procedural macro library to add the Num trait to Field implementations for ff
-
include-flate-codegen
Macro codegen for the include-flate crate
-
shumai-config-impl
A benchmark framework that empowers efficient and correct multi-thread benchmarks
-
savage_macros
A primitive computer algebra system (macro helper crate, NOT INTENDED FOR USE BY THIRD-PARTY CRATES)
-
nop-json-derive
Helper crate for internal use in nop-json
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
xshell-macros
Private implementation detail of xshell crate
-
trdelnik-test
Trdelnik proc-macro
-
sawp-ffi-derive
Generate cbindgen compatible member accessors for structs and enums
-
syndicate-macros
Support macros for programming with the Syndicated Actor model and Dataspaces
-
proc-lock-macro
Macro API for the proc-lock crate
-
lazylink-macro
Convert extern fn to libdl call
-
vmnet-derive
Helper procedural macro for the vmnet crate
-
sqlx-database-tester-macros
Macros for sqlx-database-tester
-
anchor-cereal-derive
Derive macros for anchor-cereal
-
arg-derive
Derive for arg crate
-
shaku_derive
Code generation for the shaku dependency injection framework
-
teloc_macros
Macros for teloc framework
-
xql-derive
xql derive macro
-
async-reply-derive
Derive macros for
async-replymessages -
elrond-wasm-derive
Elrond WebAssembly smart contract API procedural macros
-
inherent-pub
Mark methods in
impl Trait for Typeblocks inherent to the type -
property
Generate several common methods for structs automatically
-
actix-easy-multipart-derive
actix-easy-multipart proc-macro
-
ssbh_write_derive
ssbh_write derive macro
-
typesets-macro
The derive macros for typesets
-
edn-derive
Edn (De)Serialization derive macros
-
fn-error-context
An attribute macro to add context to errors from a function
-
crossbundle-derive
Cross-Platform Rust Toolkit for Games 🏹
-
ed-derive
Derive macros for the ed crate
-
tuirealm_derive
Derive macro which automatically implements the MockComponent trait
-
derive_setters
Rust macro to automatically generates setter methods for a struct’s fields
-
knuffel-derive
A derive implementation for knuffel KDL parser
-
serde-intermediate-derive
Derive proc macro for intermediate representation of Serde serialization
-
ketos_derive
Derive traits for Ketos scripting language
-
fncmd-impl
This crate shouldn’t be used directly. Check fncmd.
-
actix-multipart-extract-derive
Better multipart form support for Actix Web
-
unzip-n
Procedural macro to generate
unzipfor iterators over n-sized tuples -
swipl-macros
Macro crate for swipl-rs
-
machine
State machine utilities
-
edgedb-derive
Derive macros for EdgeDB database client
-
ff-uint_derive
Library for building and interfacing with fixed-sized integers and finite fields
-
topo-macro
procedural macros for the topo crate
-
butcher_proc_macro
Procedural macros for butcher
-
leetcode_test
Some useful macros and definition for exercising in leetcode
-
attributes
Procedural macros for command creation with rusty-interaction
-
find-crate
Find the crate name from the current Cargo.toml
-
quote-use
Support
usein procmacros hygienically -
rbatis_sql_macro
rbatis sql macro system
-
prometheus-client-derive-text-encode
Auxiliary crate to derive text Encode trait from prometheus-client
-
cdds_derive
Derive macros for cyclonedds-rs
-
postgres-derive
An internal crate used by postgres-types
-
ahecha_macro
Ahecha macro crate
-
panda-re-macros
Macros needed for the
panda-relibrary -
megenginelite-derive
A safe megenginelite wrapper in Rust
-
rustler_codegen
Compiler plugin for Rustler
-
wchar-impl
Internal implementation of wchar
-
alass-ffi-macros
Procedural macros for alass-ffi crate
-
trackable_derive
Custom derive for
trackablecrate -
windows-interface
The interface macro for the windows crate
-
bytify
Convenience macro for generating continuous byte arrays from arbitrary sequences of literals
-
mock_derive
An easy to setup, rich mocking library for the Rust programming language
-
git-version-macro
Internal macro crate for git-version
-
rdxl
Macros and Component System for HTML Templating
-
rustacuda_derive
Custom Derive Macro for RustaCUDA
-
ifmt-impl
Implementation detail of the ifmt crate
-
rabbithole-derive
The macro system helping users to model the relationship of their data
-
sixtyfps-macros
Macro helper for sixtyfps crate
-
subplotlib-derive
macros for constructing subplotlib based test suites, typically generated by
subplot codegen -
wasmedge-bindgen-macro
Pass string, vec and primitive types from host to webassembly
-
irzha
Write Rust programs using Ukrainian language
-
compiled-uuid
Parse UUIDs at compile time
-
include-bytes-plus
Improved include_bytes! allowing to reinterpret input differently
-
quote-doctest
A simple doctest generator for quote
-
jet-proto-proc-macros
A library of proc macros for helping with writing solana programs
-
opimps
A simple library of attribute macros to assist with overloading operators for borrowed and owned data
-
rusty-peg
A macro for defining PEG parsers
-
unique-type-id
A unique id proc-macro generator for types
-
fast-version-derive
Derive macro for the fast-version crate
-
katexit
Insert KaTeX autorender script into rustdoc
-
msgpack-schema-impl
Implementation detail of the msgpack-schema crate
-
slices
Convert string literals to static unsigned integer slices in compile time
-
mbot_proc_macro_helpers
Procedural macro helpers used by mbot
-
auto_ref
Replace &T to impl AsRef
-
clippy-mini-macro-test
A macro to test clippy’s procedural macro checks
-
node_api_macro
Write Node.js native addons with Node-API in Rust
-
versionize_derive
Implements the Versionize derive proc macro
-
gotham_formdata_derive
Implementation detail of gotham_formdata
-
euphony-macros
Core macro implementations
-
tulip-derivative
tulip fork of derivative
-
tiberius-derive
Derive macros for Tiberius
-
tokay-macros
Macro support for Rust-native builtin functions for the Tokay programming language
-
assemble-macros
Macros for assemble. shouldn’t be used by itself. Instead use assemble-core
-
macro_railroad
A library to generate syntax diagrams for Rust macros
-
inline-proc
Inline procedural macros
-
wrapping_proc_macro
A proc macro for cleaner wrapping arithmetic
-
ethers-derive-eip712
Custom derive macro for EIP-712 typed data
-
trans-schema-derive
Generating trans code from Rust into other languages (derive macros)
-
tl-proto-proc
A collection of traits for working with TL serialization/deserialization
-
solid-derive
Macros for the
solidcrate. Not intended to be used directly. -
json_schema_test_suite
Procedural Macro Attribute to run all the test cases described in JSON-Schema-Test-Suite
-
bytecheck_derive
Derive macro for bytecheck
-
parst_derive
derive macros for parst
-
best_macros
This crate was created for optimize coding in RUST
-
const-random-macro
Provides the procedural macro used by const-random
-
mono-macro
Force monomorphizing on functions with
share-genericsto minimalize binary size -
any_ref_macro
To capture and move things that are NOT ’static with memory safety
-
coerce-macros
Utility macros for Coerce
-
rep_derive
A small tool for representation/class invariants
-
error_generator
Transform structs and enums into fully qualified errors using attributes
-
diesel_derives_extra
Automatically derive some simple CRUD methods for your Diesel models
-
include_dir_macros
The procedural macro used by include_dir
-
fff_derive
Procedural macro library used to build custom prime field implementations
-
giftwrap
Wrap and unwrap your types the stylish way
-
bpf-rs-macros
Collection of proc macros used within bpf-rs and dependant crates
-
zerogc-derive
Procedural derive for zerogc’s garbage collection
-
affix
Macros for all your token pasting needs. Fork of https://github.com/dtolnay/paste with casing fixed
-
pcd-rs-derive
Derive macros for pcd-rs crate
-
cmd_lib_core
Common rust commandline macros and utils, to write shell script like tasks easily
-
cascading-wasm-language
Compiled web language based on CSS syntax
-
ckb-migration-template
Provide proc-macros to setup migration
-
penrose_proc
proc-macros for the Penrose tiling window manager library
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
derive_rich
Helps you to create richful function for your structs
-
devise_codegen
A library for devising derives and other procedural macros
-
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.
-
bevy_console_derive
derive macros for bevy_console
-
proptest-attr-macro
Procedural attribute macro for writing proptest tests
-
view_macro
a macro for constructing views
-
proxy-enum
Emulate dynamic dispatch and sealed classes using a proxy enum, which defers all method calls to its variants
-
bonfida-macros
Bonfida-utils macros
-
fbinit_macros
Provides macros for fbinit crate
-
gtmpl_derive
Derive for gtmpl_value
-
usual-proc
The proc macros behind usual
-
varlen_macro
Ergonomic variable-length types, procedural macros
-
static-address-parser
Parser used by the static-address macro crate
-
rbxm-proc
Internal proc macros for the
rbxmcrate -
arel_macro
arel macros
-
default-boxed-derive
Custom derive for default-boxed
-
assets_manager_macros
Procedural macros for assets_manager
-
cur_macro
Procedural macros for
cur -
bma-benchmark-proc
Procedure macros for bma-benchmark
-
dims_derive
Derive macros for Generating Systems of Units
-
ni-fpga-macros
Macros to be used with the ni-fpga crate
-
ntex-prost-derive
A Protocol Buffers implementation for the Rust Language
-
lain_derive
Derive macros for usage with lain
-
starlark_derive
Derive helpers for the starlark package
-
c2rs
C struct to Rust struct
-
microtype-macro
Proc macro for generating microtypes
-
nanoserde-derive
Fork of makepad-tinyserde derive without any external dependencies
-
rlink-derive
High performance Stream Processing Framework
-
tlayuda
A derive procedural macro for structs that adds a static method that generates instances of the struct with minimal configuration
-
sea-orm-field-updater
update model by field
-
postgres_query_macro
Write and execute SQL queries with ease
-
pink-extension-macro
Macros for writing fat contract
-
concourse-resource-derive
Helper create for a derivation for concourse-resource
-
libtor-derive
Internal #[derive] macros for libtor
-
noop_proc_macro
No-op proc_macro, literally does nothing
-
embarkstudios/spirv-std-macros
Macros for spirv-std
-
repr_c_pub_struct
A library for extracting
#[repr(C)] pub structures -
inertia-macros
A simple library of attribute macros to assist with overloading operators for borrowed and owned data
-
fort
Proc macro attributes for Bastion runtime
-
pijul-macros
Macros used to write libpijul
-
nitroglycerin_derive
derive(Attributes, Get, Query) for nitroglycerin/dynamodb
-
print_each_line
It prints each line and execution time during execution. You can utilize it as a super simple profiler.
-
endiannezz_derive
Addition to endiannezz crate that allows derive(Io)
-
clean-macro-docs
Hide internal rules when documenting
macro_rules!macros -
count-macro
A simple Rust macro to perform compile time counting
-
eventmill_derive
Derive macros for convient implementation of some traits of the
eventmillcrate -
ordes-macros
Utility proc macros used in ordes to generate OrdesDec and OrdesInc implementations
-
cantor_macros
Macros for cantor
-
sval_derive
Custom derive for sval
-
norpc-macros
Code generator for norpc
-
safina-async-test-core
Procedural macro for the
safina-async-testpackage -
cmdparse-derive
Derive macro implementation for cmdparse
-
uri_path_router
A proc-macro crate that generates flattened enums for routing
-
marigold-macros
Macros for the marigold language
-
rs-odbc_derive
Proc macros for rs-odbc crate
-
dxr_derive
Implementation details of DXR (derive macros)
-
castle_macro
Castle Macro, macros to make your life easier
-
pg_mapper
derive
TryFrom<tokio_postgres::Row> -
druid-derive
derive impls for druid, a Rust UI toolkit
-
gostd_derive
proc_macro_derive library for gostd
-
rtea-proc
Internal macro crate for rtea
-
metacall-inline
Inline macros for metacall crate
-
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…
-
rcommunity_macros
Macros for
rcommunity -
substrait-validator-derive
Procedural macros for substrait-validator
-
activitystreams-derive
Derive macros for activitystreams
-
gcmodule_derive
Generate code to implement Trace trait on structures
-
sp-multihash-derive
Proc macro for deriving custom sp-multihash tables
-
dacquiri_derive
Derive macro support for dacquiri
-
saturating_arithmetic
Proc macro #[saturateit] to rewrite operators into their saturating equivalents
-
positional_derive
macros for positional crate
-
lunatic-macros
Helper macros for the
lunaticcrate -
generic-new
A derive macro which generates an ergonomic constructor with shortcuts for certain types
-
vk-shader-macros-impl
Implementation detail of vk-shader-macros
-
telexide_fork_proc_macros
(fork) macros for subscribing to events in telexide
-
optbuilder
A optional builder derive macro for helping with big constructors with mostly optional parameters
-
rad_ext_template
Rad ext macro template macros
-
dukt-macros
duktape bindings macros
-
identifier_derive
Derive macros for identifier
-
nodex-macros
nodex macros
-
bmart-derive
Bohemia Automation common tools library (derive macros)
-
encryption-macros-encryption
This crate belongs to the encryption-macros crate
-
sundial-derives
Helper macro for sundial
-
dyn-any-derive
#[derive(DynAny<’a>)]
-
inject-macro
Experimental IOC library for Rust, procedural macros
-
color-hex
Procedural macro for converting hexadecimal strings to an RGB or RGBA byte array at compile time
-
apdu-derive
Implementation of procedural macro for apdu crate
-
tco
A macro for transforming a tail-calling recursive function to eliminate recursion
-
clapi_macros
Macros for clapi
-
uiautomation_derive
UI Automation Derive
-
miniserde-enum
Derive macros for miniserde on enums
-
tskit-derive
procedural macros for tskit-rust
-
ssz_rs_derive
utility crate for deriving simple serialize implementations
-
get_params_derive
derive macro for get_params as JsValue
-
sha2-derive-proc-macro
The proc macro used by the sha2-derive crate
-
loupe-derive
Profiling tool for Rust, see the
loupecrate -
fatality-proc-macro
Fatality extension to crate thiserror - proc-macro part
-
lexpr-macros
Internal crate implementing macros exposed by the
lexprcrate -
structstruck
Nested struct and enum definitions
-
muta-apm-derive
Muta tracing procedural macros
-
synthez
Steroids for
syn,quoteandproc-macro2crates -
num-variants
Utility to add a constant value to enum variants
-
hex-literal-impl
Internal implementation of the hex-literal crate
-
kanin_derive
Derive macros for kanin
-
yatt_orm_derive
Yet Another Task Tracker
-
jlrs-derive
jlrs-derive contains the custom derives offered by jlrs
-
sc2-proc-macro
Procedural macros for rust-sc2 API
-
canonical_derive
The automatic derivation of Canon for structs, and enums
-
autowired-derive
Autowired project derive macro support
-
rust-ad-macros
Rust Auto-Differentiation
-
uniui_gui_macro
Macroses for uniui_gui crate. Please refer to uniui_gui crate for full documentation
-
mazzaroth-rs-derive
Mazzaroth Rust library derivation macros
-
rp2040-hal-macros
Macros used by rp2040-hal
-
sierra-proc
Procedural macros for ‘sierra’ crate
-
parsegen
A parser generator implemented as a proc macro
-
make_tuple_traits
a proc_macro for making a bunch of traits for tuples up to a fixed size
-
debug3-derive
Derive macro for debug3
-
modelfox_macro
ModelFox makes it easy for programmers to train, deploy, and monitor machine learning models
-
dialtone_sqlx_macros
Dialtone SQLx Macros
-
c2rust-bitfields-derive
C-compatible struct bitfield derive implementation used in the C2Rust project
-
holium-macro-support
Support crate for the procedural macro for the Holium Rust SDK
-
docopt_macros
Docopt macro for command line argument parsing
-
orbtk-proc-macros
Procedural macros used by OrbTk
-
microrm-macros
Procedural macro implementations for the microrm crate
-
asteracea_proc-macro-definitions
Proc macro definitions for Asteracea. They are unlikely to work correctly unless used through the asteracea crate.
-
clone_cell_derive
Proc macro for clone_cell
-
db-helpers-derive
Various macros to help with database queries and tables
-
ddd_dapr_derive
Derive macros for convient implementation of some traits of the
ddd_daprcrate -
structmap-derive
Proc derive macro for structmap crate
-
regexm
A Rust macro for writing regex pattern matching
-
peppi-derive
Support crate for peppi
-
syn-file-expand-cli
CLI tool to read full source code of multi-file crates and output it to stdout
-
tokio-pg-mapper-derive
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
qt_macros
Macros for Qt
-
segsource-derive
Derive implementations for
segsource. You should usesegsourceinstead. -
poise_macros
Internal macro implementation crate of poise
-
const-default-derive
#[derive(ConstDefault)]
-
accursed-unutterable-type-id-derive
derive macro for accursed-unutterable-type-id
-
pegtastic-macros
Procedural macros for pegtastic. To use pegtastic, see the
pegtasticcrate. -
bytecoding_derive
Derive macro for encoding and decoding instructions and operands as bytecode
-
gxi-derive
derive macros for gxi-rs
-
ptah_derive
Derive macro for Rust’s implementation of Ptah, Poplar’s message-passing format
-
neon-frame-macro
Macros to simplify writing Neon apps
-
xaynet-macros
Macros for internal use in
xaynet-server -
ast2str-derive
A crate for pretty-printing ASTs and other recursive data structures
-
urid-derive
Procedural macros for urid
-
lattice_qcd_rs-procedural_macro
Set of procedural macro for the main library lattice_qcd_rs
-
acme-derive
Derive macros for the acme-cli in support of the Scattered-Systems ecosystem
-
subtle-ng-derive
Derive macros for subtle-ng traits
-
crabler_derive
Derive macro for crabler library
-
asn1_codecs_derive
ASN.1 Codecs derive Macros
-
conflagrate-macros
Macros for conflagrate
-
build_cfg_macros
Proc macros for build_cfg
-
simavr-section-macro
Internal implementation details of the simavr-section crate
-
fizyr-rpc-macros
procedural macros for the fizyr-rpc crate
-
bird-protocol-derive
Packet, PacketReadable, PacketWritable derives for CubicProtocol
-
sunfish_macro
Web Application Build Tool
-
for_ch
to flatten nested for-loop
-
tree_hash_derive
Procedural derive macros to accompany the tree_hash crate
-
entrance_derive
A crate which provides derive macros for the crate entrance
-
agb_macros
Macro for declaring the entry point for a game using the agb library
-
targets
Some helpers to get you started with declarative programming in Rust
-
pocket_prover-derive
Derive procedural macros for
pocket_prover -
compare_by_address_derive
Derive macro for comparing and hashing structs/unions/enums by address
-
enum-repr-derive
Simple trait for converting enum to and from its primitive repr type
-
match-lookup
proc macro for generating match block for alphabets, please dont use this. its slow and extremly likely to not be what you are looking for.
-
notation_macro
Fun notation - DSL to create notation files
-
generate-derive
Provides derive functionality for the
generatecrate -
cpreprocess
Procedural macro that runs a C preprocessor on the input
-
configr_derive
The dead easy way to use config files in your project
-
clap-handler-derive
A command handler works with
clap-deriveto generating subcommand handlers -
temply-derive
Procedural macro for temply
-
flamer
a procedural macro to insert
flame::start_guard(_)calls -
match_opt
A macro for turning a partial match into a full match returning an option
-
diesel_enum_derive
Simple Enum derive for [Postgres only] Varchar fields
-
turbolift_macros
macros for turbolift
-
char-lex-macro
Create easy enum based lexers
-
extra_args
Rust macro to pass implicit args to functions (use with care)
-
sensible
Configurable derive macro for implementing Default
-
fut-ret
A rust library to parse the return type generated by async_trait in procedural macro
-
relearn_derive
Derive macros for the relearn package
-
inventory-impl
Implementation of macros for the
inventorycrate -
autoincrement_derive
Derive macros for
autoincrementcrate -
pio-proc
proc-macro for assembling PIO code in a Rust program at compile time
-
elapsed-printer
Very simple macro for printing time elapsed to execute a function
-
tinyparse_macro
Macros for tinyparse
-
tokenstream2-tmpl
Runtime TokenStream interpolation for Rust macros
-
kg-diag-derive
Macro implementation for #[derive(Detail)]
-
stidgen
Strongly Typed ID types macro
-
laby_macros
HTML transformation macros for laby
-
deser-derive
Derive extension for deser
-
shorthand
A proc_macro to derive getter and setter for structs
-
lurk-ipld-cbor-derive
lurk-ipld dag-cbor-derive
-
sully_peg
Proc macro for PEG generation
-
dipa-derive
The derive macro for the dipa crate
-
sqlx-model-macros
sqlx model macro
-
codesnip_attr
snippet bundle tool
-
winit-main-proc
Proc macros for winit-main
-
its_ok
A macro for replacing ? with unwrap
-
ev3robot_macros
Proc-macro crate for ev3robot. Don’t depend on this crate directly
-
bitaccess_macros
bitaccess macro implementations (use
bitaccessinstead of this) -
advancedresearch-nano_ecs
A bare-bones macro-based Entity-Component-System
-
byewlma-macros
Macros for
byewlma -
craydate-macro
Proc macros for using the craydate crate
-
readonly
Struct fields that are made read-only accessible to other modules
-
dmv_derive
Defines the
Dmvderive macro -
default-args
zero-cost default arguments in rust
-
get_len_base_10_as_usize_macros
Macros for
get_len_base_10_as_usizecrate -
eva-sdk-derive
EVA ICS v4 SDK derive macros
-
recap-derive
Derives FromStr impl for types which are then deserialized using recap
-
scale_impl_generator
a proc macro to generate a large percentage of all impls on SCALE crypto primitives
-
notan_macro
Provides a set of utils as macros for Notan
-
aqua_parse_macro
The macro used in ‘aqua_parse’
-
tracing-forest-macros
Macros for tracing-forest
-
deq_macros
Deq macros
-
dilib-derive
Derive proc_macros for the dilib crate
-
z3d
Z3 DSL interface for Rust
-
nongoose-derive
Macros implementation of #[derive(Schema)]
-
starship_module_config_derive
The minimal, blazing-fast, and infinitely customizable prompt for any shell! ☄🌌️
-
from-to-repr
Derives TryFrom and From implementations for the representation type of a Rust enumeration
-
qu-derive
internal part of qu crate
-
data-query-proc
a Proc support library for the Data Query
-
goldberg
A Rust-based obfuscation macro library!
-
actix-json-responder
A procedural macro to reduce json response boilerplate on actix projects
-
assemblylift-core-guest-macros
Procedural macros for assemblylift-core-guest
-
aversion-macros
macros to support the aversion crate
-
io_self_derive
Derive macros for the io_self crate
-
compile_msg
A plugin for emitting errors, warnings and notes to the developer at compile time
-
fixed-point-macros
Macros for fixed-point package
-
poem-openapi-api-derive
Macro for unify OpenApi implements
-
load-dotenv
This is a small procedural macro to load your .env file at compile time
-
function-frame
Procedural macro to wrap any function outputs within a text frame
-
frender-macros
macros for frender
-
multiversion-macros
Implementation crate for multiversion
-
scripthookv-rs-macros
Macros for scripthookv-rs
-
fieldmask_derive
derive macros for the fieldmask crate
-
grass-macro
Procedual Macros for GRASS
-
rsrl_derive
Macros for RSRL
-
actix-handler-macro
Helper macros for using Actix. Generates handlers, actors and address traits.
-
ebpf-kern-macros
Kernel space macros for libbpf
-
monomo_macros
Macros for monomo crate
-
saito-macros
Macros for using in Saito Consensus
-
sub-model
a proc marco for easy generate sub models
-
secop-derive
A Rust framework for a hardware server speaking the SECoP protocol (derive package)
-
dynpath
An attribute macro to specify a path to a module dynamically
-
surrealdb-derive
Private implementation of procedural macros for surrealdb
-
lpu-macros
Macros used for lego-powered-up
-
constduck-procmacro
Macro implementation of #[derive(ConstDuck)]
-
binary_macros_impl
Procedural macro implementations for decoding base64-like encodings in string literals to [u8] literals
-
hobo_css_macros
hobo is a Rust frontend framework
-
carbide_derive
A crate providing procedural macros for the carbide library
-
bingen
Procedure macro for bringing a compile-time compiled assembly code as a binary slice
-
rkyv_dyn_derive
Macros for rkyv_dyn
-
fast-map-derive
Maplike using match
-
fixed-macro-impl
Proc-macro implementation for the
fixed-macrocrate -
progenitor-macro
An OpenAPI client generator - macros
-
proc-macro-kwargs
Keyword argument parsing for function-like proc-macros
-
zookeeper_derive
Derive implementations used to build the ZooKeeper library
-
automato
a crate to generate state machines enforced at compile time
-
ebml-iterable-specification-derive
Provides macros for implementing
EbmlSpecificationfor theebml-iterablecrate -
microserde-derive
Derive macros for microserde. Use the re-exports from the microserde crate instead.
-
stable-step-derive
An implementation of Step for stable rust (derive macros)
-
macro-compose
macro-compose is a library trying to simplify and organize proc-macros
-
discord_typed_interactions_proc_macro
suppose you’re working with discord slash commands and you want statically typed request types
-
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… -
forever-rs
The complete solution for Rust command-line interfaces
-
ev3dev-lang-rust-derive
Derive macros for ev3dev_lang_rust
-
arr_macro_impl
Private impl crate for arr_macro
-
ya-runtime-sdk-derive
Macro implementation of #[derive(RuntimeDef)]
-
err-per-field-derive
Derived macro for err-per-field crate
-
chekov_macros
CQRS/ES Framework macros
-
evmap-derive
Derive macro for evmap::ShallowCopy
-
npyz-derive
#[derive(…)]s for reading structured arrays in NPY files
-
envload_derive
Derive macro for envload
-
suricata-derive
Derive macros for Suricata
-
orga-macros
Macros for the orga crate
-
activitypub_federation_derive
High-level Activitypub framework
-
rustico
Rust programming, in Spanish
-
format-bytes-macros
Macros for the format-bytes crate
-
packtool-macro
In memory packing made easy: procedural macro definitions
-
validated_struct_macros
Macros for validated_struct
-
simple-hash-macro
A derive macro for simple-hash
-
desugar
Allow for Desugaring of various Rust constructs
-
partial-application-rs
A macro to transform functions into partially applicable structs
-
auto-diff-macros
Macros for auto-diff
-
moose-macros
Macros used by Moose
-
rebound-proc
Proc macros associated with the rebound crate
-
keyframe_derive
Implements #[derive(CanTween)] for keyframe
-
otopr-derive
Obvious Rust Protobuf Library - Derive Macros
-
mp4ameta_proc
Procedural macros to generate common accessors for the mp4ameta crate
-
sqlx-plus-macros
A proc-macro implementations for sqlx-plus
-
jsonrpc-utils-macros
Proc-macros for jsonrpc-utils
-
lerp_derive
Generic linear interpolation and extrapolation, automatically implemented for a variety of numeric types
-
yewtil-macro
Macros to be re-exported from the yewtil crate
-
comprehension
Iterator comprehension in Rust
-
sanitizeable_derive
derive structs without certain fields
-
derive-deref-rs
derive-deref-rs is a derive macro library used to easily defined the Derive and DrerfMut trait of the core library
-
auxtools-impl
procedural macros for use with the auxtools crate
-
canadensis_macro
A procedural macro that generates Rust data types and serialization code from inline and/or external Cyphal DSDL files
-
cstr-macros
Procedural macros for cstr
-
minceraft-derive
derive macros for minceraft
-
into-attr-derive
The macros helping to convert the structure into graphviz dot attrivute
-
fieldfilter-derive
Proc macro to derive FieldFilterable
-
cbor_enhanced_derive_protocol
Derive macro implementation for cbor_enhanced
-
trace-tools-attributes
Procedural macros for trace-tools
-
pest-ast
Derive to convert from pest parse tree to typed syntax tree
-
fbthrift_codegen_includer_proc_macro
Helps include generated thrift structures
-
reshape_helper
Helper library for Reshape
-
neo-mime-macro
mime procedural macros
-
netxbuilder
netx builder assembly
-
jmespath-macros
Statically compiles JMESPath expressions
-
disp
derive Display from Debug
-
bash_builtins_macro
Macros for the bash-builtins crate
-
festive-macros
Run your tests in isolation
-
aleo-std-timed
A profiler to conveniently time function executions
-
pbni-codegen
PBNI for Rust Codegen
-
std140-macros
Procedural macros for the std140 crate
-
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.
-
namewise
Derived trivial name-wise conversions for Rust types
-
askama_shared
Shared code for Askama
-
actori_derive
Actor framework for Rust
-
sfsm-proc
Macros to generate state machines for sfsm
-
tonic_include_protos
A helper proc-macro to include all protobuf files generated by tonic_build
-
defaults
A better
Defaultderive macro -
db-derive-impl
Derive proc-macro for db-derive
-
masala
Automatic curry. Yum!
-
tencent_scf_derive
Derive helper for crate tencent_scf
-
pathsep
a small macro to enable easy path construction in other macro calls
-
fuzzy-pickles-derive
Procedural macros for fuzzy-pickles
-
restruct
Converts between raw bytes and structured data
-
bl602-macros
Macros for BL602 IoT SDK
-
beamcode_derive
Internal proc macros for beamcode crate
-
static-map-macro
Macro to create a stack-alocated map
-
generate-random-macro
Generate random data
-
aoc_macros
helper macros for AoC
-
robespierre-fw-macros
robespierre - framework macros
-
jcers_proc
proc-macro for jcers
-
dlopen2_derive
Derive macros for the dlopen2 crate
-
xflags-macros
Private implementation details of xflags
-
custom_debug_derive
Derive Debug with a custom format per field
-
moisture
Moisture is a Rust-based parsing library intended for use with procedural macros!
-
carrier-pigeon-netmsg-derive
The NetMsg derive macro for carrier-pigeon
-
point-derive
Proc macro to help with struct to ts point conversion
-
cherry-derive
An asynchronous ORM, support MySQL, PostgreSQL, SQLite and SQL Server
-
sp-core-hashing-proc-macro
This crate provides procedural macros for calculating static hash
-
snake_cased_derive
derive for snake_cased
-
dioxus-native-core-macro
Build natively rendered apps with Dioxus
-
ioctl-gen
Simple macros for generating ioctl numbers
-
tractor-macros
Proc macros for
tractor -
rawcode_derive
Implements a
derivemacro forrawcode -
x86test-macro
Procedural macro plugin for x86test
-
fstrings-rust-proc-macro
Python3 fstring interpolation in Rust
-
bolt-client-macros
Procedural macros for bolt-client
-
variant_counter_derived
Rust’s Enum variant counter
-
tonic-error-impl
The derive proc-macro for the tonic-error crate
-
futures-select-macro-preview
The
select!macro for waiting on multiple differentFutures at once and handling the first one to complete -
ergo-pin
Ergonomic stack pinning
-
concision-derive
Concision is a data-science toolkit for building robust, data-centric applications in Rust
-
linux_details_macros
proc-macros for linux_details
-
emacs-macros
Proc macros for emacs modules
-
corresponding-macros
Procedural macros for corresponding crate
-
etanol_macros
A macros for etanol-rs
-
ffi-gen-macro
ffi-gen macro
-
flatk-derive
Derive macros for deriving traits for flatk
-
better-macro
This crate provides better versions of common macros like println
-
displaythis-impl
Implementation detail of the
displaythiscrate -
diesel-selectable-macro
A derivable
Serializemacro that selects precise fields -
fallacy-clone-derive
Derive macro crate for fallacy-clone
-
xdr-rs-serialize-derive
XDR object serialization for Rust
-
ext-trait-proc_macros
Internal: proc-macro backend of ::ext_trait
-
rustify_derive
A derive macro for implementing an Endpoint for rustify
-
waytogo-macro
Waytogo macro library
-
defunctionalize-proc-macro
Defunctionalization as a proc-macro over modules
-
finte-derive
#[derive(IntEnum)] support for finte
-
pn-dcp-macro
Aim to quickly parsing and splicing pn-dcp packet
-
macrotk
The Rust macro toolkit
-
packed_struct_codegen
This crate implements the code generation for the packed_struct library
-
casper_types_derive
Use struct types in Casper contracts without boilerplate
-
yatima-rustyline-derive
yatima-rustyline macros
-
ggplot-derive
derive(Merge) for GGPlot
-
datastore_derive
Derive macros for datastore
-
sing_macros
Macros for sing_rs
-
ffi-convert-derive
Macros implementations of CReprOf, AsRust, CDrop traits from ffi-convert
-
wasm-interfacegen-macro
Definition of the JsInterface procedural derive macro, an internal dependency of wasm-interfacegen
-
bitcoin-cash-script-macro
A procedual macro to ease writing bitcoin cash scripts, base library for the bitcoin-cash library
-
c-like-concat
simple macro that works just like C’s ##
-
zeronet_sign_derive
ZeroNet content signing
-
kexplain
Derive explanations for functions by ‘showing the work’ for things like math
-
gll-macros
Macros used with the gll crate
-
ord_by_key
Provides a convenient macro for implementing Ord trait with logic specified in an inline expression
-
bio-seq-derive
Derive macros for the bio-seq crate
-
sgx_rand_derive
Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language
-
partfun_derive
Used by other partial-* crates
-
shardize-core
Core libraries for shardize
-
crayfish-macros
Crayfish macros
-
autoproto-derive
Derive macros for
autoproto -
bevy_proto_derive
Derive macro for use with bevy_proto
-
solders-macros
A collection of attribute macros to reduce boilerplate in the solders project
-
const_panic_proc_macros
Implementation detail of the
const_paniccrate -
async-proto-derive
Proc-macros for the async-proto crate
-
poem_openapi_validator_derive
poem openapi validator
-
utf32-lit
A macro for creating
&[char]literals -
variantly
Derive helper methods for enum variants that are familiar from
std::option::Option&std::result::Resultsuch asunwrap_ororand_then -
test-env-helpers
Jest style setup and teardown test helper macros
-
derive-alias
Alias multiple derives as one
-
third-pact
Macro library for generating basic endpoints for models
-
func_trace
A procedural macro for tracing the execution of functions
-
hrpc-proc-macro
Proc macros for hRPC
-
windows-implement
The implement macro for the windows crate
-
headers-derive
derive(Header)
-
mathml-macros
Macros for mathml-rs
-
egui_inspect_derive
Derived traits for egui_inspect crate
-
af_path
path查询语言库
-
hard-xml-derive
Derive marco of hard-xml
-
doku-derive
A framework for building documentation (internal macro)
-
machinery-macros
Macro utilities for the
machineryandmachinery-apicrates -
extends-rs
rust extends impl a macro attr
-
oracle_procmacro
Procedural macro for the oracle crate
-
argio-macro
A macro to convert function input and output to stdio
-
wrapcenum-derive
Derive macro for nvml-wrapper, not for general use
-
specs_declaration
A simple macro to effectively create SPECS systems
-
attribution
A declarative custom attribute parsing framework
-
mady_macro
🌲 mady’s subpackage
-
visa-rs-proc
procedural macros used in visa-rs
-
aide-macros
Macros for the Aide library
-
tw-storage-macros
Procedural macros helper for interacting with
cw-storage-plusandcosmwasm-storage -
rsip-derives
rsip helpful macros, for internal use mostly
-
ethercat-derive
Automatic deriving of traits in the ethercat-plc crate
-
tinyhttp-codegen
Provides codegen for tinyhttp
-
pgmacro
venom_server 中 pgbaits 用的宏 作用是自动给结构体生成对应的SQL语句。
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
channel-server-derive
derive lib for channel-server crate
-
either_trait_macro
An attribute-like macro to implement traits for Either
-
test-span-macro
macro to do snapshot tests on tracing spans, usint test-span
-
rocket-config-codegen
Procedural macros for the rocket-config library
-
cuach-derive
A HTML template system for Rust
-
discrab_codegen
proc macros for Discrab (a discord bot wrapper)
-
verilated-module
A procedural macro for replacing verilated marked up structs with include of generated code
-
ref-mut-n
Defines a nested mutable reference
-
jsonschema_code_generator
Crate for generating rust types from JSON schemas
-
charify
A simple proc macro to turn its token input into a char, similar to the built-in stringify! macro
-
hashfn
A procedural macro to generate a hash representation of a function as a string slice
-
intercom-attributes
See ‘intercom’
-
gauge-mac-derive
A derive proc-macro library
-
predicate-macros
Easy to implement predicate crate traits
-
spatialos-macro
Procmacro crate used to expand SpatialOS component and types created with spatialos-codegen
-
casey
Case transforming macros for ident tokens
-
actix-proc-macros
Proc macros, to be re-exported by
actix-helper-macros -
unpat
Unboxing the pattern with easy syntax
-
nacos-rs-sdk-macro
THIS PROJECT IS SUPPORTER FOR NACOS-RS-SDK
-
bevy-contrib-inspector-derive
Implementation detail of the
bevy-contrib-inspectorcrate -
rlua-builders-derive
Derive helpers for struct/enum for rlua
-
call2-for-syn
Apply parser functions to proc-macro2 token streams
-
msfs_derive
This crate provides macros for MSFS
-
bitstream_reader_derive
Reading bit sequences from a byte slice
-
dlopen_derive
Derive macros for the dlopen crate
-
alloc_counter_macro
The #[no_alloc] macro for the alloc_counter crate
-
wasmer-derive
Wasmer derive macros
-
asterix-derive
proc-macro convenience with the deku library, for updating ASTERIX FSPECs
-
indirect-once-derive
One-time resolvable runtime indirection in the style of glibc’s ifunc
-
huber-procmacro
Interal package used by Huber
-
jni_fn
JNI-compatible method signature generator
-
cppvtbl-macros
Helper macros for cppvtbl
-
yew-component
A simple macro to generate yew components from a single struct declaration
-
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
-
pi_ecs_derive_old
ecs_derive
-
quartz_commands_macros
This crate contains the function-like procedural macro which parses quartz_commands’s custom syntax
-
iterator_item_macros
proc macros for the iterator_item crate
-
runestick-macros
Runescript, a generic stack-based virtual machine for Rust
-
iced_focus_derive
A proc-macro to derive a focus chain for Iced applications
-
derive-system
Rust implementation of https://github.com/stuartsierra/component
-
verify_macro
An attribute that automatically instruments code with logical type bounds
-
adminix_macro
macro for adminix
-
postfix-macros-impl
Proc macro crate for postfix-macros
-
sudograph-generate
Procedural macro for Sudograph
-
lamedh_attributes
Lambda macro attributes
-
scraper-macros
Macros implementation of #[derive(Scraper)]
-
reql-macros
Macros for the reql crate
-
alacritty_config_derive
Failure resistant deserialization derive
-
accessors-rs
Derive macro generating an impl for accessing the fields of a struct
-
color-macro
Css color parser at compile time
-
quote_precise
A quote implementation that preserves meaningful span locations
-
inherent
Make trait methods callable without the trait in scope
-
rust_gui_macros
This project is a part of the library rust-gui
-
futility-try-catch
try/catch proc-macro for the futility crate
-
dyn_partial_eq_derive
Implementation of dyn_partial_eq
-
lrpc-macros
lrpc’s proc macros
-
stdf-record-derive
Procedural macros supporting the
stdfcrate -
typic-derive
Type-safe transmutations between layout-compatible types
-
from_variants_impl
Internal helper crate for from_variants crate
-
mws-derive
Derive macros for mws
-
logfn
provides the logfn attribute macro for inserting logging code into your function
-
foreignc_derive
Creates methods for deriving ffi abis. Made as a part of the foreignc crate
-
acme-macros
Procedural macros created to support Acme, an all-in-one blockchain toolkit
-
bakkesmod-macros
Procedural macros for the bakkesmod crate
-
tappet-derive
Implementation detail of the
tappetcrate -
origen-core-support
Support crate for the separate ‘origen’ crate
-
pyo3-prost
Use Rust protobuf structs in Python
-
rtlola-macros
Procedural macros for more convenient handling of HirModes in the rtlola_hir crate
-
observer_attribute
Observer Attributes
-
trpc-rs-macros
Macros for
trpc-rs. You don’t need to import this directly! -
tttr-toolbox-proc-macros
Proc macros for ttt-toolbox
-
concat-arrays
A macro for concatenating fixed-size arrays
-
ntex-macros
ntex proc macros
-
abistr-macros
proc macro implementations for abistr
-
muta-codec-derive
Muta fixed codec derive procedural macros
-
cell-gc-derive
Custom derive support for cell-gc
-
cuda_std_macros
Macros for cuda_std
-
ptr_meta_derive
Macros for ptr_meta
-
asn1_der_derive
This crate contains a procedural macro to implement
derivefor myasn1_dercrate -
easy_proc_macro
Rust’s last proc-macro crate
-
serde-enum-str
Serialize and deserialize enum string
-
lovm2_internals
a lightweight virtual machine with a focus on simplicity and extendability
-
you-can-build-macros
ಠ_ಠ
-
forward_goto
Crate bringing gotos to Rust
-
jsonrpc_client_macro
Internal proc-macro crate for
jsonrpc_client -
syn-pub-items
Parser for Rust source code (patched for pub items)
-
witgen_macro
Macros for witgen which is a library to help you generate wit definitions in a wit file for WebAssembly
-
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…
-
goods-proc
Proc-macro for “goods” crate
-
cruiser_derive
Derive macros for
cruiser -
jrsonnet-gc-derive
Garbage collector derive plugin for rust-gc
-
quit_macros
Procedural macros used by crate quit
-
clickrs_proc_macro
Simplified CLIs for Rust via procedural macros (Python’s click, for Rust). The procedural macro crate.
-
tokio_env_macro
Procedural macros for tokio_env
-
ocaml-build
OCaml code generation
-
flaggy-codegen
proc-macro code generation for flaggy
-
enum-methods
Generates methods for each enum variant
-
python_comm_macros
proc macros for python_comm
-
shred-derive
Custom derive for shred
-
frame-support-procedural-tools
Proc macro helpers for procedural macros
-
generic-predicates-macro
A taste of what const generics could enable in the future
-
goglob-proc-macro
Internal library used by goglob, not for public use
-
wotw_seedgen_derive
Derive macro utilities used for wotw_seedgen
-
mediaflow_derive
Macros for the unofficial SDK to interact with the Mediaflow Pro API
-
rayon-join-macro
A convenience n-nary macro around
rayon::join() -
static_res
A compile time asset file collector
-
typed-sql-derive
Macro implementation for typed-sql
-
enum-lexer-macro
A proc_macro lexer generator. using
enum-like syntax. -
metriki-macros
Macros for metriki
-
irrefutable
Procedural macro to convert a refutable let expression to an irrefutable
-
pm-lexer
This is a sample lexer using the proc-macro crate, to be used in the pomelo testings
-
rlp-derive
Derive macro for #[derive(RlpEncodable, RlpDecodable)]
-
jnix
High-level extensions to help with the usage of JNI in Rust code
-
quickjs_regex_derive
quickjs libregexp
-
flag-mast-derive
Ergonomic Rust bit flags
-
address-literal
Procedural macro for converting Address(H160) literals to Address(H160) at compile time
-
unsafe-storage
Maintain invariants in macros without modules
-
kv-derive-macro
Macro definitions for
kv-derive -
serialize-to-javascript-impl
Implementation detail of
serialize-to-javascript -
net-literals
Literals for IP/socket addresses
-
bevy_aseprite_derive
Bevy aseprite loader derive
-
try-catch
A simple proc-macro that enables try-catch for Rust with automatic downcasting of error types
-
syn_util
helper APIs for procedural macros
-
savory-derive
Custom derive support for savory crates
-
mattro
A macro attribute parser
-
rsconnect_macros
Fine-grained reactivity in Rust (macros)
-
adorn
A plugin to provide python-style decorators in Rust
-
swc_ecma_codegen_macros
Macros for swc_ecma_codegen
-
erl_nif_macro
Write Erlang and Elixir NIFs in Rust
-
ector-macros
Ector is an open source async, no-alloc actor framework for embedded devices
-
ts3_derive
Derive macro for ts3 crate
-
pl-lens-derive
Provides procedural
derivemacros that are used in conjuction with thepl-lenscrate -
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
safe-regex-macro
Macro for the safe-regex package
-
macro_state_macros
Support crate for macro_state containing proc macros
-
consulrs_derive
A derive macro for implementing query options for Consul endpoints
-
biscuit-quote
macros for compile time datalog parsing for Biscuit authorization tokens
-
join_str
Proc macro to do simple string interpolation as an array join
-
serde_dhall_typegen
Automatically generate Rust structs and enums from Dhall types
-
mocktopus_macros
Mocktopus procedural macros
-
fastrlp-derive
Procedural macros for fastrlp
-
arcdps_codegen
Macros for arcdps
-
avantis-utils-derive
Derive macro for avantis-utils crate
-
controlled-option-macros
Procedural macros for the controlled-option crate
-
type-census-derive
Proc-macro derive for type-census
-
compile_ops
Compile time operations to not affect your performance and constness with ecuations you can encode
-
gluon-salsa-macros
Procedural macros for the salsa crate
-
gpkg-derive
Internal crate used for derive macros in gpkg crate
-
polyhorn-ui-macros
Procedural macros for Polyhorn UI that turn a CSS-like specification into style structs
-
try-let
Proc macro for a basic try-let form
-
transmute-tools
Proc macros and traits to assist with safely creating transmutable data structures
-
sea-strum_macros
Helpful macros for working with enums and strings
-
static-reflect-derive
Procedural derive for static-reflect
-
peepmatic-macro
Macros for peepmatic
-
oasis-amqp-macros
Helper macros for AMQP 1.0 type definitions
-
rustorm_codegen
code gen provides macro for generating code on data access objects on table metadata
-
ergol_proc_macro
the proc macros for ergol, an async ORM for Rust
-
srpc-macro
contains srpc’s macros
-
configure_derive
Derives for the configure crate
-
devise_core
A library for devising derives and other procedural macros
-
shard_ecs_derive
Contains derive macros for the Shard Entity Component System
-
awesome-glib
Bunch of macros to make a life of gtk/glib user easier
-
yerpc_derive
Proc macros for yerpc
-
bevy_editor_iris_derive
Macros for bevy_editor_iris
-
package_info_derive
Derive macro for exposing Cargo Package Information to Rust code
-
lvbitfile2rust-macros
Macro entrypoint for the lvbitfile2rust crate
-
derive-collect-docs
Collect documentation from Rust structs using a
CollectDocsderive macro -
c3-lang-macro
C3 Lang macro
-
bit-by-bit
Convenient proc-macro for defining structs with bitfields
-
percy-router-macro
A macro for client side web application routing
-
wasm-rpc-macros
Expose rust functions as WASM RPC interfaces
-
derive_weak
Make weak counterpart for structure
-
tackt-macros
HTTP router
-
paste-impl
Implementation detail of the
pastecrate -
ataraxy
Discord slash commands framework for Serenity
-
polyhorn-macros
Macros and parser for Polyhorn JSX-like syntax
-
address-cmp
An attribute for address comparison
-
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… -
structmeta-derive
derive macro for structmeta crate
-
async_object_derive
Async Object wrapper macros
-
inline-vbs-macros
Macros for the
inline-vbscrate -
discrim-codegen
Codegen for discrim
-
merfolk_frontend_derive
A
Frontendfor merfolk using derive macros -
ff_derive-zeroize
Procedural macro library used to build custom prime field implementations
-
simd-json-derive-int
procmacros for simd-json-derive
-
piston2d_abstraction_proc_macros
Procedural macros for the piston2d_abstraction crate
-
sunbeam-macro
A dynamic CSS class library
-
holium-macro
Procedural macro for the Holium Rust SDK
-
join_impl
Implementation of the
join!macro -
opaque_typedef_macros
Supports defining opaque typedefs
-
calcite_proc_macros
A helper library for calcite
-
bitbag_derive
Derive macros for the bitbag crate
-
open-metrics-client-derive-text-encode
Auxiliary crate to derive text Encode trait from open-metrics-client
-
nameless-clap_derive
Parse command line argument by defining a struct, derive crate
-
expression_format_impl
macros implementation for crate expression_format
-
portus_export
Procedural macro for use with portus, CCP congestion control algorithms
-
destruct-derive
Destruct structs and enums for simpler combinator implementation
-
opt_args
Create macros for functions and structs with default values
-
ez-proc-macro
internal. not stable.
-
rusty_v8_helper_derive
A rust derive macro for rusty_v8_helper
-
enumscribe_derive
Derive macros for converting between enums and strings
-
rokol_derive
Derive crate for Rokol
-
yui_derive
Internal derive and proc macro for Yui
-
typenaming-derive
Infrastructure to derive name of type - proc macro crate
-
from_bytes_derive
create from_bytes() and packed_size() to read binary data into structs
-
rust_hawktracer_proc_macro
helper crate for hawktracer profiling library
-
label-macros
Label functions and iterate over them
-
red_asn1_derive
macros for red_asn1
-
js-sandbox-macros
Procedural macros for js-sandbox
-
embedded-error-chain-macros
Procedural macros of the
embedded-error-chaincrate -
const-table
Associate struct-typed constants with enum variants
-
convert-js-macros
macros for convert-js
-
aper_derive
Synchronized state machines over WebSockets
-
elise-derive
Macros Für Elise
-
variants-struct
A derive macro to convert enums into a struct where the variants are members
-
easy-jsonrpc
Convert a trait definition into a jsonrpc api
-
stderr
A library that using macro to write to io::stderr() like print!()/println!()
-
term-data-table-derive
Derive macros for
term-data-table -
moonboot-macros
Macros for moonboot bootloader framework
-
from_tuple
Derive structs from tuples
-
telexide_proc_macros
macros for subscribing to events in telexide
-
ctjs
compile time javascript as a rust proc macro
-
checkout_server_derive
a crate to generate state machines enforced at compile time
-
awint_macro_internals
Internal macro utilities for the
awintsystem of crates -
ormlite-macro
An ORM for people who love SQL. Use the
ormlitecrate, not this one. -
abomonation_derive
A custom derive plugin for abomonation
-
vertigo-macro
Virtual DOM library for Rust - macros for html and fetch
-
paw-attributes
Proc Macro attributes for the Paw crate
-
funtime
A proc-macro helper to time Rust functions
-
const_env_impl--value
Configure const and static items by environment variables
-
oxlex-derive
Derive component for oxlex
-
toql_query_macro
Library with query macro for Toql
-
binver_derive
derive for binver
-
partialdebug-derive
macros for partialdebug
-
type_hash_macros
Internal macro definitions. They may not work properly if not used via the type_hash crate.
-
idl-macro
Generates an Anchor CPI crate from a JSON IDL
-
simd_helpers
Helpers to write more compact simd code
-
async-injector-derive
A derive to help construct dependent values in async-injector
-
sqlx-models-proc-macro
A helper crate for
sqlx-models -
derive-ocaml
Custom derive and procedural macros for easy FFI with ocaml on top of the ocaml crate
-
scones_macros
Macros that power the Scones crate
-
rg3d-core-derive
Proc-macro for the Visit trait
-
rocket_db_pools_codegen
Procedural macros for rocket_db_pools
-
seawater-macro
It is a procedural macro library used together with seawater
-
varisat-internal-macros
Internal macros for the Varisat SAT solver
-
uni_components_macro
Macroses for uni_components crate
-
peek-poke-derive
Derive macro for peek-poke
-
mux-stream-macros
Internals of mux-stream
-
redis-lua-macro
Macro component of Redis Lua scripting helper
-
enum_traits_macros
Procedural macros that adds functionality to enums by deriving traits from the crate
enum_traits -
enum_variant_macros_macros
Macros for enum_variant_macros
-
flowmacro
Definition of a ‘flow’ attribute macro to help write implementations
-
impl_trait
Allows impl trait inside inherent impl
-
sm-ext-derive
Procedural macro package for sm-ext helpers
-
from_value_derive
Implement impl Form<CustomStruct> for serde_json::Value
-
requestty-macro
The
questionsmacro forrequestty -
genco-derive
Quote macro for the even simpler code generation for Rust
-
reflect-internal
Procedural macros required by the
reflectcrate -
jsonrpc-v2-macros
Proc macros for jsonrpc-v2
-
actix_responder_macro
An attribute macro to transform a response struct to an actix responder
-
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 -
lucene_query_builder_rs_derive
This crate is used internally by lucene_query_builder
-
inline-rust
A stupid macro that compiles and executes Rust and spits the output directly into your Rust code
-
html-to-string-macro
simple html to string macro powered by syn-rsx
-
geobacter-runtime-amd-macros
Geobacter AMDGPU specific derive macros
-
validated_struct
Easily generate nested structures with getters and predicated setters
-
poem-openapi-macro
The macro collections for extending the Poem OpenAPI
-
dotenvy_macro
A macro for compile time dotenv inspection
-
notation_dsl
Fun notation - DSL to create notation files
-
err-derive
Derive macro for
std::error::Error -
baker
Derive macro for creating intermediate structs
-
rdxl_internals
RDXL Internals
-
derive_jface
Java Native Interface to rust Native Objects (derive)
-
eff-attr
Attribute macro for eff
-
malloc_size_of_derive
Crate for Firefox memory reporting, not intended for external use
-
overloadf_derive
unlock function overloading for rust
-
static-address
A macro used for compile-time parsing of Move account addresses into byte arrays for near 0-cost static addresses
-
col_proc_macros
A bunch of procedural macros for declare collections of various kinds from their contents as fast as possible
-
parse-variants
Derive the syn::parse::Parse trait for enumerations and use it to comfortably parse a variant of the enumeration
-
dill-impl
Implementation details of the dill DI library
-
ref-cast-impl
Derive implementation for ref_cast::RefCast
-
restruct_derive
Converts between raw bytes and structured data
-
lockjaw_processor
proc_macro processor for lockjaw
-
libvmm_macros
Virtual Machine Monitor macros
-
eagre-asn1
A asn1 library, currently only supporting DER
-
sppparse_derive
Derive macro for Sppparse
-
id_collections_derive
Procedural macros for the ‘id_collections’ crate
-
gen-nested-iter-yield
A macro for creating n-nested for loops over iterators
-
luao3-macros
Macros/derive for luao3
-
rocket_okapi_codegen_fork
Macros supporting rocket_okapi forked from rocket_okapi_codegen_fork
-
const-enum-tools-derive
Trait definitions for working with enums at compile time using macros
-
easy_proc_derive
Derive macros for
easy_proc -
better_typeid_derive
derive macro part of better_any
-
unique-type-id-derive
A unique id proc-macro generator for types
-
standalone-quote
Fork of quote that allows disabling the proc-macro feature in proc-macro2 so as to remove the rustc dylib dependency
-
cubic-protocol-derive
Packet, PacketReadable, PacketWritable derives for CubicProtocol
-
bart_derive
#[derive(BartDisplay)] implementation for supporting the bart package
-
gxi-transpiler
transpiles component tree to gxi component system
-
time_main
Prints the time it took to execute the main function of a program with an attribute macro
-
databake
Trait that lets structs represent themselves as (const) Rust expressions
-
structype_derive
A derive macro crate that lets you view an allowed type’s fields and will let you over-ride it
-
syn-impersonated
Parser for Rust source code
-
const_internals
Internal macros for the constant crate. Not for external use!
-
extprim_literals_macros
Internal crate to support
extprim_literals. You typically don’t need this crate directly. -
async_t_internal
contains async_t macro
-
dotinstall-macro
proc macro for dotinstall crate
-
geoip2-codegen
geoip2 macros
-
hashmap_derive
A proc_macro to derive the FromMap trait
-
shank_macro_impl
Implements and tests shank derive macros
-
newt_proc_macros
Proc macros for newt-rs
-
serde-deserialize-over-derive
Derive macros for serde-deserialize-over
-
nifpga-type-macro
helper macro for nifpga datatype
-
bencher-macro
A benchmark library
-
better-bae-macros
A Rust proc-macro attribute parser
-
retrofit_codegen
proc macro crate for retrofit
-
efmt_derive
Internal proc macros for efmt crate
-
shredder_derive
Backing derives for the shredder library
-
diesel_as_jsonb
Use your structs as Jsonb with diesel and PG
-
rusteval-derive
macros for rusteval
-
coi-derive
coi-derive provides procedural macros for coi
-
dyn_struct_derive
Derive macros for the
dyn_structcrate -
pgc-derive
Garbage collector derive plugin for pgc
-
enumn
Convert number to enum
-
include_wgsl
A tiny proc macro to include a WGSL file in your binary, and verify that it is valid at compile time
-
attribute-derive-macro
Clap for proc macro attributes
-
inkpad-derive
derive macros for inkpad
-
edgedb-sdk-macros
Proc macros and derives EdgeDB SDK for WebAssembly workers
-
ophelia-derive
ophelia derive macros
-
argopt-impl
Parse command line argument by defining a function
-
hlbc-derive
Procedural macros for the ‘hlbc’ crate
-
rocketjson_macro
Crate for working with Json and Rocket
-
tracked-impl
Internal implementation details for
tracked -
specit
Spec “it” for Rust testing
-
mockalloc-macros
Procedural macro attribute for the mockalloc crate
-
type-uuid-derive
Custom derive for the type-uuid crate
-
windows_winmd_macros
Macro helpers for the windows_winmd crate
-
starchart-derive
Derive macros used by the starchart crate
-
refview_derive
Get a reference view of some fields into a struct
-
futures-macros-lite
futures about macros in lite
-
algoliasearch
Algolia client
-
binserde_derive
derive implementation for binserde
-
mady_macro_core
🌲 mady’s subpackage
-
keypath-proc-macros
proc macros for the keypath crate
-
type-layout-derive
Derive macro implementation for type-layout crate
-
ra_ap_proc_macro_api
TBD
-
witchcraft-server-macros
Macro definitions used by witchcraft-server
-
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
-
cenum-derive
A rust derive macro for C-style primitive enums
-
pi_async_macro
A async file macros tools
-
verify-macros
Procedural macros for the Verify library
-
concision-macros
Concision is a data-science toolkit for building robust, data-centric applications in Rust
-
macro_rules_attribute-proc_macro
Use declarative macros as proc_macro attributes or derives
-
uucore_procs
uutils ~ ‘uucore’ proc-macros
-
bmw-derive
A derive proc-macro libray
-
maomi-macro
A rust wasm framework for building pages with components (helper macros)
-
byte-enum-derive
Procedural macro implementation for byte-enum
-
df_rocket_okapi_codegen
Macros supporting rocket_okapi, used in DF Storyteller project
-
awsl-syn
AWSL parser for rust macro
-
ast2str
A crate for pretty-printing ASTs and other recursive data structures
-
counting-macros
Stateful numeric incrementing macros
-
illicit-macro
procedural macros for the illicit crate
-
bunt-macros
Helper crate for
bunt. Please see the docs ofbuntfor more information. Do not use this crate directly, API stability is not guaranteed! -
proper
Derives for converting primitives to and from simple enums and newtype structs
-
thruster-socketio-proc
The proc macros behind the thruster web framework
-
zisvalidator_derive
Derive macro for zisvalidator
-
compiler-tools-derive
A proc-macro for deriving powerful and fast tokenizers with compile-time regex
-
rotate-enum
A simple macro that implements prev() and next() methods to an enum
-
i-slint-core-macros
Helper macro for i-slint-core
-
mini-internal-miku
Derive macros for miniserde. Use the re-exports from the miniserde crate instead.
-
iffy
proc macro for simulating the ternary operator from C-like languages
-
unquote
A reverse quote macro… that is: A macro to parse input from a ParseStream according to a given pattern.
-
cffi-impl
Safe* C FFI interface generator - macro
-
asn1-rs-impl
Implementation details for the
asn1-rscrate -
derive_display_from_debug
A trivial Rust macro to derive the Display trait for any type with the Debug trait
-
shuttle-codegen
Proc-macro code generator for the shuttle.rs service
-
field_names
A proc-macro for exposing a struct’s field names at runtime
-
custom-slice-macros
Utilities to define custom slice types
-
ppc750cl-macros
Procedural macros for powerpc750cl
-
enum_const_derive
enum const trait
-
mark_tuple_traits
a proc_macro for marking tuples of length up to 32 with a single marker trait to bypass the ‘fundamental’ feature
-
defunctionalize
Defunctionalization as a proc-macro over modules
-
toql_sql_expr_macro
Library with sql expr macro for Toql
-
nommy_derive
derive(Parse)
-
multiconst_proc_macros
implementation detail of multiconst
-
automate-derive
Derive macros for the automate library
-
lv2-urid-derive
Procedural macros for lv2-urid
-
formy_derive
Derive macro implementation for ‘formy’
-
convert_by_name
Derive From and Into for structs and enums based on field and variant names
-
pin-init-internal
Internal implementation details of crate
pin_init -
inline-python-macros
Macros for the inline-python crate
-
pkbuffer_derive
derive macros for
pkbuffer -
mini-internal
Derive macros for miniserde. Use the re-exports from the miniserde crate instead.
-
macrotk-core
macrotk core types and functions
-
percy-css-macro
A macro for writing your CSS next to your views
-
resrap_proc_macro
Macros for resrap
-
idmap-derive
Automaticatically derives IntegerId for the
idmapcrate -
crokey-proc_macros
proc macros for the crokey crate
-
rust-ad-core-macros
Rust Auto-Differentiation
-
rp1-macros
Macros for RP1
-
act-zero-macro
Procedural macros for act-zero
-
deltastruct_proc
The proc-macro backend for the crate Deltastruct
-
indoc-impl
Indented document literals
-
cute_custom_default
Derive macro for
Defaulttrait with customization -
bigml_derive
Internal
derivesupport for unofficial BigML client bindings -
byte-strings-proc_macros
Internal: proc-macro backend of ::byte_strings
-
col_proc_macros_impl
The implementation crate of macros marked with the proc-macro-hack derive macro
-
postgres-syntax
Compile-time syntax checking of PostgreSQL queries
-
tiny-rpc-macros
Proc-macros for tiny-rpc
-
include-repo
This crate implements the ‘include_repo!’ macro for easy AGPL compliance! Include a tarball as a const in your code!
-
tojson_macros
A simple syntax extension generates default ToJson impl
-
descriptor_derive
A simple to use struct descriptor, derive crate
-
bitrange_plugin
Compiler plugin for bitrange to parse formats
-
openssl-macros
Internal macros used by the openssl crate
-
qname-macro
Type for qualified names in XML - macro
-
mock-syn
Mock / wrap syn structs and enums overiding specific fields
-
pl-lens-macros
Temporary crate used to implement the
lens!procedural macro -
smol-potat-macro
Proc macro for smol runtime
-
rutenspitz_macro
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
serde_apply_macros
Derive macro for serde_apply
-
catchr
A testing framework inspired by Catch for C++
-
displaydoc-watt
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
scrappy_do_codegen
Macros used by scrappy-do
-
klickhouse_derive
proc-macro crate for klickhouse
-
smelter
Custom derive attribute that automatically derives builder methods
-
crayfish-trace-macros
Crayfish trace macros
-
rspc-macros
Macros for
rspc. You don’t need to import this directly! -
near-units-macro
Macro for parsing strings literals of NEAR units
-
elm_rs_derive
Derive macros for elm_rs
-
proc-caesar
Procedural macro to break Rust IDEs
-
argser-macros
Provides the Macros for the Argser-Crate
-
futures-join-macro-preview
Definition of the
join!macro and thetry_join!macro -
syn-helpers
Framework for building derive macros
-
dtd-macro
A DTD file parser
-
ctjs_macros
compile time javascript as a rust proc macro
-
vptr-macros
Procedural macros for the
vptrcrate -
ataraxy-macros
Proc-macros for Ataraxy
-
derive_dumb
Derive
Dumbgenerates a structure in which all fields are public. Original structure can be converted using function calldumb. -
proc-macro-id
Identity procedural macro
-
azul-peek-poke-derive
Derive macro for peek-poke
-
fievar
Proc macrs to generate functions that return static slices of struct field names or enum variant names
-
many-macros
Procedural macros to support create MANY modules
-
fourcc
Syntax extension to generate FourCCs (four-character code)
-
outer_attribute
A library providiving
OuterAttributethat implementssyn::parse::Parsetrait -
alt_serde_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
rrw_macro
A macro crate for rrw to easily build clients for REST-APIs
-
devault
A more flexible alternative to deriving Default
-
logisheets_derives
macros that help LogiSheets serde the xml files
-
looking-glass-derive
looking-glass is a reflection & type-erasure library for Rust
-
ffishim_derive
Procedural macros for generating ffi-compatible stubs
-
esize
Implement From for enums with a derive macro
-
code_snippet_generator
A proc_macro for turning a snippet of code into colorized html
-
partial-borrow-macros
proc-macros for partial-borrow
-
turbolift_internals
macros for turbolift
-
serde-versions-derive
An attribute macro for adding a version byte when serializing a struct via Serde. Also allows deseraializing while removing version byte.
-
macrotk-derive
macrotk core derive macros
-
nb-blocking-util
Utility proc macro for removing all async/await from a function
-
trans-derive
Serialization protocol for inter-language communication (derive macros)
-
small_ctor
A minimal, dependency free version of the ctor crate
-
concat_strs_impl
Implementation for the concat_strs crate
-
impl-tools-lib
Helper macros: autoimpl
-
const-gen-derive
A derive macro for the const-gen crate
-
testing_macros
General purpose testing macros
-
proclock-macro
Macro API for the proclock crate
-
proc_macro_test
Enable switching between std::sync, tokio::sync and loom::sync
-
clap_derive-v3
Parse command line argument by defining a struct, derive crate
-
stability
Rust API stability attributes for the rest of us
-
typed-qb-procmacro
Procmacros for typed-qb
-
napi-rs-derive
N-API procedural macros
-
rosrust_codegen
Message generation for rosrust
-
serde-reflect-intermediate-derive
Derive proc macro for reflection utils of intermediate representation for Serde serialization
-
disc-derive
Attribute macros for https://crates.io/crates/disc
-
count-tys
Function-like procedural macro that accepts a comma-delimited :ty TokenTree sequence and returns their count as a constant usize
-
pmutil
Utils for proc-macro
-
woab-macros
Procedural macros for the WoAB crate
-
yade
Yet Another Derive Error
-
alkahest-proc
Procedural macros for ‘alkahest-proc’ crate
-
sourcegen-cli
In-place Rust source generator CLI utility
-
every_variant_macro
To be used with all variant, contains the derive macro
-
sea-orm-rocket-codegen
Procedural macros for sea_orm_rocket
-
mauzi_macros
Helper crate for ‘mauzi’. Use ‘mauzi’ directly please.
-
elvis-derive
Definition of the
#[elvis]attribute, an internal dependency -
binwrite_derive
Derive macro for binwrite
-
spez-macros
proc_macro crate for spez
-
cmd-derive
Macros for the cmd-macro crate
-
gem-macros
proc macros for gemstone
-
zhi_enum_derive
derive macros to easily use enum
-
jnix-macros
Companion crate to jnix that provides proc-macros for interfacing JNI with Rust
-
limelight-derive
Derive macro for limelight
-
gxi_parsers
parsers for gxi macros
-
minihttp-codegen
Provides codegen for minnihttp
-
clouseau_macros
Internal dependency of clouseau
-
const_num_bigint_derive
const bigint
-
bitpatterns-proc-macro
Procedural macros used by the bitpatterns crate
-
enum-tags-macros
Macros for enum-tags crate
-
get-random-const
Simple compile-time random generator
-
skidscan-macros
Proc macros for skidscan
-
toql_fields_macro
Library with fields macro for Toql
-
packetrs-macro
Macro-based struct serialization/deserialization
-
drop_struct_macro_derive
A derive macro to free (drop) memory for structs that are used in the FFI
-
canrun_codegen
Procedural macros used by the Canrun crate
-
dilib-macros
Procedural macros for the dilib crate
-
syn_str
This library is what syn is to proc_macro::TokenStream for proc_macro::TokenStream::to_string,quote! being format! with String::parse::
-
absolution
‘Freedom from
syn’. A lightweight Rust lexer designed for use in bang-style proc macros. -
zipkin-macros
Macros for use with
zipkin -
valuetypes
A simple macro derive the Deref trait on one-tuple-structs
-
big_enum_set_derive
An internal helper crate for big_enum_set. Not public API.
-
cardparse_derive
Fixed width text format parsing to structs
-
serde-diff-derive
Derives serde_diff::SerdeDiff
-
relm-derive-common
Common derive implementation internally used by relm crates
-
enum_pipeline_derive
Provides derive macros for enum_pipeline
-
sapio_macros
A programming framework for bitcoin smart contracts
-
enumber
Provide useful impls on numerical enums
-
struct_layout
Customize your struct layout with this one weird trick
-
watt-non-static-runtime
Runtime for executing Rust procedural macros compiled as WebAssembly
-
slint-macros
Macro helper for slint crate
-
ux-macro
Backend agnostic GUI framework
-
syn-unnamed-struct
Extends syn expressions and meta structs with unnamed structs and meta lists
-
cornetto
#[cornetto(manage my config)]
-
duktape-macros
duktape bindings macros
-
string_literal
A simple macro that auto insert
.to_string()call to str literal -
aoc-runner-derive
Codegen for aoc-runner & others
-
display_json_derive
Procedural macros for implementing Display and Debug with serde_json::to_string and serde_json::to_string_pretty
-
pear_codegen
A (codegen) pear is a fruit
-
exhaust-macros
Proc-macro support for the ‘exhaust’ library
-
const_env--value
Configure const and static items by environment variables
-
rclrust-msg-gen
TODO
-
spanr
A tool for proc-macro authors to visualize the spans on generated code
-
structout
A proc-macro for generating structs from a common definition
-
command-macros-plugin
Implementation crate for command-macros
-
metrics-fn-codegen
Code generation module for Function Metrics
-
log-attributes
A set of function log attributes, that make logging function in- and outputs a charm
-
quickcheck_async
Runtime-agnostic attribute macros to use quickcheck with async tests
-
unrest_tmp_syn
don’t use
-
enum_to_enum_derive
Derive macro implementation for enum_to_enum. enum_to_enum derives possibly effectful conversions between enums.
-
synom
Stripped-down Nom parser used by Syn
-
is-same-derive
Derive proc macro for the is-same crate
-
actors-macros
Macro crate for Riker actor framework
-
enum-variants-strings-derive
Derive macro for converting instances of enums to and from strs using variant names
-
spirv-struct-layout-derive
This crate is just an implementation detail of the spirv-struct-layout crate
-
polling-async-trait
A proc macro that creates async methods based on polling methods for your trait
-
artemis-codegen-proc-macro
Proc macros for the artemis crate
-
chikatetsu-macros
Macros for the chikatetsu actor framework
-
penguin-config-derive
See penguin-config
-
multi-eq
Macros for creating custom equality trait derives
-
typetrait
Helper macro to generate types for typestate programming
-
parsable-macro
Macro to generate the
parsabletrait on enums or structs -
test-context-macros
Macro crate for test-context
-
autodefault
A proc macro that automatically inserts
..Default::default()into your struct literals -
remain
Compile-time checks that an enum, struct, or match is written in sorted order
-
windows_gen_macros
Macro helpers for the windows_gen crate
-
union_type
A proc macro to introduce union type into rust
-
wgpu_macros
A set of useful proc macros for wgpu
-
merfolk_frontend_derive_macros
derive macros for merfolk_frontend_derive
-
def-mod
Simplifies module implementation routing and statically verifies exports
-
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
-
spa-server-derive
spa-server derive macro
-
one_user
Constrain the number of instances that can possibly be used at a time. By default it constrains it to one instance at a time, hence one_user.
-
ast2str-lib
A crate for pretty-printing ASTs and other recursive data structures
-
ceres-derive
derive macros for ceres
-
structsy-derive
Structsy single file struct database persistent derive implementation
-
mock-syn-common
Common types for mock-syn: Mock / wrap syn structs and enums overiding specific fields
-
safer_ffi-proc_macro
Procedural macro internals of
::safer_ffi -
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… -
smd_macro
A crate for the smd! macro
-
xylem-codegen
Codegen backend for xylem
-
constant
Constant evaluation tools for Rust
-
toql_role_expr_macro
Library with role expression macro for Toql
-
async_fn-proc_macros
Collection of helper annotations and macros for concise and yet explicit
async fnsignatures -
derive_from_as
Traits to Read and write types that implement serde Serialize and deserialize to files
-
pmhelp
A WIP library to assist in the creation of procedural macros
-
derive_constructor
Construct enums without naming them
-
syncwrap
Automatically wraps async functions in a synchronous wrapper based on feature flags
-
thiserror_core2-impl
Implementation detail of the
thiserror_core2crate -
diff-enum
A macro library to help defining enum variants by their differences
-
real_c_string
Generate string parseable in compiled binary
-
mockers_derive
Macro 1.1 implementation for ‘mockers’ mocking library
-
hirola-macros
An html library for building client side webapps
-
relm-derive-state
Custom derive required by the relm-state crate
-
snowcat_macros
Procedural macros used in Snowcat
-
structbuilder_derive
Super simple macro to derive a builder trait for your struct
-
enum_to_u8_slice_derive
A simple fork of enum_to_str_derive (by @DCjanus), convert enum to u8 slice ref
-
automod
Pull in every source file in a directory as a module
-
enum_like_derive
Proc macro to derive the EnumLike trait from the enum_like crate
-
pallet-contracts-proc-macro
Procedural macros used in pallet_contracts
-
async_static
A macro for declaring async lazily evaluated statics in Rust
-
mockiato-codegen
Internally used by mockiato for code generation. This crate should never be used directly
-
askama-enum
Implement different askama templates for different enum variants
-
structmapper-codegen
A library to help you generate code that mapped one struct to another
-
canary-macro
contains canary’s macros
-
include-flate-codegen-exports
Macro codegen for the include-flate crate
-
seq-macro
Macro to repeat sequentially indexed copies of a fragment of code
-
mxml
Mixin Markup Language
-
css-rs-macro
A macro for writing your CSS next to your views
-
compile-time-run-macro
implementation crate for compile-time-run
-
attribution-macros
The macros used by the attribution crate
-
serde-semver-derive
Derive macro for serde-compatible version checker
-
arbitrary-model-tests
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
router-rs-macro
A macro for client side web application routing
-
deasync
A procedure macro to turn async implemention into sync
-
pinwheel_elements_macro
Build web applications with Rust
-
rocket_codegen
Procedural macros for the Rocket web framework
-
syn-codegen
Syntax tree describing Syn’s syntax tree
-
gxi_macro
proc-macro for writing gxi components
-
go-away-derive-internals
Derive internals for go-away
-
optional-fields-serde-macro
Macro for optional-field crate serde integration
-
samotop-async-trait
Type erasure for async trait methods
-
next-gen_proc-macro
Safe generators on stable Rust
-
lunatic-test
#[lunatic::test] macro, meant as a drop-in replacement for Rust’s #[test]
-
stringify-attr
Attribute macros for stringifying
-
swc_ecma_quote_macros
Quasi quotation system for ecmascript
-
proc-quote-impl
A procedural macro implementation of quote!
-
fluvio-test-derive
Procedure macro to run async fn as test
-
beancounter
Beancounter provides a proc macro for visualizing struct memory usage
-
ffishim
Library behind ffishim_derive
-
rustructure-macros
Macros for rustructure crate
-
toql_paths_macro
Library with paths macro for Toql
-
to-syn-error-derive
The derive macro for to-syn-error
-
fake_serialize
A rust macro for implementing dummy implementations of the traits serde::Serialize and serde::Deserialize
-
hubpack_derive
Derive macro for hubpack
-
serde-semver
Serde-compatible version checker
-
reign_derive
Opinionated Fullstack Web Framework in Rust
-
serde_tuple_macros
De/serialize structs with named fields as array of values
-
linkme-impl
Implementation detail of the linkme crate
-
serde_syn
Use serde to parse Rust source code
-
weechat-macro
Procedural macros for the weechat crate
-
unrest_tmp_synom
don’t use
-
tent_codegen
Procedure macros for tent