Lib.rs

syn

Parser for Rust source code

proc-macro-error

Almost drop-in replacement to panics in proc-macros

derive_more

Adds #[derive(x)] macros for more traits

quote

Quasi-quoting macro quote!(...)

strum

macros for working with enums and strings

proc-macro-crate

Replacement for crate (macro_rules keyword) in proc-macros

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.

synstructure

Helper methods and macros for custom derives

wasm-bindgen-macro-support

part of the implementation of the #[wasm_bindgen] attribute that is not in the shared backend crate

unicode-ident

Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31

leptos_hot_reload

types used for dev mode and hot-reloading for the Leptos web framework

expander

Expands proc macro output to a file, to enable easier debugging

macro_magic

Allows the exporting and importing of the tokens of items across module, file, and crate boundaries

derive_utils

procedural macro helper for easily writing derive macros for enums

ctor

__attribute__((constructor)) for Rust

frunk_proc_macro_helpers

Common internal functions for frunk's proc macros

enum_dispatch

Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed

windows-bindgen

Windows metadata compiler

serde_tokenstream

serde deserializer for proc_macro::TokenStreams

proc-macro2

substitute implementation of the compiler’s proc_macro API to decouple token-based libraries from the procedural macro use case

syn-serde

serialize and deserialize Syn syntax trees

displaydoc

derive macro for implementing the display Trait via a doc comment and string interpolation

databake

Trait that lets structs represent themselves as (const) Rust expressions

proc-macro2-diagnostics

Diagnostics for proc-macro2

rstml

templating for XML-based formats (HTML, SVG, MathML) implemented on top of proc-macro::TokenStreams

r2r

Easy to use, runtime-agnostic, async rust bindings for ROS2

proc-macro-warning

Emit warnings from inside proc macros

derive-new

#[derive(new)] implements simple constructor functions for structs and enums

unicode-id-start

Determine whether characters have the ID_Start or ID_Continue properties according to Unicode Standard Annex #31

structmeta

Parse Rust's attribute arguments by defining a struct

attribute-derive

Clap for proc macro attributes

docify

allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples

delegate

Method delegation with less boilerplate

swift-bridge-ir

Holds the data structures and logic for bridge module parsing and code generation

spl-discriminator-syn

Token parsing and generating library for the spl-discriminator library

diesel-derive-enum

Derive diesel boilerplate for using enums in databases

getset

we're ready to go! A procedural macro for generating the most basic getters and setters on fields

maybe-async

procedure macro to unify SYNC and ASYNC implementation

derive_builder_core

Internal helper library for the derive_builder crate

rusty-bind-parser

Parses Rust module, generates Rust code with C ABI bindings and C/C++ header files and Swift gluecode

paste

Macros for all your token pasting needs

vercel_runtime_router

Vercel Rust Function Runtime Router

smart-default

custom-derive macro for Default with more control on the fields

enum-as-inner

proc-macro for deriving inner field accessor functions on enums

safe-proc-macro2

fork of proc_macro2 crate with unsafe code removed

specr-transpile

Converts Specr lang code to Rust

rustfmt-wrapper

wrapper around rustfmt for use by code generators

ra_ap_proc-macro-srv-cli

TBD

rb-sys-build

Build system for rb-sys

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.

pmutil

Utils for proc-macro

protobuf-build

functions for generating Rust code from protobufs (using protobuf-rust or Prost)

server_fn_macro

RPC for any web framework

dbg-pls

Syntax aware pretty-printing debugging

manyhow

proc macro error handling à la anyhow x proc-macro-error

asn1-compiler

ASN.1 Toolkit in Rust. Compiler for ASN.1 specification, ASN.1 codecs and derive macros for ASN.1 Codecs.

derive-getters

boilerplate getters generator

proc_macro_roids

Traits and functions to make writing proc macros more ergonomic

concat-idents

Allows concatenating multiple identifiers and using them everywhere

necessist-frameworks

call2-for-syn

Apply parser functions to proc-macro2 token streams

rustfmt_if_chain

if_chain-aware rustfmt (kind of)

syn-mid

Providing the features between "full" and "derive" of syn

napi-derive-backend

Codegen backend for napi procedural macro

