-
syn
Parser for Rust source code
-
proc-macro-error
Almost drop-in replacement to panics in proc-macros
-
quote
Quasi-quoting macro quote!(...)
-
proc-macro-crate
Replacement for crate (macro_rules keyword) in proc-macros
-
strum
Helpful macros for working with enums and strings
-
derive_more
Adds #[derive(x)] macros for more traits
-
ctor
__attribute__((constructor)) for Rust
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
proc-macro2
A substitute implementation of the compiler’s
proc_macro
API to decouple token-based libraries from the procedural macro use case -
delegate
Method delegation with less boilerplate
-
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.
-
hex-literal
Procedural macro for converting hexadecimal string to byte array at compile time
-
derive_builder_core
Internal helper library for the derive_builder crate
-
getset
Getset, we're ready to go! A procedural macro for generating the most basic getters and setters on fields
-
serde_tokenstream
A serde deserializer for proc-macro TokenStreams
-
derive-new
#[derive(new)]
implements simple constructor functions for structs and enums -
enum-as-inner
A proc-macro for deriving inner field accessor functions on enums
-
doc-comment
Macro to generate doc comments
-
unicode-ident
Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
syn-rsx
syn-powered parser for JSX-like TokenStreams
-
futures-macro
The futures-rs procedural macro implementations
-
paste
Macros for all your token pasting needs
-
macrotest
Test harness for macro expansion
-
venial
A very small syn
-
moveit
A library for safe, in-place construction of Rust (and C++!) objects
-
wasm-bindgen-macro-support
The part of the implementation of the
#[wasm_bindgen]
attribute that is not in the shared backend crate -
utoipa-gen
Code generation implementation for utoipa
-
diesel_derives
You should not use this crate directly, it is internal to Diesel
-
ambassador
Trait implementation delegation via procedural macros
-
tinyvec_macros
Some macros for tiny containers
-
as_derive_utils
private derive utilities used by abi_stable and structural
-
git-testament
Record git working tree status when compiling your crate
-
proc-quote
A procedural macro implementation of quote!
-
cstr
Macro for building static CStr reference
-
expander
Expands proc macro output to a file, to enable easier debugging
-
const-random
Provides compile time random number generation
-
casper-node-macros
A macro to create reactor implementations for the casper-node
-
structmeta
Parse Rust's attribute arguments by defining a struct
-
dylint_linting
Utilities for writing Dylint libraries
-
databake
Trait that lets structs represent themselves as (const) Rust expressions
-
bitmask-enum
A bitmask enum attribute macro
-
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.
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
worker-macros
Macros to support the
worker
crate and remove FFI boilerplate / conversion from user code -
derive_utils
A procedural macro helper for easily writing derive macros for enums
-
protobuf-build
Utility functions for generating Rust code from protobufs (using protobuf-rust or Prost)
-
napi-derive-backend
Codegen backend for napi procedural macro
-
multihash-derive
Proc macro for deriving custom multihash tables
-
is-macro
Easily create methods for to use yout custom enum like Option / Result
-
bit-struct
Define structs which have fields which are assigned to individual bits, not bytes
-
wasmer-derive
Wasmer derive macros
-
dlib
Helper macros for handling manually loading optional system libraries
-
test-generator
Rust Test generator: enumerating entries according to file-system pattern and generating a test function for each entry
-
usdt-macro
Procedural macro for generating Rust macros for USDT probes
-
biscuit-parser
Datalog parser used in the biscuit-auth and biscuit-quote crates
-
amplify_syn
Amplifying syn capabilities: helper functions for creating proc macro libraries
-
yew-router-macro
Contains macros used with yew-router
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
derive-getters
Simple boilerplate getters generator
-
zoet
Adds
#[zoet]
macro to reduce boilerplate when implementing common traits -
serde-enum-str
Serialize and deserialize enum string
-
arrow2_convert_derive
Proc macros for arrow2_convert
-
clap_derive
Parse command line argument by defining a struct, derive crate
-
fltk-derive
Rust bindings for the FLTK GUI library
-
miette-derive
Derive macros for miette. Like
thiserror
for Diagnostics. -
command-macros
Macros for creating std::process::Command with shell-like syntax
-
impl-tools
Helper macros: autoimpl
-
struct-field-names-as-array
Provides a procedural macro that generates an array of the field names of a named struct
-
crepe
Datalog in Rust as a procedural macro
-
genemichaels
Makes your code formatty
-
macro-machines
State machine macros with logging and graphviz DOT file generation
-
impl-trait-for-tuples
Attribute macro to implement a trait for tuples
-
huber-procmacro
Internal package used by Huber
-
swift-bridge-macro
Powers swift-bridge module code generation
-
strum_macros
Helpful macros for working with enums and strings
-
leptos_macro
view macro for the Leptos web framework
-
prometheus-static-metric
Static metric helper utilities for rust-prometheus
-
unicode-id-start
Determine whether characters have the ID_Start or ID_Continue properties according to Unicode Standard Annex #31
-
rsbind
Provide tools to bind rust trait with other language and export library artifact directly. Invoke rust functions just like you write it in native language.
-
rand_derive2
Generate customizable random types with the rand crate
-
napi-derive
N-API procedural macros
-
testing_macros
General purpose testing macros
-
ff_ce
Library for building and interfacing with finite fields
-
dbg-pls
Syntax aware pretty-printing debugging
-
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.
-
schemars_derive
Macros for #[derive(JsonSchema)], for use with schemars
-
display_json
Procedural macros for implementing Display, Debug and FromStr for (de)serializing json strings
-
syn-helpers
Framework for building derive macros
-
dioxus-core-macro
Core macro for Dioxus Virtual DOM
-
jnix
High-level extensions to help with the usage of JNI in Rust code
-
com_macros_support
Support library for COM crate macros
-
sqlx-macros
Macros for SQLx, the rust SQL toolkit. Not intended to be used directly.
-
migrations_macros
Codegeneration macros for diesels embedded migrations
-
vectrix-macro
A macro for composing matrices
-
prost-derive
A Protocol Buffers implementation for the Rust Language
-
sauron-component-macro
An html library for building client side webapps
-
maybe-async
A procedure macro to unify SYNC and ASYNC implementation
-
deno_ops
Proc macro for writing Deno Ops
-
rquickjs-macro
Procedural macros for rquickjs
-
devise
A library for devising derives and other procedural macros
-
saphir_macro
Macro generation for http server framework
-
argp
Derive-based argument parser optimized for code size
-
windows-implement
The implement macro for the windows crate
-
markup-proc-macro
A blazing fast, type-safe template engine for Rust
-
string_cache_codegen
A codegen library for string-cache, developed as part of the Servo project
-
reflect
The "but I thought Rust doesn't have reflection?" memorial brand new way of defining procedural macros
-
proc_macro_roids
Traits and functions to make writing proc macros more ergonomic
-
maybe-async-cfg
A procedure macro to unify sync and async implementations depending on the features of your crate
-
ast2str
A crate for pretty-printing ASTs and other recursive data structures
-
symbols-models
Proc-macro utility to populate enums from database data (shared traits)
-
rust-i18n-macro
Macro for rust-i18n crate
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
wai-bindgen-wasmer-impl
Generate WAI glue for a Rust Wasmer host
-
rustler_codegen
Compiler plugin for Rustler
-
attribute-derive
Clap for proc macro attributes
-
asn1-compiler
ASN.1 Compiler in Rust
-
sauron-node-macro
An html library for building client side webapps
-
ouroboros_macro
Proc macro for ouroboros crate
-
deluxe
Procedural macro attribute parser
-
napi_sym
proc macro for writing N-API symbols
-
parse-display-derive
Procedural macro to implement Display and FromStr using common settings
-
safe-quote
A fork of
quote
crate that addsforbid(unsafe_code)
and depends onsafe-proc-macro2
instead ofproc-macro2
-
ra_ap_proc-macro-srv-cli
TBD
-
find-crate
Find the crate name from the current Cargo.toml
-
metamorphose
Macros collection for converting Structure to Model, for a green-barrel project
-
prometheus-client-derive-text-encode
Auxiliary crate to derive text Encode trait from prometheus-client
-
derive_deref
Adds
#[derive(Deref)]
and#[derive(DerefMut)]
-
wai-bindgen-rust-impl
Generate WAI glue for a Rust guest
-
bae
A Rust proc-macro attribute parser
-
const-random-macro
Provides the procedural macro used by const-random
-
debugger_test
Provides a proc macro for writing tests that launch a debugger and run commands while verifying the output
-
argh_derive
Derive-based argument parsing optimized for code size
-
from_variant
Automatically derive From impls for enums
-
inventory-impl
Implementation of macros for the
inventory
crate -
gettext-macros
A few proc-macros to help internationalizing Rust applications
-
dioxus-rsx
Core functionality for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences
-
qmetaobject_impl
Custom derive for the qmetaobject crate
-
simd-json-derive-int
procmacros for simd-json-derive
-
diesel_filter_query
Procedural macros for Diesel filter
-
microsoft-directx
Rust bindings for the latest DirectX (Agility SDK) headers
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
defmt-macros
defmt macros
-
thiserror-core-impl
Implementation detail of the
thiserror
crate -
katexit
Insert KaTeX autorender script into rustdoc
-
rustfmt-wrapper
Library wrapper around rustfmt for use by code generators
-
stronghold-derive
Proc macros and derives for Stronghold
-
dynasm
A plugin for assembling code at runtime. Combined with the runtime crate dynasmrt it can be used to write JIT compilers easily.
-
asn1_codecs_derive
ASN.1 Codecs derive Macros
-
uucore_procs
uutils ~ 'uucore' proc-macros
-
packed_struct_codegen
This crate implements the code generation for the packed_struct library
-
EnumBitFlags
EnumBitFlags is an implementation of flags support for enums
-
proc-bitfield
A crate to expressively declare bitfield-like structs
-
gdnative-impl-proc-macros
Internal dependency of the gdnative bindings
-
derive-syn-parse
Derive macro for
syn::parse::Parse
-
serde-intermediate-derive
Derive proc macro for intermediate representation of Serde serialization
-
actix-web-codegen
Routing and runtime macros for Actix Web
-
indoc-impl
Indented document literals
-
frunk_derives
frunk_derives contains the custom derivations for certain traits in Frunk
-
validated_struct
Easily generate nested structures with getters and predicated setters
-
test-fuzz-macro
-
opaque_typedef
Supports defining opaque typedefs
-
packable-derive
Derive macro for the
packable
crate -
parquet_derive
Derive macros for the Rust implementation of Apache Parquet
-
jsonrpsee-proc-macros
Procedueral macros for jsonrpsee
-
sort_by_derive
Derive macro SortBy and helper macros EnumAccessor and EnumSequence, deriving traits
Ord
,PartialOrd
,Eq
,PartialEq
andHash
for structs and enums that can’t automatically derive from those traits -
vtable-macro
Helper crate to generate ffi-friendly virtual tables
-
property
Generate several common methods for structs automatically
-
ext-php-rs-derive
Derive macros for ext-php-rs
-
nekosbest
nekos.best API wrapper
-
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.
-
quote_into
Easily & efficiently generate code by quoting it in a macro
-
statig_macro
Macro’s for
statig
-
zerocopy-derive
Custom derive for traits from the zerocopy crate
-
oso-derive
macros for oso, an open source policy engine for authorization that’s embedded in your application
-
typify-macro
typify macro implementation
-
conjure-codegen
Rust code generation for Conjure definitions
-
semester
High efficiency classnames macro
-
trace
A procedural macro for tracing the execution of functions
-
sqlx-type
Typed sql macros for sqlx
-
mwt
proc macros for generating mut and non-mut methods without duplicating code
-
swc_macros_common
Common utilities for swc macros
-
wa-serde-derive
serde_derive compiled to wasm
-
relm-gen-widget
Utility crate for relm-attributes and relm-derive
-
web_macro
A library for interacting with the web browser
-
cameleon-impl-macros
Utilities used by other cameleon crates implementation
-
synom
Stripped-down Nom parser used by Syn
-
microsoft-direct3d
Rust bindings for the latest DirectX (Agility SDK) headers
-
enum-display-derive
Display trait's custom derive for simple enums
-
clippy-mini-macro-test
A macro to test clippy's procedural macro checks
-
form
A small script to move inline modules into the proper directory structure
-
worker-plus-macros
Macros to support the
worker
crate and remove FFI boilerplate / conversion from user code -
cffi
Safe* C FFI interface generation
-
wasm-bindgen-macro
Definition of the
#[wasm_bindgen]
attribute, an internal dependency -
typify-impl
typify backend implementation
-
serde_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
fortuples
Procedural macros to generalize inherent and trait implementations over tuples
-
pmutil
Utils for proc-macro
-
test-shisho-policy-sdk
This is the SDK of Shisho Cloud policies to write your custom policies in Rust
-
pgx-utils
Utility functions for 'pgx'
-
kmacros
Useful macros
-
lazy-regex-proc_macros
proc macros for the lazy_regex crate
-
early_returns
Macros to make early returns easier to work with in Rust
-
syntactic-for
A syntactic 'for' loop macro
-
rkyv_derive_test
Derive macro for rkyv
-
wasmbus-macros
derive macros for wasmbus-rpc
-
integral-enum
Simple way to define integer-like enums
-
macro_state
A set of macros allowing storing and loading global state at compile-time within proc macros
-
safe-proc-macro2
A fork of
proc_macro2
crate with unsafe code removed -
fix-hidden-lifetime-bug-proc_macros
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
ractor_cluster_derive
Derives for ractor_cluster
-
vehicle-signals
DDS topics (for cyclonedds-rs) created from GENIVI/W3C Vehicle Signal Specification
-
ra_ap_proc_macro_srv
TBD
-
surge-macros
surge synthesizer -- common macros
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
structmapper-codegen
A library to help you generate code that mapped one struct to another
-
dropshot_endpoint
macro used by dropshot consumers for registering handlers
-
proc-macro-error-attr
Attribute macro for proc-macro-error crate
-
rustfmt-config_proc_macro
A collection of procedural macros for rustfmt
-
cw-storage-macro
Macro helpers for storage-plus
-
safe-regex-macro
Macro for the safe-regex package
-
quote-doctest
A simple doctest generator for quote
-
celery-codegen
Macros for rusty-celery
-
juniper_codegen
Internal custom derive trait for Juniper GraphQL
-
assertx
Additional test assertions
-
linkme-impl
Implementation detail of the linkme crate
-
wai-bindgen-wasmtime-impl
Generate WAI glue for a Rust Wasmtime host
-
edgedb-derive
Derive macros for EdgeDB database client
-
syn-mid
Providing the features between "full" and "derive" of syn
-
positional
A library to author/parse positional files
-
thiserror-impl
Implementation detail of the
thiserror
crate -
nom-rule
A procedural macro for defining nom combinators in simple DSL
-
derive_validator
Derive macros for the Validate trait of
validify
-
thiserror-impl-no-std
Implementation detail of the
thiserror
crate -
unzip-n
Procedural macro to generate
unzip
for iterators over n-sized tuples -
bevy_ecs_macros
Bevy ECS Macros
-
bevycheck
Helpful bevy error messages by proc-macro
-
nacos-macro
Nacos's proc macros
-
lofty_attr
Macros for Lofty
-
serde_derive_state
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
dummy
Macros implementation of #[derive(Dummy)]
-
pgx-pg-sys
Generated Rust bindings for Postgres internals, for use with 'pgx'
-
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
-
askama_shared
Shared code for Askama
-
bagel
Compile-time evaluation and other tools
-
usdt-attr-macro
Procedural macro for generating Rust macros for USDT probes
-
hackfn
Fake implementation of
std::ops::Fn
for user-defined data types -
retry_macro
A set of declarative macros which retries executing a function upon failure
-
nameless-clap_derive
Parse command line argument by defining a struct, derive crate
-
devise_codegen
A library for devising derives and other procedural macros
-
quote-use
Support
use
in procmacros hygienically -
diesel_as_jsonb
Use your structs as Jsonb with diesel and PG
-
macro_rules_attribute-proc_macro
Use declarative macros as proc_macro attributes or derives
-
thruster-socketio-proc
The proc macros behind the thruster web framework
-
mybatis-macro
mybatis macro driver
-
tabled_derive
Derive macros which is used by tabled crate
-
dysql-macro
Dysql is a rust crate that do dynamic-sql query through proc-macro, it bases on tokio-postgres (default feature) and sqlx crate
-
modus_ponens
Library to develop forward chaining inference engines
-
hex-literal-impl
Internal implementation of the hex-literal crate
-
swc_plugin_macro
Macro support for authoring plugin's transform fn
-
binrw_derive
Derive macro for binrw
-
hkalbasi-rustc-ap-rustc_macros
Automatically published version of the package
rustc_macros
in the hkalbasi/rust repository from commit 56126fb149ea810db234e210893833e97a5c8e36 The publishing script for this crate lives at: https://github… -
cassandra_macro_derive
Macros 1.1 implementation of #[derive(Cassandra)]
-
unroll
An attribute-like procedural macro for unrolling for loops
-
autd3-traits
Wav Modulation for AUTD
-
aquamarine-demo-crate
A demo crate for aquamarine -- the mermaid.js integration for rustdoc
-
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
-
mry_macros
Macro crate for mry, a simple but powerful mocking library that supports struct, trait, and function
-
html-macro
html macro
-
cynic-codegen
Codegen for cynic - a GraphQL query builder & data mapper for Rust
-
edgedb-query-derive
Crate that provide a bunch of derive macros that help to build EdgeDB query using edgedb-tokio crate
-
r18-trans-support
r18 translation support
-
unimock_macros
Procedural macros used by unimock
-
slint-macros
Macro helper for slint crate
-
swc_trace_macro
Proc macro for performance trace of swc
-
soroban-sdk-macros
Soroban SDK macros
-
native-json-macro
Native JSON for Rust
-
cypher_derive
A flexible and intuitive query builder for Neo4j and Cypher
-
pub-sub-client-derive
Google Cloud Pub/Sub client library
-
from-to-repr
Derives TryFrom and From implementations for the representation type of a Rust enumeration
-
sqlxmq_macros
Procedural macros for sqlxmq
-
config_parser_derive
A proc-macro for implementing ConfigParser trait of config_parser library
-
snafu-derive
An ergonomic error handling library
-
opendp_tooling
Tooling for proc-macros and code generation
-
vtable_gen
A C++-ABI VTable Generator for Rust
-
derive-env-url
Derives for env-url
-
surrealdb-derive
Private implementation of procedural macros for surrealdb
-
template-quote
A new-fasioned quote! macro implementation with pretty template-engine like syntax
-
sscanf_macro
Proc-Macros for the sscanf Crate. Not meant to be used as a standalone Crate
-
jsonrpc-derive
High level, typed wrapper for
jsonrpc-core
-
relm-derive
Custom derive required by the relm crate
-
command_attr
Procedural macros for command creation for the Serenity library
-
tylift
Lift enum variants to the type-level
-
kube-derive
Custom derives for the kube kubernetes crates
-
wasmedge-macro
The procedural macros for WasmEdge Rust bindings
-
execute_evcxr
A library for execution of evcxr-supported syntax via building and executing a binary crate
-
catalytic_table_to_struct
Table mapper for the ORM for Scylla, fully compatible with Apache Cassandra™
-
clapi
A framework for create command-line applications
-
flowmacro
Definition of a 'flow' attribute macro to help write implementations
-
portrait-framework
Framework for implementing portrait fillers
-
shuttle-codegen
Proc-macro code generator for the shuttle.rs service
-
dynamodb-helper
Macro that creates a struct for interacting with AWS DynamoDB
-
rtlola-macros
Procedural macros for more convenient handling of HirModes in the rtlola_hir crate
-
build-deps
Rust build-script dependencies generator for data/IDL files
-
awint_macro_internals
Internal macro utilities for the
awint
system of crates -
nova-macro
Implementation for nova crate
-
remoc_macro
Procedural macros for Remoc
-
syn_util
helper APIs for procedural macros
-
alt_serde_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
better-bae
A Rust proc-macro attribute parser
-
derive_validify
Derive macros for the Validify trait of
validify
-
cps
Assists in the creation of readable and maintainable macro_rules! macros
-
ra_ap_proc_macro_api
TBD
-
syn-impersonated
Parser for Rust source code
-
structstruck
Nested struct and enum definitions
-
sea-strum
Helpful macros for working with enums and strings
-
bytes-lit
Create byte slices from literal integers
-
peg-macros
Procedural macros for rust-peg. To use rust-peg, see the
peg
crate. -
catalytic_query_parser
Query parser for the ORM for Scylla, fully compatible with Apache Cassandra™
-
chalk-derive
A helper crate for use by chalk crates for
derive
macros -
sunfish_macro
Web Application Build Tool
-
derive-into-owned
Custom derives to help with types containing Cow fields
-
a2lmacros
provides macros in support of the a2lfile crate
-
windows-interface
The interface macro for the windows crate
-
dhall_proc_macros
Macros for dhall
-
rkyv_derive
Derive macro for rkyv
-
kmacros_shim
Useful macros
-
workflow-macro-tools
Macro utility functions used by the
workflow-rs
framework -
validify
An extension of the validator crate that enables payload modification
-
build-info-proc
Part of the build-info crate: This crate provides the proc-macros
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
uniffi_macros
a multi-language bindings generator for rust (convenience macros)
-
lalrproc
Procedural macro built on LALRPOP
-
syn-file-expand-cli
CLI tool to read full source code of multi-file crates and output it to stdout
-
actix-helper-macros
Helper macros to make life easier developing actix-web applications
-
no-panic
Attribute macro to require that the compiler prove a function can't ever panic
-
struct-arithmetic
Provides a Trait to derive basic arithmetic operations for your structs
-
test-span-macro
macro to do snapshot tests on tracing spans, usint test-span
-
ref-cast-impl
Derive implementation for ref_cast::RefCast
-
test-results
A series of utility macros for outputting testing results
-
macro_railroad
A library to generate syntax diagrams for Rust macros
-
validator_derive
Macros 1.1 implementation of #[derive(Validate)]
-
libcnb-proc-macros
Procedural macros used within libcnb.rs
-
beady
A macro for writing tests in a Behaviour Driven (BD) style
-
bonfida-macros
Bonfida-utils macros
-
libipld-cbor-derive
ipld cbor codec proc macro
-
makepad-micro-proc-macro
Makepad micro proc macro util lib
-
wasmedge-bindgen-macro
Pass string, vec and primitive types from host to webassembly
-
s_test_fixture
s_test_fixture or simple test fixture is a macro library to implement test fixture with no hassle
-
diesel_enum_derive
Simple Enum derive for [Postgres only] Varchar fields
-
classic-bitfield
A bitfield enum with a classic feel
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
procedural-masquerade
macro_rules for making proc_macro_derive pretending to be proc_macro
-
memoize-inner
Helper crate for memoize
-
static_init_macro
Attribute macros for static_init crate
-
renum
From and TryFrom trait derive with customization
-
abomonation_derive
A custom derive plugin for abomonation
-
pen-ffi-macro
FFI macro library for Pen programming language
-
der-oid-macro
Macro to encode DER oids at compile time
-
thirtyfour-querier-derive
#[derive(Querier)] macro for thirtyfour WebDriver library
-
sierra-proc
Procedural macros for 'sierra' crate
-
async-stream-impl
proc macros for async-stream crate
-
bytes-cast-derive
Safely re-interpreting &[u8] bytes as custom structs without copying, for efficiently reading structured binary data. Procedural macro for compile-time soundness checking.
-
matrix-sdk-test-macros
Helper macros to write tests for the Matrix SDK
-
jsonrpc-utils
Alternative pub/sub and server implementations for jsonrpc-core
-
decorators
A macro for generating decorator methods
-
include-crypt-bytes
Rust macro to embed encrypted files in compiled binary
-
mpst-seq-proc
A library with macro for mpstthree
-
swc_ecma_codegen_macros
Macros for swc_ecma_codegen
-
efg
Conditional compilation using boolean expression syntax, rather than any(), all(), not()
-
witchcraft-server-macros
Macro definitions used by witchcraft-server
-
swc_ecma_quote_macros
Quasi quotation system for ecmascript
-
include_dir_impl
Implementation crate for include_dir
-
ocaml-derive
OCaml procedural macros
-
easy-min-max
Easy to use macros for min, max and clamp. Works with no_std
-
soa_derive_internal
Internal implementation crate for soa-derive
-
versionize_derive
Implements the Versionize derive proc macro
-
custom_debug
Derive Debug with a custom format per field
-
tarantool-proc
Tarantool proc macros
-
makepad-widgets
Makepad widgets
-
auto_impl_trait
auto impl trait by provide trait file
-
higher-derive
Custom derives for
higher
-
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
procout
Output a proc macro's TokenStream to a file
-
pio-proc
proc-macro for assembling PIO code in a Rust program at compile time
-
edifact-types
Bindings for the Edifact standard
-
dough
Internal macros for the bagel crate
-
autocorrect-derive
proc-marcro-derive for autocorrect
-
call2-for-syn
Apply parser functions to proc-macro2 token streams
-
windows_macros
Rust for Windows
-
vec-reg-macro
Procedural macros for vec-reg
-
passivized_vault_client_versions
Test support crate defining which Vault versions are tested against
-
core_extensions_proc_macros
Implementation detail of the
core_extensions
crate -
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.
-
syn-path
A simple macro to declare a syn::Path at compile time
-
rogger
Logging macros for Rinrin.rs
-
awint_internals
Internal utilities for the
awint
system of crates -
lombok
Lombok port for Rust
-
tl-proto-proc
A collection of traits for working with TL serialization/deserialization
-
safer_ffi-proc_macro
Procedural macro internals of
::safer_ffi
-
giftwrap
Wrap and unwrap your types the stylish way
-
hooks-derive-core
Compile-time, async hooks
-
rbatis_sql_macro
rbatis sql macro system
-
nop-json-derive
Helper crate for internal use in nop-json
-
named_constants
Procedural macro makes enums behave like named constants in languages like C/C++ or C#
-
define_into_enum
Defines Into<T> on an enum where all variants wrap T
-
soroban-env-macros
Soroban contract environment macros
-
enum-ptr-derive
Ergonomic tagged pointer
-
fadroma-proc-derive
DSL for generating CosmWasm contract boilerplate and enabling code composition
-
display-as-proc-macro
A helper crate for display-as-template
-
byteme
Converts a struct into Vec<u8> and back. The conversion is Big Endian by default.
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
rvv-asm
Procedure macro to encode RISC-V V extension (rvv) instructions
-
proc-macro2-diagnostics
Diagnostics for proc-macro2
-
irondash_message_channel_derive
Derive proc-macros for Irondash
-
thruster-proc
The proc macros behind the thruster web framework
-
druid-derive
derive impls for Druid, a Rust UI toolkit
-
static-map-macro
Macro to create a stack-alocated map
-
pokeapi-macro
Attribute macros for
pokeapi-model
-
dubbo-build
-
cenum
A rust derive macro for C-style primitive enums
-
quick_io
A simple crate to facilitate input and output within programs, with a set of macros
-
static-graph
Generate static parallel computation graph from DSL at compile time
-
teloxide-macros
The teloxide's procedural macros
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
cdefines
A proc macro that translates c #define constants to rust consts
-
async-fn-stream
Lightweight implementation of
async-stream
without macros -
croc-look
a tool to expand macros and watch them in real time
-
has_fields
Some macros helpful for processing forms with optional fields
-
palette_derive
Automatically implement traits from the palette crate
-
derive_setters
Rust macro to automatically generates setter methods for a struct's fields
-
wasmer-wit-bindgen-rust-impl
wit-bindgen-gen-c
-
microtype-macro
Proc macro for generating microtypes
-
gflags-impl
Macros for gflags crate
-
enumset_derive
An internal helper crate for enumset. Not public API.
-
actix-json-responder
A procedural macro to reduce json response boilerplate on actix projects
-
gsettings-macro
Macro for typesafe GSettings key access
-
hecs-macros
Procedural macro definitions for hecs
-
sh-inline
Macros to run inline shell (bash) script
-
netxbuilder
netx builder assembly
-
enum-iterator-derive
Procedural macro to derive Sequence
-
vts
Macro to generate boiler plate to define new types with associated constraints
-
bitwrap_derive_extra
macro for bitwrap
-
hotg-rune-proc-block-macros
Procedural macros for the rune-proc-block crate
-
nject-macro
Zero cost dependency injection macros
-
sqlparser_derive
proc macro for sqlparser
-
futures-select-macro-preview
The
select!
macro for waiting on multiple differentFuture
s at once and handling the first one to complete -
ddd_dapr_derive
Derive macros for convient implementation of some traits of the
ddd_dapr
crate -
flamer
a procedural macro to insert
flame::start_guard(_)
calls -
sqlx-database-tester-macros
Macros for sqlx-database-tester
-
wasm-bindgen-downcast-macros
The proc-macro crate for wasm-bindgen-downcast
-
suborbital-macro
Macro for setting up a Plugin
-
shindanmaker-rs
Shindanmaker in Rust
-
netlify_lambda_attributes
Lambda macro attributes
-
sqlxinsert
Sqlx derive macro for simpler inserts
-
antlion
Handy way to evaluate at compile-time any Rust expression
-
impl-tools-lib
Helper macros: autoimpl
-
ergol_proc_macro
the proc macros for ergol, an async ORM for Rust
-
google-cloud-spanner-derive
Google Cloud Platform spanner client library macro derive
-
fn-error-context
An attribute macro to add context to errors from a function
-
arma-rs-proc
proc macros for arma-rs
-
contracts
Design-by-contract attributes
-
git-version-macro
Internal macro crate for git-version
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
macro-wasmer-universal-test
Universal test macro for wasmer-test
-
extendr-macros
Generate bindings from R to Rust
-
oracle_procmacro
Procedural macro for the oracle crate
-
relm-attributes
Attributes to simplify the use of the relm crate
-
default_variant
A proc-macro for specifying the variants or values to be used when deriving
Default
in enums -
paperclip-macros
Macros for paperclip OpenAPI tooling library
-
webwire-cli
Contract-First API System - Command Line Interface
-
roslibrust_codegen_macro
Provides macro-based message generation for roslibrust
-
kproc_macros
Useful proc macros
-
typeshare-core
The code generator used by Typeshare's command line tool
-
cynic-proc-macros
Procedural macro crate for cynic - a GraphQL query builder & data mapper for Rust
-
macropol
Ergonomic string literal interpolation in macro definitions
-
canadensis_macro
A procedural macro that generates Rust data types and serialization code from inline and/or external Cyphal DSDL files
-
ndk-macro
Helper macros for android ndk
-
bookcase_alloc_macros
Companion procedural macro crate for bookcase_alloc
-
rdxl
Macros and Component System for HTML Templating
-
count-macro
A simple Rust macro to perform compile time counting
-
structmeta-derive
derive macro for structmeta crate
-
parseal-derive
derive macro for the parseal crate
-
dbg_mac
Handy debug only macros
-
workflow_macro
Derive Macro for Workflow-Aurras
-
neli-proc-macros
Procedural macros for neli
-
invoke_impl
Proc macro to generate functions that can invoke all identical functions or methods inside impl blocks
-
python_comm_macros
proc macros for python_comm
-
syndicate-macros
Support macros for programming with the Syndicated Actor model and Dataspaces
-
pgmacro
pgbaits 用的宏 作用是自动给结构体生成对应的SQL语句。
-
swc_ecma_transforms_macros
Macros for swc_ecma_transforms
-
lemmy_apub_lib_derive
A link aggregator for the fediverse
-
win_etw_macros
Enables apps to report events to Event Tracing for Windows (ETW)
-
validify_types
Derive macros for the Validate trait of
validify
-
const-gen-derive
A derive macro for the const-gen crate
-
pink-extension-macro
Macros for writing fat contract
-
unique-type-id
A unique id proc-macro generator for types
-
zoomer
Making Rust a true modern language™️ with revolutionary macros
-
postgres-parser
An llvm-based safe wrapper for PostgresSQL's query parser. Currently based on v13
-
relm-derive-state
Custom derive required by the relm-state crate
-
join_impl
Implementation of the
join!
macro -
edict-proc
Procedural macros for edict
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
color-print-proc-macro
Implementation for the package color-print
-
proc-macro-hack-impl
Procedural functionlike!() macros using only Macros 1.1
-
rpc-toolkit-macro-internals
internals for macros for rpc-toolkit
-
destructure
Automation of Destructure Pattern
-
c-like-concat
simple macro that works just like C's ##
-
syn-pub-items
Parser for Rust source code (patched for pub items)
-
delve
Provides a number of macros that make working with enums and strings more convenient
-
css-modules
CSS Modules with a macro for convenience
-
db-rs-derive
macros for db-rs
-
c3-lang-parser
Implementation of C3 Lang
-
ts-rs-macros
derive macro for ts-rs
-
catalytic_macro
Macros for the ORM for Scylla, fully compatible with Apache Cassandra™
-
djin-protocol-derive
A for of protocol, for aoe-djin
-
struct2vec_derive
Rust structure to slice
-
symbols
Proc-macro utility to populate enums from database data
-
crcnt_ddd_macros
CRCNT DDD Basic Macro
-
stylish-macros
Internal implementation details of
stylish-core
-
interpolate_idents
Useable macro identifier concatenation plugin
-
ifmt
Inline expression interpolation for Rust
-
locutus-macros
Procedural macros for Locutus P2P network project
-
soroban-native-sdk-macros
Soroban native SDK macros
-
rotenv_codegen
A
dotenv
implementation for Rust -
justerror
Extension to
thiserror
that helps reduce the amount of handwriting -
fkl_cli
Feakin is a architecture design and visual collaboration tool. This is the parser for Feakin.
-
basic-text-literals
Basic Text string literal macro for basic-text
-
chia_streamable_macro
Streamable derive macro for serializing/deserializing types in Chia protocol format
-
syn-file-expand
Library to load full source code of multi-file crates
-
html-to-string-macro
simple html to string macro powered by syn-rsx
-
punfetch-derive
Derive macros for punfetch
-
prometheus-client-derive-encode
Auxiliary crate to derive Encode trait from prometheus-client
-
affix
Macros for all your token pasting needs. Fork of https://github.com/dtolnay/paste with casing fixed
-
glib-macros
Rust bindings for the GLib library, proc macros crate
-
async-proto-derive
Proc-macros for the async-proto crate
-
hot-lib-reloader-macro
Macro crate for hot-lib-reloader
-
zenoh-macros
Internal crate for zenoh
-
fi-night
Statically typed Finite State Machine and Pushdown Automaton implementation
-
intercom-common
See 'intercom'
-
summer-boot-macro
summer boot macro
-
aegir_compile
DSL for aegir
-
pgx-macros
Proc Macros for 'pgx'
-
notan_macro
Provides a set of utils as macros for Notan
-
crevice-derive
Derive crate for the 'crevice' crate
-
easyfix-messages-gen
Easy FIX (Financial Information Exchange) toolset - messages generator
-
notation_dsl
Fun notation - DSL to create notation files
-
sqlx-type-macro
Proc macros for sqlx-type
-
noop_proc_macro
No-op proc_macro, literally does nothing
-
cfg-vis
A macro to support
#[cfg()]
on visibility -
wasmer-derive-asml-fork
Wasmer derive macros
-
r-lombok-macros
r-lombok is a rust macros that automatically plugs into your editor and build tools
-
rust-oop
use macro to implement inheritance
-
derive-sql
A Rust macro that implements methods that wraps common SQL statements
-
faker_rand
Fake data generators for lorem ipsum, names, emails, and more
-
diesel-selectable-macro
A derivable
Serialize
macro that selects precise fields -
gramatika-macro
Proc macros for Gramatika
-
substrait-validator-derive
Procedural macros for substrait-validator
-
derive_pod
Implement the Pod trait safely with a derive macro
-
sea-strum_macros
Helpful macros for working with enums and strings
-
include_dir_macros
The procedural macro used by include_dir
-
include-crypt-bytes-cipher
Rust macro to embed encrypted files in compiled binary
-
unpat
Unboxing the pattern with easy syntax
-
fixed_width_derive
Derive trait for use with the fixed_width crate
-
shipyard_proc
Crate providing attribute macro to Shipyard
-
pear_codegen
A (codegen) pear is a fruit
-
wasmtime-rust-macro
Macro support crate for wasmtime-rust
-
deku_derive
bit level serialization/deserialization proc-macro for structs
-
rocketjson_macro
Crate for working with Json and Rocket
-
rustc-ap-rustc_macros
Automatically published version of the package
rustc_macros
in the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
rust_json_derive
ToJson and FromJson derive for rust-json
-
openwhisk_macro
Derive Macro for OpenWhisk Rust Client
-
fire-stream-api
A more or less simple communication protocol library
-
opt_args
Create macros for functions and structs with default values
-
lamedh_attributes
Lambda macro attributes
-
crokey-proc_macros
proc macros for the crokey crate
-
llvm-plugin-inkwell-internals
Internal macro crate for inkwell
-
forever-rs
The complete solution for Rust command-line interfaces
-
bracer
Macros to help write ARM assembly
-
ffi-convert-derive
Macros implementations of CReprOf, AsRust, CDrop traits from ffi-convert
-
derive_builder_core_fork_arti
Internal helper library for the derive_builder crate
-
xshell-macros
Private implementation detail of xshell crate
-
cuach-derive
A HTML template system for Rust
-
casey
Case transforming macros for ident tokens
-
maud_macros
Compile-time HTML templates
-
bpaf_derive
Derive macros for bpaf Command Line Argument Parser
-
fastrlp-derive
Procedural macros for fastrlp
-
albert_stream
minimal procedural macros parser that produce a convenient AST
-
elephantry-derive
Macro implementation of #[derive(Entity)]
-
test-shisho-datasource
This is the utility for Shisho Cloud Policy SDK
-
schemafy_lib
Generates serializeable Rust types from a json schema
-
aegir_derive
Macros for aegir
-
asterix-derive
proc-macro convenience with the deku library, for updating ASTERIX FSPECs
-
bytecheck_derive
Derive macro for bytecheck
-
watt-non-static-runtime
Runtime for executing Rust procedural macros compiled as WebAssembly
-
cascading-wasm-language
Compiled web language based on CSS syntax
-
workflow-core-macros
Macros for the workflow-core crate
-
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
-
redacted_debug
A small procedural macro to allow redacting sensitive information without losing the ease of use of deriving Debug
-
macro-utils
Some macros to make code writing more elegant and funny
-
assert-parse-register-assert-macro
The util macro for 'assert-parse'
-
overloading
A POC crate that utilizes
Fn*
traits to implement partial overloading -
euphony-macros
Core macro implementations
-
positional_derive
Macros for positional crate
-
askama_derive
Procedural macro package for Askama
-
xladd-derive
A simple macro that helps write Excel UDF functions in Rust
-
cosmic-macros-primitive
Some primitive macros needed to jump start cosmic-space
-
open-fastrlp-derive
Procedural macros for fastrlp
-
retrofit_codegen
proc macro crate for retrofit
-
inet2_derive
Derivation macros for Internet2-based crates
-
from-pest
Convert from a pest grammar to a typed AST
-
bytenum
Bytenum is a rust derive macro that creates a try_from<T> implementation for an enum with only unit variants. All types supported by #[repr(T)] are supported by bytenum.
-
rtaichi_attr_impl
Rust language binding to the Taichi Runtime C-API
-
asset-derive-macro
Simple asset handling derive macro for enums, and a proc-macro learning resource!
-
aleo-std-timed
A profiler to conveniently time function executions
-
zoet-macro
Implementation detail for
#[zoet]
macro -
xtask-wasm-run-example
crate for the
run-example
feature of xtask-wasm -
msgpack-schema-impl
Implementation detail of the msgpack-schema crate
-
opendp_derive
Minimal proc-macro wrappers around the opendp_tooling crate
-
structmap-derive
Proc derive macro for structmap crate
-
postgres_macros
A set of support macros for rust-postgres
-
bitrange_plugin
Compiler plugin for bitrange to parse formats
-
opimps
A simple library of attribute macros to assist with overloading operators for borrowed and owned data
-
dbg-pls-derive
derive(Debug)
-
validated_struct_macros
Macros for validated_struct
-
lambda_runtime_errors_derive
Rust runtime errors derive for AWS Lambda
-
dotenv_codegen_implementation
A
dotenv
implementation for Rust -
casco
CSS-like parser for procedural macros
-
metriken-derive
Proc macros for metriken
-
proc_macro2_helper
Various utility code to extract data that can be used with proc macro2
-
derive_state_machine_future
Custom derive implementation for the
state_machine_future
crate. Use that crate instead of this one directly. -
databake-derive
Custom derive for the databake crate
-
winit-main
Abstract away winit's event-loop inversion of control
-
hs-bindgen-types
Utility types behind hs-bindgen ergonomics
-
server-function
A macro for easy RPC creation
-
ascent_macro
implementation of ascent macros
-
netsim-embed-macros
supporting macros for the 'ipc' feature of netsim-embed
-
jump-kun-macros
A crate for jump-kun. Parses jump-kun config file and creates fucntions.
-
chia_py_streamable_macro
Derive macro to create python bindings for Chia types
-
translator
A procedural macro which translates your repr-C structs into C++, Python and C# at compile time for helping write FFI libraries
-
git-testament-derive
Record git working tree status when compiling your crate - inner procedural macro
-
standalone-quote
Fork of quote that allows disabling the proc-macro feature in proc-macro2 so as to remove the rustc dylib dependency
-
mock-syn
Mock / wrap syn structs and enums overiding specific fields
-
baker
Derive macro for creating intermediate structs
-
webgl-rc-macro
GLSL loading macro for webgl-rc
-
box-self
Easy way to duplicate a new function with self: Box<Self> signature
-
tonic-rpc-macro
Core macro for tonic-rpc
-
nanoserde-derive
Fork of makepad-tinyserde derive without any external dependencies
-
wayrs-scanner
Generates code for wayrs-client from xml files
-
proc-macro3
defines a macro that imports either from
proc_macro
orproc-macro2
depending on theproc-macro2
feature flag -
fp-bindgen-macros
Macros for fp-bindgen
-
kproc-parser
minimal procedural macros parser that produce a convenient AST
-
recorder
Generate data-only structs with utilities easily
-
i18n-format
A simple proc-macro to allow gettext! and xgettext to work together
-
canonical_derive
The automatic derivation of Canon for structs, and enums
-
v_escape_derive
Procedural macro package for v_escape
-
qinetic_utils_macros
crate for Qinetic, containing utils macros
-
teil_derive
Helper crate for the teil library
-
mddd-std
small framework for DDD init sysmem and CLI interface. Sub crate with std tools. Use "mddd" crate
-
magic_static_macro
Proc macro for magic_static
-
inkwell_internals
Internal macro crate for inkwell
-
restruct
Converts between raw bytes and structured data
-
xflags-macros
Private implementation details of xflags
-
synthez
Steroids for
syn
,quote
andproc-macro2
crates -
fizyr-rpc-macros
procedural macros for the fizyr-rpc crate
-
impl_trait
Allows impl trait inside inherent impl
-
codesnip_core
snippet bundle tool
-
cdrs-tokio-helpers-derive
Derive CDRS helper traits
-
structdump
Dump structure to source code
-
io-ensure
Prototype of the
std::io::ensure
family of macros -
derive-stack-queue
Derives for stack-queue
-
kiwi-macros
Macros for the kiwi entity component system
-
cflp
A context-free-language parser generated by procedural macros
-
constime
Zig's comptime for Rust with zero dependencies. Mostly something to play around with until more stuff is const fn.
-
getset-scoped
Getset, we're ready to go! A procedural macro for generating the most basic getters and setters on fields
-
test-shisho-gql-derive
This is the utility for Shisho Cloud Policy SDK
-
stateroom-wasm-macro
A macro for building a Stateroom service as a WebAssembly module
-
quote-impersonated
Quasi-quoting macro quote!(...)
-
makepad-live-compiler
Makepad platform live DSL compiler
-
tsync-macro
Macros for tsync (see https://github.com/Wulf/tsync)
-
cprint
Cargo-like print
-
below_derive
Proc macros for below
-
astarte-device-sdk-derive
Derive macros implementation used by Astarte Device SDK
-
gc_derive
Garbage collector derive plugin for rust-gc
-
sunbeam-macro
A dynamic CSS class library
-
datasize_derive
Derive macros for the
datasize
crate -
checkout_server_derive
a crate to generate state machines enforced at compile time
-
easy-xml-derive
The macros for easy-xml
-
hubpack_derive
Derive macro for hubpack
-
data-encoding-macro-internal
Internal library for data-encoding-macro
-
next-gen_proc-macro
Safe generators on stable Rust
-
maud-live-view-macros
Compile-time HTML templates
-
structdiff-derive
Fork of nanoserde's parsing library
-
rust-hdl-macros
Macro support for RustHDL
-
alacritty_config_derive
Failure resistant deserialization derive
-
hobo_derive
hobo is a Rust frontend framework
-
catchr
A testing framework inspired by Catch for C++
-
open-coroutine-macros
The proc macros for open-coroutine
-
swc_eq_ignore_macros
Macros for EqIgnoreSpan and TypeEq
-
witgen_macro_helper
Macros helpers for witgen which is a library to help you generate wit definitions in a wit file for WebAssembly
-
shoulda_macro
derive macro for test assertions
-
pmacro_ruly
macros for ruly
-
spacetimedb-bindings-macro
Easy support for interacting between SpacetimeDB and Rust
-
defmt-test-macros
defmt-test macros
-
qbittorrent-web-api-gen
Generated web api for qBittorrent
-
udf-macros
UDF procedural macros implementation
-
rbxm-proc
Internal proc macros for the
rbxm
crate -
mass-cfg-attr
A way to mass toggle cfg-attr on attributes
-
hobo_css_macros
hobo is a Rust frontend framework
-
rad_ext_template
Rad ext macro template macros
-
shopify_function_macro
Macros for the
shopify_function
crate -
namewise-derive
Derived trivial name-wise conversions for Rust types
-
yaserde_derive
Serialization and deserialization macros
-
veil-macros
Veil procedural macros
-
derive-redis-swapplex
Derives for redis-swapplex
-
multiversion-macros
Implementation crate for multiversion
-
visa-rs-proc
procedural macros used in visa-rs
-
rocket_codegen
Procedural macros for the Rocket web framework
-
suricata-derive
Derive macros for Suricata
-
mapper-impl
Implementation detail of the
mapper
crate -
gtk-blueprint
Use Blueprint in Rust GTK applications
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
uniffi_checksum_derive
a multi-language bindings generator for rust (checksum custom derive)
-
hidden-trait
Proc macro for exposing a trait implementation
-
aliri_braid_impl
Implementation macros for the
aliri_braid
crate -
tower-lsp-macros
Internal procedural macros for tower-lsp
-
neon-frame-macro
Macros to simplify writing Neon apps
-
implicit-trait
Add methods to foreign types with implicitly defined traits
-
knife-macro
Knife框架公共宏定义
-
pipederive
Proc macros for data integration app using pipebase framework
-
hirola-macros
Hirola is an un-opinionated web framework that is focused on simplicity and predictability
-
volmark
Debugging and other macros for my Hornvale project
-
natural-derive
Proc macros for naturally deriving basic trait impls for new types
-
quickcheck_macros
A macro attribute for quickcheck
-
enum-display-macro
A macro to derive Display for enums
-
tao-macros
Proc macros for tao
-
flaky_test
atttribute macro for running a flaky test multiple times
-
flow_impl_derive
Definition of a derive macro for FlowImpl
-
cmd_lib_core
Common rust commandline macros and utils, to write shell script like tasks easily
-
argp_derive
Derive-based argument parsing optimized for code size
-
rusty-peg
A macro for defining PEG parsers
-
repr_c_pub_struct
A library for extracting
#[repr(C)] pub struct
ures -
clone_into_derive
This crates generate clone macro for structs. It's quite convenient if you want that a struct copy to another struct which includes the struct fully.
-
kelk-derive
Kelk-derive contains derive macros for auto-generated code used in Pactus blockchain
-
optional-fields-serde-macro
Macro for optional-field crate serde integration
-
machine
State machine utilities
-
nonparallelex
Rust macro for ensuring non-parallel execution of functions, extended Fork of
nonparallel
-
typeshare-annotation
The annotation used to mark types for typeshare
-
kiwi-internal-macros
Internal macros for the kiwi entity component system
-
futures-join-macro-preview
Definition of the
join!
macro and thetry_join!
macro -
risc0-zeroio-derive
Derive macro for risc0-zeroio
-
rhachis-run-macro
A proc macro for the Rhachis game library
-
plex
A syntax extension for writing lexers and parsers
-
unquote
A reverse quote macro... that is: A macro to parse input from a ParseStream according to a given pattern.
-
qcheck-macros
A macro attribute for quickcheck
-
lunatic-macros
Helper macros for the
lunatic
crate -
fastcrypto-derive
Collection of useful cryptographic macros
-
ace_it
Macro to automate wrapping types into enums
-
bin-layout-derive
This library used to serialize and deserialize data in binary format
-
workflow-html-macros
Workflow Macros for HTML Rendering
-
stability
Rust API stability attributes for the rest of us
-
autosurgeon-derive
Procedural macros for implementing autosurgeon
-
relm-derive-common
Common derive implementation internally used by relm crates
-
gc-arena-derive
proc-macro support for gc-arena
-
any_ref_macro
To capture and move things that are NOT 'static with memory safety
-
syn-inline-mod
Inlines modules in Rust source code for source analysis
-
binread_derive
Derive macro for binread
-
fort
Proc macro attributes for Bastion runtime
-
requestty-macro
The
questions
macro forrequestty
-
acme-macros
Acme is a complete development toolkit for extending platform functionality
-
lunatic-test
#[lunatic::test] macro, meant as a drop-in replacement for Rust's #[test]
-
extends-rs
rust extends impl a macro attr
-
protocol-derive
Easy protocol definitions
-
rocket_sync_db_pools_codegen
Procedural macros for rocket_sync_db_pools
-
semester-macro
High efficiency classnames macro
-
norpc-macros
Code generator for norpc
-
vertigo-macro
Reactive Real-DOM library for Rust - macros for html and fetch
-
starlark_derive
Derive helpers for the starlark package
-
regexp2rust_macro
regexp(ecma262) to rust code macro
-
comet_macro_procs
Macros for Comet
-
sawp-flags-derive
SAWP BitFlags Handling and Storage Derive Macro
-
workflow-task-macros
Macros for the workflow-task crate
-
vex-rt-macros
Internal macros library for the vex-rt crate
-
double-dyn
Macro for implementing functions with multiple dynamic argument dispatch
-
proc-macro-nested
Support for nested proc-macro-hack invocations
-
tuirealm_derive
Derive macro which automatically implements the MockComponent trait
-
async-trait-with-sync
async-trait
withSync
patch -
castle_macro
Castle Macro, macros to make your life easier
-
mattro
A macro attribute parser
-
ffizz-macros
FFI helper macros (typically not depended on directly)
-
kv-derive-macro
Macro definitions for
kv-derive
-
cosmic-macros
macros for thecosmicinitiative.io
-
cairo-lang-proc-macros
Procedural macros
-
panda-re-macros
Macros needed for the
panda-re
library -
mirror-mirror-macros
Macros for the mirror-mirror crate
-
encoding_index_tests
Helper macros used to test index tables for character encodings
-
match_deref
Deref patterns in "match" for stable Rust. Now you can match through Rc, String, etc
-
edict-proc-lib
Procedural macros library for edict
-
prc-rs-derive
A derive macro for implementing Diff on the diff-struct crate
-
atspi-macros
Macros to assist in various impl blocks for the
atspi
crate -
prost-serde-derive
Derive macro for serializing/deserializing structs generated by Prost with Serde
-
fstrings-proc-macro
Python3 fstring interpolation in Rust
-
bevy_console_derive
derive macros for bevy_console
-
typetag-impl
Implementation detail of the typetag crate
-
bma-benchmark-proc
Procedure macros for bma-benchmark
-
sfsm-proc
Macros to generate state machines for sfsm
-
fmt-derive-proc
A more robust and versatile derive macro for Debug and Display
-
fievar
Proc macrs to generate functions that return static slices of struct field names or enum variant names
-
cri-kit
cri kit for rust CRI container runtime interface devs
-
ferrum_oxidize
Compiler library for the Ferrum programming language
-
swc_visit_macros
Visitor generator for stable rustc
-
atri_macros
AtriPlugin macros
-
topo-macro
procedural macros for the topo crate
-
blackbox_core_codegen
Rust dependency injection library
-
telegram-bot2-macros
telegram-bot2-macros contains all macros used by the telegram-bot2 crate
-
more-di-macros
Macro implementation of #[injectable(Trait)]
-
async-component-macro
async-component derive macro
-
tensorflow-internal-macros
The package provides macros for internal usage in TensorFlow. No backwards compatibility guarantees are made.
-
slog-extlog-derive
Custom derive code for slog-extlog
-
nonparallel-async
Rust macro for ensuring non-parallel execution of async functions
-
econf-derive
Load environment variables into your struct members in one shot
-
checked_decimal_macro_core
A package for macro used in
checked_decimal_macro
-
derive-adhoc-macros
Macros that implement the derive_adhoc crate
-
zino-derive
Derived traits for zino
-
drias
utilities for spans and diagnostics
-
anthill-di-derive
Derive extension for anthill-di
-
bmart-derive
Bohemia Automation common tools library (derive macros)
-
forky_test
Rust Utilities
-
flag-mast
Ergonomic Rust bit flags
-
binhoc_macros
Generate code for rust clients communicating with axum servers
-
devise_core
A library for devising derives and other procedural macros
-
replisdk-experimental-proc
Procedural macros crate for replisdk-experimental
-
bolero-generator-derive
value generator for testing and fuzzing
-
persistent-structs
A Macro that generate helper functions to make non-mutable structs nicer to use
-
skyline_macro
Macros for helping power skyline-rs
-
auto-const-array
Define a const array without specify length
-
replisdk-proc
Procedural macros crate for replisdk
-
sqlx-model-macros
sqlx model macro
-
workflow-wasm-macros
Macros for workflow-wasm
-
gltf-derive
Internal macros for the gltf crate
-
test-env-helpers
Jest style setup and teardown test helper macros
-
join_export
Exports of the
join!
,join_async!
,join_spawn!
,join_async_spawn!
,async_spawn!
macros which are reexported byjoin
crate -
bunt-macros
Helper crate for
bunt
. Please see the docs ofbunt
for more information. Do not use this crate directly, API stability is not guaranteed! -
sval_derive
Custom derive for sval
-
spirv-std-macros
Macros for spirv-std
-
mockers_macros
Compiler plugin for 'mockers' mocking library
-
yaah
YAAH – Yet Another AOC Helper
-
dilib-macros
Procedural macros for the dilib crate
-
extism-pdk-derive
Helper package for the Extism Plug-in Development Kit (PDK) for Rust
-
obfustring
Procedural macro that obfuscates string literals with RNG at compile time
-
tlayuda
A derive procedural macro for structs that adds a static method that generates instances of the struct with minimal configuration
-
burn-tensor-testgen
Burn tensor test gen crate
-
arel_macro
arel macros
-
attributes
Procedural macros for command creation with rusty-interaction
-
async-backtrace-attributes
Procedural macros for the
async-backtrace
crate -
aoc-runner-web-derive
Fork of aoc-runner-derive with wasm focus
-
poem-extensions-macro
Macros for poem-extensions
-
mddd-macro
small framework for DDD init sysmem and CLI interface. Sub crate with macros. Use "mddd" crate
-
str-match
Format pattern like str match macro
-
shiv-macro-impl
Macro impl for shiv
-
pinwheel_macro
Build web applications with Rust
-
min-max
max! and min! macros
-
axum-starter-macro
A help crate for simplify the code of starting axum server
-
bevis-derive
Derive macros for Bevis
-
rkyv_typename_derive
Derive macro for rkyv_typename
-
seawater-macro
A procedural macro library used together with seawater
-
rkyv_dyn_derive
Macros for rkyv_dyn
-
near-abi-client-impl
Library to generate Rust clients for NEAR smart contracts
-
glasses
Macros for writing lots of tests (or specs!)
-
accio
Retrieves code blocks distributed to multiple sites
-
cust_derive
Macros for cust
-
makepad-derive-wasm-bridge
Makepad wasm bridge derive macros
-
restruct_derive
Converts between raw bytes and structured data
-
asn1_derive
#[derive] support for asn1
-
sawp-ffi-derive
Generate cbindgen compatible member accessors for structs and enums
-
jnix-macros
Companion crate to jnix that provides proc-macros for interfacing JNI with Rust
-
xylem-codegen
Codegen backend for xylem
-
form-yew
a macro to help with forms in yew
-
poise_macros
Internal macro implementation crate of poise
-
include-flate-codegen-exports
Macro codegen for the include-flate crate
-
bootstraps
Proc macro for Windows DllMain entry point
-
diff_derive
A derive macro for implementing Diff on the diff-struct crate
-
datatest-derive
Procmacro for the datatest crate
-
graphblas_sparse_linear_algebra_proc_macros
Utility crate with procedural macros for graphblas_sparse_linear_algebra
-
sanitizer_macros
Derive macro for the sanitizer crate
-
inherent-pub
Mark methods in
impl Trait for Type
blocks inherent to the type -
fire-protobuf-codegen
Rust only protobuf implementation
-
truck-geoderive
Derive macros generating an impl of the geometric traits
-
puppet-derive
The proc-macro for the puppet actor framework
-
target-test-dir-support
Support for the
target-test-dir
proc-macro crate -
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.
-
pm-lexer
This is a sample lexer using the proc-macro crate, to be used in the pomelo testings
-
int-enum-impl
Implementation detail of the
int-enum
crate -
human-time-macros
This is a library for human readable elapsed time string
-
tailwind-parse-macro
Procedural macro for tailwind-parse
-
perfect-derive
Provides a prototype of the proposed perfect_derive macro
-
const_env_impl--value
Configure const and static items by environment variables
-
profile_time
Provides 2 simple macros to separate debug code and release code
-
workflow-rpc-macros
Macros for the workflow-rpc crate
-
arcon_macros
Macros for Arcon
-
serde_columnar_derive
Macros implementation of #[columnar]
-
defunctionalize
Defunctionalization as a proc-macro over modules
-
wrapping_macros
A macro for wrapping arithmetic
-
function_name-proc-macro
macro that expands to the name of the annotated function
-
samotop-async-trait
Type erasure for async trait methods
-
parse-variants
Derive the syn::parse::Parse trait for enumerations and use it to comfortably parse a variant of the enumeration
-
derive-async-local
Derives for async-local
-
identity-diff-derive
Derive procedural macro for the identity-diff crate
-
rust-macios-objective-c-runtime-proc-macros
Macros for Objective-C for use in Rust-MaciOS library
-
blackbox_cast_codegen
Trait cast library
-
genserver_codegen
code generation for genserver crate
-
rash_derive
rash derive crate
-
hippotat-macros
Asinine HTTP-over-IP, proc-macros
-
codesnip_attr
snippet bundle tool
-
near-sdk-abi-impl
Utility library for making typesafe cross-contract calls in NEAR SDK smart contracts
-
cdbc-macro
Rust Coroutine Database Driver Connectivity
-
butcher_proc_macro
Procedural macros for butcher
-
apdu-derive
Implementation of procedural macro for apdu crate
-
minitrace-macro
Attribute procedural macro for minitrace-rust
-
blaze-proc
Blaze internal/external proc macros
-
makepad-derive-widget
Makepad widget derive macros
-
get_len_base_10_as_usize_macros
Macros for
get_len_base_10_as_usize
crate -
indiscriminant_impl_str
A proc-macro for mapping between values and enum discriminants
-
reflected_proc
Proc macro for reflected
-
praiya-macro
Proc macros for the Praiya API client
-
progenitor-macro
An OpenAPI client generator - macros
-
barter-macro
Barter ecosystem macros
-
agb_macros
Macro for declaring the entry point for a game using the agb library
-
frunk_proc_macros_impl
Proc macros inernal implementations for Frunk
-
mysql_helper
Make mysql to struct simple with macro
-
derive-diesel-connection
Derives for diesel-connection
-
rust-typed
Get the types of a struct
-
phenotype-macro
Exports
#[derive(Phenotype)]
macro forPeapod
crate -
restep
Simple and useful REST API endpoint generator
-
oasgen-macro
Dependency of oasgen. Generates OpenAPI 3.0 spec based on Rust code. Works with actix-web, but architected to easily extend to other frameworks (or no framework).
-
surreal-derive
Derive macros for SurrealDB Rust client
-
harled_macro
Macros for the harled crate
-
auto_unwrap
A small proc-macro that replaces instances of
?
with.unwrap()
-
mock_derive
An easy to setup, rich mocking library for the Rust programming language
-
require_lifetimes
A proc-macro to force rust authors to write lifetimes in function signatures
-
rune-macros
Helper macros for Rune
-
sha2-derive-proc-macro
The proc macro used by the sha2-derive crate
-
subtle-ng-derive
Derive macros for subtle-ng traits
-
aggregate_derive
Aggregate attributes of structs for runtime
-
proptest-attr-macro
Procedural attribute macro for writing proptest tests
-
bytestream_derive
Codegen for Supercell bytestream
-
foreign-types-macros
An internal crate used by foreign-types
-
lr_parser
macros for ruly2
-
dioxus-table-macro
Make data-driven table rendering easy with Dioxus - macro crate
-
attribution
A declarative custom attribute parsing framework
-
bytify
Convenience macro for generating continuous byte arrays from arbitrary sequences of literals
-
quit_macros
Procedural macros used by crate quit
-
fixed-macro-impl
Proc-macro implementation for the
fixed-macro
crate -
wasm-bindgen-test-macro
Internal testing macro for wasm-bindgen
-
hooks-yew-derive
Compile-time hook component for yew
-
c3-lang-macro
C3 Lang macro
-
dynomite-derive
Derives AWS DynamoDB dynomite types from native Rust struct types
-
qinetic_ecs_macros
crate for Qinetic, containing entity-component-system macros
-
fates_macro
Helper macro for Fates crate. See https://crates.io/crates/fates
-
micro-timer
Dumb tiny logging timer
-
feignhttp-codegen
FeignHTTP macro support
-
elastic_types_derive
Compile-time code generation for Elasticsearch type implementations
-
dict_derive
Derive macros for some PyO3 traits to convert python dicts into rust structs
-
safe-goto
Emulating a safe goto-like instruction in Rust in the spirit of the "Safe goto with value" pre-RFC from IRLO
-
walle-macro
macro for walle-core
-
tokio-actor
Macro based Asynchronous Actor System
-
phper-macros
The proc-macros for phper crate
-
sourcegen-cli
In-place Rust source generator CLI utility
-
qinetic_app_macros
crate for Qinetic, containing application macros
-
rat-in-a-tube-definitions
Definitions for Rat In a Tube
-
sequential-macro
Allows for the creation of sequential Rust tests
-
ctrlgen-impl
Generate enums for message-passing services
-
sc2-macro
Procedural macros for rust-sc2 API
-
expansion
expant the native libs
-
klickhouse_derive
proc-macro crate for klickhouse
-
prop_tune_macro
The procedural macro crate for proc_tune
-
frc42_macros
Filecoin FRC-0042 calling convention procedural macros
-
ahecha_macro
Ahecha macro crate
-
meilisearch-index-setting-macro
Helper tool to generate settings of an Meilisearch index
-
pub_this
Make your structs' fields be pub
-
cw-ownable-derive
Macros for generating code used by the
cw-ownable
crate -
wasm_bindgen_helper_macros
helper macros for a couple arbitrary use cases
-
decanter-derive
This crate implements basic cryptographic primitives native to the ecosystem
-
biscuit-quote
macros for compile time datalog parsing for Biscuit authorization tokens
-
native-windows-derive
A very light and simple rust GUI library
-
open-rpc-derive
OpenRPC Schema Generator
-
md-icons-helper
Helper library for md-icons
-
auto_ref
Replace &T to impl AsRef<T>
-
try-catch
A simple proc-macro that enables try-catch for Rust with automatic downcasting of error types
-
better-bae-macros
A Rust proc-macro attribute parser
-
ctrlgen-derive
Generate enums for message-passing services
-
alipay_macros
alipay-rs macro
-
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…
-
field_names
A proc-macro for exposing a struct's field names at runtime
-
salsa-macros
Procedural macros for the salsa crate
-
error_generator
Transform structs and enums into fully qualified errors using attributes
-
libsql_bindgen_macros
Rust macros for writing WebAssembly-powered user-defined functions for libSQL
-
dynpath
An attribute macro to specify a path to a module dynamically
-
crud-api-endpoint
CLI generator for your API. Enpoint description
-
efbuilder
A procedural macro for generating efficient builders
-
cssparser-macros
Procedural macros for cssparser
-
scale-encode-derive
Derive macro for scale-encode
-
bird-protocol-derive
Packet, PacketReadable, PacketWritable derives for bird-protocol crate
-
portaldi-macros
Macros for portaldi
-
shiv-macro
Macros for shiv
-
cbe-frozen-abi-macro
Cartallum CBE Frozen ABI Macro
-
rpc-toolkit-macro
macros for rpc-toolkit
-
include-bytes-plus
Improved include_bytes! allowing to reinterpret input differently
-
rxing-one-d-proc-derive
proc macros to simplify the development of one-d barcode symbologies in rxing (https://github.com/hschimke/rxing)
-
quork-proc
The proc macros for quork (not intended for independant use)
-
neon-macros
Procedural macros supporting Neon
-
geng-derive
Game Engine (derive macros)
-
oxi-module
Proc macro for the
nvim-oxi
crate -
polyhorn-macros
Macros and parser for Polyhorn JSX-like syntax
-
plotly_derive
Internal proc macro crate for Plotly-rs
-
com_macros
COM crate macros
-
ff_derive
Procedural macro library used to build custom prime field implementations
-
mlua_derive
Procedural macros for the mlua crate
-
arcdps_codegen
Macros for arcdps
-
enum-repr-derive
Simple trait for converting enum to and from its primitive repr type
-
rustbus_derive
derive proc-macros for the rustbus crate
-
steam-language-gen-derive
Implementation detail of
steam-language-gen
crate -
const-field-offset-macro
Procedural macro to generate constant field offset from repr(c) struct
-
plctag-derive
macros for
plctag
-
specit
Spec "it" for Rust testing
-
intercom-attributes
See 'intercom'
-
actix_header
shortcut to implement actix-web headers
-
include-doc
Include examples in your Rustdocs
-
json_schema_test_suite
Procedural Macro Attribute to run all the test cases described in JSON-Schema-Test-Suite
-
derive_bounded
Builtin-macros workalike but with a way to specify bounds
-
assert2-macros
procedural macros for assert2
-
postgres_query_macro
Write and execute SQL queries with ease
-
structdump-derive
Dump structure to source code - derive macro
-
dyn_safe-proc_macros
::dyn_safe
’s internal crate -
nj-derive
procedure macro for node-bindgen
-
crud-derive
CLI generator for your API. derive Crud implementation.
-
elfo-macros
Macros for matching and deriving messages
-
proclock-macro
Macro API for the proclock crate
-
rustico
Rust programming, in Spanish
-
scraper-macros
Macros implementation of #[derive(Scraper)]
-
tide-jsx-impl
The macros needed for
render
-
bevy_kindly_macros
An extension to Bevy Kindly with macros to define entity kinds for Bevy ECS
-
git-const
Proc macro to provide properties of git repo
-
autoexport
Automatically use all the modules laid out in a top-level mod
-
ringhopper-proc
Procedural macros for the Ringhopper Halo modding crate
-
juniper_codegen_puff
Code generation for
juniper
crate. Released for Puff. -
bio-seq-derive
Derive macros for the bio-seq crate
-
reshape_helper
Helper library for Reshape
-
gset
A procedural macro for generating the most basic getters and setters on fields
-
progenitor-impl
An OpenAPI client generator - core implementation
-
ramhorns-derive
Experimental Mustache-like templating engine
-
aocd-proc
Procedural macros for aocd
-
oxi-test
Proc macro for the
nvim-oxi
crate -
indiscriminant_impl_bits
A proc-macro for mapping between values and enum discriminants
-
better_typeid_derive
derive macro part of better_any
-
marigold-macros
Macros for the marigold language
-
pest-ast
Derive to convert from pest parse tree to typed syntax tree
-
syner_derive
A procedural macro to generate a parser for attributes from a struct
-
include-repo
This crate implements the 'include_repo!' macro for easy AGPL compliance! Include a tarball as a const in your code!
-
subplotlib-derive
macros for constructing subplotlib based test suites, typically generated by
subplot codegen
-
labels
This crate provides labels for functions to document their test status: tested, untested, parent_tested
-
trigraph
A trigraph macro for your rust code
-
test-with-tokio-macros
proc macro for test-with-tokio
-
cherry-derive
A Rust async ORM, support for MySQL, PostgreSQL and SQLite
-
edifact-types-macros
Macros for edifact-types
-
tracelogging_macros
TraceLogging for Rust Proc Macros
-
bevy_ecs_markers_macros
Proc Macros for Bevy ECS Markers
-
xdr-rs-serialize-derive
XDR object serialization for Rust
-
indiscriminant_impl_byte_str
A proc-macro for mapping between values and enum discriminants
-
optbuilder
A optional builder derive macro for helping with big constructors with mostly optional parameters
-
gvariant-macro
Proc macros for the gvariant crate
-
enum-flags
EnumFlags is a csharp like enum flags implementation
-
range_checker_macro
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
polyhorn-ui
Shared API contract for multi-platform Polyhorn UI
-
envcrypt-macro
internal
-
cbe-sdk-macro
Cartallum CBE SDK Macro
-
show-image-macros
macros for the show-image crate
-
cfe_progmacro
Configurations and secrets defined in structs are automatically read from environment variables
-
derive-stable-id
This crate contains all traits that are required for the stable-id crate
-
icgeek_candid_gen
Macros for generate candid interface
-
ag-grid-derive
Internal proc-macro library for ag-grid-rs
-
near_schemafy_lib
Generates serializeable Rust types from a json schema
-
select-macro-utils
Waits on multiple concurrent branches
-
konst_proc_macros
Implementation detail of the
konst
crate -
ez_config
A lightweight and simple to use mapper from environment variables to config classes
-
hs-bindgen-derive
Handy macro to generate C-FFI bindings from Rust to Haskell
-
malloc_size_of_derive
Crate for Firefox memory reporting, not intended for external use
-
faux_macros
Implementations for #[create], #[methods], when!
-
eclair_bindings_derive
proc-macro crate, for use together with 'eclair_bindings'
-
wolfram-library-link-macros
Procedural macros used by wolfram-library-link
-
for_let
Syntax sugar for a for-loop + pattern binding
-
leetcode_test
Some useful macros and definition for exercising in leetcode
-
dynamic-dispatch-proc-macro
Proc macros for dynamic dispatch crate
-
regex-bnf-macro
The proc-macro crate for regex-bnf
-
bitfield-derive
This crate provides derive to generate struct with bitfield access
-
magnus-macros
Derive and proc macros for magnus
-
ublox_derive
Utility macros for the ublox crate
-
saturating_arithmetic
Proc macro #[saturateit] to rewrite operators into their saturating equivalents
-
slices
Convert string literals to static unsigned integer slices in compile time
-
lwb-parser
parser framwork with automatically generated ASTs for the LWB project
-
async_trait_proto
Async traits using nightly features
-
deserialize_xml_derive
Provides the procedural macro that powers the crate
deserialize_xml
-
inertia-macros
A simple library of attribute macros to assist with overloading operators for borrowed and owned data
-
fast-map
Map-like structs
-
hwp_macro
make_4chid를 위한 매크로
-
clap-serde-proc
Procedural macro for clap-serde-derive
-
openapitor
An OpenAPI client generator
-
leafwing_abilities_macros
Macros for the
leafwing_abilities
crate -
gtmpl_derive
Derive for gtmpl_value
-
rosrust_codegen
Message generation for rosrust
-
enumber
Provide useful impls on numerical enums
-
bevy_state_tool
A small package to simplify bevy writing
-
ptr_meta_derive
Macros for ptr_meta
-
partial-borrow-macros
proc-macros for partial-borrow
-
typesafe_repository_macro
Macros for typesafe_repository
-
const_env--value
Configure const and static items by environment variables
-
target_handler
A derive macro to create a handler for multiple enum variants
-
rust-macios-app-kit-proc-macros
Macros for Appkit for use in Rust-MaciOS library
-
castflip_derive
Derive macros for castflip
-
absolution
‘Freedom from
syn
’. A lightweight Rust lexer designed for use in bang-style proc macros. -
s-macro
A basic Rust library for conveniently making a String
-
hard-xml-derive
Derive marco of hard-xml
-
static-noise
A simple crate for generation static noise at compile time
-
zone_cfg_derive
Rust bindings for Zone management (proc macro generation helper)
-
xls_table_derive
Procedural macros for investments crate
-
include-blob-macros
Include large binary files in an application without incurring the compile time cost
-
unix-print
A no_std and no_libc stdout printing library
-
quickcheck_async
Runtime-agnostic attribute macros to use quickcheck with async tests
-
view_macro
a macro for constructing views
-
enum_const_value
Providing const values for enums. Unit and enums with associated types are supported. Each variant gets a unique sequential value.
-
mendes-macros
Macros for mendes web toolkit
-
entrait_macros
Procedural macros reexported by entrait
-
caisin-macros
caisin tools
-
macro-ruby
Execute ruby code at compile time trough mruby
-
serde-reflect-intermediate-derive
Derive proc macro for reflection utils of intermediate representation for Serde serialization
-
reproto-ast
structures for the reproto AST
-
reflect-internal
Procedural macros required by the
reflect
crate -
lazylink-macro
Convert extern fn to libdl call
-
maikklein/unreal-api-derive
Rust integration for Unreal Engine 5
-
kwarg_macros
Keyword argument plugin
-
func_trace
A procedural macro for tracing the execution of functions
-
makepad-derive-live
Makepad platform live DSL derive macros
-
rtaichi_attr
Rust language binding to the Taichi Runtime C-API
-
defaults
A better
Default
derive macro -
defr
Golang
defer
statements but in Rust -
tokenstream2-tmpl
Runtime TokenStream interpolation for Rust macros
-
bevy_atmosphere_macros
Proc macros for bevy_atmosphere
-
swc_config_macro
Macros to prevent mistakes
-
rustspec_assertions
BDD style assertion library
-
lurk-ipld-cbor-derive
lurk-ipld dag-cbor-derive
-
refinery-macros
This crate should not be used directly, it is internaly related to Refinery
-
open-metrics-client-derive-text-encode
Auxiliary crate to derive text Encode trait from open-metrics-client
-
puroro-codegen
Google Protocol Buffer's compiler plugin implementation for puroro
-
optional_struct_macro_impl
Helper crate defining the proc_macro for the optional_struct crate
-
static_table_derive
Procedural macros for investments crate
-
sub-model
a proc marco for easy generate sub models
-
toml-cfg
A procedural macro for configuring constant values across crates
-
random_struct_layout
The custom attributes to randomize struct members layout
-
roxido_macro
Macros to support the roxido crate
-
yew-fs-router-macro
Macros for yew-fs-router
-
witgen_macro
Macros for witgen which is a library to help you generate wit definitions in a wit file for WebAssembly
-
ntex-prost-derive
A Protocol Buffers implementation for the Rust Language
-
variants-struct
A derive macro to convert enums into a struct where the variants are members
-
into_query_derive
Provides a derive macro for IntoQuery
-
btl
Simple shell scripting in rust. Github Repo: https://github.com/znx3p0/btlsh
-
cuda_std_macros
Macros for cuda_std
-
fast_async_trait_proc
-
fractran_macros
A compiler plugin that converts Fractran code into Rust at compile time, letting your Fractran programs be optimised by LLVM to super-fast native code
-
duration_in_ms_macros
Macros for the duration_in_ms package
-
ormx-macros
lightweight procedural macros bringing orm-like features to sqlx
-
auto_into
a rust macro that provides (slight) ergonomics for writing functions
-
east-macro
Macros for East
-
surrealdb-obj-derive-impl
a derive from surrealdb-schema-derive,only feat obj
-
match_bytes
A language extension for matching byte patterns in slices of bytes
-
syn_str
This library is what syn is to proc_macro::TokenStream for proc_macro::TokenStream::to_string,quote! being format! with String::parse::<TokenStream>
-
ic-stable-memory-derive
Derive macros for ic-stable-memory
-
actix-multipart-extract-derive
Better multipart form support for Actix Web
-
irzha
Write Rust programs using Ukrainian language
-
swc_ecma_visit_macros
Visitors for swc ecmascript nodes which works on stable rustc
-
bitfield
This crate provides macros to generate bitfield-like struct
-
bigml_derive
Internal
derive
support for unofficial BigML client bindings -
bitflags12
A macro to generate structures which behave like bitflags
-
proxy-enum
Emulate dynamic dispatch and sealed classes using a proxy enum, which defers all method calls to its variants
-
illicit-macro
procedural macros for the illicit crate
-
monostate-impl
Implementation detail of the monostate crate
-
packetrs-impl
Macro-based struct serialization/deserialization
-
indirect-once
One-time resolvable runtime indirection in the style of glibc's ifunc
-
kll-macros
Rust macros for kll-core
-
structout
A proc-macro for generating structs from a common definition
-
asn1-rs-derive
Derive macros for the
asn1-rs
crate -
matrix-pickle-derive
Derive support for matrix-pickle
-
elm_rs_derive
Derive macros for elm_rs
-
postfix-macros
Postfix macros on stable Rust, today
-
f64ad_core_derive
Easy to use, efficient, and highly flexible automatic differentiation in Rust
-
locenv-macros
A collection of macros to aid on module development for locenv
-
lexgen_util
Runtime library for lexers generated by lexgen
-
sonic_serde_macros
Macros used in sonic_serde_object
-
tryvial-proc
Procedural macro for the
tryvial
crate -
complex_test_helper
Extends Rust's testing capabilities by providing several macros for testing complex workflows
-
r18-proc-macros
r18 procedure macros
-
syncwrap
Automatically wraps async functions in a synchronous wrapper based on feature flags
-
puball
Public all the field in your struct
-
dns_common_derive
Personal derive macros for Rust code
-
nt-list_macros
Macros for nt-list
-
test-context-macros
Macro crate for test-context
-
deluxe-core
Core traits and helpers for Deluxe procedural macro attribute parser
-
serde_syn
Use serde to parse Rust source code
-
aleo-std-time
A convenience attribute to time functions
-
tlua-derive
Tlua derive macro definitions
-
gtk-properties-macro
Experimental property declaration macro for gtk-rs
-
stockbook-stamp-macro
Implementation detail of the
stockbook
crate -
hun-offsetof
Provides C-like macros: offset_of and container_of
-
srpc-macro
contains srpc's macros
-
tls_codec_derive
Derive macros for the tls_codec trait
-
rustmex-entrypoint
Rustmex: providing convenient Rust bindings to Matlab MEX API's
-
scanfmt_macros
Procedural macro for scanfmt
-
gat-std-proc
Proc macros for gat-std
-
prql-compiler-macros
Macros for PRQL compilation at build time
-
cxx-async-macro
The macro for simple interoperability between C++ coroutines and asynchronous Rust
-
saneput-proc
Procedural macro for saneput
-
router-rs-macro
A macro for client side web application routing
-
next-gen-proc_macros
Internal: proc-macro backend of ::next_gen
-
portrait-codegen
Internal procedural macros for portrait
-
display_adapter
A proc macro for defining ad-hoc Display adapters
-
aper_derive
Synchronized state machines over WebSockets
-
ruzhda
Rust programming, in Bulgarian
-
struct-name-macro
Derive macro for struct name
-
yomo
YoMo Rust development sdk
-
yew-router-nested-macro
Contains macros used with yew-router
-
socket_addr_macros
Check and parse SocketAddr at compile-time
-
concoction_macro
A bunch of personal procedural macros
-
constant
Constant evaluation tools for Rust
-
rocket_db_pools_codegen
Procedural macros for rocket_db_pools
-
scpi_derive
SCPI/IEEE488.2 parser support library
-
gotham_restful_derive
Derive macros for gotham_restful
-
allot_codegen
Macros for allot
-
tpfs_log_event_procmacro
A simple procmacro to support logging functions
-
gumdrop_derive
custom derive support for gumdrop
-
chalk-macros
Macros for Chalk
-
swipl-macros
Macro crate for swipl-rs
-
wasm-rpc-macros
Expose rust functions as WASM RPC interfaces
-
pinwheel_elements_macro
Build web applications with Rust
-
concision-macros
Procedural Macros created for Concision, a complete data-science toolkit written in Rust
-
concision-derive
Derive macros created for Consision, a complete data-science toolkit written in Rust
-
sully_peg
Proc macro for PEG generation
-
fbinit_macros
Provides macros for fbinit crate
-
ndjsonloggercore
-
clean-macro-docs
Hide internal rules when documenting
macro_rules!
macros -
inject-macro
Experimental IOC library for Rust, procedural macros
-
inpt-macros
Procedural macro implementation for the inpt crate
-
jrsonnet-gc-derive
Garbage collector derive plugin for rust-gc
-
peepmatic-macro
Macros for peepmatic
-
orbtk-proc-macros
Procedural macros used by OrbTk
-
macro-compose
macro-compose is a library trying to simplify and organize proc-macros
-
arg-derive
Derive for arg crate
-
dustr
Generate dart code based on a rust ffishim
-
ssbh_write_derive
ssbh_write derive macro
-
ocaml-gen-derive
The inner library of ocaml-gen, for generating OCaml code
-
packer_derive
Derives for the packer crate
-
uiautomation_derive
UI Automation Derive
-
bitregions-impl
implementation for the bitregions crate
-
chemin-macros
Proc macro crate for "chemin" crate
-
af_path
path查询语言库
-
reborrow-derive
Emulate reborrowing for user types
-
particular_derive
Derive macro for the 'particular' crate
-
uwurandom-proc-macros
proc macros for uwurandom-rs
-
hs-bindgen-attribute
Handy macro to generate C-FFI bindings from Rust to Haskell
-
sgx_serialize_derive
Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language
-
crud-api-derive
CLI generator for your API. derive Api implementation
-
structsy-derive
Structsy single file struct database persistent derive implementation
-
rbtag
A procedural macro to add build DateTime and git commit information at compile time
-
vk-shader-macros-impl
Implementation detail of vk-shader-macros
-
tailwindcss-to-rust-macros
Helpers macros for using the Rust code generated by tailwindcss-to-rust
-
keycode_macro
A Rust crate for parsing Chrome’s mapping of keys. Used in the
keycode
crate. -
conrod_derive
A crate providing procedural macros for the conrod library
-
pacaptr-macros
Implementation of several macros used in pacaptr
-
lazy-settings-macros
Application settings created lazily and in a distributed manner
-
near-abi-client-macros
Library to generate Rust clients for NEAR smart contracts
-
actix-proc-macros
Proc macros, to be re-exported by
actix-helper-macros
-
mpesa_derive
MpesaSecurity
trait derive macro crate -
fourcc
Syntax extension to generate FourCCs (four-character code)
-
dionysos-derives
derive crate for dionysos: Scanner for various IoCs
-
tinyhttp-codegen
Provides codegen for tinyhttp
-
cmd_lib_macros
Common rust commandline macros and utils, to write shell script like tasks easily
-
struct_mapping_derive
Token StructMapping for testing StructMapping implementations
-
fire-stream-api-codegen
Codegen for fire stream api
-
entity-gym-derive
Derive macros for the entity-gym-rs crate
-
aoc-runner-derive
Codegen for aoc-runner & others
-
dotenvy_codegen_impl
Internal implementation for dotenvy_codegen
-
rust-query-hydrate-derive
Derive macro for hydrate feature of rust-query
-
runestick-macros
Runescript, a generic stack-based virtual machine for Rust
-
harled_core
Core traits and types of the harled crate
-
jrsonnet-gcmodule-derive
Generate code to implement Trace trait on structures
-
rweb-testing-macros
Macros for testing framework for rweb
-
fuels-macros
Fuel Rust SDK marcros to generate types from ABI
-
qu-derive
internal part of qu crate
-
sc2-proc-macro
Procedural macros for rust-sc2 API
-
print_return_values
A crate containing a macro to print the return values of functions
-
thisctx_impl
Macro implementation of the
thisctx
crate -
rusty_jsc_macros
Macros for rusty_jsc
-
deltoid-derive
Derive macro that generates code to calculate and apply deltas to structs and enums
-
derive_rich
Helps you to create richful function for your structs
-
clia-rustorm-codegen
code gen provides macro for generating code on data access objects on table metadata
-
trait-based-collection-macros
The procedural macros for the collection crate
-
parst_derive
derive macros for parst
-
runix-derive
Derive macros for runix
-
to-mut-proc-macro
Convert immutable reference to mutable reference
-
shura_proc
Derive macros for the shura component system
-
proc-macro2-impersonated
A substitute implementation of the compiler’s
proc_macro
API -
nougat-proc_macros
Internal: proc-macro backend of ::nougat
-
crabmole-derive
Crabmole derives
-
sourcegen
This crate contains a procedural macro to work together with "sourcegen-cli" crate
-
grafana-plugin-sdk-macros
Convenience macros for the Grafana backend plugin SDK
-
include_uri
Proc-macro to include URI as literals at build time
-
miniserde-enum
Derive macros for miniserde on enums
-
dioxus-html-macro
An html macro for dioxus applications
-
nanorpc-derive
macros for nanorpc
-
fn_block
Crate defining macros for calling blocks or expressions in a closure
-
ayyeve-ui-proc-macros
proc macros for ayyEve's ui garbage
-
blade-macros
Macros helpers for Blade users
-
xfinal-macro
macro utilities for rust-xfinal
-
clap-vergen-macro
proc-macro for cargo-vergen
-
default-args
zero-cost default arguments in rust
-
quote_precise
A quote implementation that preserves meaningful span locations
-
enum_cycling_derive
Small macro for working with enums
-
hdf5-derive
Derive macro for HDF5 structs and enums
-
flexpiler_derive
Derive macro project for main crate 'flexpiler'
-
const-type-layout-derive
Derive macro implementation for const-type-layout crate
-
wasmtime_serde_guest_macro
Simple library for serializing complex types to the wasmtime runtime using serde
-
cain
Procedural macro to transform sequential branches into nested branches
-
wasmtime_serde_host_macro
Simple library for serializing complex types to the wasmtime runtime using serde
-
shader_macro
use this macro from dxfilter crate
-
datastore_derive
Derive macros for datastore
-
try_match_inner
The internal procedural macro of
try_match
-
axum-route
Minimalistic route macro for axum
-
scotch-host-macros
Scotch host macros
-
sql_db_mapper_derive
Derives used by code generated by sql_db_mapper
-
ferric-macros
A Probablistic Programming Language with a declarative syntax for random variables
-
dcc-lsystem-derive
Macro implementation of #[derive(TurtleContainer)]
-
smarterr-macro
Smart error handling library
-
dxr_derive
Declarative XML-RPC (derive macros)
-
typestuff-macro
Macros for the typestuff crate
-
turbolift_internals
macros for turbolift
-
ast-description-lang
A language to describe your language's AST
-
mmtk-macros
MMTk macros provides procedural macros used by mmtk-core
-
scotch-guest-macros
Scotch guest macros
-
derive-ocaml
Custom derive and procedural macros for easy FFI with ocaml on top of the ocaml crate
-
config-manager-proc
Macro implementation for config-manager-rs derives
-
docfg
Convenience macro to add documentation gated features
-
linked_list_c_derive
Safely work with c compatible linked lists
-
near-sdk-abi-macros
Utility library for making typesafe cross-contract calls in NEAR SDK smart contracts
-
inline-proc
Inline procedural macros
-
submillisecond_macros
Macros used by the submillisecond web framework
-
azalea-buf-macros
#[derive(McBuf)]
-
model_macro_derive
derive macro collection
-
airline-macros
Macros for Airline
-
rustic_bird_macro_derive
something I will use to make a twitter api crate
-
dot-generator
the set of macros to generate dot files
-
encoding-next_index_tests
Helper macros used to test index tables for character encodings
-
toy-arms_derive
A derive macro crate for toy-arms
-
ff_derive-zeroize
Procedural macro library used to build custom prime field implementations
-
jlrs-derive
jlrs-derive contains the custom derives offered by jlrs
-
if-let-return
Simple macro for
if let ... pattern
-
gotham_formdata_derive
Implementation detail of gotham_formdata
-
log4r
Stupidly simple logging utils
-
wezterm-dynamic-derive
config serialization for wezterm via dynamic json-like data values
-
compiler-tools-derive
A proc-macro for deriving powerful and fast tokenizers with compile-time regex
-
activitystreams-derive
Derive macros for activitystreams
-
wotw_seedgen_derive
Derive macro utilities used for wotw_seedgen
-
dioxus-use-request-macro
Macro crate for the dioxus-use-request crate
-
metriki-influxdb-reporter
Influxdb reporter for metriki
-
loupe-derive
Profiling tool for Rust, see the
loupe
crate -
rust2fun_macros
Procedural macros for rust2fun
-
aide-macros
Macros for the Aide library
-
tco
A macro for transforming a tail-calling recursive function to eliminate recursion
-
hash32-derive
Macros 1.1 implementation of #[derive(Hash32)]
-
qualify-derive
Simple utility for wrapping derive macros that do not qualify paths properly
-
cyfs-base-derive
Rust cyfs-base-derive package
-
jrsonnet-macros
Macros to reduce boilerplate in jrsonnet-evaluator usage
-
tulisp-proc-macros
Proc macros for tulisp
-
client-handle-core
An internal helper library of client-handle
-
oauth1-request-derive
A derive macro for
oauth1_request::Request
trait -
locales
Easy to use I18n
-
evmc-declare
Bindings to EVMC (VM declare macro)
-
aoc-toolbox-derive
Macros implementation of aoc-toolbox
-
slashy_macros
Macros used by slashy
-
doku-derive
A framework for building documentation (internal macro)
-
rvvm-macro
macros for the rvvm crate
-
superbitty-macros
A helper crate to the
bitfields
crate -
lazy-re
A library for lazy reverse engineers
-
sapper_std
Wrappers for rapid coding for sapper web framework
-
tealr_derive
Derive/Proc macro's to reduce boilerplate when using tealr
-
lightningcss-derive
Derive macros for lightningcss
-
ctjs
compile time javascript as a rust proc macro
-
constdefault-derive
#[derive(ConstDefault)]
-
zoozle
Some I/O macros like C++ cin/cout
-
assets_manager_macros
Procedural macros for assets_manager
-
just_macros
macros for justjs
-
pcd-rs-derive
Derive macros for pcd-rs crate
-
simple_generators_macros
helper crate for simple_generators, containing the macro
-
nova-impl
Implementation for nova crate
-
ioctl-gen
Simple macros for generating ioctl numbers
-
typesets-macro
The derive macros for typesets
-
pathsep
a small macro to enable easy path construction in other macro calls
-
self-rust-tokenize-derive
Turns instances of Rust structures into a token stream that creates the instance
-
taos-macros
TDengine connector internal macros
-
trackable_derive
Custom derive for
trackable
crate -
nstdapi
A helper crate for
nstd
providing manipulation of an item’s ABI attributes -
proc_qq_codegen
QQ client framework
-
npyz-derive
#[derive(...)]s for reading structured arrays in NPY files
-
microrm-macros
Procedural macro implementations for the microrm crate
-
bevy_startup_tree_macros
procedural macros for bevy_startup_tree
-
fast-rustc-ap-rustc_macros
Automatically published version of the package
rustc_macros
in the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
asynchelp-macros
Proc macros for asynchelp
-
flat-bytes-derive
Derive macro for flat-bytes
-
influxdb_derive
Private implementation detail of the influxdb crate
-
unrest_tmp_syn
don't use
-
aoc_macros
helper macros for AoC
-
postgres-derive
An internal crate used by postgres-types
-
kayak_ui_macros
A proc macro library that provides RSX like syntax for Kayak UI
-
tracked-impl
Internal implementation details for
tracked
-
derive-aktor
Create actors in rust with a derive macro
-
gotcha_macro
gotcha web framework macro
-
concoct-macros
Macros for concoct
-
adorn
A plugin to provide python-style decorators in Rust
-
retry-block
Utilities to retry operations that may fail with configurable backoff behavior using macros over blocks of code
-
actix-handler-macro
Helper macros for using Actix. Generates handlers, actors and address traits.
-
serde-semver
Serde-compatible version checker
-
tonic_include_protos
A helper proc-macro to include all protobuf files generated by tonic_build
-
delve-derive
Provides a number of macros that make working with enums and strings more convenient
-
azalea-block-macros
Proc macros used by azalea-block
-
polling-async-trait
A proc macro that creates async methods based on polling methods for your trait
-
binary_macros_impl
Procedural macro implementations for decoding base64-like encodings in string literals to [u8] literals
-
InheritDerive
-
coi-actix-web-derive
Provides derives for coi-actix-web
-
abscissa_derive
Custom derive support for the abscissa application microframework
-
indiscriminant_lib
A proc-macro for mapping between values and enum discriminants
-
iroha
A tokenization Library for Rust
-
dynamic-graphql-derive
Dynamic GraphQL schema macro
-
round_view_derive
Procedural macros to generate methods r2_view, r3_view, r4_view and r5_view
-
unwrap_helpers
Helper macros for unwrapping
-
has_fields_macros
Macros for the has_fields crate
-
bigquery-functions-types-macros
proc macros to define BigQuery function types
-
function-frame
Procedural macro to wrap any function outputs within a text frame
-
autoload
rust autoload macro,single scan load ioc aop
-
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…
-
trace2
A proc macro for tracing the execution of functions, similar to trace crate, but thread safe and use log
-
ketos_derive
Derive traits for Ketos scripting language
-
canadensis_derive_register_block
Derive macro for
canadensis::register::RegisterBlock
-
ffishim
Library behind ffishim_derive
-
hello_macro_derive
hello macro derive
-
proxy-sys
A dynamic Windows System DLL proxy
-
h2s_macro
A macro part of h2s
-
redbpf-macros
Procedural macros for redbpf
-
rapira-derive
serialization library like borsh and bincode
-
actix-easy-multipart-derive
actix-easy-multipart proc-macro
-
janetrs_macros
Attribute macros for JanetRS
-
simd_helpers
Helpers to write more compact simd code
-
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.
-
azalea-registry-macros
Macros internally used in azalea-registry
-
leveldb-orm-derive
An ORM for leveldb
-
sea-orm-field-updater
update model by field
-
format-bytes-macros
Macros for the format-bytes crate
-
rawcode_derive
Implements a
derive
macro forrawcode
-
result-like-derive
derive macros for result-like
-
rlp-derive
Derive macro for #[derive(RlpEncodable, RlpDecodable)]
-
rotate-enum
A simple macro that implements prev() and next() methods to an enum
-
async-trait-static
async fn in trait for no_std
-
code_snippet_generator
A proc_macro for turning a snippet of code into colorized html
-
deref-derive
Derive Deref and DerefMut for structs
-
idkthings_core_macros
core macros for idkthings
-
derive-deref-rs
derive-deref-rs is a derive macro library used to easily defined the Derive and DrerfMut trait of the core library
-
cbor-data-derive
A library for using CBOR as in-memory representation for working with dynamically shaped data
-
pagetop-macros
Group the main procedural and declarative macros for use from PageTop
-
rustacuda_derive
Custom Derive Macro for RustaCUDA
-
js-macros
Quickly prototype procedural macros using JavaScript or TypeScript!
-
custom_debug_derive
Derive Debug with a custom format per field
-
rust-xfinal-macro
macro utilities for rust-xfinal
-
opaque_typedef_macros
Supports defining opaque typedefs
-
matroskin-grpc-build-macros
Reserved the library for
elastio
company. Will be filled with code once we open-source our crate. -
bevy_ui_styled_macros
Macros for bevy_ui_styled
-
holium-backend
Backend crate for the Holium Rust SDK procedural macro
-
telexide_proc_macros
macros for subscribing to events in telexide
-
molt-argparse-procmacro
The inner procedural macro for molt-argparse. Not intended to be used directly.
-
cbor_enhanced_derive_protocol
Derive macro implementation for cbor_enhanced
-
code_gene_macro
code generation macros
-
cpreprocess
Procedural macro that runs a C preprocessor on the input
-
c-closures-build
Generates C/C++ FFI compatible
*Closure
structures from rust closures, useful for cross language functional programming -
rdxl_static
Static Site Generation Utilities for RDXL
-
elfo-macros-impl
Macros for matching and deriving messages, implementation internals
-
shorthand
A proc_macro to derive getter and setter for structs
-
enum-variants-strings-derive
Derive macro for converting instances of enums to and from strs using variant names
-
concat-arrays
A macro for concatenating fixed-size arrays
-
hooks-derive
Compile-time, async hooks
-
makepad-micro-serde-derive
Makepad micro serde derive macro
-
encdec-macros
encdec simple encoder/decoder derive macros
-
proper
Derives for converting primitives to and from simple enums and newtype structs
-
random_variant_macro
To be used with all variant, contains the derive macro
-
woab-macros
Procedural macros for the WoAB crate
-
attribute-derive-macro
Clap for proc macro attributes
-
minicdn_macros
Static files, compressed for efficiency (macros crate)
-
tokay-macros
Macro support for Rust-native builtin functions for the Tokay programming language
-
azalea-protocol-macros
Macros internally used in azalea-protocol
-
proto_import
A macro for including prost-generated macros by package name
-
craydate-macro
Proc macros for using the craydate crate
-
compile_warning
A proc macro that emits a compile-time warning
-
test-vectors-macro
A proc macro to support the test-vectors crate
-
char-lex-macro
Create easy enum based lexers
-
pino_enum_string
general rust utility functions and macros
-
fehler-macros
Macros des Fehlers
-
safina-async-test-core
Procedural macro for the
safina-async-test
package -
sylt-macro
Proc-macros for developing the sylt programming language
-
multiconst_proc_macros
implementation detail of multiconst
-
structbuilder_derive
Super simple macro to derive a builder trait for your struct
-
recap-derive
Derives FromStr impl for types which are then deserialized using recap
-
turboengine-macros
TBA
-
phlow-derive
A helper derive crate to create new phlow extensions
-
sgx_rand_derive
Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language
-
relearn_derive
Derive macros for the relearn package
-
constduck-procmacro
Macro implementation of #[derive(ConstDuck)]
-
pg_mapper
derive
TryFrom<tokio_postgres::Row>
-
rabbithole-derive
The macro system helping users to model the relationship of their data
-
tokio-pg-mapper-derive
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
gmod-macros
Proc macros for gmod-rs
-
erl_nif_macro
Write Erlang and Elixir NIFs in Rust
-
ntex-macros
ntex proc macros
-
entity_data-macros
Macros for entity_data crate
-
swc_xml_codegen_macros
Internal macro for the xml code generator
-
dlopen_derive
Derive macros for the dlopen crate
-
include-flate-codegen
Macro codegen for the include-flate crate
-
async_t_internal
contains async_t macro
-
rust_swig
Tool for connecting libraries written in Rust with other languages
-
load-dotenv
This is a small procedural macro to load your .env file at compile time
-
termite-macro
Macros for termite
-
laps_macros
Macros for crate
laps
-
tappet-derive
Implementation detail of the
tappet
crate -
holium-macro-support
Support crate for the procedural macro for the Holium Rust SDK
-
openssl-macros
Internal macros used by the openssl crate
-
spacetimedb-bindgen
Easy support for interacting between SpacetimeDB and Rust
-
enum_index_repr_derive
Macros for enum_index_repr
-
easy_proc
Helper macros for making proc macros
-
size-of-derive
Automatically derives the SizeOf trait
-
kal-derive
Collection of derive macro for kal
-
jsonrpc-utils-macros
Proc-macros for jsonrpc-utils
-
shadow-derive
Procedual macros for rustot crate shadow state
-
ff-derive-num
Procedural macro library to add the Num trait to Field implementations for ff
-
kind-derive
Derive generator the kind compiler
-
proc-bitfield-macros
The supporting proc-macro library for the proc-bitfield crate
-
actix-admin-macros
macros to be used with actix-admin crate
-
zzrpc-derive
Macros for zzrpc
-
makepad-live-id-macros
Makepad live id macros
-
mediaflow_derive
Macros for the unofficial SDK to interact with the Mediaflow Pro API
-
display_tree_derive
Derive macro for
display_tree
crate -
abistr-macros
proc macro implementations for abistr
-
intuitive_macros
macros for the intuitive crate
-
compiler_base_macros
All macros in Compiler_Base
-
rp2040-hal-macros
Macros used by rp2040-hal
-
proc-lock-macro
Macro API for the proc-lock crate
-
dynec-codegen
dynec codegen library implementation
-
autodefault
A proc macro that automatically inserts
..Default::default()
into your struct literals -
syn-unnamed-struct
Extends syn expressions and meta structs with unnamed structs and meta lists
-
gxi-transpiler
transpiles component tree to gxi component system
-
xixixao/rust_to_metal_sl
ShaderToy clone in Rust, currently supporting MacOS
-
ntex-grpc-derive
A Protocol Buffers implementation for the Rust Language
-
kson-effect-param-macro
Macros for the kson crate
-
lib3d6
Potentially my personal utility library, for now a test
-
instrumenter-proc-macro
Proc macros for instrumenter
-
unrest_tmp_synom
don't use
-
surrealdb-obj-derive-macro
a derive from surrealdb-schema-derive,only feat obj
-
z3d
Z3 DSL interface for Rust
-
stidgen
Strongly Typed ID types macro
-
lending-iterator-proc_macros
Internal: proc-macro backend of ::lending_iterator
-
target-test-dir-macro
A proc-macro attribute implementation for providing test-specific directories (use
target-test-dir
) -
stf-macro
An example of a simple test framework in Rust
-
struct_layout
Customize your struct layout with this one weird trick
-
utf32-lit
A macro for creating
&[char]
literals -
usdt-impl
Main implementation crate for the USDT package
-
variantly
Derive helper methods for enum variants that are familiar from
std::option::Option
&std::result::Result
such asunwrap_or
orand_then
-
memoise
Simple memoization library for rust
-
deluxe-macros
Derive macros for Deluxe procedural macro attribute parser
-
instrs-derive
Derive macro for instrs crate
-
odoo-api-macros
Macros for the
odoo-api
crate -
net-literals
Literals for IP/socket addresses
-
deser-derive
Derive extension for deser
-
mocktopus_macros
Mocktopus procedural macros
-
enumscribe_derive
Derive macros for converting between enums and strings
-
algae-derive
Algae is a collection of core algorithms and data-structures, written in Rust
-
algae-macros
Algae is a collection of core algorithms and data-structures, written in Rust
-
node_api_macro
Write Node.js native addons with Node-API in Rust
-
syn_derive
Derive macros for
syn::Parse
andquote::ToTokens
-
csplib-macros
Code generator for csplib
-
reql-macros
Macros for the reql crate
-
bystr
macro to create compile-time, fixed length, byte array from a string
-
count-tys
Function-like procedural macro that accepts a comma-delimited :ty TokenTree sequence and returns their count as a constant usize
-
serde_apply_macros
Derive macro for serde_apply
-
structype_derive
A derive macro crate that lets you view an allowed type's fields and will let you over-ride it
-
elapsed-printer
Very simple macro for printing time elapsed to execute a function
-
const-table
Associate struct-typed constants with enum variants
-
async-reply-derive
Derive macros for
async-reply
messages -
langbox_procmacro
Proc-macros for langbox
-
securefmt
Drop-in replacement for the Debug derive macro that hides fields marked as sensitive
-
cstr-macros
Procedural macros for cstr
-
heaven
A web framework in the making
-
rustpython-derive
Rust language extensions and macros specific to rustpython
-
custom-slice-macros
Utilities to define custom slice types
-
ppc750cl-macros
Procedural macros for powerpc750cl
-
discrim-codegen
Codegen for discrim
-
splitter-derive
Splitter derive macro
-
discord_typed_interactions_proc_macro
suppose you're working with discord slash commands and you want statically typed request types
-
get-random-const
Simple compile-time random generator
-
derive_jface
Java Native Interface to rust Native Objects (derive)
-
locked
allows for locking structures to specific versions
-
dusk-proc-macros
A collection of procedural macros for use by the Dusk programming language compiler
-
ataraxy
Discord slash commands framework for Serenity
-
mauzi
Experimental i18n library using proc-macros
-
static-router-macros
Macros for the
static-router
crate -
proc-macro-id
Identity procedural macro
-
bruteforce-macros
Macro repository for bruteforce-rs
-
awsl-syn
AWSL parser for rust macro
-
photonio-macros
Procedural macros for PhotonIO
-
lv2-core-derive
Procedural macros for lv2-core
-
stremio-serde-hex
Hexadecimal encoding/decoding with serde
-
bitbar-derive
Proc-macros for the bitbar crate
-
usual-proc
The proc macros behind usual
-
lv2-urid-derive
Procedural macros for lv2-urid
-
extract-variant-internal
Internal lib for https://docs.rs/extract-variant
-
iso-rs
A crate to query ISO data, which includes countries, currencies, etc
-
unhygienic2
A dead simple macro to erase macro hygiene
-
luao3
Lua bindings for Rust, oriented around macros. Lossly inspired by pyo3, but based on mlua.
-
bolt-proto-derive
Procedural macros for bolt-proto
-
serde_dhall_typegen
Automatically generate Rust structs and enums from Dhall types
-
fbthrift_codegen_includer_proc_macro
Helps include generated thrift structures
-
autolog
A mini Rust library for logging when a function is called
-
corresponding-macros
Procedural macros for corresponding crate
-
dodo-derive
Dodo persistence library derives
-
utf16_literal
Provides the u16! macro that emits a UTF-16 string literal
-
verilog-arc
A rust proc macro based code generation backend for OpenVAF
-
wedpr_l_macros
Library of WeDPR shared macros
-
bancho-packets-derive
Derive macro for bancho-packets BanchoPacket trait
-
cvars-macros
Configuration variables for games - internal crate, use the main cvars crate instead
-
coproduct-idtype-macro
a proc macro for the coproduct crate
-
diesel_derives_extra
Automatically derive some simple CRUD methods for your Diesel models
-
pyo3-prost
Use Rust protobuf structs in Python
-
codegen_template
A Rust code templating macro for code generation
-
ranting_derive
A proc-macro library for internal support of ranting
-
fail_on_ci
Script to abort compilation if one of the known CI-Servers is detected
-
rustify_derive
A derive macro for implementing an Endpoint for rustify
-
partial-enum
proc-macro generating partially inhabited enums
-
event-driven-macros
Macros for the Event Driven Finite State Machine library
-
css-rs-macro
A macro for writing your CSS next to your views
-
data-query-proc
a Proc support library for the Data Query
-
mini-internal-miku
Derive macros for miniserde. Use the re-exports from the miniserde crate instead.
-
struct2map-derive
Proc derive macro for structmap crate
-
bytes-kman-derive
macros for bytes-kman
-
hb_macros
Useful macros for creating and handling errors. See hb_error crate.
-
doctor-syn
Computer algebra system for Rust expressions
-
outer_attribute
A library providiving
OuterAttribute
that implementssyn::parse::Parse
trait -
poggers-derive
traits for poggers
-
metacall-inline
Inline macros for metacall crate
-
wrapping_proc_macro
A proc macro for cleaner wrapping arithmetic
-
pin-init-internal
Internal implementation details of crate
pin_init
-
raffia_macro
Macros for Raffia
-
byte-strings-proc_macros
Internal: proc-macro backend of ::byte_strings
-
ff-uint_derive
Library for building and interfacing with fixed-sized integers and finite fields
-
nifpga-type-macro
helper macro for nifpga datatype
-
pi_async_macro
A async file macros tools
-
lattice_qcd_rs-procedural_macro
Set of procedural macro for the main library lattice_qcd_rs
-
edn-derive
Edn (De)Serialization derive macros
-
syn-codegen
Syntax tree describing Syn's syntax tree
-
grass-macro
Procedual Macros for GRASS
-
oss_derive
aliyun-oss-client 's macro
-
packtool-macro
In memory packing made easy: procedural macro definitions
-
gen-nested-iter-yield
A macro for creating n-nested for loops over iterators
-
scudo-proc-macros
Proc macros to use with the Rust bindings for the Scudo Allocator
-
ndjsonlogger
-
is_empty_derive
Easily check if the struct is empty
-
juri-macros
juri macros
-
coerce-macros
Utility macros for Coerce
-
ceiling-macros
Macros for the ceiling crate
-
proc-macro-kwargs
Keyword argument parsing for function-like proc-macros
-
glicol_macros
Macros for Glicol engine
-
mooshroom-macros
mc
-
tauri-bindgen-ts-macro
Macro for tauri-bindgen-ts
-
later-derive
Macro to generate stub for later: Background jobs manager and runner for Rust
-
multi-default-trait-impl
Define multiple default implementations for a trait
-
proc-quote-impl
A procedural macro implementation of quote!
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
bones_bevy_asset_macros
Macros for the bones_bevy_asset crate
-
penrose_proc
proc-macros for the Penrose tiling window manager library
-
git-ref-format-macro
Macros for the git-ref-format crate
-
ev3robot_macros
Proc-macro crate for ev3robot. Don't depend on this crate directly
-
teleser_gen
Telegram TMProto bot frame
-
macro_state_macros
Support crate for macro_state containing proc macros
-
muzzman-lib-macros
MuzzManLib Macros
-
tagname_derive
derive(TagName) implementation
-
dir-test-macros
Provides a procedural macro for
dir-test
-
esize
Implement From<usize> for enums with a derive macro
-
col_proc_macros
A bunch of procedural macros for declare collections of various kinds from their contents as fast as possible
-
ff_derive_wasm_unknown_unknown
Independent adaptation of the open-sourced ff_derive library that removes features incompatible with wasm32-unknown-unknown architecture
-
comprehension
Iterator comprehension in Rust
-
generate-derive
Provides derive functionality for the
generate
crate -
rcommunity_macros
Macros for
rcommunity
-
askama-enum
Implement different askama templates for different enum variants
-
cargo-toml-macros
Convinient macros for pulling fields from your Cargo.toml. Prettier than std::env
-
flatty-macros
Flatty procedural macros
-
bl602-macros
Macros for BL602 IoT SDK
-
cfmt-macros
Format output without Rust code segment in binary to reduce the ultimate binary size
-
arbitrary-model-tests
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
partial-application-rs
A macro to transform functions into partially applicable structs
-
postgres_query_derive
Define SQL queries with human-readable parameter names
-
actix_responder_macro
An attribute macro to transform a response struct to an actix responder
-
field-projection-internal
Internal implementation details of crate
field-projection
-
enum_to_u8_slice_derive
A simple fork of enum_to_str_derive (by @DCjanus), convert enum to u8 slice ref
-
yerpc_derive
Proc macros for yerpc
-
tinyparse_macro
Macros for tinyparse
-
rs-sandbox-derive
Derive macros created for the rs-sandbox
-
rs-sandbox-macros
Procedural macros created for the rs-sandbox
-
textparse_derive
Derive macros for textparse crate
-
snax
JSX-like syntax for proc macro authors
-
uniui_gui_macro
Macroses for uniui_gui crate. Please refer to uniui_gui crate for full documentation
-
faster-pest-derive
proc-macro for faster-pest
-
brainfuck_macros
A compiler plugin that converts brainfuck code into Rust at compile time, letting your BF programs be optimised by LLVM to super-fast native code
-
mlzlog
A collection of log4rs tools to log like the mlzlog Python package
-
block_on_proc
Generate a blocking method for each async method in an impl block. Supports either
tokio
orasync-std
backend. -
logfn
provides the logfn attribute macro for inserting logging code into your function
-
prost-amino-derive
A Protocol Buffers implementation for the Rust Language modified to enable amino (de)serialization
-
ceres-derive
derive macros for ceres
-
scale_documentation_parser
a proc macro to parse the structured SCALE documentation into Rust datastructures
-
torn-api-macros
Macros implementation of #[derive(ApiCategory)]
-
poem-openapi-macro
The macro collections for extending the Poem OpenAPI
-
kanin_derive
Derive macros for kanin
-
verilated-module
A procedural macro for replacing verilated marked up structs with include of generated code
-
temps-macros
-
template-quote-impl
A new-fasioned quote! macro implementation with pretty template-engine like syntax
-
rebound-proc
Proc macros associated with the rebound crate
-
pork
proc macro demo
-
comemo-macros
Procedural macros for comemo
-
excel-emulator-macro
Helper macros for excel-emulator
-
grandeur_gdnative_macros
RSX macros for generic abstract Update-Render-Reconcile-Thing
-
tiberius-derive
Derive macros for Tiberius