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