-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
proc-macro2
A substitute implementation of the compiler’s
proc_macroAPI to decouple token-based libraries from the procedural macro use case -
cfg-if
A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted.
-
lazy-regex
lazy static regular expressions checked at compile time
-
ouroboros
Easy, safe self-referential struct generation
-
arrayref
Macros to take array references of slices
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
assertables
assert macros for better testing, debugging, quality assurance, and runtime reliability
-
bitfield
macros to generate bitfield-like struct
-
maud
Compile-time HTML templates
-
envconfig
Build a config structure from environment variables without boilerplate
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
delegate
Method delegation with less boilerplate
-
syn-mid
Providing the features between "full" and "derive" of syn
-
xflags
Moderately simple command line arguments parser
-
bounded-integer
Bounded integers
-
pastey
Macros for all your token pasting needs. Successor of paste.
-
getset
we're ready to go! A procedural macro for generating the most basic getters and setters on fields
-
find-crate
Find the crate name from the current Cargo.toml
-
enclose
A convenient macro, for cloning values into a closure
-
tiny-fn
Type erased closures on stack
-
docify
allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
safe-quote
Quasi-quoting macro quote!(...)
-
futures-async-stream
Async stream for Rust and the futures crate
-
error_set
Quick error declarations and automatic conversions between errors for precisely typed error handling. Inspired by Zig's error set type.
-
g2p
create types that implement fast finite field arithmetic
-
cglue
FFI safe abstractions for making plugins and C-compatible libraries
-
dir-test
macro to generate tests from files in a directory
-
doc-comment
Macro to generate doc comments
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
tsync
Generate typescript types from rust code
-
argyle
A lightweight, agnostic CLI argument parser
-
as_variant
macro to convert enums with newtype variants to
Options -
if_chain
Macro for writing nested
if letexpressions -
try_match
Fallible pattern matching with a function-like syntax
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
actify
An intuitive actor model with minimal boilerplate
-
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
document-features
Extract documentation for the feature flags from comments in Cargo.toml
-
test-strategy
Procedural macro to easily write higher-order strategies in proptest
-
optional_struct
defining a macro that will generate, from a structure, another structure with only Option<T> fields
-
const-random
compile time random number generation
-
result-like
Option/Result-like monad interface for your own enum
-
munge
Macro for custom destructuring
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
uniplate
boilerplate-free operations on tree-shaped data types
-
v_escape
The simd optimized escaping code with macro
-
swift-mt-message
A fast, type-safe Rust implementation of SWIFT MT message parsing with comprehensive field support, derive macros, and validation
-
fixed-hash
Macros to define custom fixed-size hash types
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
validit
Validate data structures internal state
-
include-flate
A variant of include_bytes!/include_str! with compile-time deflation and runtime lazy inflation
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
k9
rust testing library
-
cmn
121 mathematical, physical, and cryptographic constants for Rust — no_std, WASM-ready, compile-time const, typed runtime lookup, 14 utility macros
-
data-encoding-macro
Macros for data-encoding
-
cryptify
A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.
-
include_bytes_aligned
macro that embeds the bytes of an external file into the executable and guarantees that they are aligned
-
deriving_via
DerivingVia
-
macroforge_ts_syn
TypeScript syntax types for compile-time macro code generation
-
link-section
Low-level link-section macro support for Rust
-
marlin-verilog-macro-builder
🦀 No nonsense hardware testing in Rust 🛠️
-
sugars
An useful collection of macros to make tasks easier
-
wasmtime-internal-versioned-export-macros
INTERNAL: Macros for defining versioned exports in Wasmtime
-
ctor-lite
Run code at program startup or shutdown
-
fieldwork
derivable accessors for struct fields
-
cimpl
C implementations from Rust - FFI utilities and macros for creating safe, ergonomic C bindings
-
cans
An elegant and lightweight Rust-based literal template engine for managing web content, enhanced with a world module for streamlined regional and city information, as well as robust MIME type management
-
eventcore
Type-driven event sourcing library for Rust with atomic multi-stream commands
-
collection_literals
macros for initializing any collection
-
str-macro
The str!() macro, similar to vec![] but for strings
-
target-feature-dispatch
Easy dispatching by target features (both static and dynamic)
-
hypertext
A blazing fast type-checked HTML macro crate
-
pg_named_args
PostgreSQL named arguments
-
assert_approx_eq
assert approximately equal
-
turf
Build SCSS to CSS during compile time and inject those styles into your binary
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
valq
macros for querying semi-structured data with the JavaScript-like syntax
-
log_limit
A rate limiting logging crate
-
watt
Runtime for executing Rust procedural macros compiled as WebAssembly
-
jemmy
This package provides a coherent set of manual accessor macros
-
flyway
Flyway-rs project, Database change control,similar to flyway in Java
-
quote-use
Support
usein procmacros hygienically -
overload
macro to simplify operator overloading
-
proc-macro-tool
Some common simple tool for proc-macro impl
-
easy-macros
Toolkit for building Rust procedural macros + generating debug info
-
easy-sql
Macro-first SQL toolkit with compile-time checked queries, optional migrations on top of sqlx
-
macroforge_ts
TypeScript macro expansion engine - write compile-time macros in Rust
-
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
l10n
Opinionated localization library built upon fluent-bundle
-
nameof
macro to determine the string name of a binding, type, const, or function
-
mik-sdk
Ergonomic macros for WASI HTTP handlers - ok!, error!, json!
-
gelx
Generate fully typed rust code from your gel schema and inline queries
-
dioxus-use-js
A macro that generates Rust bindings to JavaScript or TypeScript functions, with compile time checks. For use with Dioxus.
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
declarative
Generic DSL macros for easy view code manipulation
-
spacetimedsl
The SpacetimeDB Rust Server Module meta-framework
-
zerocopy-derive
Custom derive for traits from the zerocopy crate
-
assume
Macro for stating unsafe assumptions in Rust
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
cascade
Dart-like cascade macro for Rust
-
clonelicious
macro library that simplifies cloning and closure execution. The
clone!macro automatically clones variables and immediately executes the closure with the cloned values, streamlining… -
impls
Determine if a type implements a logical trait expression
-
type-leak
Enable sharing type context beyond crate boundary
-
assert_tv
De-randomized detereministic tests with test-vectors
-
moveit2
safe, in-place construction of Rust (and C++!) objects
-
mkenv
Lightweight yet useful library to help you define the environment your app needs
-
vsra
The vsr command-line interface for very_simple_rest
-
auto_generate_cdp
experimental crate to generate the Chrome Devtools Protocol
-
spacetimedsl_derive-input
Contains structs which represent the input and output of SpacetimeDSL. Can be used by other proc-macro crates to build Macros which utilize SpacetimeDSL under the hood.
-
rustapi-validate
Type-safe request validation for RustAPI. Wrapper around the
validatorcrate with deep framework integration. -
sumtype
Generate zerocost sumtype of iterators or closures
-
tinyvec_macros
Some macros for tiny containers
-
metered
Fast, ergonomic metrics for Rust!
-
wrapper-lite
Helper macro for building a wrapper type and implementing common traits for it
-
inline-python
Inline Python code directly in your Rust code
-
fomat-macros
Alternative syntax for print/write/format-like macros with a small templating language
-
litext
Seamless proc-macro literal extraction
-
libc-print
println! and eprintln! macros on libc without stdlib
-
leptos-mview
A concise view macro for Leptos
-
tiny_bail
Small but flexible macros for bailing on failure
-
handle-this
Ergonomic error handling with try/catch/throw/inspect/finally syntax and automatic stack traces
-
jsonrpc-pubsub
Publish-Subscribe extension for jsonrpc
-
gstuff
Small macro and trinkets that make my life easier
-
loft
embedded scripting language
-
std-macro-extensions
A collection of macro extensions for Rust's standard library data structures, simplifying the creation and manipulation of common collections such as HashMap, Vec, and more
-
ioctl-sys
IO Control for POSIX-and-beyond systems (core fn & macros, see
ioctlsfor many ioctl definitions) -
tagset
Easily create trait-dispatching sum types
-
include-file
Include sections of files into Rust source code
-
atomic-dbg
Atomic
dbg/eprintln/eprintmacros -
sabry
Syntactically Awesome But RustY - crate that brings SCSS/SASS into rust
-
maudfmt
An opinionated yet customizable Maud formatter
-
match_opt
A macro for turning a partial match into a full match returning an option
-
cargo-build
Wrapper around cargo instructions accesible in
build.rswith better type safety and support for modern features. Includes functions by default. Macros are optional, but do provide… -
easy_prefs
simplest to use API we could think of to persist prefs to disk. Basically wrap a macro around a struct (see syntax), then data is saved when you write to it. Performant, testable, thread safe…
-
atlas-program-log
Lightweight log utility for Atlas programs
-
envstruct
Convert the environment variables into a structured configuration
-
vantus
Macro-first async Rust backend framework with explicit composition, typed extraction, and hardened HTTP defaults
-
steel-derive
Derive macros for use within steel
-
contained
works to provide several macros and interface for transparent wrapper types in Rust
-
benzina
Various helper types and macros for
diesel -
emboss
Macros to embed metadata as an ELF/Mach-O section in your final binary
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
sqlx-data
Zero-boilerplate Repository Pattern for modern Rust applications. Write SQL traits, get async implementations with sophisticated pagination, streaming, batch operations, and more. Seamlessly…
-
mcp-router
An MCP Router for the masses. Inspired by the myriad of difficult to use, limited use cased libraries currently available
-
saola-core
Core runtime traits and builders for the Saola type-safe ORM
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
rs-measures
macros to encapsulate numbers in measures, provided with units of measurement, allowing any meaningful operation, but statically forbidding meaningless operations with them
-
superstruct
Versioned data types with minimal boilerplate
-
preinterpret
An intuitive toolkit to simplify code generation development
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
light-magic
A lightweight, fast and easy-to-use implementation of a persistent and optionally encrypted in-memory database
-
defer
excecution of code, inspired by go's defer statement
-
cxx-qt-build
Helpers for integrating
cxx-qtcrate into a Cargo build -
error_mapper
standardized Results and Errors handling accross all your projects
-
mevy
A growing set of macros, which add witchcraft into bevy!
-
apigate
Macro-driven API gateway for Rust: declarative routing, request transformation, and reverse proxying built on axum
-
tree-type
Rust macros for creating type-safe filesystem tree structures
-
proc-macro-utils
low-level utilities on proc-macro and proc-macro2 types
-
include-sqlite-sql
A Yesql inspired macro for using SQLite SQL in Rust
-
maud-extensions
Component, inline CSS/JS, and font helper macros for Maud views
-
bevy-color-palettes
Color palettes for Bevy and egui, with macros for compile-time palette definitions, based on weirdboi_bevy_colour
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
hexga_map_on
Define the map_on! macro that can be used to impl a lot of trait quickly using macros
-
rest_macro_core
Core compiler and runtime support for very_simple_rest and the vsr CLI
-
sh-exec
Set of functions and macros to write more concise Rust scripts
-
newstr
macros for declaring String-base new types
-
quasiquodo
Compile-time quasi-quoting for typed languages
-
typesafe_repository
Abstract data persistence in a safe and unified way
-
buildstructor
Macro to derive a builder from a constructor function
-
unistructgen
A powerful Rust code generator
-
warpgate_pdk
Reusable WASM macros and functions for plugin developer kits
-
pud
Generate typed, composable, no-std-friendly modifications (“puds”) for Rust structs
-
txtpp
A simple-to-use general purpose preprocessor for text files
-
tampon
Specialized crate that contains SAFE Rust functions, macros and trait to serialize / deserialize data structure and/or object in packed bytes
-
more-convert
adds macros for various conversions
-
fyi_ansi
Compile-time ANSI formatting macros for FYI
-
multiple_errors
Propagate multiple errors instead of just the first one
-
dbgbb
A framework for analyzing debugging data in a Mathematica/Jupyter notebook
-
es-replay-macros-tests
Integration tests for es-replay-macros
-
borrowme
The missing compound borrowing for Rust
-
matched_enums
A macro that provides the option to bin enum attribute to match-statements. This makes it easier to convert values into enums.
-
negative-impl
Negative trait implementations on stable Rust
-
inline_csharp
Embed C# directly in Rust — evaluated at program runtime or at compile time
-
portfu
Rust HTTP Server Libary built Around Hyper.rs with Macros Similar to Actix
-
measures-rs
macro to generate a library to statically encapsulate numbers in objects having a unit of measurement, allowing any meaningful operation, but statically forbidding meaningless operations with them…
-
async-func
providing macros to simplify the creation of asynchronous closures with external state captured by move. Useful for structuring asynchronous code with ease and clarity.
-
pipeline-dsl
Pipeline DSL types and re-exports of #[pipeline]/#[stage]
-
shakespeare
An actor framework
-
common_hal_interface
A common interface between Rust HALs, for use in the Iron Coder IDE
-
axlog
Macros for multi-level formatted logging used by ArceOS
-
wasefire-one-of
Macros for mutually exclusive features
-
ax-log
Macros for multi-level formatted logging used by ArceOS
-
macro-toolset
Some useful macros
-
custom-format
Custom formatting for Rust
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
forge-rsx
macro library for declarative, JSX-like HTML generation. It allows you to write HTML structures with embedded logic, attributes, nested tags, loops, and more, directly in Rust code with a concise syntax.
-
forgeconf
Declarative configuration loader for Rust structs powered by attribute macros
-
sea-orm-typed-id
that provides a macro for generating type-safe database ID types for SeaORM
-
vacro
A progressive DevX framework for building Rust procedural macros. Painless parsing, visual debugging, and robust tooling.
-
prost-dto
Data transfer object conversion macros for prost
-
syn-grammar
A parser generator for Rust that compiles EBNF-like grammars into syn::parse::Parse implementations
-
trl
auto generation of some common methods based on Rust macros
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
schema
Access the schema for a Rust item
-
saying
The say! macro for convenient styled printing
-
atspi-common
Primitive types used for sending and receiving Linux accessibility events
-
errgonomic
Macros for ergonomic error handling with thiserror
-
arr_macro
Initialize arrays with ease!
-
entrait
Loosely coupled Rust application design made easy
-
decycle
Solve circular trait obligation
-
aethermapd
Privileged system daemon for aethermap
-
phf_macros
Macros to generate types in the phf crate
-
utmt
Unit Test Macros. Several tools and macros for unit test improving.
-
xopsy
Structural pattern matching DSL for JSON. Perform declarative diagnostics and surgical in-place updates on dynamic data.
-
print-break
debugging macro that pretty-prints variables and pauses execution
-
stackaroo
Swap out of the OS-provided stack
-
rustradio_macros_code
Macro code for rustradio
-
opeyml
A declarative, zero-overhead YAML surgery DSL for Rust
-
xopsyml
A high-performance, structural pattern-matching DSL for YAML. Perform declarative diagnostics and surgical in-place updates with zero-allocation.
-
axiomabuf
A 1-pass, zero-allocation static macro-router for Protocol Buffers
-
aoc-star
CLI tool to manage your Advent of Code solutions
-
spacetime-bindings-macro-input
Unofficial Input Crate for the SpacetimeDB Macro Bindings
-
path_macro2
Cross-platform path construction macro supporting both slash (/) and comma (,) syntax with variable interpolation
-
mongodb-internal-macros
Internal macros for the mongodb crate
-
weirdboi_bevy_colour
Colour palettes for Bevy, with macros for compile-time palette definitions
-
num-lazy
Number macros for generic-typed functions
-
ioctls
IO Control for POSIX-and-beyond systems (numerous ioctl specifications, see
ioctl-sysfor core functions & macros) -
leptos_styling
A powerful styling solution for Leptos applications that enables seamless integration of CSS and SCSS stylesheets with type-safe class names and zero runtime overhead
-
type-state-builder
Type-state builder pattern derive macro with compile-time safety and enhanced ergonomics
-
cmdparsing
adds a macro to parse arguments
-
include_tt
Macros for ultra-flexible injection of token trees, literals, or binary data into Rust code from external files during compilation
-
inline_java
Embed Java directly in Rust — evaluated at program runtime or at compile time
-
string_types
String newtypes
-
config-manager
build config from environment, command line and files
-
lerpable
a derive macro for combining ADTs
-
gen_ops
Macros for operator overloading for generic types
-
ax-crate-interface-lite
way to define an interface (trait) in a crate, but can implement or use it in any crate
-
auto_ops
Macros for easy operator overloading
-
armature-macros
Declarative macros for Armature framework
-
singlemap
rust single map a macro
-
tensorism
easy tensor manipulation on top of ndarray
-
functionality
Rust |> Functional programming = 💖. Useful traits, functions and macros for prettier code.
-
triblespace-macros-common
Shared implementation helpers for triblespace procedural macros
Try searching with DuckDuckGo.