charybdis

High-Performance ORM for ScyllaDB

derive-adhoc

ergonomic way to write derive() macros

template-quote

new-fasioned quote! macro implementation with pretty template-engine like syntax

genemichaels

Makes your code formatty

aquamarine-demo-crate

demo crate for aquamarine -- the mermaid.js integration for rustdoc

venial

very small syn

synthez

Steroids for syn, quote and proc-macro2 crates

ra_ap_project_model

TBD

pax-language-server

Language Server for Pax Language

hydroflow_lang

Hydroflow's Surface Syntax implementation

proc-quote

procedural macro implementation of quote!

macro_railroad

generate syntax diagrams for Rust macros

dioxus-rsx

Core functionality for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences

proc-macro-rules

Emulate macro-rules pattern matching in procedural macros

catalytic_table_to_struct

Table mapper for the ORM for Scylla, fully compatible with Apache Cassandra™

clap_derive

Parse command line argument by defining a struct, derive crate

gotcha

enhanced web framework based on actix-web

frunk_derives

contains the custom derivations for certain traits in Frunk

parse-variants

Derive the syn::parse::Parse trait for enumerations and use it to comfortably parse a variant of the enumeration

datafusion-python

Apache Arrow DataFusion DataFrame and SQL Query Engine

ambassador

Trait implementation delegation via procedural macros

test-generator

Test generator: enumerating entries according to file-system pattern and generating a test function for each entry

unique-type-id

unique id proc-macro generator for types

is-macro

Easily create methods for to use yout custom enum like Option / Result

self-rust-tokenize

Turns instances of Rust structures into a token stream that creates the instance

macroex

extractor based low level macro parsing crate that provides high level parsing support through derive macros

amplify_syn

Amplifying syn capabilities: helper functions for creating proc macro libraries

derive_setters

macro to automatically generates setter methods for a struct's fields

impl-tools

Helper macros: autoimpl

good-ormning

Maybe an ORM

syn-inline-mod

Inlines modules in Rust source code for source analysis

syn-file-expand-cli

CLI tool to read full source code of multi-file crates and output it to stdout

as_derive_utils

private derive utilities used by abi_stable and structural

packed_struct_codegen

implements the code generation for the packed_struct library

utoipauto

Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase

subcli

Component Generation Tool for FRAME Pallets in the Substrate Framework

cstr

Macro for building static CStr reference

scyllax-macros-core

Core macro impl for scyllax

machine-check

Formal verification tool for digital systems

rustifact

seamless bridge between a build script and the main crate

stilts-lang

parser for stilts

timelang

DSL (Domain Specific Language) and grammar for parsing and rendering human-readable date/time and duration values

dynasm

plugin for assembling code at runtime. Combined with the runtime crate dynasmrt it can be used to write JIT compilers easily.

yew_icons

Easily include a variety of SVG icons into your Yew app

relm-gen-widget

relm-attributes and relm-derive

fluent_web

SFC frontend web framework for rust!

com_macros_support

Support library for COM crate macros

pest-ast

Derive to convert from pest parse tree to typed syntax tree

deno-proc-macro-rules

Deno fork of proc-macro-rules. Emulate macro-rules pattern matching in procedural macros

quote-use

Support use in procmacros hygienically

askama_shared

Shared code for Askama

napi_sym

proc macro for writing N-API symbols

devise_core

devising derives and other procedural macros

structstruck

Nested struct and enum definitions

reflect

"but I thought Rust doesn't have reflection?" memorial brand new way of defining procedural macros

syn-rsx

syn-powered parser for JSX-like TokenStreams

swift-bridge-build

Parse Rust files for swift-bridge modules and generate the corresponding Swift and C code for them

derive_more_preview

Adds #[derive(x)] macros for more traits

terrars

Terraform in Rust

string_cache_codegen

codegen library for string-cache, developed as part of the Servo project

static-graph

Generate static parallel computation graph from DSL at compile time

prql-compiler-macros

Macros for PRQL compilation at build time

wadl

parser for Rust

symbols

Proc-macro utility to populate enums from database data

rand_derive2

Generate customizable random types with the rand crate

twust

Static checker for tailwindcss class names in rust for rust

