-
zerocopy
zero-copy parsing and serialization
-
ra_ap_stdx
TBD
-
ra_ap_hir_expand
TBD
-
compiler_builtins
Compiler intrinsics used by the Rust compiler. Also available for other targets if necessary!
-
ra_ap_hir_def
TBD
-
ra_ap_hir_ty
TBD
-
ruva
Event Driven Message Handling
-
ra_ap_span
TBD
-
ra_ap_limit
TBD
-
expunge
redact and transform struct fields declaratively
-
box_raw_ptr
providing safe wrappers for working with raw pointer. These raw pointers are
*const T
and*mut T
. These wrappers ensure memory safety by encapsulating the raw pointers in safe abstractions… -
rustrict
profanity filter for Rust
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
composer-primitives
primitives types for composer
-
nz
Collection of 100% safe macros for creating non-zero integers type more easily
-
auto-currying
Automatically implement Curry for callable types such that they are curried functions
-
padder
Highly efficient data and string formatting library for Rust
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
savvy-bindgen
Parse Rust functions, and generate C and R code
-
equator
Composable assertion library
-
rsor
Reusable slice of references
-
light_ranged_integers
similar to ranged_integers, but working on a stable compiler version
-
soa-rs
A Vec-like structure-of-arrays container
-
labview-interop
Types and wrappers for interperating with LabVIEW when called as a library
-
cprint
Cargo-like print
-
structz
Anonymous struct implementation in rust
-
conjure-object
Runtime support for generated Conjure objects
-
kittycad-execution-plan
A DSL for composing KittyCAD API queries
-
tokio-postgres-generic-rustls
rustls-backed TLS for tokio-postgres without a required crypto backend
-
cast_checks
A procedural macro to check for invalid casts
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
variadiz
Variadic function support for rust
-
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
emplacable
Return unsized values from functions
-
confgr_core
A collection of traits used by the confgr derive macro
-
cast_checks_convert
-
crosstrait
Cast from
dyn Any
to other trait objects, with no_std, no alloc support -
prima_bridge
implement the bridge pattern
-
univec
A vector that can hold elements of any single type
-
atomic_float
Floating point types which can be safely shared between threads
-
transitive
derive macros for Rust
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
confgr
application configuration derive macro
-
gilder
Golden testing library
-
aws-sdk-elasticloadbalancing
AWS SDK for Elastic Load Balancing
-
arrow_convert
Convert between nested rust types and Arrow with arrow
-
using
A macro for simpler builders with method cascading
-
owned_ref_cell
offering a custom RefCell variant with owned references for flexible and dynamic borrowing management
-
airbag
handling errors and panics using 3rd party services
-
maelstrom-test
Test macros for Maelstrom
-
zellij-tile
A small client-side library for writing Zellij plugins
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
tor-basic-utils
General helpers used by Tor
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
dylint_linting
writing Dylint libraries
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
tor-async-utils
Async/futures helpers for use with Tor
-
nu-std
The standard library of Nushell
-
extensor
the main extensor crate for building arbitrary valent tensors and more
-
nanoval
A nan-tagged value for representing f64, i32, u32, booleans, null and arbitrary pointers
-
glib
Rust bindings for the GLib library
-
iter-n
functions returning impl Iterator to return one of several distinct types
-
into_index
Helper traits allowing indexing into vectors and similar types by other types than
usize
-
com-scrape-types
Support code for bindings generated with com-scrape
-
scale-typegen
Type Generation for SCALE encoded Rust Types
-
golem-rust
Golem Rust tooling library that facilitates writing Golem backends in Rust
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
prost-unwrap-core
A procedural macro implementation for prost-unwrap library
-
algtype
Conversion between data and its representation, like Haskell Generic
-
ort_custom_op
writing custom operators for the onnxruntime in Rust
-
count_enum
Enum trait for finite types, e.g., conversion with usize, iteration on values
-
value-bag-sval2
detail for value-bag
-
tuppipe
pipe operator-like implementation using tuples in Rust
-
matreex
matrix implementation
-
swift-bridge-build
Parse Rust files for swift-bridge modules and generate the corresponding Swift and C code for them
-
dittolive-ditto-sys
Native bindings to Ditto library
-
terminator
Formatter for pretty panics and errors
-
c-emit
Polished builder API to write C Code
-
mini-config
Minimalistic Dynamic Configuration Library for Rust
-
bump-scope
A bump allocator with support for scopes
-
thin-boxed-slice
ThinBoxedSlice
stores the size of the slice before the content of the slice, so thatsize_of::<ThinBoxedSlice>
is only the size of a pointer -
mem_dbg
Traits and associated procedural macros to display recursively the layout and memory usage of a value
-
cynic-codegen
Procedural macro code generation for cynic - a code first GraphQL client for Rust
-
prost-unwrap-transform
A procedural macro container for prost-unwrap library
-
prompt-organizer
better manage AI prompts in your Rust code
-
cynic-querygen
Generates code for using cynic from GraphQL query input
-
break-block-macro
A little syntactic sugar to tide us over until the
?
operator can be used to exit try-catch scopes -
partial_derive2
makes all the properties of a struct type an optional property
-
static_cell
Statically allocated, initialized at runtime cell
-
oco_ref
A smart pointer for storing immutable values with relatively-cheap cloning. (Like a
Cow
meets anRc
!) -
volatile
wrapper types for raw pointers
-
tlkit
Tool Kit integration
-
async-recursion
Recursion for async functions
-
enumerable
helping you to enumerate all possible values of a type
-
cronus_parser
The DSL parser for cronus API spec
-
pretty-readme
Macro to make using a README.md file as the root module documentation easy, seamless, and testable
-
roadblk
Validator integration
-
tighterror
A minimalistic error representation framework
-
thiserror-ext
Useful extension utilities for
thiserror
-
materially
A macro for material implication
-
elicit
SmartPointer-like structure for polymorphism
-
hooks
Compile-time, async hooks
-
add_macro
adds the some useful macros for easily work
-
eule
Async generic serialization crate with a minimal interface
-
size
expressing, formatting, and interacting with file sizes
-
sosecrets-rs
Secret
wrapper type that reveals the secret at mostMEC: typenum::Unsigned
times with compile time guarantees -
filterable-enum
generating filterable enums (Combining bitflags and discriminated unions)
-
parsel
Zero-code parser generation by using AST node types as the grammar
-
cew
Personal Rust utility library
-
null-kane
currency crate with the option to add your own currency localization logic
-
racros
Collection of rust macros
-
xx
A collection of useful Rust macros and small functions
-
studs
collection of extenstions to the Rust standard library
-
dicom-object
A high-level API for reading and manipulating DICOM objects
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
async-fn-stream
Lightweight implementation of
async-stream
without macros -
thiserror
derive(Error)
-
cargo_toml
Cargo.toml
struct definitions for parsing with Serde -
aerosol
dependency injection for Rust
-
indices
Zero allocation macros and methods for retrieving multiple mutable indices from a mutable slice safely
-
TSPL
The Simplest Parser Library
-
floating-ui-utils
Rust port of Floating UI. Utilities for Floating UI.
-
doc-chunks
Clusters of doc comments and dev comments as coherent view
-
acme-core
core library for the Acme project. It contains the core primitives that are used throughout the project.
-
xwt-error
A suite of reusable error types that naturally emerge from the xwt API. Use when you don't want/need your own more precise types
-
tyco
Macro for generating scoped TYped COntexts
-
dto_mapper
create dynamic DTOs (Data Transfer Object) from a structure
-
type-safe-id
A type-safe, K-sortable, globally unique identifier
-
rustc_span
Reuse rustc_span for compiler_base
-
cfgenius
Conditional compilation with macro support in Rust
-
preprocess
Preprocesses a struct with built-in preprocessors
-
pared
Projected reference counted pointers
-
graphannis-capi
C-API to the ANNIS linguistic search and visualization system
-
wext
web-sys extension traits, convenience functions and types
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
taskchampion-lib
Personal task-tracking
-
forward-traits
A general trait-forwarding crate
-
option_trait
Helper traits for more generalized options
-
fancy-default
A better
derive(Default)
implementation -
irox-types
Enums and structs to describe Rust's basic type system
-
advise
User-friendly status reporting
-
rustdoc-types
Types for rustdoc's json output
-
prefixes
Attribute-like macros imitating literal prefixes, e.g. #[f]"Hello, {world}"
-
human-panic
Panic messages for humans
-
nolife
open a scope and then freeze it in time for future access
-
zip_clone
Zip an iterator to a repeately cloned object
-
aprox_eq
determining aproximate equality between floating point types and deriving this capability to structs comprised of floating point numbers and other implementers of
AproxEq
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
pareg
useful tools for command line argument parsing
-
macro_rules_rec
Expand syntax of
macro_rules
to enable self recursive call -
typed-builder
Compile-time type-checked builder derive
-
oi-unwrap
unwrap without unwrap
-
corlib
A various ideas library
-
pegination
cursor pagination
-
pingora-error
Error types and error handling APIs for Pingora
-
linker-set
Declarative programming via linker-constructed arrays
-
dyn-error
Macros for dynamic errors
-
atc-router
Versatile DSL based rule matching engine used by the Kong API Gateway
-
libc-print
println! and eprintln! macros on libc without stdlib
-
rangecutter
working with adjacent ranges
-
frunk_utils
working with frunk
-
windows-syscall
Windows inline syscalls for Rust
-
anony
Anonymous struct
-
polars-utils
Private utils for the Polars DataFrame library
-
typenum-consts
Procedural macros that take a literal integer (or the result of an evaluation of simple mathematical expressions or an environment variable whose value is a literal integer) and convert…
-
phnt
Rust bindings to the System Informer’s (formerly known as Process Hacker)
phnt
native Windows headers -
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
serror
serialize anyhow errors into json format
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
strongly
A proc macro to create strongly-typed primitives
-
error_set
An error set macro that provides a concise way to define errors and ergonomically coerce between sets. Inspired by Zig's error set type.
-
twitch_types
common types for Twitch
-
iri-string
IRI as string types
-
apply_conditionally
Chain and apply methods on objects conditionally
-
aide
A code-first API documentation library
-
typle
Generic tuple bounds and transformations
-
pyo3-polars
Expression plugins and PyO3 types for polars
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
numtest
Unit testing for numerical methods
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
typed-builder-macro
Compile-time type-checked builder derive
-
ex_em_ell
Provide macros for serializing and deserializing XML
-
termal_core
contains implementation for the termal library
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive
-
tiny-ordered-float
Tiny version of OrderedFloat
-
buffered-reader
A super-powered Reader
-
async-trait
Type erasure for async trait methods
-
aeruginous
Open Source Development Toolbox
-
dyncast
Downcasting made easy
-
bit_roles
Granular role management based on bit flags
-
anyhow
Flexible concrete Error type built on std::error::Error
-
windows-targets
Import libs for Windows
-
generic-statics
generic statics for rust
-
itsuki
macro that defines a simple zero-based sequential enum
-
bty
Streamlined definition and usage of branded types in Rust
-
build-deftly
Derive custom builders, using the derive-deftly macro system
-
functor_derive
A derive macro to derive a functor for a type
-
funkjon
One of the worst macros this world has ever been (dis)graced with
-
okey
Everything is Result::Ok
-
erdp
display an error and its nested errors
-
io-extra
An extension trait for
std::io::Error
, with shorthand constructors for variousstd::io::ErrorKind
s -
fmu_from_struct
A derive macro for automatically setting up FMU models in Rust
-
ownedbytes
Expose data as static slice
-
gitoxide-core
implementing all capabilities of the gitoxide CLI
-
negative-impl
Negative trait implementations on stable Rust
-
allem
Generate useful variants for your custom types
-
bitfield
macros to generate bitfield-like struct
-
unc-chunks-primitives
hosts UNC chunks-related error types
-
unc-client-primitives
hosts UNC client-related error types
-
cstr8
string types that are both valid UTF-8 and nul-terminated
-
unc-stdx
contains polyfills which should really be in std, but currently aren't for one reason or another
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!
,include!
, orconcat_idents!
) -
cplex-rs
Binding of IBM Cplex library
-
re_tuid
128-bit Time-based Unique Identifier
-
split_exact
splitting strings into arrays of slices
-
re_error
Helpers for handling errors
-
amass
Automatically generate
From
impls for nested enums, even across crates -
re_query
Querying data in the re_data_store
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
yash-builtin
built-in utilities of yash
-
pinned-init
facilitate safe pinned initialization
-
field_iterator
A derivable trait for iterating over the fields of a struct
-
tantivy-common
common traits and utility functions used by multiple tantivy subcrates
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
egui-probe
Trait and derive macro for exposing value editing in egui
-
orx-split-vec
An efficient constant access time vector with dynamic capacity and pinned elements
-
sugar_path
Sugar functions for manipulating paths
-
backon
Retry with backoff without effort
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
orx-pinned-vec
PinnedVec
trait defines the interface for vectors which guarantee that elements added to the vector are pinned to their memory locations unless explicitly changed -
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
re_string_interner
string interning library
-
crates-io-macro-crate
An example macros-by-example crate for demonstrating a regression
-
rustc_errors
Reuse rustc_errors for compiler_base
-
with_builtin_macros-proc_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!
,include!
, orconcat_idents!
) -
tremor-common
Tremor common functions
-
nutype
The newtype with guarantees
-
multiple_errors
Propagate multiple errors instead of just the first one
-
axotag
share tag-parsing code between axodotdev projects
-
rustversion
Conditional compilation according to rustc compiler version
-
macon
builder macro-based generator with its own idioms
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
documented
Traits and derive macros for accessing your type's documentation at runtime
-
compiler-test-derive
A macro to generate easily tests across compilers and engines
-
untry
Kind of the opposite of the ? operator
-
trait-tactics
Macros that provide common patterns for implementing traits in terms of other traits
-
macon_api
builder macro-based generator with its own idioms
-
compiler_base_macros
-
validated
The cumulative sibling of
Result
andEither
-
lexactivator
SDK for Rust
-
proc-bitfield
expressively declare bitfield-like structs
-
rdb-pagination
SQL query extension library for handling pagination and sorting in relational databases
-
rustpython-literal
Common literal handling utilities mostly useful for unparse and repr
-
stdont
Kitchen sink of utils that I'd like to see in std
-
exhaustive
The trait for generating all values of a type, and a property-based test macro
-
bevy_reflect
Dynamically interact with rust types
-
nutype_macros
The newtype with guarantees
-
dioxus-html
HTML Element pack for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
nanokit
A collection of tiny, reusable utility methods that reduce code size and improve performance
-
horfimbor-eventsource
an eventsource implementation on top of eventstore
-
hermit-sync
Synchronization primitives for kernels
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
refined_type
imbuing rules into types and elevating them to more robust types
-
defer-rs
Deferred execution Rust utilities
-
jkcenum
Rust enum library
-
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
jget
Rust tools
-
slice-utils
A collection of slice utils, like itertools
-
stdext
Extensions for the Rust standard library structures
-
slice_adapter
help share slice between thread
-
cel-interpreter
An interpreter for the Common Expression Language (CEL)
-
safelog
Conditionally suppress confidential information from logs
-
cmdstruct
A lightweight macro for implementing commands with a struct
-
qm-utils
functions and macros
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
retry-error
An error type for an operation that can fail more than once
-
fracpack
Convert to and from the fracpack format
-
iter_accumulate
An iterator adaptor that accumulates the elements and yields the current accumulated value for each iteration
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
ironcalc_base
The democratization of spreadsheets
-
egui_struct
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
thisisplural
#[derive(Plural)] for creating frictionless new types with any collection type like Vec or HashMap
-
kube-core
Kube shared types, traits and client-less behavior
-
ffi_types
C ABI compatible wrappers for cbindgen/bindgen
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
const-sub-array
Extract a fixed size sub-array out of an array with complie-time length and offset checks
-
leptos-mview
A concise view macro for Leptos
-
flip-flop
implements the flip-flop operator from Perl and Ruby as a Rust macro
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
golangify
published at 01.04.2024 this crate brings familiar flavor for newcomers from golang
-
rrplug
framework for R2Northstar plugins
-
try-iterator
Adds a few fallible methods to iterators
-
liftor
Functors for Rust lifetimes
-
byondapi
Idiomatic Rust bindings for BYONDAPI
-
socketpair
Cross-platform socketpair functionality
-
io-streams
Unbuffered and unlocked I/O streams
-
char-device
Character Device I/O
-
rancor
Scalable and efficient error handling without type composition
-
tstr
Type-level strings
-
ascent_base
support library for the ascent package
-
memoffset
offset_of functionality for Rust structs
-
by_address
Wrapper for comparing and hashing pointers by address
-
entrait
Loosely coupled Rust application design made easy
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
layered-io
I/O traits extending Read and Write
-
io-extras
File/socket handle/descriptor utilities
-
leptos_datatable
A leptos component for creating tables with data validation
-
processmanager
manage process lifecycles, graceful shutdown and process faults
-
rustrix
Supports macro and basic operations for matrix
-
cargo-manifest
Helper crate to parse and manipulate manifests -
Cargo.toml
files -
conerror
macro that automatically adds context to errors
-
reaktor
Reaktor
-
fiberplane-pdk
Fiberplane Provider Development Kit
-
error-ext
Error utilities
-
rudi
out-of-the-box dependency injection framework for Rust
-
instancebuilder
Convenient way of managing dependency injection
-
reductor
Generic abstractions for combining and nesting reduction patterns for iterables
-
onechatsocial-result
Revolt Backend: Result and Error types
-
o2o
Object to Object mapper for Rust. Derive 'From' and 'Into' traits.
-
bytes
Types and traits for working with bytes
-
entrait_macros
Procedural macros reexported by entrait
-
named-tup
Create named tuples using the tup!() macro
-
qcontext
One-time initializable static state with statically-checked zero-cost interior mutability
-
indoc
Indented document literals
-
enum-rotate
Rotate and iterate your enums
-
wrappr
A libary for some useful wrapping traits
-
array-as-struct
ergonomic "field" accesses on array types
-
dolby_vision
Dolby Vision metadata parsing and writing
-
kusprint
A set of macros for printing objects to stdout without having to specify a template literal
-
hexavalent
Write HexChat plugins in Rust
-
dyn-hash
Hash trait that is object-safe
-
borrow-or-share
Traits for either borrowing or sharing data
-
meritrank2
Meritrank library with additional experimental functions
-
rst-common
A shortcut to common Rust crates
-
a1_notation
A package for converting to and from A1 spreadsheet notation
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
bitflags
A macro to generate structures which behave like bitflags
-
valido
An extensible Rust validation library that actually encourages the "Parse, don't validate" philosophy
-
i18n_utility-rizzen-yazston
The
i18n_utility
crate of the Internationalisation project -
activity-vocabulary-core
Core types to represent ActivityStreams 2.0 types
-
i18n_provider-rizzen-yazston
The
i18n_provider
crate of the Internationalisation project -
i18n_lexer-rizzen-yazston
The
i18n_lexer
crate of the Internationalisation project -
i18n_localiser-rizzen-yazston
The
i18n_localiser
crate of the Internationalisation project -
i18n-rizzen-yazston
The
i18n
crate of the Internationalisation project -
enumcapsulate
Safe casting for newtype enums and their variants
-
error_handling
Macro used to clean and centralize error handling within async processes
-
once-option
OnceOption
type, similar toOption
, with the constraint that once emptied it cannot be re-set to contain a value. Useful for members that need to be consumed on drop or cannot be re-set otherwise (e… -
kittycad-execution-plan-traits
Types for KittyCAD execution plans
-
bool_ext
defines and implements a complete set of
Option
/Result
-style Boolean functional combinators on Rust’sbool
primitive type -
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
ahqstore-types
Standard types used by AHQ Store
-
simpl_cache
caching tools
-
cpr_bf
A brainfuck interpreter
-
cargo-cabal
that helps you to turn in one command a Rust crate into a Haskell Cabal library
-
assert-eq-float
assert_eq_float!
macros that support floats -
k8s-openapi-ext
Collection of fluent builder traits for Kubernetes objects
-
arrow-array
Array abstractions for Apache Arrow
-
primitive-from-enum
macros for get primitive enum from complex
-
teo-teon
Object notation for Teo
-
bash-builtins
implement loadable builtins for bash
-
more_io
Additional functions to read and write as primitive types
-
crevice
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
typers
Type level programing
-
flagged
Bitflag-based warning type
-
summum-types
A sum-type macro crate with all the conversions, accessors, and support for abstract methods across variants, and interoperability between sum-types
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
derive_destructure2
Destructure structs that implement Drop
-
surreal_devl
Contains core logic of surreal derive
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
trait-variant
working with impl traits in Rust
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
sodium
FRP (Functional Reactive Programming)
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
count-to-non-zero
Extends Rust’s Iterator trait to include a
count_to_non_zero
method, returning an Option for a more expressive and type-safe way of counting elements. This crate provides… -
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
i-codegen-code
Common tools supporting the
derive-codegen
crate -
more-itertools
python more-itertools
-
testresult
type for concise and precise test failures
-
anxious
panic-free dialect of Rust
-
cl-format
Use Common Lisp format in Rust
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
derive_constructors_proc
Deriving From, TryFrom and create new_with_*args* functions
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
bitty_write_macro
A drop-in
write!
replacement that optimizes non-formatting writes for code size -
snafu
An ergonomic error handling library
-
components-arena
creating complex domain-specific self-referential data structures
-
frayed
Unfused and unashamed iterators
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
constructor-lite
Generate minimal constructors for structs
-
phantom-type
A
PhantomData
analog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData
-
refined-float
Refined float with a subset of functions of std float
-
genies
整合DDD与Dapr 兼容基于 Eventuate 的Java 项目
-
value-box
Allows developers to pass Rust-allocated structures over ffi
-
cfg_rust_features
Set cfg options according to probing for Rust compiler, language, and library features
-
genz
Uniqueness of types via invariant lifetimes
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
validify
struct validation and modification functionality through the use of derive macros
-
devela
A cohesive Rust development layer
-
actify
An intutive actor model with minimal boilerplate
-
rsclp
A lib crate to parse proccess arguments
-
surrealdb-extras
additional functionality for working with SurrealDB
-
explicit-endian
Transparent traits to explicitely declare in-memory endianness for a virable or struct record
-
lazy_thread_local
Lazily initialised per-object thread-local storage
-
qbdi-sys
QBDI library rust binding (use rust bindgen)
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
dyn-context
mechanism for lifetimes erasing
-
quasi_iter
that contains supplementary iterator objects and methods
-
shopify_function
write Shopify Functions in Rust
-
pin-project
safe and ergonomic pin-projection
-
libloading
Bindings around the platform's dynamic library loading primitives with greatly improved memory safety
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
ribbons
unwrapping
Option
andResult
types with a formatted error message. (less boilerplate thanunwrap_or_else
) -
gandiva_rust_udf_common
A basic library for gandiva rust udf macro
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
nbio
Non-Blocking I/O
-
blanket
macro to derive blanket implementations for your traits
-
const-random
compile time random number generation
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
radiation
Convert Rust type into raw bytes and vice versa
-
array_ex
Easy and powerful compile-time array initialization
-
k8s-controller
lightweight framework for writing kubernetes controllers
-
irox-enums
Traits for better Enumerated Types
-
prev-iter
Iterator which allows you to view the previous element
-
shared_singleton
trait provides singleton pattern state management with shared container
-
oxydized-money-macros
Companion library to oxydized-gains providing convenience macros
-
mist-pdk
mist plugin development kit
-
opaque-debug
Macro for opaque Debug trait implementation
-
zconvertenumn
Convert number to enum
-
nonempty
Correct by construction non-empty vector
-
local-type-alias
Local type aliases in impl blocks
-
ucsi
SI-based unit typing system
-
smallvec-wrapper
Macro and common structs to play with
smallvec
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
variadics
Variadic generics on stable Rust using tuple lists
-
constcat
concat! with support for const variables and expressions
-
glam-traits
Traits for the vectors in glam
-
pusherator
Push-based version of Rust iterators
-
get-field-by-type
Get a value of field, based on the type of a field
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
unwind-context
Macro to add colored panic context to your functions
-
even_bigger_s
Better String Literal
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
typestr
type-level strings and slices
-
pythonic-helper
that provides Python-like functions (and some surprises)
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
error-code
Error code
-
dyn-clone
Clone trait that is object-safe
-
derive-enum-from-into
Derive for From and TryInto for enums with single fields
-
generics
macros for parsing generics (with optional where clause) in
macro_rules!
-
enumnvictorhowisers
Convert number to enum
-
tupley
Extension for primitive tuple (Hlist based on recursive structure)
-
derive-debug-extras
More customisable #[derive(Debug)]
-
soapy
Structure-of-arrays derive macro
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
cfg-if-edc
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.
-
document_validator
A small library to help you implement document validation
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
typify-impl
typify backend implementation
-
eiffel-macros
Eiffel is a library for Eiffel language inspired guard clauses with Rust macros. This is the macro rules part of the library.
-
typify
JSON schema to rust type code generator
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
custom_float
Custom floating-point types
-
thiserror-nostd-notrait
derive(Error)
-
darling
A proc-macro library for reading attributes into structs when implementing custom derives
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
vitasdk-sys
Raw bindings to vitasdk
-
struct_scheme
structure scheme display
-
snowflaked
creating and working with snowflake ids
-
bellframe
Fast and idiomatic primitives for Change Ringing
-
sitrep
Frontend-agnostic progress reporting
-
type_enum
Create tagged unions consisting of different types
-
easify
Development tools. Includes various helper functions and proc-macros to simplify your code and boost your development
-
deptypes
Dependent types
-
extism-pdk
Extism Plug-in Development Kit (PDK) for Rust
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
intern-all
A safe and predictable interner for data of mixed and arbitrary type
-
auto-delegate
Auto delegate allows you that automatic impl of traits and delegate their handling to child members
-
dyn_size_of
report approximate amount of memory consumed by variables, including the memory allocated on heap
-
ffi-closure
Send and recevie closures through FFI
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
rustc_utils
working with the Rust compiler
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
awint_macro_internals
Internal macro utilities for the
awint
system of crates -
http-request-derive
Use derive to create HTTP requests
-
static_option
An option type that is statically known to be Some or None
-
swipl
A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications
-
entrypoint
opinionated application framework/wrapper that eliminates main function boilerplate
-
rcss-layers
Part of Rust CSS embedding library that allows saving styles as seperate layers
-
retry_durations
generates a duration iterator for [retry] crates
-
derive_convert
Derives 'impl (Try)From for Self' and 'impl (Try)From<Self>'
-
dddk_macro
Derive macro lib for dddk_core
-
atomic_ref_box
Box with thread-safe, immutable weak references
-
also_sync
Macros to automatically wrap async functions as sync
-
zerror
error interface for context-aware error-reporting
-
canpack
Canpack Rust utilities
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
mmap-append
Append-only memory-mapped I/O, resizable, with low lock contention
-
devela_depend
Optional external dependencies for
devela
-
zerror_core
A complete implementation of the zerror:Z trait
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
pathext
A small path trait extension with some convenience methods
-
tiago_functions
Algumas funções para uso externo
-
smarterr
Smart error handling library
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
seoul
trait Isomorphism
-
ref_wrapper
Wrapper of dynamically borrowed data
-
attr_alias
Reduce attribute repetition with aliases
-
macro-bits
performing macro-based bit manipulation
-
enumflags2
Enum-based bit flags
-
octseq
Abstractions for types representing octet sequences
-
trait-make
working with impl traits in Rust
-
tynm
Returns type names in shorter form
-
derive_builder_macro
Rust macro to automatically implement the builder pattern for arbitrary structs
-
easy_retry
easy to use retry library for Rust
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
runtime-contracts
Structured, understandable runtime contracts
-
netherite
A tokio implementation of the Minecraft Protocol with derive macros
-
frunk_laws
contains laws for algebras declared in Frunk
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
easy_node
Smart pointer for graph nodes
-
openai-magic-instantiate
Use LLMs to instantiate well-typed values
-
turbostate
Finite State Machine
-
try_convert
Auto-generate TryFrom and an error type, with minimal boilerplate
-
similarity
calculating similarity between numerical slices
-
onlyerror
Obsessively tiny error derive macro
-
openapiv3-extended
data structures that represent the OpenAPI v3.0.x specification easily deserializable with serde
-
enum-display
A macro to derive Display for enums
-
bparse
parsing bytes
-
mapstruct
Create refactor safe derivatives of Structs with proc-macros
-
e
Provide some utility tools
-
binf
that adds utilities for dealing with binary flags
-
garde-fr
Validation library
-
e_macro
A module for e library, it provides some utility macros for Rust
-
staged-builder
A proc macro which generates staged builders for types
-
kuchikiki
(口利き) HTML tree manipulation library
-
achan
& convenient representation for any value
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
combin-iterator
Some usefull facilities for combining iterators
-
mutually_exclusive_features
Macros to check that only none or one of a set of features is enabled at a time, as known as mutually exclusive features
-
interning
Thread-Lcoal and Global Interning Library
-
rhizo-types
A collection of common Structs and Enums used in the software components that comprise the Rhizo network
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
cached_field
Proc macro to cache associate function result on strut field. An analogy to python's @cached_property class decorator.
-
c-enum
A macro to generate c-like enums
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
lines_lossy
extension to
BufRead
with a functionlines_lossy
that works likeBufRead::lines
but with lossy UTF-8 decoding -
partial-context
Partial Context Types
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
anygma
makes it easy to define arrays containing different types
-
clone_box
convenience macro for casting to parent object-trait by cloning
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
cryptify
A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.
-
i18n_pattern-rizzen-yazston
The
i18n_pattern
crate of the Internationalisation project -
lbr-prelude
LambdaBuffers runtime library for the Prelude schema
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
bounded-collections
Bounded types and their supporting traits
-
audiotags-macro
macros used during the development of audiotags
-
orchestra
Generate an orchestra of subsystems from a single struct
-
autosurgeon
working with data in automerge documents
-
import_file_macro
Macro from compile-time file loading
-
panda-re
The official library for interfacing with PANDA (Platform for Architecture-Neutral Dynamic Analysis)
-
rs-measures
macros to encapsulate numbers in measures, provided with units of measurement, allowing any meaningful operation, but statically forbidding meaningless operations with them
-
defer
excecution of code, inspired by go's defer statement
-
error-info
Centralized error information ready for internationalization
-
macroquest
Write MacroQuest plugins in Rust
-
beetle-nonzero
Combines the std
NonZero
structs into one struct -
oxi-types
Rust bindings to types used by Neovim's C API
-
tc-error
TinyChain's generic error struct
-
semval
Semantic validation
-
auto_enums
allow multiple return types by automatically generated enum
-
tupperware
Storage traits for your types
-
html_tag
An Enigmatic Way to use HTML in Rust
-
inventory
Typed distributed plugin registration
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
derive_variants
derives an additional enum from a nested enum that contains only variants and no nested fields
-
vmm
A math library focused on vectors and square matrices
-
nonicle
Tools for type-safe, canonical data representations
-
serde_literals
Support for serialising and deserialising literals directly into enum unit variants
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
bezier_easing
port of Gaëtan Renaudeau's bezier-easing from https://github.com/gre/bezier-easing
-
panic-analyzer
an audit tool to scan your crate or workspace searching for potential panic points in your codebase
-
include_data_uri
include a file as a data uri
-
pyadvreader
Split text file into text sequences, strings and (line) comments
-
string-config-parser
configuration file parser for Rust
-
lexi-matic
A Lexer Library
-
wtflip
A language in a Rust macro... or something.
-
ouroboros
Easy, safe self-referential struct generation
-
cowstr
Copy-on-Write shared strings
-
base64_type
type wrapper for Vec<u8> that uses base64 for serialization
-
iterator-sorted
Stable functions for checking iterator sorting
-
tiny-fn
Type erased closures on stack
-
rusty_helloworld
Mastering Rust, step by playful step.Rusty_Helloworld is your one-stop shop for exploring the diverse landscape of Rust through practical examples. Whether you're a beginner diving…
-
async-time-mock-async-std
Mockable time for use in async runtimes (async-std compatibility)
-
fuzed-iterator
Iterator wrapper for detecting incorrect use of non-fused iterators
-
polimorphism
Function overloading via a procedural macro
-
shank_gov_idl
Converts information extracted via shank derive macros to a solita compatible IDL
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
auto-builder
A derive macro to implement the builder pattern for any struct
-
hot_reload
Trait and service definition of periodic hot reloader and notifier for config-file, KVS, etc
-
slicemath
element-wise operations on arrays of numeric values
-
type-sets
Sets implemented in the rust type-system
-
dummy-alloc
Global allocator that fails all allocations
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
htmxpress
Procedural macros for generating htmx strings
-
wei-result
wei result
-
default-impl
A macro for implementing traits with their default implementations
-
whiskers-widgets
Dynamic UI sub-system for whiskers
-
cap-std-ext
Extension APIs for cap-std
-
smol_str
small-string optimized string type with O(1) clone
-
predicates
boolean-valued predicate functions
-
plexer
A Pattern-matching LEXER
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
partial-result
results that return success for non-critical errors
-
virtue
A sinless derive macro helper
-
iter-comprehensions
iterator comprehensions
-
flaky_test
atttribute macro for running a flaky test multiple times
-
static_assertions_next
Compile-time assertions to ensure that invariants are met
-
rand-gen
Allows for easy creation of random data for structs!
-
tlua
Zero-cost high-level wrapper for Tarantool-LuaJIT
-
fi2b
Convert floating point and integer numbers into bytes and put them into an array
-
yup-hyper-mock
testing clients using hyper
-
userfaultfd
Rust bindings for the Linux userfaultfd functionality
-
mat-rs
no_std implementation of mathematical matrix types
-
structx
Simulating anonymous struct and named arguments in Rust
-
collect_array_ext_trait
Collect an iterator into an array
-
gdnative_export_node_as_path
Boilerplate-code replacement macros when exporting node references through NodePath
-
tracks-hust
A way to embed Rust into HTML code and use it wherever you'd like
-
hust-macro
A way to embed Rust into HTML code and use it wherever you'd like
-
simple_scan
Iterator extensions for simple scan operation
-
scope-exit
The util to call procedure when exit current scope. scope exit. like defer in go.
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
any_cmp
Support dynamic type comparisons
-
page-turner
A generic abstraction of APIs with pagination
-
derive_default_builder
derives a builder implementation relying on all fields implementing Default
-
mongo_indexed
derive macro to declaratively index mongo collections
-
recursion
cache-aware stack safe recursion
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
struct-metadata
Macros for attaching metadata to structs
-
internal
fields in Rust
-
recvmsg
Traits for receiving datagrams reliably, without truncation
-
aquamarine-demo-crate
A demo crate for aquamarine -- the mermaid.js integration for rustdoc
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
itermacros
Some useful macros related to iterators
-
io-arrays
Random-access I/O
-
type-factory
unique opaque types
-
gamo
A Range like struct for user defined types
-
culpa
error-handling syntax in Rust
-
open-ambient
Open files and directories with constant paths
-
pyo3io-macros
I/O utilities bindings for PyO3
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
simple-mermaid
Mermaid diagrams RustDoc integration
-
mutify
Macro for coercing a
mut var: T
orvar: &mut T
into a&mut T
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
simplicio
Gets rid of the boilerplate in rust
-
cursive-extras
Extra views for the Cursive TUI library as well some helper functions and macros
-
ratbaseconfig
lib with base ratatui config for my (mb your) apps
-
sendkeys-rs
A macro to send keystrokes using the windows crate
-
anonymous-trait
Anonymous trait implementation with capturing the environment
-
sql_tool_core
这个库是 sql_tool_macros 库的核心,存储 trait
-
lfml-escape
code/logic shared between the macro & the types
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
lemurs-8080
An emulator for the Intel 8080 microprocessor
-
crab-errors-rs
handle errors in rust
-
error-window
proc macro that will make your main function output errors as dialog boxes as well as errors to the console
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
sharded_mutex
No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.
-
st-map
Runtime for a stack-alocated map
-
look_inside
Look inside structs, enums, and unions!
-
no-std-thiserror
thiserror but no_std compatible
-
lucidity-core
A distributed orchestrator platform for Rust
-
clamped_values
generic
ClampedValue
struct that stores a value and ensures that it is always within the specified minimum and maximum values -
chandeliers-sem
Semantics of Candle, a shallow embedding of Lustre in Rust
-
soapy-shared
Custom types used by soapy macros
-
wutil
A lightweight library that contains potentially useful functions, wrappers, and macros
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
chandeliers-err
Internal error message generators for the Chandeliers project
-
k9
rust testing library
-
builder_derive_more
Additional procedural macros for the builder pattern
-
ephemeropt
An ephemeral Option that reverts to None after some time
-
smurf
SMall Useful Rust Functions
-
ghost
Define your own PhantomData
-
enumn
Convert number to enum
-
inherent
Make trait methods callable without the trait in scope
-
readonly
Struct fields that are made read-only accessible to other modules
-
pathbuf
A macro to conveniently build PathBufs
-
replace_err
Adds a
replace_err
method toResult
which throws away the current error and replaces it -
maybe-uninit-ext
Extended maybe-uninit types
-
constmuck
const-equivalents of bytemuck functions
-
comfy-print
Non-panicking versions of println! and friends. Async implementation.
-
anymap3
A safe and convenient store for one value of each type
-
toast-cell
Zero-cost type-branded cell with no runtime checks
-
scout-audit-clippy-utils-soroban
For internal usage by cargo-scout-audit
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
olis_string
Small-string optimization for Rust, aims to replace std::string::String
-
npp
A safe rust wrapper for NVIDIA Performance Primitives (NPP) APIs
-
result-like
Option/Result-like monad interface for your own enum
-
pi_null
define trait is named Null. u8,u32,u64,Option...is implements Null
-
conv2
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
type_cell
Attach values statically to a type using static get/set methods
-
enum-extract-error
A companion crate for
enum-extract
that exports an error type -
conditional-assignment
very simple, small crate to help make conditional assignments more ergonomic
-
enum_downcast
Safe downcasting for enums
-
dsl
build your own dsl
-
aoko
extension library
-
oop
Object-Oriented Inheritence in Rust
-
common-testing
Common testing shortcuts and utilities reused across projects
-
variante
Statically-verified enum variant names as strings
-
file_rw
high-performance, memory-mapped file I/O utilities
-
enum-extract-macro
A derive macro for extracting enum variants into their own types
-
xitca-service
async traits for xitca
-
comfy-print-sync
Non-panicking versions of println! and friends. Sync implementation.
-
nanocl_error
Nanocl error types
-
generic_asset
A upgraded version of Tantans asset loading macro for bevy 0.12
-
merge2
Merge structs into single by values
-
slice_trait
A generic trait for any slice, with item as type parameter
-
error_mapper
standardized Results and Errors handling accross all your projects
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
deep-struct-update
Struct update syntax with nesting
-
degeneric-macros
Hides struct generics into trait associated types
-
windows-helpers
Helpers for the windows crate
-
case_insensitive_string
A case insensitive string struct
-
leafslug_time
Useful set of time-oriented functions, for my leafslug collection
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
stock-symbol
A data type for representing stock symbols
-
num-conv
num_conv
is a crate to convert between integer types without usingas
casts. This provides better certainty when refactoring, makes the exact behavior of code more explicit, and allows using turbofish syntax. -
range_checker
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
to_tokenstream
An interface for creating a compiler within a Rust macro
-
shared_resources
shared resources container which is thread-safe, and lock-free
-
seqgen
Sequence generation library
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]
checks -
more-di
support for dependency injection (DI)
-
copstr
COpy STRing module
-
safe_cache
A key-value cache library in Rust featuring dynamic typing with support for multiple data types, automatic expiration, and thread-safe operations using Arc and RwLock
-
map-self
Map a value itself instead of its contained value in usual closure style
-
collate
Traits and a data structure to support collation and bisection
-
safecast
Traits to define safe casting between types
-
retrying
General-purpose retrying library for Rust with macros and functions
-
callable
closures implementing PartialEq and argument operations
-
positional
author/parse positional files
-
fauxgen
write your own generators in stable rust
-
rutie
The tie between Ruby and Rust
-
brug
enum command generation for implementation blocks
-
expression_engine
An expression engine written in pure rust
-
adventage
Advent of Code, easier!
-
evcxr_repl
A REPL for Rust
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
enum-ordinalize
enables enums to not only obtain the ordinal values of their variants but also allows for the construction of enums from an ordinal value
-
yewdux-utils
Ergonomic state management for Yew applications
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
derive-where
Deriving with custom trait bounds
-
wdl-macros
Macros used within the
wdl
crate ecosystem -
inter-struct
Automatically generated traits for arbitrary structs
-
const-units
that lets you check the dimensions of your quantities at compile time and run time
-
traitful
A collection of helper macros for trait patterns
-
timely-container-master
Container abstractions for Timely
-
arrays
Construct an array from an iterator
-
uni_rc_lock
trait which may represent either Rc<RefCell<T>> or Arc<RwLock<T>>
-
mogrify
macro for autogenerating a “Parse, Don’t Validate”
TryFrom
implementation for structs -
shared_error
SharedError wrapper for cloneable Error
-
fb_cloned
Cloned macro
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
columnation-master
An experimental columnar arena
-
static_interner
Similar to
internment
crate, but with interface and performance tweaks -
mod_template
Creating macros that define modules from template modules
-
inline_dyn
A container type for storing dynamically-sized types inline
-
once_cell
Single assignment cells and lazy values
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
gat-lending-iterator
iterators who's items can [mutably] reference the iterator
-
aoc-parse
A little library for parsing your Advent of Code puzzle input
-
io-adapters
Adapters to convert between different writable APIs
-
tosserror
derive(Toss)
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator
-
type_reflect
Extensible runtime reflection through a Derive macro
-
firedbg-lib
FireDBG Support Library
-
aoc-util
function for aoc
-
ordered-float
Wrappers for total ordering on floats
-
iter-chunks
Extend Iterator with chunks
-
ferment
Syntax tree morphing of FFI-compatible stuff
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
packed_streaming_iterator
Additions to streaming_iterator
-
ferment-interfaces
Traits for FFI conversions and some helper methods
-
number-diff
number-based is an attempt of mine to make working with calculus easier
-
flexible-io
Wraps values such that dyn-safe IO traits need not appear as static bounds
-
exposed-macro
Contains macros required by "exposed"
-
explicit_cast
explicit widening, truncating, and sign casting of primitive integers
-
timelang
A DSL (Domain Specific Language) and grammar for parsing and rendering human-readable date/time and duration values
-
fileslice
Slices of files
-
async-injector
Reactive dependency injection for Rust
-
tinypointers
Pointer implementations that take 8 or 16 bits
-
rudi-core
Rudi core types
-
formatx
A macro for formatting non literal strings at runtime
-
debug_utils
enhanced debugging in Rust
-
model-mapper
Derive macro to map between different types
-
itermap
Iterator tools for maps (
HashMap
,BTreeMap
, etc.) -
head-tail-iter
An iterator that repeatedly splits head & tail
-
scalar_map
map
for scalar types -
aoc_driver
helper macros and functions for AoC
-
std-ext
Extend the standard library functionality
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
iter-read
A Read implementation for iterators over u8 and related types
-
edgedb-composable-query
ComposableQuery trait for EdgeDB. Use with edgedb-composable-query-derive.
-
lazy_format
lazily formatting values for later
-
c-types
Re-exports of cross-platform types, gathered from libc and winapi
-
closure_example
A short description of my package
-
concat-with
Extend the function of the
concat!
macro instd
-
indicator
Abstractions for stream aggregation, we call them
Indicator
s -
io-lifetimes
A low-level I/O ownership and borrowing library
-
tupletools
functions for tuples
-
generic-global-variables
tools for implement generic global variables
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
macaroni
The missing macro std library for Rust
-
maybe-single
A singleton. Maybe.
-
enum_common_fields
Macro for easy access to common fields of enums
-
simple-life
async lifecycle trait and convenient macros
-
coi
Dependency Injection library
-
tuplex
Rust tuple extension
-
ts_quote
Procedural macros for quasi-quoting TypeScript from Rust
-
lsdata
LSD (Less Syntax Data) configuration/data transfer format
-
wave_func_collapse
wave function collapse algorithm
-
pack1
Byte array newtypes for different primitive types
-
math_captcha
mathematical CAPTCHA code generator written in Rust
-
pattern_code
Given a path patterm matched source code
-
rustility
A collection of utilities I often find myself using in Rust
-
model_macro
traits collection
-
cond
Rust macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
mstr
2-word, immutable Cow<str>
-
kalman-fusion
single-variable Kalman filtering for Float and Fixed types
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
checked-float
making invariant-enforcing floating point wrappers
-
colourado-iter
A small and minimalistic library to generate a random color palette of infinite size
-
tuples
many useful tools related to tuples
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
lox_utils
General helpers used by Lox
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
linspace
Traits for numpy linspace equivalent functions, into both vectors and arrays, the latter of which can be executed at compile-time
-
currying
anything implementing FnOnce. Arguments can be passed one at a time, yielding a new something implementing FnOnce (and possibly FnMut and Fn) which can be called with one less argument.
-
fn_zip
zip trait for functions, allowing two functions to be combined at compile-time before being called
-
unroll_range
Repeats a block of code for each number in a specified range
-
nonmax
Numeric types that cannot hold maximum values
-
swapbytes
swapping the endianess of structures
-
pointer-identity
Wrapper type to treat the pointer address of types as identity rather than the value
-
thiserror-core
derive(Error)
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
igc_parser
A high-level parsing/deserializing crate for IGC flight recorder files
-
padded-iterator
An iterator that can be padded to a specified length
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
rs-utilities
Some utilities
-
writeable
A more efficient alternative to fmt::Display
-
veil
Rust derive macro for redacting sensitive data in
std::fmt::Debug
-
cli_input
Various functions for gathering user input in the terminal
-
map_tuple
Map individual elements of a tuple
-
lmml
LMML Music Macro Language
-
ointer
Steal the high bits of a pointer to store an extra value
-
retour
A cross-platform detour library written in Rust
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
lyneate
beautiful code underlining and error reporting
-
rnet
Easily call into Rust from C# or other .net langauges
-
stable-inline-python
Stable Variant of inline-python
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
light_enum
provide a derive keyword to generate a light enum
-
is_none_or
function for the Option type
-
parametrics
working with parametric functions
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
macroex
An extractor based low level macro parsing crate that provides high level parsing support through derive macros
-
number-types
A typenum clone I made for fun with some positive changes but much fewer features
-
table_enum
A convenient rust macro to create enums with associated constant data (note: this is different from normal rust enums which are really tagged unions)
-
anyerror
A type of any error for transport
-
dync
An efficient alternative to
dyn Trait
for containerized types -
rtoolbox
functions for other crates, no backwards compatibility guarantees
-
is-odd
Returns true if the given number is odd
-
vlq-bij
Bijective Variable-Length Quantity encodings
-
batbox-tuple-macros
Macro for calling your macro for all tuple sizes
-
batbox-cmp
Traits & functions related to Ord
-
ebr
epoch-based reclamation with low cacheline ping-pong
-
strung
Easy access of struct fields in strings using different/custom pre/postfix: "Hello, {field}"
-
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox
. -
slicefields
Allows for data structures whose members are sub byte aligned (e.g. a one bit alignment)
-
notzero
macro for constructing
std::num::NonZero*
from constants -
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
range-cmp
Trait that allows comparing a value to a range of values
-
trait-theories-std
A collection of invariants of Rust std traits
-
flatty-base
Flatty traits and primitives
-
flatty-portable
Flatty portable trait and primitives
-
ux2
Non-standard integer types like
u7
,u9
,u10
,u63
,i7
,i9
etc -
rc_bump
An arena for heterogeneous types and without lifetimes
-
do-not-use-testing-rosidl_runtime_rs
Message generation code shared by Rust projects in ROS 2
-
kvtree
Heterogenous in memory key value tree storage
-
impl-enum
Macros that make using enums like trait objects more convenient
-
atom_box
A safe idiomatic Rust implementation of Atomic Box using hazard pointers
-
pipe-chain
Combinators & parser library
-
vecc
macro to create a vector of vector
-
const-size-flatten
Flatten and FlatMap with constant inner iterator size
-
try-unwrap
A revolutionary new crate that allows you to unwrap() without making your stupid software panic
-
enum-tools
Automatically derive functions and trait implementations for enums
-
crustal
generating C/C++ code
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
avocado-schema
A schema DSL which can be interpreted to implement multiple purposes
-
getfn
generating function pairs to refer to functions via custom expressions
-
sqlx_query
Expands to either sqlx function
query
or macroquery!
call depending onsqlx_compiletime_checks
has been enabled during the build -
typestring
String constants lifted into types. This is a stopgap until const generics support strings.
-
const-gen
generating (relatively) complex compile-time constants in rust
-
core_float
based on the Rust Core Library and aims to provide an identical set of APIs for f32 and f64 floating-point types
-
lazy-attribute
convenient attribute macro for lazy function execution
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
drop-tracker
check when a variable gets dropped. Useful for testing wrappers and containers that use unsafe memory management.
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
type-path
Get the string array representation of a Rust type path
-
eeric-interpreter
A front-end abstraction layer over eeric
-
general-iter
An enum of iterators to avoid Box<&dyn Iterator>
-
sod
Service Oriented Design
-
chemistru-macro-api
API for chemistru macros, generating element constants and maps
-
sod-tungstenite
Service Oriented Design - Tungstenite
-
goof
A reusable, composable, aggregate and
no_std
-friendly error library -
larc
Lazy Arc/Weak pointers
-
async_pipeline_for_lucas
Easy way to pipeline sync and async functions
-
proto-mapper-core
Internal helper library for proto-mapper
-
consclr
console text colorful
-
chisel-common
Chisel common macros, types and functions
-
read_chunks
An extension to the Read trait allowing easier chunked reading
-
type-weave
Helpers for joining custom data types
-
propresenter
Unofficial library for interacting with ProPresenter 7
-
suitest
quality of life test suites
-
unwinding
in Rust and for Rust
-
burrtype
A framework for exporting types to other languages
-
append-only-bytes
Shareable append-only bytes
-
random_variant
To be used with all variant, contains the derive macro
-
index-ext
Index slices with arbitrary ints and as arrays
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
cherrybomb-oas
Cherrybomb OpenAPI Specification (OAS) struct and functions
-
useful_macros
My useful macros