-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
quote
Quasi-quoting macro quote!(...)
-
pin-project
safe and ergonomic pin-projection
-
lazy-regex
lazy static regular expressions checked at compile time
-
proc-macro2
A substitute implementation of the compiler’s
proc_macroAPI to decouple token-based libraries from the procedural macro use case -
ouroboros
Easy, safe self-referential struct generation
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
arrayref
Macros to take array references of slices
-
maud
Compile-time HTML templates
-
envconfig
Build a config structure from environment variables without boilerplate
-
assertables
assert macros for better testing, debugging, quality assurance, and runtime reliability
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
delegate
Method delegation with less boilerplate
-
multiversion
Easy function multiversioning
-
test-fuzz
fuzzing Rust easy
-
xflags
Moderately simple command line arguments parser
-
pastey
Macros for all your token pasting needs. Successor of paste.
-
syn-mid
Providing the features between "full" and "derive" of syn
-
bounded-integer
Bounded integers
-
swc_macros_common
Common utilities for swc macros
-
enclose
A convenient macro, for cloning values into a closure
-
getset
we're ready to go! A procedural macro for generating the most basic getters and setters on fields
-
tiny-fn
Type erased closures on stack
-
find-crate
Find the crate name from the current Cargo.toml
-
merge
multiple values into one
-
futures-async-stream
Async stream for Rust and the futures crate
-
safe-quote
Quasi-quoting macro quote!(...)
-
cglue
FFI safe abstractions for making plugins and C-compatible libraries
-
doe
powerful Rust crate designed to enhance development workflow by providing an extensive collection of useful macros and utility functions. It not only simplifies common tasks but also…
-
docify
allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
tsync
Generate typescript types from rust code
-
g2p
create types that implement fast finite field arithmetic
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
doc-comment
Macro to generate doc comments
-
dir-test
macro to generate tests from files in a directory
-
safe-proc-macro2
A substitute implementation of the compiler’s
proc_macroAPI to decouple token-based libraries from the procedural macro use case -
as_variant
macro to convert enums with newtype variants to
Options -
argyle
A lightweight, agnostic CLI argument parser
-
v_escape
The simd optimized escaping code with macro
-
document-features
Extract documentation for the feature flags from comments in Cargo.toml
-
try_match
Fallible pattern matching with a function-like syntax
-
test-strategy
Procedural macro to easily write higher-order strategies in proptest
-
binding_macros
Macros to build customized bindings interface
-
actify
An intuitive actor model with minimal boilerplate
-
error_set
Quick error declarations and automatic conversions between errors for precisely typed error handling. Inspired by Zig's error set type.
-
const-random
compile time random number generation
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
munge
Macro for custom destructuring
-
diplomat
FFI generation macro
-
cryptify
A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.
-
result-like
Option/Result-like monad interface for your own enum
-
optional_struct
defining a macro that will generate, from a structure, another structure with only Option<T> fields
-
validit
Validate data structures internal state
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
trybuild-internals-api
A fork of trybuild with the internals exposed as a public API
-
libc-print
println! and eprintln! macros on libc without stdlib
-
leptosfmt
view macro formatter CLI for the Leptos web framework
-
boilerplate
Minimal compile-time Rust template engine
-
data-encoding-macro
Macros for data-encoding
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
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
-
stageleft
Type-safe staged programming for Rust
-
quote-use
Support
usein procmacros hygienically -
libperl-macrogen
Generate Rust FFI bindings from C macro functions in Perl headers
-
include-flate
A variant of include_bytes!/include_str! with compile-time deflation and runtime lazy inflation
-
cmn
121 mathematical, physical, and cryptographic constants for Rust — no_std, WASM-ready, compile-time const, typed runtime lookup, 14 utility macros
-
uniplate
boilerplate-free operations on tree-shaped data types
-
if_chain
Macro for writing nested
if letexpressions -
include_bytes_aligned
macro that embeds the bytes of an external file into the executable and guarantees that they are aligned
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
ctor-lite
Run code at program startup or shutdown
-
k9
rust testing library
-
deriving_via
DerivingVia
-
wasmtime-internal-versioned-export-macros
INTERNAL: Macros for defining versioned exports in Wasmtime
-
jsonrpc-pubsub
Publish-Subscribe extension for jsonrpc
-
fieldwork
derivable accessors for struct fields
-
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
-
cimpl
C implementations from Rust - FFI utilities and macros for creating safe, ergonomic C bindings
-
str-macro
The str!() macro, similar to vec![] but for strings
-
macroforge_ts_syn
TypeScript syntax types for compile-time macro code generation
-
eventcore
Type-driven event sourcing library for Rust with atomic multi-stream commands
-
collection_literals
macros for initializing any collection
-
metastruct
Abstractions for iterating and mapping over struct fields
-
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
target-feature-dispatch
Easy dispatching by target features (both static and dynamic)
-
pg_named_args
PostgreSQL named arguments
-
sugars
An useful collection of macros to make tasks easier
-
hypertext
A blazing fast type-checked HTML macro crate
-
overload
macro to simplify operator overloading
-
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
-
flyway
Flyway-rs project, Database change control,similar to flyway in Java
-
valq
macros for querying semi-structured data with the JavaScript-like syntax
-
log_limit
A rate limiting logging crate
-
proc-macro-tool
Some common simple tool for proc-macro impl
-
jemmy
This package provides a coherent set of manual accessor macros
-
dioxus-use-js
A macro that generates Rust bindings to JavaScript or TypeScript functions, with compile time checks. For use with Dioxus.
-
l10n
Opinionated localization library built upon fluent-bundle
-
rust-i18n-cli
cargo-i18n tool for the rust-i18n crate
-
mac
A collection of great and ubiqutitous macros
-
impls
Determine if a type implements a logical trait expression
-
auto_generate_cdp
experimental crate to generate the Chrome Devtools Protocol
-
nameof
macro to determine the string name of a binding, type, const, or function
-
embedded-interfaces
Traits for common embedded interfaces and procedural macros for effortless definition of registers and commands for embedded device drivers
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
assert_tv
De-randomized detereministic tests with test-vectors
-
declarative
Generic DSL macros for easy view code manipulation
-
type-leak
Enable sharing type context beyond crate boundary
-
gelx
Generate fully typed rust code from your gel schema and inline queries
-
spacetimedsl
The SpacetimeDB Rust Server Module meta-framework
-
cascade
Dart-like cascade macro for Rust
-
genemichaels
Makes your code formatty
-
assume
Macro for stating unsafe assumptions in Rust
-
mik-sdk
Ergonomic macros for WASI HTTP handlers - ok!, error!, json!
-
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
-
macroforge_ts
TypeScript macro expansion engine - write compile-time macros in Rust
-
assert_approx_eq
assert approximately equal
-
mkenv
Lightweight yet useful library to help you define the environment your app needs
-
warpgate_pdk
Reusable WASM macros and functions for plugin developer kits
-
inline-python
Inline Python code directly in your Rust code
-
sumtype
Generate zerocost sumtype of iterators or closures
-
tinyvec_macros
Some macros for tiny containers
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
handle-this
Ergonomic error handling with try/catch/throw/inspect/finally syntax and automatic stack traces
-
rustapi-validate
Type-safe request validation for RustAPI. Wrapper around the
validatorcrate with deep framework integration. -
leptos-mview
A concise view macro for Leptos
-
metered
Fast, ergonomic metrics for Rust!
-
litext
Seamless proc-macro literal extraction
-
easy-macros
Toolkit for building Rust procedural macros + generating debug info
-
saola-core
Core runtime traits and builders for the Saola type-safe ORM
-
wrapper-lite
Helper macro for building a wrapper type and implementing common traits for it
-
easy-sql
Macro-first SQL toolkit with compile-time checked queries, optional migrations on top of sqlx
-
fomat-macros
Alternative syntax for print/write/format-like macros with a small templating language
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
defer
excecution of code, inspired by go's defer statement
-
contained
works to provide several macros and interface for transparent wrapper types in Rust
-
sabry
Syntactically Awesome But RustY - crate that brings SCSS/SASS into rust
-
passerine
A small extensible functional scripting language designed for concise expression with little code
-
ioctl-sys
IO Control for POSIX-and-beyond systems (core fn & macros, see
ioctlsfor many ioctl definitions) -
scouter-macro
Macro utilities for scouter
-
tagset
Easily create trait-dispatching sum types
-
pipeline-dsl
Pipeline DSL types and re-exports of #[pipeline]/#[stage]
-
tiny_bail
Small but flexible macros for bailing on failure
-
mevy
A growing set of macros, which add witchcraft into bevy!
-
bit-struct
Define structs which have fields which are assigned to individual bits, not bytes
-
atomic-dbg
Atomic
dbg/eprintln/eprintmacros -
loft
embedded scripting language
-
maudfmt
An opinionated yet customizable Maud formatter
-
session_log
session log library for Rust
-
moveit2
safe, in-place construction of Rust (and C++!) objects
-
buildstructor
Macro to derive a builder from a constructor function
-
envstruct
Convert the environment variables into a structured configuration
-
steel-derive
Derive macros for use within steel
-
benzina
Various helper types and macros for
diesel -
light-magic
A lightweight, fast and easy-to-use implementation of a persistent and optionally encrypted in-memory database
-
vsra
The vsr command-line interface for very_simple_rest
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
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…
-
vantus
Macro-first async Rust backend framework with explicit composition, typed extraction, and hardened HTTP defaults
-
include-file
Include sections of files into Rust source code
-
rustapi-openapi
Native OpenAPI 3.1 specification generator for RustAPI. Integrates Swagger UI.
-
superstruct
Versioned data types with minimal boilerplate
-
rs-measures
macros to encapsulate numbers in measures, provided with units of measurement, allowing any meaningful operation, but statically forbidding meaningless operations with them
-
preinterpret
An intuitive toolkit to simplify code generation development
-
fixtura
Declarative fake data injection for Rust tests. Built on fake-rs.
-
maud-extensions
Component, inline CSS/JS, and font helper macros for Maud views
-
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… -
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
bevy-color-palettes
Color palettes for Bevy and egui, with macros for compile-time palette definitions, based on weirdboi_bevy_colour
-
guarden
Zero-cost abstractions for scoped guards, deferred execution, and async task detachment
-
include-sqlite-sql
A Yesql inspired macro for using SQLite SQL in Rust
-
proc-macro-utils
low-level utilities on proc-macro and proc-macro2 types
-
gstuff
Small macro and trinkets that make my life easier
-
tree-type
Rust macros for creating type-safe filesystem tree structures
-
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… -
hexga_map_on
Define the map_on! macro that can be used to impl a lot of trait quickly using macros
-
rmcp-macros
Rust SDK for Model Context Protocol macros library
-
wip
providing traits and macros to use while developing Rust code
-
match_opt
A macro for turning a partial match into a full match returning an option
-
pud
Generate typed, composable, no-std-friendly modifications (“puds”) for Rust structs
-
tampon
Specialized crate that contains SAFE Rust functions, macros and trait to serialize / deserialize data structure and/or object in packed bytes
-
typesafe_repository
Abstract data persistence in a safe and unified way
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
dbgbb
A framework for analyzing debugging data in a Mathematica/Jupyter notebook
-
sh-exec
Set of functions and macros to write more concise Rust scripts
-
quasiquodo
Compile-time quasi-quoting for typed languages
-
gpui-macros
Macros used by gpui
-
polyvers
Single-macro schema versioning for Rust: declare a struct family with #[add]/#[edit]/#[delete] mutations across versions and parse them at runtime without serde(flatten) overhead. Optional binary codecs: rkyv…
-
emboss
Macros to embed metadata as an ELF/Mach-O section in your final binary
-
fyi_ansi
Compile-time ANSI formatting macros for FYI
-
apigate
Macro-driven API gateway for Rust: declarative routing, request transformation, and reverse proxying built on axum
-
borrowme
The missing compound borrowing for Rust
-
actorizor
macro based actor framework for Tokio-based apps
-
axlog
Macros for multi-level formatted logging used by ArceOS
-
macro-toolset
Some useful macros
-
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.
-
more-convert
adds macros for various conversions
-
error_mapper
standardized Results and Errors handling accross all your projects
-
utmt
Unit Test Macros. Several tools and macros for unit test improving.
-
jaarg
It can parse your arguments you should use it it's called jaarg
-
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.
-
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
-
negative-impl
Negative trait implementations on stable Rust
-
common_hal_interface
A common interface between Rust HALs, for use in the Iron Coder IDE
-
gpui_refineable
A macro for creating 'refinement' types that can be used to partially initialize or mutate a complex struct
-
mcp-router
An MCP Router for the masses. Inspired by the myriad of difficult to use, limited use cased libraries currently available
-
newstr
macros for declaring String-base new types
-
ax-log
Macros for multi-level formatted logging used by ArceOS
-
schema
Access the schema for a Rust item
-
custom-format
Custom formatting for Rust
-
txtpp
A simple-to-use general purpose preprocessor for text files
-
saying
The say! macro for convenient styled printing
-
multiple_errors
Propagate multiple errors instead of just the first one
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
errgonomic
Macros for ergonomic error handling with thiserror
-
sea-orm-typed-id
that provides a macro for generating type-safe database ID types for SeaORM
-
forgeconf
Declarative configuration loader for Rust structs powered by attribute macros
-
decycle
Solve circular trait obligation
-
trl
auto generation of some common methods based on Rust macros
-
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…
-
gen_ops
Macros for operator overloading for generic types
-
vacro
A progressive DevX framework for building Rust procedural macros. Painless parsing, visual debugging, and robust tooling.
-
smol-macros
Macros for setting up a smol runtime
-
blf_lib
Multi-purpose Blam-File library
-
atspi-common
Primitive types used for sending and receiving Linux accessibility events
-
entrait
Loosely coupled Rust application design made easy
-
unistructgen
A powerful Rust code generator
-
rust_code_obfuscator
easily obfuscate strings and control-flow using cryptify lib
-
shakespeare
An actor framework
-
phf_macros
Macros to generate types in the phf crate
-
arr_macro
Initialize arrays with ease!
-
print-break
debugging macro that pretty-prints variables and pauses execution
-
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
-
xopsy
Structural pattern matching DSL for JSON. Perform declarative diagnostics and surgical in-place updates on dynamic data.
-
reunroll
Tail-recursive loop unroller
-
tupa-core
Core types and pipeline definition macro for Tupã
-
rest_macro_core
Core compiler and runtime support for very_simple_rest and the vsr CLI
-
rpm-spec-profile
Distribution profiles for the RPM spec analyzer: identity, macros, rpmlib features, whitelists
Try searching with DuckDuckGo.