napi-derive

N-API procedural macros

prometheus-static-metric

Static metric helper utilities for rust-prometheus

extendable-data

set of rust macros that allows you to specify data that can be "extended" or inherited from

catalytic_query_parser

Query parser for the ORM for Scylla, fully compatible with Apache Cassandra™

algoliasearch

Algolia client

derive-attr-parser

Very simple parser for proc macro attributes

butane_core

Internals for Butane. Do not use this crate directly -- use the butane crate.

r18-trans-support

r18 translation support

schema

Access the schema for a Rust item

impl-trait-for-tuples

Attribute macro to implement a trait for tuples

inator

Optimal zero-copy parsers with nondeterministic finite automata

bflib

BrainFuck-to-Rust transpiler using Rust proc macro

leptosfmt-formatter

view macro formatter for the Leptos web framework

versionize_derive

Implements the Versionize derive proc macro

log-once

Collection of helper macros for logging some events only once

gensym

Creates unique identifiers for macros using procedural macros

derive-sql

Structure the interaction with SQL database - currently only SQLite via trait and a procedural macro

ra_ap_load-cargo

TBD

swc_config_macro

Macros to prevent mistakes

workflow-macro-tools

Macro utility functions used by the workflow-rs framework

prost-derive

Protocol Buffers implementation for the Rust Language

windows-implement

implement macro for the windows crate

burrtype

framework for exporting types to other languages

flamer

procedural macro to insert flame::start_guard(_) calls

conjure-codegen

code generation for Conjure definitions

macroific

Proc macro development utilities

macroific_attr_parse

Attribute parsing utilities for the macroific crate

schemars_derive

Macros for #[derive(JsonSchema)], for use with schemars

swc_trace_macro

Proc macro for performance trace of swc

membrane_types

companion crate for membrane

fn-error-context

attribute macro to add context to errors from a function

safe-quote

fork of quote crate that adds forbid(unsafe_code) and depends on safe-proc-macro2 instead of proc-macro2

chandeliers-san

AST definition and static analysis procedures of Candle

gsettings-macro

Macro for typesafe GSettings key access

serde-enum-str

Serialize and deserialize enum string

product-os-store

Product OS : Store provides a flexible and higher-level framework for defining storage engines / database engines and the actions to read and write to those storage engines / databases…

prettier-please

minimal syn syntax tree pretty-printer

notation_dsl

Fun notation - DSL to create notation files

introspect-core

containing the core functionality used for introspect and supporting crates

clippy-tracing

add, remove and check for tracing::instrument in large projects where it is infeasible to manually add it to thousands of functions

re_types_builder

Generates code for Rerun's SDKs from flatbuffers definitions

struct_baker

enable ergonomic creation of compile time parsers

contracts

Design-by-contract attributes

strum_macros

macros for working with enums and strings

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.

penum

enum conform to a given pattern

fv-template

Field-value based string templating

portrait-framework

Framework for implementing portrait fillers

scroll_derive

macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate

EnumBitFlags

EnumBitFlags is an implementation of flags support for enums

syn-path

macro to declare a syn::Path at compile time

zerocopy-derive

Custom derive for traits from the zerocopy crate

syn-impersonated

Parser for Rust source code

ambient_project_macro_common

Common implementation of a proc-macro that generates boilerplate from an ambient.toml

deluxe-core

Core traits and helpers for Deluxe procedural macro attribute parser

autophagy

AOT compiler for Rust

pio-proc

proc-macro for assembling PIO code in a Rust program at compile time

depends_core

Ergonomic, performant, incremental computation between arbitrary types

positional

author/parse positional files

modus_ponens

develop forward chaining inference engines

bomboni_prost

working with prost. Part of Bomboni library.

find-crate

Find the crate name from the current Cargo.toml

syn_builder

Builder functions for syn structures and enums to ease the generation of Rust code

curve25519-dalek-derive

curve25519-dalek Derives

cali_cli

Cali's codegen and cli application

chandeliers-lus

Procedural macros for the Chandeliers project, implementing a deep embedding of Lustre in Rust

necessist-core

const_gen_proc_macro

Create proc macro that adds compile time functionality for the creation of constants

jsonrpc-derive

