-
derive_more
Adds #[derive(x)] macros for more traits
-
proc-macro-error
Almost drop-in replacement to panics in proc-macros
-
strum
macros for working with enums and strings
-
proc-macro-crate
Replacement for crate (macro_rules keyword) in proc-macros
-
proc-macro2
A substitute implementation of the compiler’s
proc_macro
API to decouple token-based libraries from the procedural macro use case -
quote
Quasi-quoting macro quote!(...)
-
linkme
Safe cross-platform linker shenanigans
-
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.
-
syn
Parser for Rust source code
-
unicode-ident
Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31
-
paste
Macros for all your token pasting needs
-
expander
Expands proc macro output to a file, to enable easier debugging
-
synstructure
Helper methods and macros for custom derives
-
derive_utils
A procedural macro helper for easily writing derive macros for enums
-
enum_dispatch
Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
-
ctor
__attribute__((constructor)) for Rust
-
delegate
Method delegation with less boilerplate
-
displaydoc
A derive macro for implementing the display Trait via a doc comment and string interpolation
-
r2r
Easy to use, runtime-agnostic, async rust bindings for ROS2
-
structmeta
Parse Rust's attribute arguments by defining a struct
-
proc-macro-warning
Emit warnings from inside proc macros
-
maybe-async
A procedure macro to unify SYNC and ASYNC implementation
-
macro_magic
Allows the exporting and importing of the tokens of items across module, file, and crate boundaries
-
swc_macros_common
Common utilities for swc macros
-
rstml
Rust templating for XML-based formats (HTML, SVG, MathML) implemented on top of proc-macro::TokenStreams
-
docify
allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
deluxe
Procedural macro attribute parser
-
serde_tokenstream
A serde deserializer for proc_macro::TokenStreams
-
databake
Trait that lets structs represent themselves as (const) Rust expressions
-
proc-macro2-diagnostics
Diagnostics for proc-macro2
-
derive-new
#[derive(new)]
implements simple constructor functions for structs and enums -
enum-as-inner
A proc-macro for deriving inner field accessor functions on enums
-
ra_ap_proc-macro-srv-cli
TBD
-
unicode-id-start
Determine whether characters have the ID_Start or ID_Continue properties according to Unicode Standard Annex #31
-
manyhow
proc macro error handling à la anyhow x proc-macro-error
-
syn-mid
Providing the features between "full" and "derive" of syn
-
vercel_runtime_router
Vercel Rust Function Runtime Router
-
smart-default
Rust custom-derive macro for Default with more control on the fields
-
rustfmt-wrapper
wrapper around rustfmt for use by code generators
-
derive-adhoc
An ergonomic way to write derive() macros
-
macrotest
Test harness for macro expansion
-
pmutil
Utils for proc-macro
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
specr-transpile
Converts Specr lang code to Rust
-
attribute-derive
Clap like parsing for attributes in proc-macros
-
derive-getters
boilerplate getters generator
-
windows-bindgen
Windows metadata compiler
-
reflect
The "but I thought Rust doesn't have reflection?" memorial brand new way of defining procedural macros
-
scryer-prolog
A modern Prolog implementation written mostly in Rust
-
safe-proc-macro2
A fork of
proc_macro2
crate with unsafe code removed -
proc_macro_roids
Traits and functions to make writing proc macros more ergonomic
-
utoipauto
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
makepad-micro-proc-macro
Makepad micro proc macro util lib
-
getset
we're ready to go! A procedural macro for generating the most basic getters and setters on fields
-
rustfmt_if_chain
An if_chain-aware rustfmt (kind of)
-
function_name
macro that expands to the name of the annotated function
-
curve25519-dalek-derive
curve25519-dalek Derives
-
dbg-pls
Syntax aware pretty-printing debugging
-
genemichaels
Makes your code formatty
-
bitmask-enum
A bitmask enum attribute macro
-
protobuf-build
functions for generating Rust code from protobufs (using protobuf-rust or Prost)
-
frunk_proc_macro_helpers
Common internal functions for frunk's proc macros
-
asn1-compiler
ASN.1 Toolkit in Rust. Compiler for ASN.1 specification, ASN.1 codecs and derive macros for ASN.1 Codecs.
-
ambassador
Trait implementation delegation via procedural macros
-
optional_struct_macro_impl
Helper crate implementing the proc_macro for the optional_struct crate
-
macro_railroad
generate syntax diagrams for Rust macros
-
unique-type-id
A unique id proc-macro generator for types
-
derive_setters
Rust macro to automatically generates setter methods for a struct's fields
-
proc-macro-rules
Emulate macro-rules pattern matching in procedural macros
-
uniffi_meta
-
krk
The shuttle cli helper for (js like experience)
-
opendp
differential privacy algorithms for the statistical analysis of sensitive private data
-
venial
A very small syn
-
tryexpand
Test harness for macro expansion
-
vitasdk-sys-build-util
Internal build utilities for raw bindings to vitasdk
-
dynasm
A plugin for assembling code at runtime. Combined with the runtime crate dynasmrt it can be used to write JIT compilers easily.
-
rustifact
A seamless bridge between a build script and the main crate
-
eiffel
language inspired guard clauses with Rust macros
-
cstr
Macro for building static CStr reference
-
terrars
Terraform in Rust
-
swift-bridge-ir
Holds the data structures and logic for bridge module parsing and code generation
-
is-macro
Derive methods for using custom enums like Option / Result
-
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
-
syn-helpers
Framework for building derive macros
-
wasmtime-versioned-export-macros
Macros for defining versioned exports in Wasmtime
-
synthez
Steroids for
syn
,quote
andproc-macro2
crates -
simpl_cache
caching tools
-
int-enum
A derive macro for conversion between integer and enum types
-
neli-proc-macros
Procedural macros for neli
-
as_derive_utils
private derive utilities used by abi_stable and structural
-
chalk-derive
A helper crate for use by chalk crates for
derive
macros -
parse-variants
Derive the syn::parse::Parse trait for enumerations and use it to comfortably parse a variant of the enumeration
-
impl-tools
Helper macros: autoimpl
-
twust
Static checker for tailwindcss class names in rust for rust
-
wadl
parser for Rust
-
do-with-in
A template language for Rust metaprogramming using partial staging
-
procmeta
integration procmeta-core and procmeta-proc
-
napi-derive-backend
Codegen backend for napi procedural macro
-
rusty-bind-parser
Parses Rust module, generates Rust code with C ABI bindings and C/C++ header files and Swift gluecode
-
quote-use
Support
use
in procmacros hygienically -
ra_ap_load-cargo
TBD
-
rb-sys-build
Build system for rb-sys
-
proc_macro2_helper
Various utility code to extract data that can be used with proc macro2
-
mirror-mirror
Reflection library for Rust
-
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.
-
call2-for-syn
Apply parser functions to proc-macro2 token streams
-
string_cache_codegen
A codegen library for string-cache, developed as part of the Servo project
-
workflow-macro-tools
Macro utility functions used by the
workflow-rs
framework -
proc-quote
A procedural macro implementation of quote!
-
contracts
Design-by-contract attributes
-
macrors
custom macro library in Rust
-
extendable-data
A set of rust macros that allows you to specify data that can be "extended" or inherited from
-
impl-trait-for-tuples
Attribute macro to implement a trait for tuples
-
ra_ap_proc_macro_api
TBD
-
fsmentry
Finite State Machines with an entry API and data storage
-
coi-rocket
integration support between coi and rocket
-
warcrwlock
in Rust that provides an attribute macro for mods, structs and impls. Rewrite code using under the hood asynchronous reference (Arc) and asynchronous writing and read(RWlock) control elements.
-
frc42_macros
Filecoin FRC-0042 calling convention procedural macros
-
smtlib-build-util
The build utils for building the smtlib family of crates
-
macroific
Proc macro development utilities
-
actix-multipart-derive
Multipart form derive macro for Actix Web
-
tlkit-expand
Tool kit
-
hydroflow_lang
Hydroflow's Surface Syntax implementation
-
spez
Macro to specialize on the type of an expression
-
machine-check-machine
Machine crate for the formal verification tool machine-check
-
python-ast
compiling Python to Rust
-
dioxus-rsx
Core functionality for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences
-
lucidity
A distributed orchestrator platform for Rust
-
gsettings-macro
Macro for typesafe GSettings key access
-
ct-python
Execute Python code at compile time to generate Rust code
-
structstruck
Nested struct and enum definitions
-
v_utils
My utils crate
-
sh
Macro for easily running commands
-
stilts-lang
The parser for stilts
-
template-quote
A new-fasioned quote! macro implementation with pretty template-engine like syntax
-
surreal_derive_plus
Query builder for surrealdb
-
gengo
Get the language distribution stats of your repository
-
stageleft
Type-safe staged programming for Rust
-
penum
Make enum conform to a given pattern
-
kproc-parser
minimal procedural macros parser that produce a convenient AST by including only the necessary code
-
rcss
Rust CSS embedding library
-
restructed
Quickly derive subsets of your structs
-
place_macro
Macros you wish you had while you were writing your non-proc macro
-
reflected
Something like reflection
-
form
A small script to move inline modules into the proper directory structure
-
deno-proc-macro-rules
Deno fork of proc-macro-rules. Emulate macro-rules pattern matching in procedural macros
-
rand_derive2
Generate customizable random types with the rand crate
-
derive_deref
Adds
#[derive(Deref)]
and#[derive(DerefMut)]
-
dict_derive
Derive macros for some PyO3 traits to convert python dicts into rust structs
-
subenum
A proc-macro to create subsets of enums, that can be converted to and from
-
r18-trans-support
r18 translation support
-
parquetry-gen
Parquet code generator
-
opentalk-proc-macro-fields-helper
Helper function for working with fields in proc macros, used in OpenTalk crates
-
fortuples
Procedural macros to generalize inherent and trait implementations over tuples
-
derive-attr-parser
Very simple parser for proc macro attributes
-
membrane_types
A companion crate for
membrane
-
EnumBitFlags
EnumBitFlags is an implementation of flags support for enums
-
syn-file-expand
load full source code of multi-file crates
-
code-product
macro producing multiple expansions
-
clippy-tracing
add, remove and check for
tracing::instrument
in large projects where it is infeasible to manually add it to thousands of functions -
rust-assistant
Rust Assistant Library
-
proc-macro-assertions
Easily create asserts on proc macro inputs
-
cfg_eval
#[cfg_eval]
in stable Rust 🙃 -
symbols
Proc-macro utility to populate enums from database data
-
impl_new
A procedural macro to generate a new function impl block for you
-
biscuit-parser
Datalog parser used in the biscuit-auth and biscuit-quote crates
-
napi-derive-backend-ohos
Codegen backend for napi-harmony procedural macro
-
strum_macros
macros for working with enums and strings
-
debug-span
Visualize proc-macro2 spans for debugging and assertions
-
variantly
Derive helper methods for enum variants that are familiar from
std::option::Option
&std::result::Result
such asunwrap_or
orand_then
-
jni_fn
JNI-compatible method signature generator
-
fn-error-context
An attribute macro to add context to errors from a function
-
pg_named_args
PostgreSQL named arguments
-
futures-macro
The futures-rs procedural macro implementations
-
derive-syn-parse
Derive macro for
syn::parse::Parse
-
myn
Minimalist Rust syntax parsing for procedural macros
-
maybe-async-cfg
A procedure macro to unify sync and async implementations depending on the features of your crate
-
zoo-endpoint
Macro used by zoo consumers for registering handlers. This wraps dropshot’s
Endpoint
and adds some extra functionality for tracing. -
chandeliers-san
AST definition and static analysis procedures of Candle
-
modus_ponens
develop forward chaining inference engines
-
flamer
a procedural macro to insert
flame::start_guard(_)
calls -
spread_macros
Macros around an extended spread syntax
-
jsonrpc-derive
High level, typed wrapper for
jsonrpc-core
-
proclet
Proc macros made easy
-
property
Generate several common methods for structs automatically
-
gensym
Creates unique identifiers for macros using procedural macros
-
serde_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
find-crate
Find the crate name from the current Cargo.toml
-
fv-template
Field-value based string templating
-
schema
Access the schema for a Rust item
-
dmacro
define C-like debug trace macro: enter!() and leave!()
-
custom_attrs
that allows you to configure values specific to each variants of an enum
-
macro_types
easier to create procedural macros
-
windows-implement
The implement macro for the windows crate
-
frunk_derives
contains the custom derivations for certain traits in Frunk
-
rkyv-with
Third-party derive macro for rkyv's *With traits
-
fn-decorator
contains macros for implementing wrapper functions around member or static functions
-
destructure
Automation of Destructure Pattern
-
crud-api-endpoint
CLI generator for your API. Enpoint description
-
disjoint_impls
Support for a variety of mutually disjoint implementations
-
diesel_as_jsonb
Use your structs as Jsonb with diesel and PG
-
netsblox-extension-util
Allows for automatic generation of a NetsBlox extension that uses WASM
-
sunbeam-ir
Sunbeams intermediary types used to parse and generate CSS
-
from-attr
that makes it easy to parse attributes
-
apidoc-expand
Apidoc expand
-
tao-macros
Proc macros for tao
-
pest_tree
Convert output from pest parser into statically typed trees
-
nuidl
The nucom IDL compiler
-
quote-alias
A helper macro for easily reusing static token streams
-
getters2
Generate getters, mutable getters, setters, and copy accessors for structs and enums
-
vtable_gen
A C++-ABI VTable Generator for Rust
-
serde_nested_with
Use serde attributes on nested fields
-
fire
fire implementation for rust
-
serde_keyed_derive
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
serde_derive_default
Derive Default using serde field level annotations
-
frunk-enum-derive
Derive macros to implement the frunk::LabelledGeneric trait on enums
-
just-convert
Easy conversion of structures
-
static-graph
Generate static parallel computation graph from DSL at compile time
-
relm-gen-widget
relm-attributes and relm-derive
-
bevy_commandify
A macro for creating bevy commands
-
jl-sys
contains the generated bindings for the Julia C API used by jlrs
-
syn_derive
Derive macros for
syn::Parse
andquote::ToTokens
-
gandiva_rust_udf_build
A basic shared library for gandiva rust udf
-
amplify_syn
Amplifying syn capabilities: helper functions for creating proc macro libraries
-
aoc-auto
Automatically imports your solutions to Advent of Code challenges for easy running
-
machine-check-bitmask-switch
Bitmask switch crate for the formal verification tool machine-check
-
swc_visit_macros
Visitor generator for stable rustc
-
micro_games_macros
macros to make it easier to build complex systems with Bevy
-
yew-alt-html
Alternative macro for building Html in Yew
-
golem-rust
Golem Rust tooling library that facilitates writing Golem backends in Rust
-
enum-try-as-inner
A proc-macro for deriving inner field accessor functions on enums
-
yew-lmth
A macro crate for writing HTML-like syntax for Yew application, inspired by Sycamore and Dioxus
-
iconify
Proc-macros for generating icons from the Iconify API
-
packed_struct_codegen
implements the code generation for the packed_struct library
-
prometheus-static-metric
Static metric helper utilities for rust-prometheus
-
macroific_attr_parse
Attribute parsing utilities for the macroific crate
-
temp
A procedural macro to manage temporary variables
-
validated_struct
Easily generate nested structures with getters and predicated setters
-
opt_args
Create macros for functions and structs with default values
-
enutil
General Enum Utility Macros
-
const-addrs
A set of macros for creating networking types from a string literal
-
str-match
Format pattern like str match macro
-
cvec
a const-generics / adt-const-param compatible Vec alternative
-
proc-macro-utils
low-level utilities on proc-macro and proc-macro2 types
-
derive_more_preview
Adds #[derive(x)] macros for more traits
-
atri_plugin
AtriPlugin
-
racc
port of Berkeley YACC to Rust, and allows you to write grammar definitions directly in Rust source code
-
crdts_derive
CRDTs proc_macro
-
callback-trait
Implement trait for Fn so that functions that accept traits as parameters can directly receive Fn parameters
-
savvy-bindgen
Parse Rust functions, and generate C and R code
-
replace_ident_in_expr
Replaces target ident with given ident in an expr
-
include_file_path
Macro to returns absolute path of a specified file
-
ra_ap_proc_macro_srv
TBD
-
bintex
Create bitfield LaTeX diagrams with the use of the deku library
-
elm-parser
Elm markup parser to leptos
-
safe-quote
A fork of
quote
crate that addsforbid(unsafe_code)
and depends onsafe-proc-macro2
instead ofproc-macro2
-
opendp_tooling
Tooling for proc-macros and code generation
-
chandeliers-syn
Syntax of the Lustre language, to be parsed by procedural macros
-
caravel_export_poc
Caravel Module Wrapper
-
sourcegen-cli
In-place Rust source generator CLI utility
-
set_builder
A procedural macro to create Iterators over a set defined by Haskell-inspired set-builder notation
-
sw4rm-rs-generation
handle generation of rust models & apis from OpenAPI v2, v3, and v3.1 specs
-
swc_eq_ignore_macros
Macros for EqIgnoreSpan and TypeEq
-
dojo-macros
ORM for Rust
-
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.
-
napi_sym
proc macro for writing N-API symbols
-
struct_morph
macro for morphing one struct into another
-
constructivist
Simplify the construction of structured data
-
anony
Anonymous struct
-
curried
currying function to be used in normal && generic && map case, with procedural macro
-
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.
-
enalang_macro
Exhaustingly Notorious Algorithms - macro support
-
clap_main
provide a #[clap_main] macro to automatically parse and pass args to your main function
-
windows-interface
The interface macro for the windows crate
-
err-derive
Derive macro for
std::error::Error
-
casey
Case transforming macros for ident tokens
-
basicmethod
Add constructor, get and set method using derive macro
-
stageleft_tool
Helper macros for the stageleft crate
-
try-from-map
A derive macro for converting a HashMap<String, String> into a struct
-
u-num-it
typenum macro for matching types from a given range
-
derive-deftly
An ergonomic way to write derive() macros
-
proc-macro-faithful-display
A Display implementation for proc-macro types more faithful to the input stream
-
ext_format
A small, yet powerful, Rust crate for string interpolation
-
ambient_package_macro_common
Common implementation of a proc-macro that generates boilerplate from an
ambient.toml
-
derive-into-owned
Custom derives to help with types containing Cow fields
-
include-bytes-plus
Improved include_bytes! allowing to reinterpret input differently
-
krpc-macro
RPC framework for service registration and discovery through API exposure, compatible with Dubbo3 protocol, intertunable with Java projects
-
guard_macros
Convenient Rust guard macros
-
rubber_duck
Enables building functions that can be called with named arg syntax
-
syn-rsx
syn-powered parser for JSX-like TokenStreams
-
sea-bae
proc-macro attribute parser
-
ifmt
Inline expression interpolation for Rust
-
new-derive
New
derive macro -
ambient_project_macro_common
Common implementation of a proc-macro that generates boilerplate from an
ambient.toml
-
validator_struct
ergonomic addition to the validator crate
-
pest-ast
Derive to convert from pest parse tree to typed syntax tree
-
mono-macro
Force monomorphizing on functions with
share-generics
to minimalize binary size -
env-extract
Extracts environment variables into Strings or Enums
-
local-impl
A proc macro for creating extension traits
-
convert_by_name
Derive From and Into for structs and enums based on field and variant names
-
locenv
aid on module development for locenv
-
python-mod
A macro library for including a Python module in Rust. At this point, very imcomplete.
-
lcrt
help writing leetcode solutions in rust
-
surrealdb_functions
procmacro for surrealdb functions (fn::*)
-
enum-kinds
Generate enums with matching variants but without any of the associated data
-
auto-rust
automatically generate Rust code using LLMs at compilation time
-
prql-compiler-macros
Macros for PRQL compilation at build time
-
axum_error_macro
derive macro for your custom Error enum to generate quickly its status code and message
-
lombok
port for Rust
-
noop_proc_macro
No-op proc_macro, literally does nothing
-
winit-main
Abstract away winit's event-loop inversion of control
-
enumorph
Derive macro to generate
TryFrom
andFrom
implementations for converting between newtype enum variants and their wrapped values -
test-group
Organize tests into groups with macros for filtering in nextest
-
decolor
Asynchronous runtime abstractions for implicit function decoloring
-
enum_const_value
Providing const values for enums. Unit and enums with associated types are supported. Each variant gets a unique sequential value.
-
xladd-derive
macro that helps write Excel UDF functions in Rust
-
tauri-types
Type generating macros for Tauri apps
-
onlytypes
creating types that can only be created by a certain function
-
unsafe_target_feature
A more convenient #[target_feature] replacement
-
macroex-extras
Additional "fun" extractors for macroex. Support crate for a certain in development UI crate.
-
unit-enum
A procedural macro for deriving ordinal methods in unit-like enums for Rust
-
functional_trait
A macro that impls trait for Fns
-
macro_railroad_annotation
Easily embed macro_railroad images in your docs using this attribute macro!
-
typed-fields
A collection of macros that generate newtypes
-
qroc
Perl for procedural macros
-
import-modules
based on require-all
-
functional_macro
A functional macro for Rust
-
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.
-
no-panic
Attribute macro to require that the compiler prove a function can't ever panic
-
time_this
two macros to quickly time functions for debugging purposes
-
pipewire-wrapper-macro-impl
Attribute and prop macroses implementations for pipewire-wrapper crate
-
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
-
build-deps
Rust build-script dependencies generator for data/IDL files
-
enum-display-derive
Display trait's custom derive for simple enums
-
cpy-binder
when creating binds from Rust to C++ and Python
-
unzip-n
Procedural macro to generate
unzip
for iterators over n-sized tuples -
http-error-derive
Create an enum with error message and http code
-
envtime
Runtime and compile time environment resolution for Rust
-
chandeliers-lus
Procedural macros for the Chandeliers project, implementing a deep embedding of Lustre in Rust
-
tylift
Lift enum variants to the type-level
-
rcss-bundler
Part of Rust CSS embedding library that allows using collect and save all styles in a file
-
debug_code
The util to remove code when not debug build
-
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
-
bflib
a BrainFuck-to-Rust transpiler using Rust proc macro
-
qsync
Generate react-query hooks for your rust backend (see https://github.com/Wulf/create-rust-app)
-
polkavm-derive-impl
The derive crate for PolkaVM guest programs (implementation)
-
typemarker
Procedural macro for easily creating multiple linked marker types
-
cbit
A proc-macro to use callback-based iterators with
for
-loop syntax and functionality -
mutablex
A horrid macro for making mutables of X size
-
around
execute code around a function
-
jaffi
Support for the jaffi code generator
-
small_ctor
A minimal, dependency free version of the ctor crate
-
builder-rs
A procedural macro for generating builder patterns for Rust structs
-
bang_notation
!-notation for Rust
-
derive_builder_core
Internal helper library for the derive_builder crate
-
builder_m4cro
derive macro to implement the builder pattern
-
fn_overloads
Create functions with varying arguments and return types. Please don't use this.
-
json_typegen_shared
Codegen from JSON samples. Not intended to be used directly. See repository for the intended crates.
-
default2
Default implementation using macros
-
easyfix-messages-gen
Easy FIX (Financial Information Exchange) toolset - messages generator
-
watt-non-static-runtime
Runtime for executing Rust procedural macros compiled as WebAssembly
-
tiaojian-macro
conditional compile proc-macro
-
namedarg
main package
-
enum_all_variants
Generate a list of all enum variants in Rust
-
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…
-
merge-cfg
Merge or cover config based on priorities
-
aidecomment
that can get the OpenAPI operation summary and description from doc comments and provide them to aide
-
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.
-
simple_function_logger
function logger
-
gettext-macros
A few proc-macros to help internationalizing Rust applications
-
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…
-
antlion
Handy way to evaluate at compile-time any Rust expression
-
procout
Output a proc macro's TokenStream to a file
-
roadblk-expand
Validator proc-macro expand impl
-
pyo3-opentelemetry
Macro and utilities for passing OpenTelemetry context from Python to Rust
-
command-rpc
rpc service which is not ready yet but needs to be published because of testing purposes
-
derive-try-from-primitive
Custom derive a try_from method for primitive to enum conversions
-
getters0
Rust Getters Derive Macro: Effortlessly auto-generate customizable getter methods for Rust structs
-
autophagy
AOT compiler for Rust
-
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
-
delegate-trait-impl
Delegate trait implementations
-
execute_evcxr
execution of evcxr-supported syntax via building and executing a binary crate
-
nano_parser_gen_macro
A parser generator inspired by yacc (procedural macro)
-
templest
A procedural macro to manage temporary variables
-
c-like-concat
macro that works just like C's ##
-
bevy_ergo_plugin
Macros to make building bevy plugins more ergonomic
-
multihash-derive
Proc macro for deriving custom multihash tables
-
hydroflow_plus
Functional programming API for hydroflow
-
xml2gpui_macros
Helper macros to convert XML attributes to GPUI attributes
-
erased-generic-trait
Macros for generating trait objects from traits with generic methods
-
all-the-same
A procedural macro that copy-pastes match arms for new type variant enums
-
napi-derive
N-API procedural macros
-
to_query
Structure to HTTP GET Query Parameters
-
testtesttest2
test
-
katexit
Insert KaTeX autorender script into rustdoc
-
aors
Useful rs tools for Advent of Code
-
napi-derive-ohos
N-API procedural macros
-
k3-wasm-macros
Macros to be used in Rust K3 apps
-
notation_dsl
Fun notation - DSL to create notation files
-
better
rustcoed make better
-
lvgl-codegen
Code generation based on LVGL source code
-
memoeyes
Procedural macros for automatic memoization
-
macro-field-utils
work with darling fields
-
bae
proc-macro attribute parser
-
syn-file-expand-cli
CLI tool to read full source code of multi-file crates and output it to stdout
-
zbus-lockstep-macros
Macros to keep types in lockstep with DBus XML definitions
-
syn-impersonated
Parser for Rust source code
-
serde-clap-deserialize
Proc macro for setting serde/clap defaults
-
edict-proc-lib
Procedural macros library for edict
-
bitlight-core-derive
providing derive macros for the Bitlight core
-
utoipa_auto_discovery
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
better-debug
A cooler, and sane Debug macro
-
double-dyn
Macro for implementing functions with multiple dynamic argument dispatch
-
from-num
Attribute macro #[from_num(...)]
-
to_sql_condition
genreate sql condition proc macro
-
fully_pub
Macro that makes multiple items or fields public at once
-
envhead
build environment variable names using a static prefix. Works great with the popular clap crate.
-
sleigh2macro
Macro used to transpile Ghidra code into rust
-
enumify
macro that declares an
enum
(and a bunch ofimpl From
s) based on a set of types -
css-modules
CSS Modules with a macro for convenience
-
stability
Rust API stability attributes for the rest of us
-
functions_ai
Function to string implementation for LLMs
-
derive-box-dyn
Proc macro to convert struct to Box<dyn T>
-
code-product-lib
macro producing multiple expansions
-
include-wasm-rs
Builds a Rust WebAssembly module at compile time and returns the bytes
-
error-enum
Provide a easy way to define an enum that represents errors with error codes, document comments and several other functionalities
-
enum_helpers
Adds functions like is_, as_, as_mut_ and into_ to enums
-
intercom-common
See 'intercom'
-
openssl-macros
Internal macros used by the openssl crate
-
match_any_trait
match expressions for any trait
-
rspark-derive
Macros for rspark
-
cfg-vis
A macro to support
#[cfg()]
on visibility -
codegen-libc
A codegen tool for extracting libc cfg
-
razy-importer-macros
Proc macros for razy-importer
-
band_proc_macro
Support library for band
-
proptest-attr-macro
Procedural attribute macro for writing proptest tests
-
derive_util
tools for derive macros
-
macros-utils
macros crate
-
entropy-macro
Macros library for ENTROPY<rust>
-
v_eval
Expression evaluator with context
-
net-config
defines core macros for the configuration of all the binaries in the netstalker project. It is used to define the configuration of the binaries in the net project.
-
do-with-in-base
A template language for Rust metaprogramming using partial staging
-
semx_bst
对应硬件板级定义
-
dioxus-autofmt
Autofomatter for Dioxus RSX
-
awesome-glib
Bunch of macros to make a life of gtk/glib user easier
-
fort
Proc macro attributes for Bastion runtime
-
gll
GLL parsing framework
-
getter-methods
Derive macro to create getter / accessor methods
-
zerocopy-derive
Custom derive for traits from the zerocopy crate
-
inherit
derive macro
-
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.
-
const_env_impl--value
Configure const and static items by environment variables
-
autoget
macro to generate getters for structs
-
rs-derive
A procedural macro library containing useful derive macros
-
lex_derive
Some derive macros for creating a lexer
-
mwt
proc macros for generating mut and non-mut methods without duplicating code
-
cmd-proc-macro
Run some shell script when build the project, and yield the stdout as &[u8]
-
regexp2rust_macro
regexp(ecma262) to rust code macro
-
getset-macro
A procedural macro that simplifies the creation of getter, setter and constructor methods for fields in your Rust structs
-
ntree-macros
Complementary proc macros for ntree-rs
-
message_macro_derive
A macro to generate/parse binary representation of messages
-
rust_minify
minify rust code
-
transitive
derive macros for Rust
-
enum_access
Custom derive for automatically generating the accessor methods for Enums
-
nitka-proc
Procedural macros for NITKA - Near Integration Test Kit and Automation
-
unroll
An attribute-like procedural macro for unrolling for loops
-
shuttle-codegen
Proc-macro code generator for the shuttle.rs service
-
mockers_macros
Compiler plugin for 'mockers' mocking library
-
net-literals
Literals for IP/socket addresses
-
compiler_cli_args
proc-macro that expands to the CLI args that were passed to rustc
-
derive_dumb
Derive
Dumb
generates a structure in which all fields are public. Original structure can be converted using function calldumb
. -
usdt-impl
Main implementation crate for the USDT package
-
const_gen_proc_macro
Create proc macro that adds compile time functionality for the creation of constants
-
box-self
Easy way to duplicate a new function with self: Box<Self> signature
-
farmfe_macro_plugin
macro for farm plugins
-
enso-macro-utils
writing macros
-
auto-trait
macro to generate trait implementation for wrapper types
-
viewy-codegen
Procedural macros for Viewy web ui library
-
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.
-
impl_index
Macro for deriving the Index trait
-
tlayuda
A derive procedural macro for structs that adds a static method that generates instances of the struct with minimal configuration
-
wvwasi-macro
Macros for the wvwasi crate
-
auto_builder_derive
Macros for generating a 'safe' builder
-
structified_enum
Marcos to structify unit-like enum with discriminants
-
bevy_derive
derive implementations for Bevy Engine
-
grass-macro
Procedual Macros for GRASS
-
cdefines
A proc macro that translates c #define constants to rust consts
-
redis-macros-derive-bincode
Derive macros to serialize/deserialize structures with bincode to store in redis
-
truc
Stuff
-
behavior
A macro checks like behavior in elixir
-
bevycheck
bevy error messages by proc-macro
-
jsonrpsee-proc-macros
Procedueral macros for jsonrpsee
-
catalytic_macro
Macros for the ORM for Scylla, fully compatible with Apache Cassandra™
-
structs-from-excel
that adds a procedural macro that unravels structs via a given, purpose-formatted Excel spreadsheet
-
pzmacro
general macro; demo: https://github.com/FaceWaller/pzmacro
-
lazy-regex-proc_macros
proc macros for the lazy_regex crate
-
clap_derive
Parse command line argument by defining a struct, derive crate
-
version_macro
rust cargo build binary with git version and build time
-
s_test_fixture
or simple test fixture is a macro library to implement test fixture with no hassle
-
current_semver
Get the current semver type from the environment
-
tantivy-macro
derive tantivy schema api
-
invoke_impl
Proc macro to generate functions that can invoke all identical functions or methods inside impl blocks
-
dustr
Generate dart code based on a rust ffishim
-
relm-derive-common
Common derive implementation internally used by relm crates
-
enum2map
A small macro to convert enums with associated data into a HashMap
-
structdump
Dump structure to source code
-
scroll_derive
A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate
-
from_form
TryFrom impl HashMap<String,String> -> Struct
-
literify
Stringifies tokens inside token stream
-
lower
desugar math where the compiler wont
-
uucore_procs
uutils ~ 'uucore' proc-macros
-
acme-macros
Acme is a complete development toolkit for extending platform functionality
-
openai-macros
macros for the openai-utils crate
-
quickerr
A macro to define errors quickly, like
thiserror
but terser and more opinionated -
macro-visit
Function like proc-macro visitor for build.rs
-
optbuilder
A optional builder derive macro for helping with big constructors with mostly optional parameters
-
wasm-bindgen-struct
Macro to make declaring
wasm-bindgen
imports much easier -
rvv-asm
Procedure macro to encode RISC-V V extension (rvv) instructions
-
dep-inj-target
Stateless target creator of dep-inj
-
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.
-
puff_bench_macro
Benchmark macros
-
mpst-seq
macro for mpstthree
-
vts
Macro to generate boiler plate to define new types with associated constraints
-
canadensis_macro
A procedural macro that generates Rust data types and serialization code from inline and/or external Cyphal DSDL files
-
doc_consts
get doc comments on fields as runtime constants
-
random_struct_layout
The custom attributes to randomize struct members layout
-
introspect-proc-macros
Procedural macros for
introspect
-
join_impl
join!
macro -
include-crypt-bytes
Rust macro to embed encrypted files in compiled binary
-
sourcegen
contains a procedural macro to work together with "sourcegen-cli" crate
-
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
-
aigen_macros
Procedural macros for testing
-
derive-docs
generating documentation from Rust derive macros
-
splat_derive
providing a Splat derive macro, which generates a splat method for the struct deriving it
-
include_uri
Proc-macro to include URI as literals at build time
-
default-args
zero-cost default arguments in rust
-
for-else
Python-esque for-else construct for Rust
-
redpen-shim
A proc-macro attribute provider that allows crates to annotate their code with redpen lints without breaking their build
-
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…
-
z3d
Z3 DSL interface for Rust
-
deriving_via
DerivingVia
-
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…
-
translator
A procedural macro which translates your repr-C structs into C++, Python and C# at compile time for helping write FFI libraries
-
bevy_derive_commands
A macro for creating bevy Commands methods
-
gtk-properties-macro
Experimental property declaration macro for gtk-rs
-
jsonschema_code_generator
generating rust types from JSON schemas
-
clown
approximation of capture-by-closure lambdas
-
classic-bitfield
A bitfield enum with a classic feel
-
quote2
An alternative lightweight version of quote
-
swc_trace_macro
Proc macro for performance trace of swc
-
renum
From and TryFrom trait derive with customization
-
fixed-size
Attribute macro to replace variable length types with fixed length types in struct definitions. Useful for overriding String when using prost.
-
async-trait-static
async fn in trait for no_std
-
convert-chain
chain converter
-
prost-derive
A Protocol Buffers implementation for the Rust Language
-
proclet-utils
proclet
-
cs453getters
Just an assignment
-
depends_core
Ergonomic, performant, incremental computation between arbitrary types
-
leptos_macro
view macro for the Leptos web framework
-
usdpl-build
Universal Steam Deck Plugin Library core
-
derive-extras
Adds a number of useful extra
#[derive(...)]
macros -
double_dot_macro_types
Misc types and functions required for the double_dot_macro ecosystem
-
sqlx-macros
Macros for SQLx, the rust SQL toolkit. Not intended to be used directly.
-
postfix-macros
Postfix macros on stable Rust, today
-
iter_all_proc
Iterate all enum vases
-
foxglove_derive
A derive macro for a Foxglove trait
-
include-repo
implements the 'include_repo!' macro for easy AGPL compliance! Include a tarball as a const in your code!
-
derive_hub
A proc-macro for a simple actor framework
-
core_extensions_proc_macros
detail of the
core_extensions
crate -
uniffi_checksum_derive
a multi-language bindings generator for rust (checksum custom derive)
-
indirect-once
One-time resolvable runtime indirection in the style of glibc's ifunc
-
opimps
attribute macros to assist with overloading operators for borrowed and owned data
-
tco
A macro for transforming a tail-calling recursive function to eliminate recursion
-
rogger
Logging macros for Rinrin.rs
-
fill-array
macro allowing to fill arrays with an expression
-
actix-handler-macro
Helper macros for using Actix. Generates handlers, actors and address traits.
-
to_table
for DomCom, add sort by field to struct
-
function-frame
Procedural macro to wrap any function outputs within a text frame
-
bool_to_bitflags
compact multiple bools into a single bitflags field automatically with getters and setters
-
default-with
Fill a struct that cannot implement Default with the remaining fields initialized with Default::default
-
jsm
Jay's stupid macros
-
proxygen-macros
proc-macros for proxygen
-
enum-utils
A set of useful proc macros for enums
-
win_etw_macros
Enables apps to report events to Event Tracing for Windows (ETW)
-
variants-struct
A derive macro to convert enums into a struct where the variants are members
-
glib-macros
Rust bindings for the GLib library, proc macros crate
-
elfo-macros-impl
Macros for matching and deriving messages, implementation internals
-
match_type
Match on the type of an expression at compile time
-
r2r_msg_gen
Internal dependency to the r2r crate
-
thirtyfour-querier-derive
#[derive(Querier)] macro for thirtyfour WebDriver library
-
wasm-bindgen-macro
Definition of the
#[wasm_bindgen]
attribute, an internal dependency -
stidgen
Strongly Typed ID types macro
-
o2o-impl
'o2o' crate
-
errgo
generate enum variants inline
-
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…
-
wurst
Webby UI Rust abstraction
-
diesel_sqltype_enum_pg
Diesel automatic derivation of
FromSql
andToSql
for enums withSqlType
generated bydiesel
and takingToString
andFromStr
as base. Postgres binding only -
ucc
Universal compiler invocator for heterogeneous CPU/GPU computation applications
-
panic_discard
A proc-macro that discards panics that happen within a function
-
domcom-form-manager
A macro to simplify forms. Must be used with domcom
-
extension-fn
No boilerplate code for extension function definitions
-
markup-proc-macro
A blazing fast, type-safe template engine for Rust
-
tarantool-proc
Tarantool proc macros
-
devise_core
devising derives and other procedural macros
-
cargo-acl
code ACL checker
-
wedpr_l_macros
WeDPR shared macros
-
cargo-toml-macros
Convinient macros for pulling fields from your Cargo.toml. Prettier than std::env
-
toml-cfg
A procedural macro for configuring constant values across crates
-
preserves-schema-macros
Preserves Schema code generation macros for Rust
-
i18n-format
proc-macro to allow gettext! and xgettext to work together
-
swc_ecma_transforms_macros
Macros for swc_ecma_transforms
-
neon-frame-macro
Macros to simplify writing Neon apps
-
json_schema_test_suite
Procedural Macro Attribute to run all the test cases described in JSON-Schema-Test-Suite
-
q-num
proc_macro to define fixed-point numbers in Rust using Q notation
-
concat-arrays
A macro for concatenating fixed-size arrays
-
nginx_derive
Helper crate for nginx-rust
-
saturating_arithmetic
Proc macro #[saturateit] to rewrite operators into their saturating equivalents
-
turbo-crates
A set of useful crates (WIP)
-
cmd-macro
makes std::process::Command simple to use
-
trace2
A proc macro for tracing the execution of functions, similar to trace crate, but thread safe and use log
-
i-build
bui
-
esp-hal-procmacros
Procedural macros for esp-hal
-
axum_thiserror
procedural macro for custom error handling in web applications, enabling the association of specific HTTP status codes with error types
-
defmt-macros
defmt macros
-
rash_derive
rash derive crate
-
structbuilder_derive
Super simple macro to derive a builder trait for your struct
-
syn-graphs
graph description language parsers using syn
-
dynamodb-helper
Macro that creates a struct for interacting with AWS DynamoDB
-
yui
An attribute reader generator for Rust
-
synsert
A primitive for writing structural search and replace programs for rust
-
primwrap
Derive operation traits for primitive wrapper structs
-
macro-compose
trying to simplify and organize proc-macros
-
static_table_derive
Procedural macros for investments crate
-
miniserde-enum
Derive macros for miniserde on enums
-
mddd-std
small framework for DDD init sysmem and CLI interface. Sub crate with std tools. Use "mddd" crate
-
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…
-
file_env_const
macros for loading data from files or environment variables at compile time
-
gix-macros
Proc-macro utilities for gix
-
machine_uuid
retrieve a machines UUID
-
script-macro
Write proc-macros inline with other source code
-
compilation-guard
Force compilation to fail when certain condition is met
-
html-to-string-macro
html to string macro powered by syn-rsx
-
sdi
Rust statically resolved dependency injection lib
-
constime
Zig's comptime for Rust with zero dependencies. Mostly something to play around with until more stuff is const fn.
-
wick-component-codegen
Code generator for wick components
-
async-trait-with-sync
async-trait
withSync
patch -
fsm-macro
A statically checked finite state machine written in rust
-
cypher_derive
A flexible and intuitive query builder for Neo4j and Cypher
-
sqlxx
Extension to sqlx
-
nj-derive
procedure macro for node-bindgen
-
chatdbg_macros
Rust-specific (macro) support for ChatDBG (https://github.com/plasma-umass/chatdbg)
-
struct-arithmetic
Trait to derive basic arithmetic operations for your structs
-
named-ctor
proc-macro to generate constructor functions with syntaxt similar to named params
-
inherent-pub
Mark methods in
impl Trait for Type
blocks inherent to the type -
sunbeam-build
A dynamic CSS class library
-
fastsim-proc-macros
Procedural macros for FASTSim
-
ai-write
Macro inserting ChatGPT responses into rust code at compile-time
-
derive-from-one
Automatically generates
From
impls so you don’t have to -
proc-macro3
defines a macro that imports either from
proc_macro
orproc-macro2
depending on theproc-macro2
feature flag -
fail_on_ci
Script to abort compilation if one of the known CI-Servers is detected
-
owo-code
OwO Code owo! pwogwam owo in ur nyative wanguage owo!
-
wayrs-scanner
Generates code for wayrs-client from xml files
-
color-hex
Procedural macro for converting hexadecimal strings to an RGB or RGBA byte array at compile time
-
gandiva_rust_udf_shared
A basic shared library for gandiva rust udf
-
unsafe_fn
macro to mark a function as unsafe without its body being unsafe
-
macro_state
A set of macros allowing storing and loading global state at compile-time within proc macros
-
server-function
A macro for easy RPC creation
-
structout
A proc-macro for generating structs from a common definition
-
css-macros
MAcros to work with css files with stylist
-
yaserde_derive
Serialization and deserialization macros
-
inertia-macros
attribute macros to assist with overloading operators for borrowed and owned data
-
sql_tool_macros
这个库用于存储宏
-
nom-rule
A procedural macro for defining nom combinators in simple DSL
-
command_attr
Procedural macros for command creation for the Serenity library
-
tt-equal
The macro
tt_equal
acts as a predicate for whether two token trees are equal -
spacetimedb-bindings-macro
Easy support for interacting between SpacetimeDB and Rust
-
custom_debug_derive
Derive Debug with a custom format per field
-
syn_builder
Builder functions for
syn
structures and enums to ease the generation of Rust code -
croc-look
expand macros and watch them in real time
-
fuels-macros
Fuel Rust SDK marcros to generate types from ABI
-
get_files_macro
macro that can resolve a directory's file names before compile-time
-
utf16_literal
u16! macro that emits a UTF-16 string literal
-
accio
Retrieves code blocks distributed to multiple sites
-
boa_macros
Macros for the Boa JavaScript engine
-
diesel_derives_extra
Automatically derive some simple CRUD methods for your Diesel models
-
rcstruct
Generate transparent
Struct(Rc<RefCell<Struct>>)
newtypes -
mrml-common-macros
Common macros for the MRML crate
-
aggregate_types
Aggregate attributes of structs for runtime
-
colonbuilder
builder offers from_str method to build struct from colon separate string
-
rust-i18n-macro
Macro for rust-i18n crate
-
rustler_codegen
Compiler plugin for Rustler
-
on_your_marks
Getters and Setters for Rust
-
pax-macro
Macros for Pax, used both for parser codegen and for showing Pax where to attach to Rust code
-
from-to-repr
Derives TryFrom and From implementations for the representation type of a Rust enumeration
-
sp-crypto-hashing-proc-macro
Procedural macros for calculating static hashes
-
mass-cfg-attr
A way to mass toggle cfg-attr on attributes
-
derive-discriminant
A derive macro for enum discriminants
-
mattro
A macro attribute parser
-
wrapcenum-derive
Derive macro for nvml-wrapper, not for general use
-
bincode_macro
Add macros to bincode to make it easier to use
-
ai_function
Procedural Macro for creating text from a function to use in Large language Models
-
clap_usage
Generates usage config for clap CLIs
-
cloneable_dyn
Macros to make structs and enums clonable that use dyn Objects
-
derive-ocaml
Custom derive and procedural macros for easy FFI with ocaml on top of the ocaml crate
-
cameleon-impl-macros
used by other cameleon crates implementation
-
inttype-enum
Converts an [
enum
] into an [inttype
], and try to convert it back -
extendr-macros
Generate bindings from R to Rust
-
beancounter
proc macro for visualizing struct memory usage
-
typewit_proc_macros
detail of typewit
-
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
-
env-smart
Proc macro to insert env vars into code
-
apidoc-proc
Apidoc proc
-
crux_macros
Macros for use with crux_core
-
derive-error
Derive macro for Error using macros 1.1
-
rio-proc-macros
Rio proc macros
-
rattler_macros
that provideds some procedural macros for the rattler project
-
neo4rs-macros
Macros used by neo4rs
-
openwhisk_macro
Derive Macro for OpenWhisk Rust Client
-
tari_comms_rpc_macros
RPC service proc macro
-
justerror
Extension to
thiserror
that helps reduce the amount of handwriting -
cssparser-macros
Procedural macros for cssparser
-
pgrx-macros
Proc Macros for 'pgrx'
-
celery-codegen
Macros for rusty-celery
-
intuicio-derive
Procedural macro module for Intuicio scripting platform
-
esp32_test_macro
macro that adds to test result message to end of the test functions
-
pen-ffi-macro
FFI macro library for Pen programming language
-
dioxus-check
Checks Dioxus RSX files for issues
-
kalosm-learning-macro
A macro to derive kalosm learning traits
-
ni-fpga-macros
Macros to be used with the ni-fpga crate
-
match-by-hash
Match statement, but for any value and with a hash function
-
jintemplify_plugin_macro
jintemplify plugin proc-macro
-
arg_enum_proc_macro
A procedural macro compatible with clap arg_enum
-
agb_macros
Macro for declaring the entry point for a game using the agb library
-
cocoa-purity
macro collection
-
tokio-actor
Macro based Asynchronous Actor System
-
specit
Spec "it" for Rust testing
-
traitify
A macro to turn an impl block into a trait
-
a2lmacros
macros in support of the a2lfile crate
-
tracers-macros
Macros which generate tracers and the code that fires the tracers. See the 'tracers' crate for further instructions
-
adv_linalg
A small type system and an attribute macro automatically optimizing behind-the-scenes for working in linear algebra
-
trace
A procedural macro for tracing the execution of functions
-
pretty_derive
A procedural macro for pretty
-
worker-macros
Macros to support the
worker
crate and remove FFI boilerplate / conversion from user code -
document_validator_core
Required dependencies for document_validator and document_validator_macros
-
serde_dhall_typegen
Automatically generate Rust structs and enums from Dhall types
-
autoload
macro,single scan load ioc aop
-
crokey-proc_macros
proc macros for the crokey crate
-
disintegrate-macros
Disintegrate macros. Not for direct use. Refer to the
disintegrate
crate for details. -
rust-oop
use macro to implement inheritance
-
elapsed-printer
Very simple macro for printing time elapsed to execute a function
-
pacaptr-macros
several macros used in pacaptr
-
units-relation
A procedural macro to be used with the library Rs-Measures to define relations among units of measurement
-
jj-lib-proc-macros
Proc macros for the jj-lib crate
-
js-macros
Quickly prototype procedural macros using JavaScript or TypeScript!
-
enum_stream_codegen
A parser generator. This package handles code generation for the
enum_stream
macro.” -
proc-macro-type-name
Convert Rust field names (snake case) to type names (pascal case) using proc_macro2 identifiers
-
trigraph
macro for your rust code
-
mutself
Create self-modifying executables
-
sunset-sshwire-derive
Derive macros for Sunset SSH packet encoder/decoder
-
steel-derive
Derive macros for use within steel
-
brain_fuck
BrainFuck compiler in Rust procedural macro metaprogramming
-
typeshare-core
The code generator used by Typeshare's command line tool
-
sully_peg
Proc macro for PEG generation
-
actix-json-responder
A procedural macro to reduce json response boilerplate on actix projects
-
expansion
expant the native libs
-
pyo3-prost
protobuf structs in Python
-
leptos_i18n_macro
Macros for the leptos_i18n crate
-
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 -
bytes-lit
Create byte slices from literal integers
-
rust-typed
Get the types of a struct
-
polling-async-trait
A proc macro that creates async methods based on polling methods for your trait
-
lock_order
macro for helping produce a deterministic lock ordering to prevent deadlocks
-
tower-lsp-macros
Internal procedural macros for tower-lsp
-
ferrotype
An opinionated wrapper for insta.rs
-
netsim-embed-macros
supporting macros for the 'ipc' feature of netsim-embed
-
runtime-struct-field-names-as-array
procedural macro that generates an array of the field names of a named struct
-
deno_ops
Proc macro for writing Deno Ops
-
kittycad-execution-plan-macros
Macros for working with KittyCAD execution plans
-
easy_proc
Helper macros for making proc macros
-
derive-all
Derive macro that derives all macros possible
-
ai_functions
Procedural macro for creating text from a function for use in Large Language Models
-
af-macros
Macros for the indigo crate
-
fuel-indexer-macro-utils
Fuel Indexer Macro Utils
-
inter-struct-codegen
Proc macro codegen crate for merge-struct
-
humblegen
An experimental code-generator in the vain of protobuf, but a little more humble
-
prometheus-client-derive-encode
Auxiliary crate to derive Encode trait from prometheus-client
-
wit-bindgen-rust-macro
Procedural macro paired with the
wit-bindgen
crate -
cmd-impl
-
safe_attr
An attribute #[safe] to mark functions, allowing the ommission of unsafe
-
poise_macros
Internal macro implementation crate of poise
-
shumai-config-impl
A benchmark framework that empowers efficient and correct multi-thread benchmarks
-
sh-builtin-bash
Procedural macro and bindings for creating bash builtins
-
near-lake-context-derive
Derive macro for LakeContext
-
ts-macros
tree-sitter convenience macros
-
nject-macro
Zero cost dependency injection macros
-
logfn
attribute macro for inserting logging code into your function
-
lpu-macros
Macros used for lego-powered-up
-
magnus-macros
Derive and proc macros for magnus
-
spooky-season
👻 SPOOKY! 👻🎃👻
-
neon-macros
Procedural macros supporting Neon
-
tamasfe-macro-utils
Proc-macro utilities, intended for personal use
-
env_int
env_int!("env_name", (fallback value)) macro
-
derive-asset-container
Derive AssetManager trait
-
hecs-macros
Procedural macro definitions for hecs
-
elm_rusty
Auto generate Rust models to Elm models
-
type-id-derive-impl
-
colorize-proc-macro
Proc macro version of colorize from the colorize-macros package
-
metamorphose
Macros collection for converting Structure to Model, for a green-barrel project
-
wolfram-library-link-macros
Procedural macros used by wolfram-library-link
-
cfg_attrs
An alternative to #[cfg_attr(...)] that is easier to use with doc comments
-
tokenstream2-tmpl
Runtime TokenStream interpolation for Rust macros
-
viewit
Attribute and derive macros for creating accessors for struct
-
rem-repairer
Lifetime repairer for Rusty Extraction Maestro
-
proc-macro2-fallback
Only the non-libproc_macro-based codepath of the proc-macro2 crate
-
sad_macros
Macros for said crate
-
as_warp_reply
Macro to implement the warp reply trait on custom structs
-
prost-serde-derive
Derive macro for serializing/deserializing structs generated by Prost with Serde
-
workflow_macro
Derive Macro for Workflow-Aurras
-
libcnb-proc-macros
Procedural macros used within libcnb.rs
-
astree_macro
Easily build AST from Rust structures
-
pfetch-extractor
proc-macro to extract pfetch logos at compile time
-
bonfida-macros
Bonfida-utils macros
-
tl-proto-proc
A collection of traits for working with TL serialization/deserialization
-
typle
Generic tuple bounds and transformations
-
struct_layout
Customize your struct layout with this one weird trick
-
get_fields
procedural macro that generates an array of the field names of a named struct
-
cronback-dto-core
Data transfer object library for Cronback
-
nb-field-names
generate class methods of returning field names of structs
-
lvbitfile2rust
Generate Rust register maps (
struct
s) from lvbitx files - in the spirit of svd2rust -
scuttle-proc
Procedural macros for scuttle. This crate is not intended to be used outside of scuttle.
-
ferment-macro
Macros for boilerplate
-
ocaml-build
OCaml code generation
-
overloading
A POC crate that utilizes
Fn*
traits to implement partial overloading -
error-http
Procedural macro for associating error enums with HTTP codes
-
abomonation_derive_ng
A custom derive plugin for abomonation
-
byteme
Converts a struct into Vec<u8> and back. The conversion is Big Endian by default.
-
multi-eq
Macros for creating custom equality trait derives
-
altrios-proc-macros
ALTRIOS procedural macros
-
embed-rust
A macro that allows to embed a Rust executable
-
actix-web-codegen-const-routes
Routing and runtime macros for Actix Web with support for const routes
-
atmosphere-macros
Macro crate of atmosphere
-
hun-offsetof
C-like macros: offset_of and container_of
-
cain
Procedural macro to transform sequential branches into nested branches
-
narrative-macros
Procedural macros for the narrative crate
-
replisdk-experimental-proc
Procedural macros crate for replisdk-experimental
-
git_rev
Procedural macros for including git revision hashes in code
-
bounded-integer-macro
Proc macro for
bounded-integer
. Do not use directly. -
extism-convert-macros
Macros to remove boilerplate with Extism
-
bevy_utils_proc_macros
Bevy Utils Proc Macros
-
mmtk-macros
MMTk macros provides procedural macros used by mmtk-core
-
nut_self
Makes your code nut
-
extends-rs
rust extends impl a macro attr
-
partial-application-rs
A macro to transform functions into partially applicable structs
-
esso
Jest style tests in RUST
-
litcrypt2
Let's encrypt your string statically during compile time
-
catchr
A testing framework inspired by Catch for C++
-
thiserror-impl-no-std
detail of the
thiserror
crate -
fantasy-cpu-emulator
Fantasy CPU Emulator
-
derive-elves
Writing inclusive derive macros is tedious, this creates provides helper functions that make it easier
-
native-windows-derive
A very light and simple rust GUI library
-
prove
struct
-
remoc_macro
Procedural macros for Remoc
-
xlsx_group_write_macro_derive
excel-group-write 辅助派生宏
-
macro-ob
a macro to inline rot13 to confuse IDEs
-
stateful_macro_rules
Generate macro_rules macros that have states
-
sqlxmq_macros
Procedural macros for sqlxmq
-
more-di-macros
Macro implementation of #[injectable(Trait)]
-
ff_derive_ce
Procedural macro library used to build custom prime field implementations
-
lexopt_derive
Derive macros for lexopt
-
parsegen
A parser generator implemented as a proc macro
-
one_user
Constrain the number of instances that can possibly be used at a time. By default it constrains it to one instance at a time, hence one_user.
-
leon-macros
Proc macros for crate leon
-
sub-model
a proc marco for easy generate sub models
-
xq-derive
Used to write eDSL proc-macro
-
enum-methods
Generates methods for each enum variant
-
include_optional
Option-returning versions of include_X macros
-
modelfox_macro
ModelFox makes it easy for programmers to train, deploy, and monitor machine learning models
-
table-enum-core
You are probably looking for the table-enum crate, which wraps this crate and is much more ergonomic to use
-
form-yew
a macro to help with forms in yew
-
sqlparser_derive
proc macro for sqlparser
-
config-gen-macro-impl
A helper crate containing the macro implementation for config-generator
-
tensorflow-internal-macros
The package provides macros for internal usage in TensorFlow. No backwards compatibility guarantees are made.
-
dunge_macros
Procmacro for the dunge library
-
serde_flat_path
A macro for expanding long structure chains within serde
-
closure_attr_core
Internal library for the closure_attr crate
-
telexide_proc_macros
macros for subscribing to events in telexide
-
cxx-auto
Automatically generate cxx bindings
-
klvm-derive
Derive macros for implementing KLVM traits
-
err-as-you-go
easy inline error types
-
unreal_asset_proc_macro
Proc macro implementations for unreal_asset
-
crepe
Datalog in Rust as a procedural macro
-
auto-delegate-macros
Auto delegate allows you that automatic impl of traits and delegate their handling to child members
-
taos-macros
TDengine connector internal macros
-
azalea-block-macros
Proc macros used by azalea-block
-
reduct-macros
Macros crate for ReductStore
-
xls_table_derive
Procedural macros for investments crate
-
c2rs
C struct to Rust struct
-
syn-path
macro to declare a syn::Path at compile time
-
jetstream_p9_wire_format_derive
Supporting proc-macro for the
p9
crate -
paperclip-macros
Macros for paperclip OpenAPI tooling library
-
gcp_client
Experimantal GCP client
-
airgl
down into the white wind flow’rs
-
rings-derive
Helper macros for rings node implementation
-
butane_codegen
Macros for Butane. Do not use this crate directly -- use the butane crate.
-
go-pmacro
some proc-macros for the goscript project
-
macroscope
makes writing proc macros a breeze
-
ascent_macro
ascent macros
-
extendable-enums
A set of rust macros that allows you to specify data that can be "extended" or inherited from
-
fievar
Proc macrs to generate functions that return static slices of struct field names or enum variant names
-
traitlit
exposes an atribute for implementing traits for integer and float types
-
comat
a better coloring crate
-
srsql
cuckoo
-
syrette_macros
Macros for Syrette, the convenient dependency injection framework
-
ai-agent-macro
ai-agents macro
-
neovide-derive
Derive macros for the Neovide gui
-
verilog-arc
proc macro based code generation backend for OpenVAF
-
proc-bitfield-macros
The supporting proc-macro library for the proc-bitfield crate
-
versionize_derive
Implements the Versionize derive proc macro
-
wasmbus-macros
derive macros for wasmbus-rpc
-
rerust
Reactive programming with dataflow semantics
-
bingen
Procedure macro for bringing a compile-time compiled assembly code as a binary slice
-
foundationdb-macros
Macro definitions used to maintain the FoundationDB's crate
-
autd3-traits
Wav Modulation for AUTD
-
smartdeploy-macros
Smartdeploy macros
-
native_api_1c_core
Core library for Native API 1C
-
pinned-init-macro
Proc macros for the pinned-init crate
-
drias
spans and diagnostics
-
leafwing_input_manager_macros
Macros for the
leafwing-input-manager
crate -
actix_responder_macro
An attribute macro to transform a response struct to an actix responder
-
conjure-macros
Macros exposed by conjure-http. Do not consume directly.
-
gpt_fn_macros
Macros for the ChatGPT-rs crate
-
notan_macro
set of utils as macros for Notan
-
mser_macro
-
polyhorn-ui
Shared API contract for multi-platform Polyhorn UI
-
schematic_macros
Macros for the schematic crate
-
multiversion-macros
multiversion
-
bevy_atmosphere_macros
Proc macros for bevy_atmosphere
-
burrtype_internal
Reflection types for
burrtype
andburrtype_derive
-
derive-env-url
Derives for env-url
-
foundations-macros
Procedural macros used by foundations
-
xtask-wasm-run-example
run-example
feature of xtask-wasm -
casco
CSS-like parser for procedural macros
-
actix-web-codegen
Routing and runtime macros for Actix Web
-
krnl-macros
Macros for krnl
-
ruwren-macros
Proc-macros for ruwren
-
rotate-enum
macro that implements prev() and next() methods to an enum
-
diesel_enum_derive
Enum derive for [Postgres only] Varchar fields
-
rust2fun_macros
Procedural macros for rust2fun
-
ambient_element_component
Helper procedural macro for the Ambient runtime that converts a function to an
ElementComponent
, allowing for more concise definitions of components -
tui-helper-proc-macro
Macros for widgetui
-
wasmedge-bindgen-macro
Pass string, vec and primitive types from host to webassembly
-
forward_goto
bringing gotos to Rust
-
ndk-macro
Helper macros for android ndk
-
hydroflow_datalog_core
Datalog implementation for Hydroflow
-
clone_from
Derive Clone including clone_from
-
templing
Minimal templating engine
-
pipewire-macros
macros for the pipewire crate
-
memory-serve-macros
Macro for memory-serve
-
teloxide-macros
The teloxide's procedural macros
-
pgmacro
pgbaits 用的宏 作用是自动给结构体生成对应的SQL语句。
-
idewave_packet
Macro for implementing packet structures
-
wasmedge-macro
The procedural macros for WasmEdge Rust bindings
-
ruzhda
Rust programming, in Bulgarian
-
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
-
exemplar_proc_macro
Proc macros for the exemplar crate
-
derive_less
A macro for templating item declarations
-
auto_impl_trait
auto impl trait by provide trait file
-
quickcheck_macros
A macro attribute for quickcheck
-
psl-codegen
Generate native Rust code from Mozilla's Public Suffix List
-
matrix-sdk-test-macros
Helper macros to write tests for the Matrix SDK
-
test-shisho-datasource
Shisho Cloud Policy SDK
-
sqlx-type-macro
Proc macros for sqlx-type
-
volo-build
Compile thrift and protobuf idls into rust code at compile-time
-
spirv-std-macros
Macros for spirv-std
-
color-print-proc-macro
package color-print
-
thruster-proc
The proc macros behind the thruster web framework
-
equalia
Automatically implement PartialEq for your structs
-
token_stream2
A better TokenStream for procedural macros
-
error_generator
Transform structs and enums into fully qualified errors using attributes
-
dmntk-macros
DMNTK | Procedural and derive 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.
-
asn1_codecs_derive
ASN.1 Codecs derive Macros
-
utoipauto-core
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
kexplain
Derive explanations for functions by 'showing the work' for things like math
-
yew-router-macro
Contains macros used with yew-router
-
invoke-witc
rust macros invokes witc
-
leftwm-macros
A window manager for Adventurers
-
hardlight-macros
A collection of procedural macros for the Hardlight RPC framework
-
ts-rs-macros
derive macro for ts-rs
-
cargo-rtic-scope
RTIC Scope backend
-
cali_derive
Contains the macro's used to simplify a Cali project's setup & testing
-
iffy
proc macro for simulating the ternary operator from C-like languages
-
vertigo-macro
Reactive Real-DOM library with SSR for Rust - macros
-
auto-builder-core
A derive macro to implement the builder pattern for any struct
-
luna-orm-macro
ORM based on sqlx
-
ruva-macro
Event Driven TEvent Handling
-
avocado-schema-derive
A derive macro to support runtime reflection of struct values
-
needs_env_var
Skip compilation if environment variable is missing
-
thallium_derive
The derive macros for the thallium crate
-
either_trait_macro
An attribute-like macro to implement traits for Either
-
flatty-macros
Flatty procedural macros
-
dsntk-macros
DSNTK | Procedural and derive macros
-
print_each_line
It prints each line and execution time during execution. You can utilize it as a super simple profiler.
-
equator-macro
Composable assertion library
-
natural-derive
Proc macros for naturally deriving basic trait impls for new types
-
frclib-structure-macros
A derive macro for implementing the FrcStruct trait on structs
-
as-method
Call function using the method syntax!
-
openapi-client-generator
Generates a client library based on an OpenAPI spec
-
uniffi_macros
a multi-language bindings generator for rust (convenience macros)
-
dummy
Macros implementation of #[derive(Dummy)]
-
c2rust-macros
Procedural macro support crate for C2Rust
-
micrortu_ie_representation_derive
SDK for MicroRTU
-
spin-macro
Rust procedural macros for Spin and associated WIT files
-
derive-deref-rs
derive macro library used to easily defined the Derive and DrerfMut trait of the core library
-
lofty_attr
Macros for Lofty
-
dbgprint
A set of macros that output the STDOUT and STDERR of the program only in debug mode
-
pagetop-macros
A collection of procedural macros that enhance the development experience within PageTop
-
include_cstr
Macro for building static CStr reference from file content
-
commander-macros
used by commander-rust only. Please don't use it!
-
jsonrpc-utils-macros
Proc-macros for jsonrpc-utils
-
smarterr-macro
Smart error handling library
-
ident_case_conversions
converting between cases in idents, primarily meant for proc macro usage
-
hashfn
A procedural macro to generate a hash representation of a function as a string slice
-
charybdis_macros
Proc macro crate for Charybdis ORM
-
stry-attrouter
A attribute based router for various Rust web servers
-
mmkv-proc-macro-lib
Proc macro lib of Rust version of MMKV
-
nt-list_macros
Macros for nt-list
-
blackboxmc_proc
Procedrual macros for the BlackboxMC crates
-
try_clone_derive
wich add a derive TryClone macro for the TryClone Trait of the fallible_allocation crate
-
egui-probe-proc
Derive macro for egui-probe crate
-
typed_floats_macros
only used to generate the
typed_floats
crate -
pgx-macros
Proc Macros for 'pgx'
-
lazy-re
lazy reverse engineers
-
ops-derive
Derive macros for std::ops
-
dir-test-macros
procedural macro for
dir-test
-
auto_unwrap
A small proc-macro that replaces instances of
?
with.unwrap()
-
indiscriminant_lib
A proc-macro for mapping between values and enum discriminants
-
sonic_spin
Reads ::() as a general postfix operator
-
enum-utility-macros
A macro to generate useful helpers for enums
-
bevy_startup_tree_macros_core
core of bevy_startup_tree_macros
-
subtle-ng-derive
Derive macros for subtle-ng traits
-
element-ptr-macro
The internal macro crate for
element-ptr
-
varianteq
Derive the equality of enum variants ignoring fields
-
rtest-derive
heper crate with derive macros for rtest
-
derive-stack-queue
Derives for stack-queue
-
safer-ffi-gen-macro
Proc macro implementation for safer-ffi-gen
-
resx_derives
Derive macros for Resx
-
macroific_core
Shared functionality for macroific & macroific_macro
-
rustic-jsonrpc-macro
JSON-RPC 2.0 server library written in Rust
-
girolle_macro
A nameko macro proc-macro to generate a Nameko Function
-
grafana-plugin-sdk-macros
Convenience macros for the Grafana backend plugin SDK
-
unicode_names2_macros
Support macros for
unicode_names2
-
dyn-dyn-macros
Procedural macros used by the dyn-dyn crate
-
transmute-tools
Proc macros and traits to assist with safely creating transmutable data structures
-
lib3d6
Potentially my personal utility library, for now a test
-
rudi-macro
Macros for Rudi
-
tree_sitter_grep_proc_macros
(proc-macros used internally by tree-sitter-grep)
-
rate-limit-macro
Procedural macro that provides a simple way to rate-limit blocks of code
-
unsafe_fn_body
Wrap the function body in an unsafe block using attribute macros
-
address-cmp
An attribute for address comparison
-
cmd_lib_macros
Common rust commandline macros and utils, to write shell script like tasks easily
-
http-request-derive-macros
Use derive to create HTTP requests
-
rust-ad-core
Rust Auto-Differentiation
-
sycamore-state-macros
sycamore-state proc macro implementation
-
from-env-derive
A derive macro for FromEnv trait
-
struct-scheme-derive-macros
macros for struct_scheme
-
huber-procmacro
Internal package used by Huber
-
attribution
A declarative custom attribute parsing framework
-
functor_derive_lib
The proc macro for a derive macro to derive a functor for a type
-
shopify_function_macro
Macros for the
shopify_function
crate -
name_of
expression for Rust
-
silent-db-macros
Macros for silent-db
-
icondata_macros
A helper macro to specify icons in a declarative way
-
simple-bind
One-line non-exhaustive binds
-
rupring_macro
rupring macro
-
bash_builtins_macro
Macros for the bash-builtins crate
-
orbital
Automation of boiler-templates generated by CakePattern
-
regiface-macros
implements the macros for the regiface crate
-
enumber
Provide useful impls on numerical enums
-
parquet_derive
Derive macros for the Rust implementation of Apache Parquet
-
edifact-types-macros
Macros for edifact-types
-
sorted_locks_derive
Macro to aquire
std::syn::RwLock
orstd::syn::Mutex
locks with consistent order to prevent deadlock -
email-macros
Macros for email-lib
-
global-static-singleton
global-static macro sister crate
-
zalgo-codec-macro
zalgo_embed! macro for compiling source code that's been converted into a single grapheme cluster by the zalgo-codec-common crate
-
bitenum_macro
bitenum macro
-
genies_derive
Derive macros for convient implementation of some traits of the
ddd_dapr
crate -
croissant-macro
Procedural macro library for Croissant
-
qunit-macros
Macros for qunit
-
flololoat
Mass Convert to floats
-
syn_util
helper APIs for procedural macros
-
cassandra_macro_derive
Macros 1.1 implementation of #[derive(Cassandra)]
-
perstruct-proc-macros
macro for adding persistent backing to a struct
-
dialogue-core
the core of dialogue-macro
-
instant-xml-macros
Procedural macros for instant-xml
-
arrow-udf-macros
Procedural macros for generating Arrow functions
-
edn-derive
Edn (De)Serialization derive macros
-
visa-rs-proc
procedural macros used in visa-rs
-
serde-json-helpers
A collection of procedural macros compatible with stable Rust 2018 that simplify some common operations not covered by
serde_derive
-
benchy-macros
Procedural macros for benchy
-
chess-derive
Derive procedural macros for the chess-core crate
-
ouroboros_macro
Proc macro for ouroboros crate
-
rstml-component-macro
Macros for rstml-component
-
ryde_router_macros
Macros for the router crate in ryde
-
zang-macro
Rust language tokens translated to Uzbek
-
dep-inj
easier dependency injection
-
env_to_array
Auxiliary crate for collecting arrays in different encodings from string constant & environment variables
-
is-tree-macro
is-tree macro library
-
bevy_bundlication_macros
Macros for bevy_bundlication
-
memor
memoization macro for rust
-
tttr-toolbox-proc-macros
Proc macros for tttr-toolbox
-
durian_proc_macros
Procedural macros for the durian crate for ease of creating Packet structs
-
udf-macros
UDF procedural macros implementation
-
nessie-lex-proc-macros
Procedural macros for the nessie-lex crate
-
cxx-qt-macro
A set of macros for Qt/C++ interop in Rust
-
bevy_replicon_snap_macros
Macros for bevy_replicon_snap
-
janetrs_macros
Attribute macros for JanetRS
-
serenity-commands-macros
creating/parsing Serenity slash commands
-
tuplez-macros
Procedural macros implementation of tuplez
-
sinais_macro
A macro repository for the
sinais
simple signal event library -
semx_entry
为对应架构定义汇编入口以及异常入口
-
product-os-store-macros
Product OS : Store Macros provides a highly flexible higher order framework for defining SQL queries by using Rust directly. This crate is to be used with Product OS : Store.
-
assert2-macros
procedural macros for assert2
-
warframe-macros
warframe.rs' macros
-
text-image
A proc-macro to generate raw image from text and a font file, for embedded-graphics
-
desaturate-macros
Procedural macros for the desaturate crate
-
upgrayedd-macros
Ergonomic function interposition in Rust
-
cast_checks_macro
-
shardize-core
Core libraries for shardize
-
micromegas-tracing-proc-macros
macros to help with instrumentation, part of micromegas
-
argh_derive
Derive-based argument parsing optimized for code size
-
sqlb-macros
Macros for sqlb. Not intended to be used directly.
-
nova-impl
nova crate
-
xshell-macros
Private implementation detail of xshell crate
-
usdt-macro
Procedural macro for generating Rust macros for USDT probes
-
flipperzero-test-macros
Procedural macros for flipperzero-test
-
struct_auto_from
auto generating conversion methods between structs
-
try-let
Proc macro for a basic try-let form
-
munge_macro
Macro for custom destructuring
-
ff_derive-zeroize
Procedural macro library used to build custom prime field implementations
-
bootstraps
Proc macro for Windows DllMain entry point
-
many-macros
Procedural macros to support create MANY modules
-
aprox_derive
determining aproximate equality between floating point types and deriving this capability to struct comprised of floating point numbers
-
auto_ref
Replace &T to impl AsRef<T>
-
indicator_macros
Abstractions for stream aggregation, we call them
Indicator
s -
syndicate-macros
Support macros for programming with the Syndicated Actor model and Dataspaces
-
fiberplane-pdk-macros
Macros for the Fiberplane PDK
-
rscx-web-macros
A set of macros enhancing RSCX components in Rust
-
pest-typed-tree
Generates typed tree, based on grammar, allowing reduce .unwrap() count :)
-
cutlass
Macro based library to take the boilerplate out of configuration handling
-
enum-from-functions
A procedural macro that will create an enum with associated functions that each have a corresponding variant
-
astmaker
Build Abstract Syntax Trees and tree-walking models quickly in Rust
-
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.
-
calculagraph
A handy library for measuring the execution time of function
-
rustpython-derive-impl
Rust language extensions and macros specific to rustpython
-
bomboni_core
Internal part of Bomboni library
-
luminal_macro
Procedural macros for luminal
-
tslink
Creates typescript definitions based on rust code
-
runa-wayland-scanner-codegen
Generate code from wayland protocol specifications
-
unimock_macros
Procedural macros used by unimock
-
bevy_ecs_macros
Bevy ECS Macros
-
blend-formula-proc-macro
macros for blend-formula crate
-
envar
macro to read environment variables at compile time
-
composint-macro
Space efficient structs using otherwise useless bits
-
tosho-macros
A macro library for tosho-mango
-
autodefault
A proc macro that automatically inserts
..Default::default()
into your struct literals -
solrust_derive_internals
Implementations of derive macro for solrust
-
socket_addr_macros
Check and parse SocketAddr at compile-time
-
byte-strings-proc_macros
Internal: proc-macro backend of ::byte_strings
-
primitive_enum
Little utility for dealing with enums no extra data in variants
-
raffl-macro
Rust Asynchronous FFI Library - A library for writing asynchronous callback-friendly FFI
-
cpreprocess
Procedural macro that runs a C preprocessor on the input
-
embedded-resources
Define peripheral usage in a single place for use everywhere
-
inline-proc
Inline procedural macros
-
embeddir
A macro for embedding all files in a directory into the executable
-
yolo_keyword
Adds the yolo keyword
-
flatfish
A macro to write Fully Qualified Syntax without nesting turbofishes
-
auto-const-array
Define a const array without specify length
-
nodex-macros
nodex macros
-
ramhorns-derive-ext
Experimental Mustache-like templating engine
-
fut-ret
parse the return type generated by async_trait in procedural macro
-
unstyled_macro
Unstyled is just another library which allows to write scoped CSS styles in Rust
-
makepad-derive-live
Makepad platform live DSL derive macros
-
goglob-common
Internal library used by goglob, not for public use
-
snax
JSX-like syntax for proc macro authors
-
ref-mut-n
Defines a nested mutable reference
-
malloc_size_of_derive
Firefox memory reporting, not intended for external use
-
rocketmq-macros
Unofficial Rust implementation of Apache RocketMQ
-
range_checker_macro
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
html-macro
html macro
-
procmacro2
A substitute implementation of the compiler’s
proc_macro
API to decouple token-based libraries from the procedural macro use case -
zolt-proc
Proc macros for the 'zolt' crate
-
evento-macro
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
native-proc
Procedural macro for parsing prost-build structs and generating local matching types
-
gtk-blueprint
Use Blueprint in Rust GTK applications
-
pear_codegen
A (codegen) pear is a fruit
-
include-utils-macro
Internal proc macro for the
include-utils
crate -
nuidl-lib
Code generation library for nuidl
-
oters_macro
Macro definitions for the oters programming language
-
deep_causality_macros
Procedural macros that generate constructurs and getters
-
hexhex_macros
use hexhex instead of this
-
spanr
proc-macro authors to visualize the spans on generated code
-
better-macro
better versions of common macros like println
-
maikklein/unreal-api-derive
Rust integration for Unreal Engine 5
-
fizyr-rpc-macros
procedural macros for the fizyr-rpc crate
-
comprehension
Iterator comprehension in Rust
-
extra_args
Rust macro to pass implicit args to functions (use with care)
-
eiffel-macros-gen
Eiffel is a library for Eiffel language inspired guard clauses with Rust macros. This is the proc-macro part of the library.
-
round_view_derive
Procedural macros to generate methods r2_view, r3_view and r4_view
-
delve
number of macros that make working with enums and strings more convenient
-
parse_api
parse api
-
spanned_error_message
Pretty error messages with spans outside of proc macros
-
tryfrom-via-fromstr
Derive
TryFrom
by delegating to theFromStr
impl -
solders-macros
A collection of attribute macros to reduce boilerplate in the solders project
-
error-chain-utils
A set of utilities for use with error-chain
-
substrait-expr-funcgen
automatically generating code from Substrait YAML files
-
clippy-mini-macro-test
A macro to test clippy's procedural macro checks
-
ra_ap_salsa-macros
Procedural macros for the salsa crate
-
workflow-wasm-macros
Macros for workflow-wasm
-
defmt-test-macros
defmt-test macros
-
axum-wasm-macros
A macro to enable compabatility between Axum and and WASM
-
irzha
Write Rust programs using Ukrainian language
-
pulp-macro
Safe generic simd
-
memoize-inner
Helper crate for memoize
-
ffishim
behind ffishim_derive
-
proc_qq_codegen
QQ client framework
-
vercel_runtime_macro
Vercel Rust Function Runtime Macro
-
synca
Write asynchronous code, and synca will create a synchronous version
-
secrets-manager-macro
Macro for using AWS Secrets Manager secrets in your application
-
kvx_macros
Macros for kvx: an abstraction layer over various key-value store backends
-
rzhavchina
Rust programming, in Russian
-
p5doc
p5.js diagram within rustdoc
-
cps
Assists in the creation of readable and maintainable macro_rules! macros
-
hpl-compression-macro-merkle-tree-utils
HPL macro for defining an platform-gate
-
test-fuzz-macro
-
garde_derive
Derive macros for garde
-
dlopen2_derive
Derive macros for the dlopen2 crate
-
alkahest-proc
Procedural macros for 'alkahest-proc' crate
-
devault
A more flexible alternative to deriving Default
-
awf-help
Actix web flask use proc macros
-
const-random-macro
procedural macro used by const-random
-
fixedlength-format-parser
Build parsers for files with fixed length, record-like fields
-
docsplay-macros
details of docsplay
-
native-json-macro
Native JSON for Rust
-
passivized_vault_client_versions
Test support crate defining which Vault versions are tested against
-
oxi-macros
Proc macros for nvim-oxi
-
log-attributes
A set of function log attributes, that make logging function in- and outputs a charm
-
yew-component
macro to generate yew components from a single struct declaration
-
git-version-macro
Internal macro crate for git-version
-
fusen-macro
RPC framework for service registration and discovery through API exposure, compatible with Dubbo3 protocol, intertunable with Java projects
-
format_args_conditional
A procedural macro that can expand to one macro or another based on whether
format_args!
input could be optimized aswrite_str
-
macro-rules-rt
Transforms text or TokenStream using Rust's macro_rules syntax
-
speare_macro
macro to make speare crate easier to use
-
cgi-attributes
A function attribute macro to generate a CGI-wrapped main
-
quote_into
Easily & efficiently generate code by quoting it in a macro
-
macro-wasmer-universal-test
Universal test macro for wasmer-test
-
enum-fields
Quickly access shared enum fields in Rust
-
text-grid-macros
create formatted plain-text tables
-
hollywood_macros
Macros for the Hollywood actor framework
-
bevy-yoleck-macros
Macros for bevy-yoleck
-
clone_with
procedural macro to clone a struct with some fields changed
-
limousine_derive
Proc macros for building hybrid index data structures
-
culpa-macros
Internal implementation details of
culpa
-
default_variant
A proc-macro for specifying the variants or values to be used when deriving
Default
in enums -
integral-enum
way to define integer-like enums
-
trakt-macros
Procedural macros for the trakt-rs crate
-
place_macro_core
contains implementation of procedural macros for place_macro
-
rpc-it-macros
RPC library for my own demand
-
futures-select-macro-preview
The
select!
macro for waiting on multiple differentFuture
s at once and handling the first one to complete -
actix-default-responder
Procedural macro for generating default
Responder
implementation for a specific data type (ie. json, xml, etc). -
typeunion
Attribute macro to declare type unions in Rust
-
num_enum_derive
Internal implementation details for ::num_enum (Procedural macros to make inter-operation between primitives and enums easier)
-
digestible-macros
Macros for generating digest implementations
-
tracelogging_macros
TraceLogging for Rust Proc Macros
-
restruct
Converts between raw bytes and structured data
-
syewreal_macros
Proc macros for syewreal
-
hpl-toolkit-attribute-account-schemas-ix-injector
HPL attribute macro for defining a compressed account schema
-
safe-goto
Emulating a safe goto-like instruction in Rust in the spirit of the "Safe goto with value" pre-RFC from IRLO
-
i2f
Macros that converts number literals into int or float literals
-
leptos-struct-table-macro
Macros for the leptos-struct-table crate
-
formality-macros
Macros used by a-mir-formality and formality-core
-
axum-starter-macro
A help crate for simplify the code of starting axum server
-
json_schema_test_suite_test_case
Procedural Macro Attribute to run all the test cases described in JSON-Schema-Test-Suite
-
proc-macro-id
Identity procedural macro
-
type-change
Convert between different types of the same field name
-
derive-redis-swapplex
Derives for redis-swapplex
-
derive_constructor
Construct enums without naming them
-
macrotk
macro toolkit
-
require_lifetimes
A proc-macro to force rust authors to write lifetimes in function signatures
-
prest-db-macro
macro that derives Table trait to work with gluesql db
-
rrplug_proc
proc macros of rrplug
-
macro_script
tiny script for macro rules
-
test_each_file
Generates a test for each file in a specified directory
-
renaissance
rich man cries like a crocodile
-
code_gene_macro
code generation macros
-
patum
Make enum conform to a given pattern
-
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
-
axum-resp-result-macro
Help Struct For Axum Response
-
leptos-fluent-macros
Macros for leptos-fluent
-
typeof-literal
A macro that returns the type of any literal expression or composite of literals
-
from_remote_derive
Procedural macro for deriving
From
for types with same internal structure -
valence_entity
Minecraft entities for Valence
-
enum-filter
Filter to a specific enum variant from an iterator
-
dotenvx_codegen_implementation
A
dotenv
implementation for Rust -
minutus-macros
Procedural macro definitions for minutus
-
rem-controller
Non-local control flow repairer for Rusty Extraction Maestro
-
async-backtrace-attributes
Procedural macros for the
async-backtrace
crate -
auto_curry
Procedural macro to automatically curry functions
-
conservator_macro
conservator macro
-
diesel-selectable-macro
A derivable
Serialize
macro that selects precise fields -
assets_manager_macros
Procedural macros for assets_manager
-
holium-backend
Backend crate for the Holium Rust SDK procedural macro
-
minus-one
A proc-macro crate to subtract one from a number
-
to_phantom
Convert generics to PhantomData in proc macros
-
hot-lib-reloader-macro
Macro crate for hot-lib-reloader
-
syn_str
what syn is to proc_macro::TokenStream for proc_macro::TokenStream::to_string,quote! being format! with String::parse::<TokenStream>
-
derive-combine
A macro for combining multiple structs into one
-
bevy_talks_macros
Macros for the
bevy_talks
crate -
efbuilder
A procedural macro for generating efficient builders
-
simpl_actor_macros
tokio actors macros
-
ord_by_key
convenient macro for implementing Ord trait with logic specified in an inline expression
-
simple_cache_macros
caching tools
-
o2o-macros
Macro definitions of 'o2o' crate
-
wasmdev_macro
wasmdev macro implementation
-
amap
define
[Option<T>; N]
easily -
defaults
A better
Default
derive macro -
restep
useful REST API endpoint generator
-
melior-macro
Internal macros for Melior
-
lit-mod
collection of procedural macros for working with string literals
-
ezno-parser-visitable-derive
Derives 'Visitable' trait for Ezno AST
-
feature-gate
macro for feature-gating modules and types
-
inline-rust
A stupid macro that compiles and executes Rust and spits the output directly into your Rust code
-
maybe-impl
support to conditionally implement one or more traits
-
adtest
better test generation
-
fix-hidden-lifetime-bug-proc_macros
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
algorithmify_macros
Macros for the algorithmify library
-
entity_data-macros
Macros for entity_data crate
-
named_derive
A package that just creates a derive macro called name to save me 10 seconds from having to copy and paste code. Figuring out how to use this took 30 minites. Amazing waste of time.
-
mendes-macros
Macros for mendes web toolkit
-
kproc_macros
Useful proc macros
-
synom
Stripped-down Nom parser used by Syn
-
light-macros
Macros used in Light Protocol on-chain programs
-
charify
proc macro to turn its token input into a char, similar to the built-in stringify! macro
-
derive-adhoc-macros
Macros that implement the derive_adhoc crate
-
dropshot_endpoint
macro used by dropshot consumers for registering handlers
-
rapid-web-codegen
Codegen utilities for the rapid framework
-
semx_bsp
对应硬件板级定义
-
choice_nocase
Transforms a string as a list of strings separated by
|
where all combinations of character cases are generated. By construction first one is fully uppercase, second one is fully lowercase. -
typemarker_core
Core module of typemarker that includes all the code for the macro and tests
-
impl-template
A procedural macro for generating impl-blocks based on a simple template
-
pm-lexer
sample lexer using the proc-macro crate, to be used in the pomelo testings
-
dysql-macro
Dysql is a rust crate that do dynamic-sql query through proc-macro, it bases on sqlx crate
-
confql
Procedural macro for creating GraphQL server from yaml file trees and a schema
-
xmlserde_derives
macros that help xmlserde serde the xml files
-
rust_source_bundler
bundle local Rust library source files into a single file
-
dont-expand
Dummy macros to shadow macros to avoid expansion in cargo expand
-
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!
-
proc-macro-kwargs
Keyword argument parsing for function-like proc-macros
-
ambient_editor_derive
A procedural macro to generate Ambient UI code for a struct or enum
-
nougat-proc_macros
Internal: proc-macro backend of ::nougat
-
orm_mysql_macro
A macro for mysql orm
-
macro-ruby
Execute ruby code at compile time trough mruby
-
set_enum_fields
Adds the ability to set the fields of an enum, and return the fields of enum mutable. Based on enum-fields
-
risp_macro
LISP
-
cosmic-macros
macros for thecosmicinitiative.io
-
rust-analyzer-salsa-macros
Procedural macros for the salsa crate
-
a653rs_macros
Macros implementation for a653rs
-
tauri-interop-macro
Macros for the tauri-interop crate
-
bevy_interleave_macros
macros for e2e packed to planar bind groups
-
better-default-derive
A better Default macro
-
bigquery-functions-types-macros
proc macros to define BigQuery function types
-
ergol_proc_macro
the proc macros for ergol, an async ORM for Rust
-
baroque
cuckoo
-
overloadable
functions done easy in rust
-
yui_internal
Internal functions, struct for derive in Yui
-
protobuf-convert
Macros for convenient serialization of Rust data structures into/from Protocol Buffers
-
code_snippet_generator
A proc_macro for turning a snippet of code into colorized html
-
agb_xm
converting XM tracker files for use with agb-tracker on the Game Boy Advance. You shouldn't use this package directly
-
phper-macros
The proc-macros for phper crate
-
weensy-proc-macro
A collection of useful bits and bobs for programming the Teensy 4.1 microcontroller
-
iroha
A tokenization Library for Rust
-
submillisecond_macros
Macros used by the submillisecond web framework
-
binmarshal-macros
Derive and helper macros for binmarshal
-
r18-proc-macros
r18 procedure macros
-
libasm
adds inline assembly to stable rust
-
uri_path_router
A proc-macro crate that generates flattened enums for routing
-
stringify-attr
Attribute macros for stringifying
-
cpp-inherit
Macros for enabling you to subclass a Rust struct from a C++ class
-
tailwind_fuse_macro
Macros for tailwind-fuse
-
anchor_client_gen
generating crate from anchor IDL
-
stringify-ident-proc-macro
Replacement for the stringify! macro for use in const functions
-
ama
Quasi-quotation system for designing procedural macros mixed with Rust code
-
quote_precise
A quote implementation that preserves meaningful span locations
-
try_match_inner
The internal procedural macro of
try_match
-
swc_ecma_codegen_macros
Macros for swc_ecma_codegen
-
shower
get string of code block
-
roslibrust_codegen_macro
macro-based message generation for roslibrust
-
shoulda_macro
derive macro for test assertions
-
crate-_-name
macro to get the name of the current crate
-
sscanf_macro
Proc-Macros for the sscanf Crate. Not meant to be used as a standalone Crate
-
flyway-codegen
Flyway-rs project, Database change control,similar to flyway in Java
-
auto-import
Please do not use this
-
chitey-codegen
Routing macros for Chitey
-
rquickjs-macro
Procedural macros for rquickjs
-
macroquest-macros
Internal macros for the MacroQuest ecosystem
-
leptos-spin-macro
Spin support for Leptos
-
enum-display-macro
A macro to derive Display for enums
-
my_proc_macro
proc macro
-
proc_macro_tools
Tools for writing procedural macroses
-
jump-kun-macros
jump-kun. Parses jump-kun config file and creates fucntions.
-
s2p
helper create to convert list of struct to polars dataframe
-
termal_proc
fancy colored cli using ansi codes
-
nestruct
that provides macros to easily flatten or nest structs and enums in your code
-
tabled_derive
Derive macros which is used by tabled crate
-
catalytic_table_to_struct
Table mapper for the ORM for Scylla, fully compatible with Apache Cassandra™
-
membrane_macro
A companion crate for
membrane
-
frunk_proc_macros
Proc macros for Frunk
-
absolution
‘Freedom from
syn
’. A lightweight Rust lexer designed for use in bang-style proc macros. -
nullable_struct
A derive macro that makes it easy to create nullable versions of structs
-
quote-impersonated
Quasi-quoting macro quote!(...)
-
macro-v
Attribute macro for making the visibility of the
macro_rules!
macro the same as other items -
edgedb-query-derive
that provide a bunch of attribute macros that help to build EdgeDB query using edgedb-tokio crate
-
wasmtime-c-api-macros
Support macros for
wasmtime-c-api
-
machine
State machine utilities
-
smelter
Custom derive attribute that automatically derives builder methods
-
hippotat-macros
Asinine HTTP-over-IP, proc-macros
-
arma-rs-proc
proc macros for arma-rs
-
af-core-macros
Macros for the indigo crate
-
typeshare-annotation
The annotation used to mark types for typeshare
-
quickcheck_async
Runtime-agnostic attribute macros to use quickcheck with async tests
-
cfmt-macros
Format output without Rust code segment in binary to reduce the ultimate binary size
-
generic_trait_alias
A proc-macro attribute which can be used to create custom type aliases for abstraction
-
extend1
Alternative to
Extend::extend_one
that is stable and does not require#![feature(extend_one)]
-
confique-macro
Macro crate for 'confique'. Do not use directly! Semver not guaranteed!
-
unprolix
Boilerplate generator for constructors, getters and setters with derive macros
-
syn-pub-items
Parser for Rust source code (patched for pub items)
-
spindle_macros
A macro backend for
spindle
: ergonomic GPGPU data parallel computing in Rust -
replisdk-proc
Procedural macros crate for replisdk
-
spatialos-macro
Procmacro crate used to expand SpatialOS component and types created with spatialos-codegen
-
proc_include_dir_as_map
Magic which implements the procedural macro
include_dir_as_map
-
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 -
azalea-registry-macros
Macros internally used in azalea-registry
-
rotenv_codegen
A
dotenv
implementation for Rust -
display_json
Procedural macros for implementing Display, Debug and FromStr for (de)serializing json strings
-
tabler-dominator
Tabler icons for Dominator
-
include-flate-codegen
Macro codegen for the include-flate crate
-
leptos_tea_macros
Macros used by leptos_tea
-
tiny-web-macro
macro library for automatically connecting a web engine to the web project
-
r-lombok-macros
r-lombok is a rust macros that automatically plugs into your editor and build tools
-
enum_to_string
Generate a serialized string using the display trait easily
-
async_trait_proto
Async traits using nightly features
-
askama-enum
Implement different askama templates for different enum variants
-
file_check_macro
A macro for checking the presence of a template file at compile time. E.g. for Tera templates
-
pg_sgr_from_row
Write asynchronous code, and synca will create a synchronous version
-
scyllax-macros-core
Core macro impl for scyllax
-
ngyn_macros
Modular backend framework for web applications
-
tiny_json_derive
tiny-json-rs derive crate
-
aide-macros
Macros for the Aide library
-
blade-macros
Macros helpers for Blade users
-
pork
proc macro demo
-
native_model_macro
A procedural macro for native_model
-
swipl-macros
Macro crate for swipl-rs
-
castle_schema_parser
Castle Schema Parser
-
workflow-html-macros
Workflow Macros for HTML Rendering
-
mirror-mirror-macros
Macros for the mirror-mirror crate
-
async_static
A macro for declaring async lazily evaluated statics in Rust
-
rocket_sync_db_pools_codegen
Procedural macros for rocket_sync_db_pools
-
sqlx-model-macros
sqlx model macro
-
simd-json-derive-int
procmacros for simd-json-derive
-
elm_to_view
A macro for parsing elm_markup to leptos view
-
lurk-macros
Custom derives for
lurk
-
rxing-one-d-proc-derive
proc macros to simplify the development of one-d barcode symbologies in rxing (https://github.com/rxing-core/rxing)
-
abomonation_derive
A custom derive plugin for abomonation
-
veil-macros
Veil procedural macros
-
rtaichi_attr_impl
Rust language binding to the Taichi Runtime C-API
-
cell_derive
A derive macro for quickly implementing
get_or_init
andget_mut
functions for structs that containOnceCell
orOnceLock
structs -
diesel_filter_query
Procedural macros for Diesel filter
-
faux_macros
Implementations for #[create], #[methods], when!
-
near-async-derive
contains derive macros for near-async
-
default-struct-builder
Generates builder methods of every field of a struct
-
sly_static_macros
macros for sly_static
-
bfieldcodec_derive
Derive macro for BFieldCodec
-
postgres-json-derive
Derive macro for implementing ToSql and FromSql for a struct
-
diesel_findable
Macro to generate find_by_{attr} functions
-
wasm-bindgen-test-macro
Internal testing macro for wasm-bindgen
-
syntactic-for
A syntactic 'for' loop macro
-
ezjsonrpc
JSONRPC 2.0 server/client with proc_macro helpers
-
derive-collect-docs
Collect documentation from Rust structs using a
CollectDocs
derive macro -
netxbuilder
netx builder assembly
-
volmark
Debugging and other macros for my Hornvale project
-
derive-with
#[derive(With)]
generates with-constructor for each field in struct -
from-attr-core
from-attr core type
-
nmacro
Code generator for Naumi
-
aery_macros
Proc macros for Aery
-
procmeta-proc
A derive-macro for procmeta-core
-
holium-macro-support
Support crate for the procedural macro for the Holium Rust SDK
-
gp-runtime-interface-proc-macro
procedural macros for usage within the context of the Substrate runtime interface
-
c_macros
A bunch of macros useful for interfacing with C code
-
tigerbeetle-unofficial-sys
Native bindings to the tigerbeetle library
-
test-context-macros
Macro crate for test-context
-
better-bae
proc-macro attribute parser
-
locenv-macros
A collection of macros to aid on module development for locenv
-
shinyframework_codegen
Shiny codegen
-
ffi
Macro for routing C FFI callbacks to struct methods
-
polywrap_schemafy_lib
Generates serializable Rust types from a json schema
-
procmeta-core
proc-macro helper
-
config_parser_derive
A proc-macro for implementing ConfigParser trait of config_parser library
-
async-generic
Write code that can be both async and synchronous without duplicating it
-
bevy_ineffable_macros
Macros for the bevy_ineffable crate
-
stateroom-wasm-macro
A macro for building a Stateroom service as a WebAssembly module
-
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).
-
genserver_codegen
code generation for genserver crate
-
tagged-base64-macros
Procedural macros associated with tagged-base64
-
perfect-derive
prototype of the proposed perfect_derive macro
-
enum_stringify
Macro to generate string conversion functions for enums
-
include-dir-macro
macro to include a directory tree of files in the compiled binary
-
ibex_macros
Macros for Ibex templating
-
sov-modules-macros
Macros for use with the Sovereign SDK module system
-
schemafy
Generates serializeable Rust types from a json schema
-
shallow-debug
A basic Debug derive macro that can be used on any type
-
proc-caesar
Procedural macro to break Rust IDEs
-
wood_derive
autoderive for wood serialization
-
usdt-attr-macro
Procedural macro for generating Rust macros for USDT probes
-
leptos_workers_macro
Macros for leptos_workers, a WebWorker library for the Leptos web framework
-
untwine
Declarative parsing with a BNF-like syntax
-
p9_wire_format_derive
Supporting proc-macro for the
p9
crate -
add_getters_setters
Makes it much easier to add getters and setters for fields of structures. Done by simply just adding some attributes to the struct and fields
-
wedpr_ffi_macros
WeDPR ffi shared macros
-
rename
Easy modification of structure names
-
unconst
Macro to unconst const/fn/enum/struct/trait/impl/type items
-
scyllax-macros
Macros for scyllax
-
elfo-macros
Macros for matching and deriving messages
-
ts-rs-macros-serde-json
derive macro for ts-rs
-
struct_as_array
that allows you to represent the structure as an array
-
bevy_fn_plugin
Create Bevy plugins from functions
-
microtype-macro
Proc macro for generating microtypes
-
forky_web_macros
Rust Utilities
-
derive-async-local
Derives for async-local
-
lucidity-macros
A distributed orchestrator platform for Rust
-
unrust-proc-macro
The unrust proc macro crate
-
polywrap_plugin_implementor
Macros to easily build plugins to interact with Polywrap Client
-
peg-macros
Procedural macros for rust-peg. To use rust-peg, see the
peg
crate. -
derive_state_machine_future
Custom derive implementation for the
state_machine_future
crate. Use that crate instead of this one directly. -
native_db_macro
A procedural macro for native_db
-
derived-deref
deriving the
Deref
andDerefMut
traits -
juniper_codegen
Internal custom derive trait for Juniper GraphQL
-
objective-rust-macros
Macros for objective-rust
-
bevy_state_macros
Macros to allow bevy systems for states with attributes
-
kiwi-macro
Macros for the Kiwi SDK
-
ecsact_rust_codegen
Ecsact rust code generator
-
wa-serde-derive
serde_derive compiled to wasm
-
real_c_string
Generate string parseable in compiled binary
-
fp-bindgen-macros
Macros for fp-bindgen
-
serde-env-field-wrap
An attribute that wraps all the fields of a struct or an enum with the EnvField type
-
witgen_macro_helper
Macros helpers for witgen which is a library to help you generate wit definitions in a wit file for WebAssembly
-
relm-derive
Custom derive required by the relm crate
-
syscall_encode_macros
Proc macros for the syscall_encode trait
-
unpat
Unboxing the pattern with easy syntax
-
interactive-clap-derive
Interactive mode extension crate to Command Line Arguments Parser (https://crates.io/crates/clap) (derive macros helper crate)
-
bind
Proc macro for binding values into an expression (usually a closure)
-
token_stream_flatten
Flattening iterator adaptor for token streams
-
fixed_width_derive
Derive trait for use with the fixed_width crate
-
sqlite-loadable-macros
macros for the sqlite-loadable crate
-
bevy_trait
Macros for creating Traits in Bevy
-
third-pact
Macro library for generating basic endpoints for models
-
derive-quickcheck-arbitrary
derive quickcheck::Arbitrary
-
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 -
cl-format-macros
Proc macro for cl-format
-
depends_derives
Ergonomic, performant, incremental computation between arbitrary types
-
bitread_macro
The bitread library macros
-
ctor-used-linker
__attribute__((constructor)) for Rust
-
aargvark_proc_macros
Helper crate for aargvark
-
custom-slice-macros
define custom slice types
-
erg_proc_macros
proc macros for Erg
-
meilisearch-index-setting-macro
Helper tool to generate settings of a Meilisearch index
-
union_type
A proc macro to introduce union type into rust
-
dynamic_call_proc_macro
Look up a trait method by name at runtime, and call it using json
-
async-blocking-bridger
A way to write a blocking client and async client without repeating yourself
-
openai-func-enums-macros
A companion crate for async-openai to ease the composition of function calls by leveraging Rust's type system and enums
-
rdxl_static
Static Site Generation Utilities for RDXL
-
templr_macros
Procedural macros for templr
-
baskerville_macro
Macros for Baskerville - Infer and validate data-type schemas in Rust
-
surrealdb-extras-proc-macro
A
cargo generate
template for quick-starting a procedural macro crate -
prismatic
An experimental Rust crate for decomposing the initialization of structs
-
preprocess-macro
Preprocesses a struct with built-in preprocessors
-
test-log-macros
Supporting procedural macro crate for test-log
-
ps-driver-deserializer
A proc macro to deserialize a PS driver
-
saphir_macro
Macro generation for http server framework
-
js-sandbox-macros
Procedural macros for js-sandbox
-
binf_macros
that adds utilities for dealing with binary flags
-
macro_magic_core
Core implementation behind macro_magic
-
portaldi-macros
Macros for portaldi
-
mock_derive
An easy to setup, rich mocking library for the Rust programming language
-
named_return
Derives a wrapper function which insert the named return variables
-
serde_syn
Use serde to parse Rust source code
-
wasmer-derive-asml-fork
Wasmer derive macros
-
egui_struct_macros
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
rad_ext_template
Rad ext macro template macros
-
typify-macro
typify macro implementation
-
count-tys
Function-like procedural macro that accepts a comma-delimited :ty TokenTree sequence and returns their count as a constant usize
-
include-crypt-bytes-cipher
Rust macro to embed encrypted files in compiled binary
-
miniorm-macros
a *very* simple ORM built on top of sqlx
-
inline-sql-macros
procedural macros for inline-sql
-
thruster-socketio-proc
The proc macros behind the thruster web framework
-
colorthis
Meta macros that aid macro authors to create colors from a generalized syntax
-
gents_derives
some macros for gents
-
css-in-rs-macro
Core macro for css-in-rs
-
puball
Public all the field in your struct
-
ezno-ast-generator
Quasi-quoted constant compiled TS definitions for Ezno AST
-
stronghold-derive
Proc macros and derives for Stronghold
-
stilts-macros
The macros that generate the templates for stilts
-
basic-text-literals
Basic Text string literal macro for basic-text
-
plex
A syntax extension for writing lexers and parsers
-
test-shisho-gql-derive
Shisho Cloud Policy SDK
-
toursql
a derive macro for gluesql
-
farmfe_macro_cache_item
Macro to create a farm cache item
-
fixtures
Run tests against fixtures
-
pavex_macros
Procedural macros for the Pavex framwork
-
opengl-registry-macros
Macros utilizing the OpenGL API and Extension Registry
-
ffi_wrapper_nounwind
Automatically generate FFI wrappers that catch unwinding from FFI into Rust
-
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
-
debugger_test
proc macro for writing tests that launch a debugger and run commands while verifying the output
-
diesel-crud-codegen
-
gecs_macros
Procedural macros for the gecs crate
-
event-driven-macro
Event Driven Message Handling
-
lexa-framework-macro
Framework web backend personnel par dessus Axum
-
fauxgen-macros
macro support package for fauxgen
-
poem-extensions-macro
Macros for poem-extensions
-
open-rpc-derive
OpenRPC Schema Generator
-
samotop-async-trait
Type erasure for async trait methods
-
from_tuple
Derive structs from tuples
-
overflow
Proc macros for changing the overflow behavior of math expressions
-
ntex-prost-derive
A Protocol Buffers implementation for the Rust Language
-
uringy-macros
Procedural macros for the uringy crate
-
fast_tuple
procedural macro library that provides an easy way to construct and annotate tuples
-
witchcraft-server-macros
Macro definitions used by witchcraft-server
-
gotcha_macro
gotcha web framework macro
-
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.
-
struct_ext
A set of useful derive macros for structs
-
hpl-compression-macro-merkle-tree-apply-fn
HPL macro for defining an platform-gate
-
more-syn-types
parsing Rust Standard Library macros
-
taurpc-macros
Macros for the taurpc crate
-
build-info-proc
Part of the build-info crate: This crate provides the proc-macros
-
xitca-codegen
proc macro for xitca
-
adorn
A plugin to provide python-style decorators in Rust
-
rem-borrower
Permission repairer for Rusty Extraction Maestro
-
ace_it
Macro to automate wrapping types into enums
-
beady
A macro for writing tests in a Behaviour Driven (BD) style
-
dbn-macros
Proc macros for dbn crate
-
capnp_conv_macros
attribute macros that implement capnp read/write traits
-
derive-try-from-ref
A derive macro to generate TryFrom<&T> implementation
-
radiation-macros
Macroses to derive traits for radiation crate
-
trait_info_gen
Procedural macros for obtaining Trait information at compile time
-
ferris-extensions
Extension macros for Rust
-
cli-settings-derive
Manage CLI settings with configuration file(s) and command line parsing, using serde and clap
-
ryde_db_macros
db macros for ryde
-
starbase_macros
Macros for the starbase framework
-
safe_bindgen
automatically generate C, Java, and C# files from Rust source files
-
optional_struct_export
Helper crate exporting the proc_macro as an actual proc_macro for the optional_struct crate
-
azalea-buf-macros
#[derive(McBuf)]
-
standard-dist
Derivable random distributions for types
-
i-slint-core-macros
Helper macro for i-slint-core
-
trecs_proc
proc_macros
-
htmxpress_macros
Procedural macros for generating htmx strings
-
stak-macro
Macros to integrate Stak Scheme
-
reflexive
Handy way to evaluate at compile-time any Rust expression
-
qt_macros
Macros for Qt
-
hoax
procedural macro crate that "hides" any string literal in a plain sight
-
hkalbasi-rustc-ap-rustc_macros
Automatically published version of the package
rustc_macros
in the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
irrefutable
Procedural macro to convert a refutable let expression to an irrefutable
-
implicit-trait
Add methods to foreign types with implicitly defined traits
-
spaik-proc-macros
Procedural macros for SPAIK
-
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 -
pub-fields
proc macro attribute that defaults all struct fields to public
-
type_reflect_core
functions for type_reflect
-
staged-builder
A proc macro which generates staged builders for types
-
derive_bounded
Builtin-macros workalike but with a way to specify bounds
-
utoipa-gen
Code generation implementation for utoipa
-
rdxl
Macros and Component System for HTML Templating
-
enum_data_proc
a proc-macro,Add bit operations and arithmetic operations to enum
-
savvy-macro
Generate R-ready Rust functions by adding
#[savvy]
macro -
wrapping_proc_macro
A proc macro for cleaner wrapping arithmetic
-
makepad-derive-wasm-bridge
Makepad wasm bridge derive macros
-
dotenvy_macro
A macro for compile time dotenv inspection
-
derive_builder_core_fork_arti
Internal helper library for the derive_builder crate
-
io_deser
Procedural macro crate for generating implementation of IoDeSer trait for structs
-
progenitor-macro
An OpenAPI client generator - macros
-
bevy_ecs_markers_macros
Proc Macros for Bevy ECS Markers
-
type-sitter-proc
procedural macros for type-sitter (generate typed wrappers for tree-sitter grammars from node-types.json and queries)
-
async-recursion2
Recursion for async functions
-
getset-scoped
Getset, we're ready to go! A procedural macro for generating the most basic getters and setters on fields
-
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.
-
medea-macro
Internal macros and codegen for Medea media server project
-
py_fstr
A macro for making Python like fstrings
-
ctjs
compile time javascript as a rust proc macro
-
struct_db_macro
A procedural macro for struct_db
-
makepad-derive-widget
Makepad widget derive macros
-
pyo3-opentelemetry-macros
Macro for passing OpenTelemetry context from Python to Rust
-
pyo3-helper-macros
A procedural macro to help wrapping rust structs for pyo3
-
ambient_project_macro
Ambient internal host project macro. Host-only.
-
hydroflow_datalog
Datalog proc-macro for Hydroflow
-
serde_default
Generate a Default impl using serde attributes
-
derive-deftly-macros
Macros that implement the derive_deftly crate
-
summer-boot-macro
summer boot macro
-
devise_codegen
devising derives and other procedural macros
-
fbthrift_codegen_includer_proc_macro
Workaround for https://github.com/rust-lang/rfcs/issues/752
-
masala
Automatic curry. Yum!
-
recorder
Generate data-only structs with utilities easily
-
cdrs-tokio-helpers-derive
Derive CDRS helper traits
-
miette-derive
Derive macros for miette. Like
thiserror
for Diagnostics. -
for_ch
to flatten nested for-loop
-
drop_struct_macro_derive
A derive macro to free (drop) memory for structs that are used in the FFI
-
sneks
macros for naming enum variants
-
test-impl
A macro for use in testing, to run a test on multiple trait implementations
-
peepmatic-macro
Macros for peepmatic
-
enum-impl
procedural macro auto-generating common methods on enums
-
lightning-wire-msgs-derive-base
derive macros for defining serialization and deserialization of lightning wire messages
-
rust_hls_macro_lib
Helper functions for rust_hls and rust_hls_macro
-
screeps-async-macros
Macros for screeps-async
-
syner
A procedural macro to generate a parser for attributes from a struct
-
serde_avro_derive_macros
Derive avro schema for Rust structs for serde_avro_fast
-
macros-core
lightweight, and highly configurable library for quickly parsing macro input into custom objects
-
galvan-test-macro
Test macros for the Galvan programming language
-
proc-macro-rules-macros
Emulate macro-rules pattern matching in procedural macros
-
code-product-macro
macro producing multiple expansions
-
dygma_focus_proc_macros
Dygma Focus API, proc macros
-
dao-dao-macros
A package macros for deriving DAO module interfaces
-
target_handler
A derive macro to create a handler for multiple enum variants
-
bind_it
A macro that allows impl traits in let/static/const bindings until they actually stabilized
-
ogrim-macros
Helper crate for
ogrim
. Please see the docs ofogrim
for more information. Do not use this crate directly, API stability is not guaranteed! -
gandiva_rust_udf_macro
A basic library for gandiva rust udf macro
-
azalea-protocol-macros
Macros internally used in azalea-protocol
-
arbitrary-model-tests
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
type_utils
Generate types based on existing types
-
impl-from-into-similar
Implement Into to any struct to convert between structs sharing similar fields. Uses serde_json.
-
secp256kfun_arithmetic_macros
Helper macros for secp256kfun's aritmetic macros
-
accessors-rs
Derive macro generating an impl for accessing the fields of a struct
-
ryzz_macros
Macros for the ryzz crate
-
defile-proc_macros
See https://docs.rs/defile
-
ownable-std-macros
proc macros for lto ownable contracts
-
native_api_1c_macro
Macro library for Native API 1C
-
arg_ripper
A proc macro for pulling local variables out of functions as arguments
-
enum2str
derive macro that creates a Display impl for enums. This is useful for strongly typing composable sets of strings.
-
sea-orm-field-updater
update model by field
-
easy_proc_macro
Rust's last proc-macro crate
-
bevy_reflect_derive
Derive implementations for bevy_reflect
-
salsa-macros
Procedural macros for the salsa crate
-
my-ast
AST definition like general programming languages and S-expression macros
-
gll-macros
Macros used with the gll crate
-
tracy-gizmos-attributes
Procedural macro attributes for automatic function instrumentation
-
rubedo-macros
Proc macros for Rubedo
-
css-rs-macro
A macro for writing your CSS next to your views
-
lending-iterator-proc_macros
Internal: proc-macro backend of ::lending_iterator
-
jlrs-macros
contains the custom derives offered by jlrs
-
sing_util
Internal functions and types for sing_rs
-
sin
Sin aims to be an alternative to the proc-macro2/syn ecosystem geared towards developer UX and custom syntax parsing
-
repr_c_pub_struct
extracting
#[repr(C)] pub struct
ures -
srcpos
Structure of the location in the source code
-
swc_config_macro
Macros to prevent mistakes
-
derive-name-macros
Derive macros for derive-name crate
-
static_init_macro
Attribute macros for static_init crate
-
proc_macro_helper
Procedural macros helper
-
workflow-rpc-macros
Macros for the workflow-rpc crate
-
rlp-derive
Derive macro for #[derive(RlpEncodable, RlpDecodable)]
-
fn-fixture-lib
Internal library for fn-fixture
-
make_fields
Tiny derive macro to work with fields inspired by lens's makeFields
-
turbolift_internals
macros for turbolift
-
pascal_ident_to_string
A macro to convert an identifier to a string literal in pascal case
-
jrsonnet-macros
Macros to reduce boilerplate in jrsonnet-evaluator usage
-
miniserde-derive-enum
Derive macros for miniserde that support enums
-
typetrait
Helper macro to generate types for typestate programming
-
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…
-
derive_display_from_debug
A trivial Rust macro to derive the Display trait for any type with the Debug trait
-
mm_example_crate
part of macro_magic
-
mini-internal
Derive macros for miniserde. Use the re-exports from the miniserde crate instead.
-
swift-bridge-macro
Powers swift-bridge module code generation
-
rscx-macros
proc macros for the rscx crate
-
dyn_safe-proc_macros
::dyn_safe
’s internal crate -
russx_macros
Procedural macros for russx
-
hyprland-macros
Macros used in hyprland-rs
-
proc-macro-crate-name-test
testing to see whether CARGO_PKG_NAME is populated correctly when proc macro crate is re-exported
-
derive-quote-to-tokens
derive quote::ToTokens
-
discriminant_hash_derive
Derive macro to implement Hash trait based on enum's discriminants only and ignore variant's fields
-
serde_derive_state
Macros 1.1 implementation of #[derive(Serialize, Deserialize)]
-
xparse-macros
A parser combinator that is fully statically dispatched and supports both sync & async parsing
-
extest
Extra utilities for your tests
-
clickrs
Simplified CLIs for Rust via procedural macros (Python's click, for Rust)
-
unrest_tmp_syn
don't use
-
arcon_codegen
Code generation for Arcon
-
lexa-syn
Utilitaires pour la crate syn (proc-macro)
-
duktape-macros
duktape bindings macros
-
const_env--value
Configure const and static items by environment variables
-
suitest_macros
suitest macros
-
kittycad-modeling-cmds-macros
Macros for working with KittyCAD execution plans
-
symbols-models
Proc-macro utility to populate enums from database data (shared traits)
-
proc-macro-error-attr
Attribute macro for proc-macro-error crate
-
mvrocketlib-macro
The proc macro crate for the MVRocketLib library
-
stylish-macros
Internal implementation details of
stylish-core
-
charybdis_parser
Parser crate for Charybdis ORM
-
big-int-proc
Proc macros for
big-int
-
rkyv_derive_test
Derive macro for rkyv
-
marigold-macros
Macros for the marigold language
-
rstml-to-string-macro
html to string macro powered by rstml
-
derive-redis-json
A derive to store and retrieve JSON values in redis encoded using serde
-
deluxe-macros
Derive macros for Deluxe procedural macro attribute parser
-
goon_proc_macros
Proc macros for goon_rs
-
rat-in-a-tube-definitions
Definitions for Rat In a Tube
-
schemars_derive
Macros for #[derive(JsonSchema)], for use with schemars
-
func_
Proc macro to add function name constant within body of function
-
chassis-proc-macros
Procedural Macros for chassis crate
-
essence_macros
Helper macros for the compile time orm
-
serialize_derive
derive for #[derive(Serialize)]
-
ra-ap-rustc_macros
Automatically published version of the package
rustc_macros
in the rust-lang/rust repository from commit c8f0d492a74efd98df11287108b7f68c76d937dc The publishing script for this crate lives at:… -
atm0s-media-server-proc-macro
Proc macro for atm0s-media-server
-
to_and_fro
Proc macro for generating implimentations of Display and FromStr for Enum Variants
-
counting-macros
Stateful numeric incrementing macros
-
quickstart-lib-rust
Just for testing
-
azalea-inventory-macros
Internal macros for azalea-inventory
-
der-oid-macro
Macro to encode DER oids at compile time
-
partial-borrow-macros
proc-macros for partial-borrow
-
lexgen
A fully-featured lexer generator implemented as a proc macro
-
def-mod
Simplifies module implementation routing and statically verifies exports
-
utility-types
proc-macro to realize several utility types of TypeScript
-
quote-doctest
doctest generator for quote
-
hpl-toolkit-macro-account-schemas-instruction
HPL macro for defining a instruction to get account schema values
-
liberty-macros
liberty
macros -
unc-rpc-error-macro
generates schema for Rust structs which can be used by TypeScript
-
tstr_proc_macros
detail of tstr
-
pi_proc_macros
Utils Proc Macros
-
canadensis_derive_register_block
Derive macro for
canadensis::register::RegisterBlock
-
client-handle-core
An internal helper library of client-handle
-
multiconst_proc_macros
detail of multiconst
-
wattle-proc
proc
-
test-ignore-if-utils
Build utils for the
test-ignore-if
crate -
macro_rules_attribute-proc_macro
Use declarative macros as proc_macro attributes or derives
-
off-side
syntax (indent instead of braces, like in Python) to write Rust!
-
err-gen
Error-generation macro for hierarchical actor design
-
enum_to_str_derive
provide a simple way to convert enum to static str ref
-
wasm-typescript-definition
serde support for exporting Typescript definitions using wasm-bindgen
-
nys
A declarative parer generator library
-
box_shorthand
Rust derive macro to create shorthand functions for initializing boxed enum variant values
-
vararg
macro for creating variadic functions
-
literal-enum
Convert an [
enum
] to a [literal
], and try to convert it back -
diman_unit_system
Internal procedural macros for diman
-
mashin_core
The core of mashin, consumed by the runtime engine
-
rimpiazza
A compile time procedural macro to replace keywords in a string
-
funtime
A proc-macro helper to time Rust functions
-
newt_proc_macros
Proc macros for newt-rs
-
constructor-macro
Derive constructor macros for structs
-
bend
Bend types (Forwarder macro to easily forward errors (auto-implements From trait for error type))
-
mashin_macro
Proc macro for writing mashin resources
-
fsmentry-macros
Finite State Machines with an entry API and data storage
-
rkyv_derive
Derive macro for rkyv
-
field_names
A proc-macro for exposing a struct's field names at runtime
-
async_auto_traits
Assert and mask auto traits in
async fn
return types -
rcss-core
RCSS - (core) contain parser functionality
-
reacty_yew
Generate Yew components from React component via Typescript type definitions
-
sea-strum
macros for working with enums and strings
-
pmhelp
A WIP library to assist in the creation of procedural macros
-
sauron-macro
An html library for building client side webapps
-
do-with-in-internal-macros
A template language for Rust metaprogramming using partial staging
-
fbinit_macros
Facebook init token macros
-
fancy
Easily print colored text
-
ambient_api_macros
Macros for the Ambient API
-
hpl-toolkit-macro-add-service
HPL macro for defining an platform-gate
-
ryde_css_macros
Macros for the ryde_css crate
-
serde-versions-derive
An attribute macro for adding a version byte when serializing a struct via Serde. Also allows deseraializing while removing version byte.
-
nonparallelex
Rust macro for ensuring non-parallel execution of functions, extended Fork of
nonparallel
-
netsblox-extension-macro
Macros used by netsblox-extension-util
-
bunt-macros
Helper crate for
bunt
. Please see the docs ofbunt
for more information. Do not use this crate directly, API stability is not guaranteed! -
hashed-type-def-procmacro
Proc-macro generator for a hash based type identifier: hash code is computed on the basis of type definition
-
yaah
AOC Helper
-
thiserror-impl
detail of the
thiserror
crate -
fieldwise
Derived field-wise conversions for Rust structs
-
decay_type
Macro for decaying Rust types to their simplest value type form
-
ssttt
More Syn Syntax Tree Traversal Trait
-
i-codegen-derive
Proc-macro supporting the
derive-codegen
crate -
router-rs-macro
A macro for client side web application routing
-
docify_macros
Support macros for docify
-
vhdl_lang_macros
VHDL Language Frontend - Macros
-
dylink_macro
Run-time dynamic linker loader attribute
-
mquote
Quasi-quoting library aimed on better readability and usability
-
nade-macro
Macros for nade
-
tlkit-proc
Tool Kit expand proc-macro
-
kayak_ui_macros
A proc macro library that provides RSX like syntax for Kayak UI
-
inline-python-macros
Macros for the inline-python crate
-
syn-codegen
Syntax tree describing Syn's syntax tree
-
relm-derive-state
Custom derive required by the relm-state crate
-
seekr-macro
proc macros used in seekr
-
gdnative-impl-proc-macros
Internal dependency of the gdnative bindings
-
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)
-
winrt_gen
Code generation for the winrt crate
-
utoipauto-macro
Rust Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase
-
duchess-macro
Interal component of duchess crate
-
mock-syn
Mock / wrap syn structs and enums overiding specific fields
-
safer_ffi-proc_macro
Procedural macro internals of
::safer_ffi
-
devela_macros
procedural macros for devela
-
bit-by-bit
Convenient proc-macro for defining structs with bitfields
-
testing_macros
General purpose testing macros
-
xflags-macros
Private implementation details of xflags
-
sweet_macros
macro crate for sweet
-
hydroflow_macro
Macro for using Hydroflow's Surface Syntax
-
hackfn
Fake implementation of
std::ops::Fn
for user-defined data types -
odata_client_codegen
Strongly-typed OData client code generation
-
test-pretty-log-macros
Supporting procedural macro crate for test-pretty-log
-
roadblk-proc
Validator proc-macro
-
r2r_macros
Minimal ros2 bindings
-
cli-rs-command-gen
internal helper for cli-rs
-
mysql_helper
Make mysql to struct simple with macro
-
attribute-derive-macro
Clap for proc macro attributes
-
snafu-cli-debug
Derive a debug implementation on snafu errors that prints pretty CLI output
-
target-test-dir-support
Support for the
target-test-dir
proc-macro crate -
pub_this
Make your structs' fields be pub
-
versuch
Procedural macro polyfill for Ok-wrapping functions
-
enum_variant_type
Generates types for each enum variant and conversion trait impls
-
tauriless_macro
The proc-macro crate for tauriless
-
enum-str-derive
serialize/deserialize enums into/from a string
-
cargo-fixture-macros
Macros for the cargo-fixture cargo extension
-
static-map-macro
Macro to create a stack-alocated map
-
workflow-core-macros
Macros for the workflow-core crate
-
fsmentry-core
Finite State Machines with an entry API and data storage
-
rocket_codegen
Procedural macros for the Rocket web framework
-
rand-gen-proc-macro
Proc macros for the rand-gen crate
-
pi_async_macro
A async file macros tools
-
forr
a compile time for loop for code generation
-
proc-macro2-impersonated
A substitute implementation of the compiler’s
proc_macro
API -
include_wgsl
A tiny proc macro to include a WGSL file in your binary, and verify that it is valid at compile time
-
mincat-macro
macro for mincat
-
c3-lang-macro
C3 Lang macro
-
dioxus-core-macro
Core macro for Dioxus Virtual DOM
-
incdir
Compile-time including of directories
-
testaun
Very minimalist procedural macro to help with tests
-
obfustring
Procedural macro that obfuscates string literals with RNG at compile time
-
relm-attributes
Attributes to simplify the use of the relm crate
-
laps_macros
Macros for crate
laps
-
mm_example_crate2
part of macro_magic
-
oxidate
Turns strings into a Rust AST
-
satrs-mib-codegen
satrs-mib proc macro implementation
-
regex-parse-proc-macro
Using regex strings, turn strings into structs!
-
factoryizer
Add factory/builder patterns automatically
-
predawn-macro
Macros for predawn
-
synthez-core
Internal implementations of
synthez
crate -
c3-lang-parser
C3 Lang
-
desugar
Allow for Desugaring of various Rust constructs
-
serde-enum
Automaticly generates string serde implementation for enums
-
awsl-syn
AWSL parser for rust macro
-
moisture
Rust-based parsing library intended for use with procedural macros!
-
unquote
A reverse quote macro... that is: A macro to parse input from a ParseStream according to a given pattern.
-
axum_typed_multipart_macros
Macros for axum_typed_multipart
-
goglob-proc-macro-tests
Internal library used for testing goglob, not for public use
-
wasm_bindgen_helper_macros
helper macros for a couple arbitrary use cases
-
syn-unnamed-struct
Extends syn expressions and meta structs with unnamed structs and meta lists
-
dynamic-dispatch-proc-macro
Proc macros for dynamic dispatch crate
-
nonparallel-async
Rust macro for ensuring non-parallel execution of async functions
-
maud_macros
Compile-time HTML templates
-
ux2-macros
Macro backend for ux2
-
ext-trait-proc_macros
Internal: proc-macro backend of ::ext_trait
-
enum2repr
EnumRepr is a rust derive macro that creates conversion methods to map between a value and an enum. Numeric types supported by
#[repr(T)]
are supported by enum2repr. -
modql-macros
Macros for modql. Not intended to be used directly.
-
quote-use-macros
Support
use
in procmacros hygienically -
macro-dep-test-macros
testing version resolution for associated macros
-
pio-proc
proc-macro for assembling PIO code in a Rust program at compile time
-
safer_ffi-proc_macros
Procedural macro internals of
::safer_ffi
-
cflp_macros
Proc-macro library used for cflp
-
unrest_tmp_synom
don't use
-
autoerror
Automatically generate error handling traits
-
rs2js_macro
A macro to convert Rust structs to/from JsValues
-
static-noise
generation static noise at compile time
-
from-enum
derive proc macro for deriving From on enums
-
partial-enum
proc-macro generating partially inhabited enums
-
dioxus-router-macro
Macro for Dioxus Router
-
is_variant
Generates methods to match enum variant
-
macro_io
Rust package that contains procedural macros to do IO during compile time
-
inarybay
Graph-based binary format (de)serializer generator
-
diman_derive_verify
Internal procedural macros for diman
-
persistent-structs
A Macro that generate helper functions to make non-mutable structs nicer to use
-
konst_proc_macros
detail of the
konst
crate -
unite
A helper macro to compose existing types into an enum
-
macroific_macro
Proc macros for the macroific crate
-
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… -
cascading-wasm-language
Compiled web language based on CSS syntax
-
rweb-macros
web server framework for rust
-
syn-serde
serialize and deserialize Syn syntax trees
-
workflow-task-macros
Macros for the workflow-task crate
-
atspi-macros
Macros to assist in various impl blocks for the
atspi
crate -
parol
LL(k) parser generator for Rust
-
gxi_parsers
parsers for gxi macros
-
labyrinth_macros
A procedural macro crate for the cryptify crate meant to provide obfuscation through compile time string encryption. not meant to be used standalone
-
hooks-macro-core
Compile-time, async hooks
-
guard_let
guard let for rust
-
efg
Conditional compilation using boolean expression syntax, rather than any(), all(), not()
-
manyhow-macros
Macro for manyhow
-
swc_ecma_quote_macros
Quasi quotation system for ecmascript
-
syn_query
implement Trait Syn::Visit
-
structre_proc_macros
Static-checked parsing of regexes into structs (helper crate)
-
stageleft_macro
Helper macros for the stageleft crate
-
serde_dis
derive macro for enums
-
assert_fn
A proc macro for turning test helper functions into assert! style macros
-
dioxus-html-internal-macro
HTML function macros for Dioxus
-
biscuit-quote
macros for compile time datalog parsing for Biscuit authorization tokens