High level, typed wrapper for jsonrpc-core

do-with-in-base

template language for Rust metaprogramming using partial staging

pest_tree

Convert output from pest parser into statically typed trees

macro_types

easier to create procedural macros

diesel_as_jsonb

your structs as Jsonb with diesel and PG

sqlparser_derive

proc macro for sqlparser

fortuples

Procedural macros to generalize inherent and trait implementations over tuples

token_stream2

better TokenStream for procedural macros

tslink

Creates typescript definitions based on rust code

surreal_derive_plus

Query builder for surrealdb

wasmtime-versioned-export-macros

Macros for defining versioned exports in Wasmtime

derive_util

tools for derive macros

custom_attrs

that allows you to configure values specific to each variants of an enum

savvy-bindgen

Parse Rust functions, and generate C and R code

ni-fpga-interface-build

Provide the ability to access an NI FPGA application from Rust

validator_types

Basic type for validator and validator_derive

glory-hot-reload

types used for dev mode and hot-reloading for the Glory web framework

dmacro

define C-like debug trace macro: enter!() and leave!()

test-shisho-policy-sdk

SDK of Shisho Cloud policies to write your custom policies in Rust

crud-api-endpoint

CLI generator for your API. Enpoint description

argp

Derive-based argument parser optimized for code size

property

Generate several common methods for structs automatically

hw-msg

my style of CLI messaging

python-ast

compiling Python to Rust

r2r_msg_gen

Internal dependency to the r2r crate

serde_derive

Macros 1.1 implementation of #[derive(Serialize, Deserialize)]

subenum

proc-macro to create subsets of enums, that can be converted to and from

dlopen2_derive

Derive macros for the dlopen2 crate

sea-bae

proc-macro attribute parser

polkavm-derive

derive crate for PolkaVM guest programs

bae

proc-macro attribute parser

wiki-tui

easy to use Wikipedia Text User Interface

forwarding_gen

Syntax processing for emulating OOP Inheritance in Rust by forwarding trait methods

opendp_tooling

Tooling for proc-macros and code generation

async-fn-stream

Lightweight implementation of async-stream without macros

debug3

Space Efficient Pretty Printer

fn-decorator

contains macros for implementing wrapper functions around member or static functions

form

small script to move inline modules into the proper directory structure

proc-macro-assertions

Easily create asserts on proc macro inputs

to_and_fro

Proc macro for generating implimentations of Display and FromStr for Enum Variants

qsync

Generate react-query hooks for your rust backend (see https://github.com/Wulf/create-rust-app)

just-convert

Easy conversion of structures

hydroflow_datalog_core

Datalog implementation for Hydroflow

rkyv-with

Third-party derive macro for rkyv's *With traits

bnf_rules_parser

LR(1) parser generator

frunk-enum-derive

Derive macros to implement the frunk::LabelledGeneric trait on enums

prkorm

procedural macro that simplifies the creation of mysql queries for fields in your Rust structs. It comes with SELECT, INSERT, UPDATE, DELETE operations with JOINS, SUBQUERIES and other complex queries.

procmacro2

substitute implementation of the compiler’s proc_macro API to decouple token-based libraries from the procedural macro use case

proc_macro2_helper

Various utility code to extract data that can be used with proc macro2

syn-pub-items

Parser for Rust source code (patched for pub items)

agb_xm_core

converting XM tracker files for use with agb-tracker on the Game Boy Advance. You shouldn't use this package directly

enum-try-as-inner

proc-macro for deriving inner field accessor functions on enums

transitive

derive macros for Rust

rustc-ap-rustc_expand

Automatically published version of the package rustc_expand in the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github…

trait_info_gen

Procedural macros for obtaining Trait information at compile time

casey

Case transforming macros for ident tokens

noggin

declarative, zero-copy, proc-macro based HTTP header parser

test_each_file

Generates a test for each file in a specified directory

derive-syn-parse

Derive macro for syn::parse::Parse

destructure

Automation of Destructure Pattern

typeshare-core

code generator used by Typeshare's command line tool

place_macro

Macros you wish you had while you were writing your non-proc macro

macro-field-utils

work with darling fields

postgres-parser

llvm-based safe wrapper for PostgresSQL's query parser. Currently based on v13

easyfix-messages-gen

Easy FIX (Financial Information Exchange) toolset - messages generator

onlytypes-core

Core functionality for onlytypes-rs

dbcc

Compiles data base CAN (dbc) files into Rust code

sqlxinsert

Sqlx derive macro for simpler inserts

unsafe_target_feature

more convenient #[target_feature] replacement

enum-display-derive

Display trait's custom derive for simple enums

littest

Let's encrypt your string statically during compile time

ra_ap_proc_macro_api

TBD

sidetree

TUI file tree for usage with terminal text editors

ext_format

small, yet powerful, Rust crate for string interpolation

yew-alt-html

Alternative macro for building Html in Yew

chatdbg_macros

Rust-specific (macro) support for ChatDBG (https://github.com/plasma-umass/chatdbg)

protokit_build

Usable protocol buffers

frc42_macros

Filecoin FRC-0042 calling convention procedural macros

fire

fire implementation for rust

lombok

port for Rust

dioxus-core-macro

Core macro for Dioxus Virtual DOM

db-rs-derive

macros for db-rs

watt-non-static-runtime

Runtime for executing Rust procedural macros compiled as WebAssembly

syn-miette

syn::Error wrapper that provides pretty diagnostic messages using miette

iconify

Proc-macros for generating icons from the Iconify API

no-panic

Attribute macro to require that the compiler prove a function can't ever panic

macros-utils

macros crate

openssl-macros

Internal macros used by the openssl crate

generate_sql

Generate SQL according to struct

mm_example_crate

part of macro_magic

syn-file-expand

load full source code of multi-file crates

perfect-derive

prototype of the proposed perfect_derive macro

fixedlength-format-parser

Build parsers for files with fixed length, record-like fields

inarybay

Graph-based binary format (de)serializer generator

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

cbit

proc-macro to use callback-based iterators with for-loop syntax and functionality

mem_dbg-derive

Procedural macros for mem_dbg

import-modules

based on require-all

sunbeam-ir

Sunbeams intermediary types used to parse and generate CSS

razy-importer-macros

Proc macros for razy-importer

ethbind-rust

official rust language generator for ethbind

jl-sys

contains the generated bindings for the Julia C API used by jlrs

unroll

attribute-like procedural macro for unrolling for loops

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.

syn_derive

Derive macros for syn::Parse and quote::ToTokens

disjoint_impls

Support for a variety of mutually disjoint implementations

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.

custom_debug_derive

Derive Debug with a custom format per field

canadensis_macro

procedural macro that generates Rust data types and serialization code from inline and/or external Cyphal DSDL files

pilota-build2

Compile thrift and protobuf idl into rust code at compile-time

zolt-macros

Macros for the 'zolt' crate

stardom-nodes

simplistic reactive web UI library

doc_consts

get doc comments on fields as runtime constants

racc

port of Berkeley YACC to Rust, and allows you to write grammar definitions directly in Rust source code

temp

procedural macro to manage temporary variables

prometheus-macros

Macros for declaring prometheus metrics

actix-multipart-derive

Multipart form derive macro for Actix Web

easy_proc

Helper macros for making proc macros

avocado-schema-derive

derive macro to support runtime reflection of struct values

default-with

Fill a struct that cannot implement Default with the remaining fields initialized with Default::default

derive-into-owned

Custom derives to help with types containing Cow fields

schemafy

Generates serializeable Rust types from a json schema

edgedb-query-derive

that provide a bunch of attribute macros that help to build EdgeDB query using edgedb-tokio crate

small_ctor

minimal, dependency free version of the ctor crate

convert_by_name

Derive From and Into for structs and enums based on field and variant names

diesel_sqltype_enum_pg

Diesel automatic derivation of FromSql and ToSql for enums with SqlType generated by diesel and taking ToString and FromStr as base. Postgres binding only

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.

better-debug

cooler, and sane Debug macro

env-extract

Extracts environment variables into Strings or Enums

auto-rust

automatically generate Rust code using LLMs at compilation time

message_macro_derive

macro to generate/parse binary representation of messages

saunter-derive

Proc macros for the Saunter crate

mono-macro

Force monomorphizing on functions with share-generics to minimalize binary size

quote2

alternative lightweight version of quote

ambient_element_component

Helper procedural macro for the Ambient runtime that converts a function to an ElementComponent, allowing for more concise definitions of components

syn-select

lightweight selector engine for searching Rust source code

micro_games_macros

macros to make it easier to build complex systems with Bevy

set_builder

procedural macro to create Iterators over a set defined by Haskell-inspired set-builder notation

time_this

two macros to quickly time functions for debugging purposes

ormlitex-attr

See ormlitex

fsmentry-core

Finite State Machines with an entry API and data storage

impl_index

Macro for deriving the Index trait

surrealdb_functions

procmacro for surrealdb functions (fn::*)

typemarker

Procedural macro for easily creating multiple linked marker types

memoeyes

Procedural macros for automatic memoization

ucc

Universal compiler invocator for heterogeneous CPU/GPU computation applications

bevycheck

bevy error messages by proc-macro

absolution

‘Freedom from syn’. A lightweight Rust lexer designed for use in bang-style proc macros.

katexit

Insert KaTeX autorender script into rustdoc

utoipa_auto_discovery

Macros to automate the addition of Paths/Schemas to Utoipa crate, simulating Reflection during the compilation phase

fn_overloads

Create functions with varying arguments and return types. Please don't use this.

panic_discard

proc-macro that discards panics that happen within a function

schemafy_lib

Generates serializeable Rust types from a json schema

eywa

helpers toolkit to make programs more simply

cpy-binder

when creating binds from Rust to C++ and Python

bddap-aoc-macros

Procedural macros used and re-exported by the bddap-aoc crate

windows-interface

interface macro for the windows crate

enumorph

Derive macro to generate TryFrom and From implementations for converting between newtype enum variants and their wrapped values

chalk-derive

helper crate for use by chalk crates for derive macros

debugger_test

proc macro for writing tests that launch a debugger and run commands while verifying the output

envtime

Runtime and compile time environment resolution for Rust

gherkin_rust

pure Rust implementation of the Gherkin (.feature file) language for the Cucumber testing framework

autoget

macro to generate getters for structs

asn1_codecs_derive

ASN.1 Codecs derive Macros

redis-macros-derive-bincode

Derive macros to serialize/deserialize structures with bincode to store in redis

pm-lexer

sample lexer using the proc-macro crate, to be used in the pomelo testings

behavior

macro checks like behavior in elixir

c-like-concat

macro that works just like C's ##

zbus-lockstep-macros

Macros to keep types in lockstep with DBus XML definitions

tiaojian-macro

conditional compile proc-macro

pgrx-pg-sys

Generated Rust bindings for Postgres internals, for use with 'pgrx'

dict_derive

Derive macros for some PyO3 traits to convert python dicts into rust structs

bevy_ergo_plugin

Macros to make building bevy plugins more ergonomic

derive_deref

Adds #[derive(Deref)] and #[derive(DerefMut)]

mwt

proc macros for generating mut and non-mut methods without duplicating code

enum-kinds

Generate enums with matching variants but without any of the associated data

neli-proc-macros

Procedural macros for neli

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

text-image

proc-macro to generate raw image from text and a font file, for embedded-graphics

merge-cfg

Merge or cover config based on priorities

decolor

Asynchronous runtime abstractions for implicit function decoloring

primwrap

Derive operation traits for primitive wrapper structs

mockers_macros

Compiler plugin for 'mockers' mocking library

introspect-proc-macros

Procedural macros for introspect

sleigh2rust

Transpile Ghidra Sleigh parser into rust

envhead

build environment variable names using a static prefix. Works great with the popular clap crate.

testing_unit

unit testing library

derive_hub

proc-macro for a simple actor framework

edict-proc-lib

Procedural macros library for edict

better

rustcoed make better

awesome-glib

Bunch of macros to make a life of gtk/glib user easier

fully_pub

Macro that makes multiple items or fields public at once

more-syn-types

parsing Rust Standard Library macros

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.

postgres-syntax

Compile-time syntax checking of PostgreSQL queries

default2

Default implementation using macros

xladd-derive

macro that helps write Excel UDF functions in Rust