-
bitflags
A macro to generate structures which behave like bitflags
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
thiserror
derive(Error)
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
ordered-float
Wrappers for total ordering on floats
-
once_cell
Single assignment cells and lazy values
-
derive_more
Adds #[derive(x)] macros for more traits
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
predicates
boolean-valued predicate functions
-
anyhow
Flexible concrete Error type built on std::error::Error
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
darling
A proc-macro library for reading attributes into structs when implementing custom derives
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
pin-project
safe and ergonomic pin-projection
-
async-stream
Asynchronous streams using async & await notation
-
bytes
Types and traits for working with bytes
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive
-
libloading
Bindings around the platform's dynamic library loading primitives with greatly improved memory safety
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
human-panic
Panic messages for humans
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
memoffset
offset_of functionality for Rust structs
-
smol_str
small-string optimized string type with O(1) clone
-
typed-builder
Compile-time type-checked builder derive
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
dyn-clone
Clone trait that is object-safe
-
enumflags2
Enum-based bit flags
-
similar-asserts
assert_eq! like macros with colorized diff output
-
approx
Approximate floating point equality comparisons and assertions
-
snafu
An ergonomic error handling library
-
tap
Generic extensions for tapping values in Rust
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
shellexpand
Shell-like expansions in strings
-
scopeguard
RAII scope guard that will run a given closure when it goes out of scope, even if the code between panics (assuming unwinding panic). Defines the macros
defer!
, `defer_on_unwind… -
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
arrayref
Macros to take array references of slices
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
compiler_builtins
Compiler intrinsics used by the Rust compiler. Also available for other targets if necessary!
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
ouroboros
Easy, safe self-referential struct generation
-
cfg-if
A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted.
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
static_assertions
Compile-time assertions to ensure that invariants are met
-
typenum
type-level numbers evaluated at compile time. It currently supports bits, unsigned integers, and signed integers. It also provides a type-level array of type-level numbers, but its…
-
beef
More compact Cow
-
valico
JSON Schema validator and JSON coercer
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
extendr-api
Safe and user friendly bindings to the R programming language
-
backon
Make retry like a built-in feature provided by Rust
-
az
Casts and checked casts
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
if_chain
Macro for writing nested
if let
expressions -
nutype
The newtype with guarantees
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]
checks -
bitfield
macros to generate bitfield-like struct
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
orchestra
Generate an orchestra of subsystems from a single struct
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
bounded-collections
Bounded types and their supporting traits
-
inlinable_string
inlinable_string
crate provides theInlinableString
type – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExt
trait… -
inventory
Typed distributed plugin registration
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
fallible-iterator
Fallible iterator traits
-
fallible_collections
adds fallible allocation api to std collections
-
float-ord
A total ordering for floating-point numbers
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
async-trait
Type erasure for async trait methods
-
stdext
Extensions for the Rust standard library structures
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
lazy_format
lazily formatting values for later
-
volatile
wrapper types for raw pointers
-
extism-pdk
Extism Plug-in Development Kit (PDK) for Rust
-
garde
Validation library
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
assertables
macros
assert…!
for better tests, quality assurance, debug testing, and runtime reliability -
virtue
A sinless derive macro helper
-
sptr
Strict Provenance Polyfill
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
derive-where
Deriving with custom trait bounds
-
pyo3-polars
Expression plugins and PyO3 types for polars
-
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
-
opaque-debug
Macro for opaque Debug trait implementation
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
bon
Generate builders for everything!
-
buffered-reader
A super-powered Reader
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
thiserror-no-std
derive(Error)
-
nonempty
Correct by construction non-empty vector
-
field-offset
Safe pointer-to-member implementation
-
static_cell
Statically allocated, initialized at runtime cell
-
crevice
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
by_address
Wrapper for comparing and hashing pointers by address
-
testresult
type for concise and precise test failures
-
writeable
A more efficient alternative to fmt::Display
-
bounded-integer
Bounded integers
-
doc-comment
Macro to generate doc comments
-
constcat
concat! with support for const variables and expressions
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
rustdoc-types
Types for rustdoc's json output
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
tynm
Returns type names in shorter form
-
async-once-cell
Async single assignment cells and lazy values
-
cascade
Dart-like cascade macro for Rust
-
scoped-tls-hkt
more flexible version of
scoped-tls
, allowing the following additional features: Storage of references to dynamically sized types. Storage of mutable references. Storage of… -
nonmax
Numeric types that cannot hold maximum values
-
tlua
Zero-cost high-level wrapper for Tarantool-LuaJIT
-
iri-string
IRI as string types
-
aide
A code-first API documentation library
-
fatality
extension to
thiserror::Error
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
dlib
Helper macros for handling manually loading optional system libraries
-
recursion
cache-aware stack safe recursion
-
scoped-tls
standard library’s old
scoped_thread_local!
macro for providing scoped access to thread local storage (TLS) so any type can be stored into TLS -
iter-read
A Read implementation for iterators over u8 and related types
-
inout
Custom reference types for code generic over in-place and buffer-to-buffer modes of operation
-
retry
retrying operations that can fail
-
error-code
Error code
-
flex-error
Flexible error definitions using macros and traits
-
indoc
Indented document literals
-
tryhard
Easily retry futures
-
thiserror-core
derive(Error)
-
parsel
Zero-code parser generation by using AST node types as the grammar
-
unwinding
in Rust and for Rust
-
const-gen
generating (relatively) complex compile-time constants in rust
-
const-random
compile time random number generation
-
maybe-owned
MaybeOwned
(andMaybeOwnedMut
) type similar to std’sCow
but it implementsFrom<T>
andFrom<&'a T>
and does not requireToOwned
-
arrow-array
Array abstractions for Apache Arrow
-
mem_dbg
Traits and associated procedural macros to display recursively the layout and memory usage of a value
-
st-map
Runtime for a stack-alocated map
-
safe-transmute
A safeguarded transmute() for Rust
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
send_wrapper
implements a wrapper type called SendWrapper which allows you to move around non-Send types between threads, as long as you access the contained value only from within the original thread…
-
tuples
many useful tools related to tuples
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
derivative
A set of alternative
derive
attributes for Rust -
conjure-object
Runtime support for generated Conjure objects
-
fragile
wrapper types for sending non-send values to other threads
-
tiny-fn
Type erased closures on stack
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
k9
rust testing library
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
shaku
Compile Time Dependency Injection for Rust
-
joinery
A small crate for generically joining iterators with a separator
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
k8-client
Core Kubernetes metadata traits
-
tuplex
Rust tuple extension
-
safelog
Conditionally suppress confidential information from logs
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
float-cmp
Floating point approximate comparison traits
-
autosurgeon
working with data in automerge documents
-
async-fn-stream
Lightweight implementation of
async-stream
without macros -
validify
struct validation and modification functionality through the use of derive macros
-
sugar_path
Sugar functions for manipulating paths
-
arr_macro
Initialize arrays with ease!
-
panic-analyzer
an audit tool to scan your crate or workspace searching for potential panic points in your codebase
-
tstr
Type-level strings
-
cl-format
Use Common Lisp format in Rust
-
components-arena
creating complex domain-specific self-referential data structures
-
pinned-init
facilitate safe pinned initialization
-
arrow_convert
Convert between nested rust types and Arrow with arrow
-
ra_ap_stdx
Missing batteries for standard libraries for rust-analyzer
-
rdftk_names
set of modules that contain the
IRI
s andQName
strings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
aoc-parse
A little library for parsing your Advent of Code puzzle input
-
overload
macro to simplify operator overloading
-
rustrict
profanity filter for Rust
-
retour
A cross-platform detour library written in Rust
-
formatx
A macro for formatting non literal strings at runtime
-
socketpair
Cross-platform socketpair functionality
-
fixed-hash
Macros to define custom fixed-size hash types
-
dync
An efficient alternative to
dyn Trait
for containerized types -
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
nshare
Conversion between n-dimensional types in different Rust crates
-
with_locals
Function attribute to return references to locals by using CPS
-
calendrical_calculations
Calendrical calculations in Rust
-
lazy-static-include
lazy_static_include_bytes
andlazy_static_include_str
macros to replaceinclude_bytes
andinclude_str
macros -
hooks
Compile-time, async hooks
-
speculoos
Fluent test assertions
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
display-error-chain
Formats a standard error and its sources
-
shopify_function
write Shopify Functions in Rust
-
devela
A development foundation
-
as-any
provide the AsAny trait
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
mirror-mirror
Reflection library for Rust
-
sealed
Macro for sealing traits and structures
-
userfaultfd
Rust bindings for the Linux userfaultfd functionality
-
pin-utils
pinning
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}
while keeping the benefits of hand-written code -
atc-router
Versatile DSL based rule matching engine used by the Kong API Gateway
-
doku
A framework for documenting Rust data structures
-
ufotofu
Abstractions for lazily consuming and producing sequences
-
funty
Trait generalization over the primitive types
-
rustversion
Conditional compilation according to rustc compiler version
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
trybuild-internals-api
A fork of trybuild with the internals exposed as a public API
-
data-rw
io buffer write reader
-
dprint-swc-ext
Functionality to make swc easier to work with
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_parts
andVec::into_raw_parts
-
fn_vm
A lightweight frame based virtual machine, meant as the base for rigz_vm
-
buildstructor
Macro to derive a builder from a constructor function
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
more-di
support for dependency injection (DI)
-
proc-bitfield
expressively declare bitfield-like structs
-
concat-with
Extend the function of the
concat!
macro instd
-
cowstr
Copy-on-Write shared strings
-
easy-cast
Type conversions which are expected to succeed
-
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
swipl
A high-level library for building SWI-Prolog extensions and embedding SWI-Prolog in rust applications
-
bool_ext
defines and implements a complete set of
Option
/Result
-style Boolean functional combinators on Rust’sbool
primitive type -
munge
Macro for custom destructuring
-
rust_info
Extracts the current rust compiler information
-
devise
devising derives and other procedural macros
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
void
The uninhabited void type for use in statically impossible cases
-
try_match
Fallible pattern matching with a function-like syntax
-
defer
excecution of code, inspired by go's defer statement
-
fvm_shared
Filecoin Virtual Machine shared types and functions
-
rs-event-emitter
simulate promise implementation for rust
-
assert_approx_eq
assert approximately equal
-
one_err
OneErr to rule them all
-
resiter
Helper crate for handling iterators over result
-
generativity
Generation of unique invariant lifetimes
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
zoet
Adds
#[zoet]
macro to reduce boilerplate when implementing common traits -
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
checked-rs
encoding validation semantics into the type system
-
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
wmlua
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
simple-error
error type backed by a string
-
wiwi
Stuff™
-
peeking_take_while
Like
Iterator::take_while
, but calls the predicate on a peeked value. This allows you to useIterator::by_ref
andIterator::take_while
together, and still get the first value… -
myutil
Rust Util Collections
-
lazycell
providing a lazily filled Cell struct
-
gat-lending-iterator
iterators who's items can [mutably] reference the iterator
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
octseq
Abstractions for types representing octet sequences
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
macro-attr-2018
macro_attr!
macro that enables the use of custom, macro-based attributes and derivations -
enum-display
A macro to derive Display for enums
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
atom
A safe abstraction around AtomicPtr
-
documented
Traits and derive macros for accessing your type's documentation at runtime
-
sugars
An useful collection of macros to make tasks easier
-
radiation
Convert Rust type into raw bytes and vice versa
-
macro-asm-builder
macro-assemblers
-
auto_enums
allow multiple return types by automatically generated enum
-
reborrow
Emulate reborrowing for user types
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
vitasdk-sys
Raw bindings to vitasdk
-
globals
Painless global variables in Rust
-
metastruct
Abstractions for iterating and mapping over struct fields
-
iter-chunks
Extend Iterator with chunks
-
gumdrop
Option parser with custom derive support
-
aerosol
dependency injection for Rust
-
fallible-streaming-iterator
Fallible streaming iteration
-
cap-std-ext
Extension APIs for cap-std
-
smarterr
Smart error handling library
-
sosecrets-rs
Secret
wrapper type that reveals the secret at mostMEC: typenum::Unsigned
times with compile time guarantees -
TSPL
The Simplest Parser Library
-
rutie
The tie between Ruby and Rust
-
psl-types
Common types for the public suffix implementation crates
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
semval
Semantic validation
-
rudi
out-of-the-box dependency injection framework for Rust
-
io-streams
Unbuffered and unlocked I/O streams
-
libc-print
println! and eprintln! macros on libc without stdlib
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
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… -
null-kane
currency crate with the option to add your own currency localization logic
-
result-like
Option/Result-like monad interface for your own enum
-
tupletools
functions for tuples
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Display
representations -
model-mapper
Derive macro to map between different types
-
loga
Combined logging and error handling
-
entrait
Loosely coupled Rust application design made easy
-
ungrammar
A DSL for describing concrete syntax trees
-
macon
builder macro-based generator with its own idioms
-
reweb3-num
Arbitrary precision, fixed-size signed and unsigned integer types for ethereum, this a fork of bnum crate
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
soa-rs
A Vec-like structure-of-arrays container
-
many-unzip
multiunzip
from itertools but with support for larger than 12-tuples -
intern-arc
An interner that deallocates unused values
-
blanket
macro to derive blanket implementations for your traits
-
awint_macro_internals
Internal macro utilities for the
awint
system of crates -
culpa
error-handling syntax in Rust
-
backtrace-error
wrap errors with automatic backtrace capture and print-on-result-unwrap
-
corlib
A various ideas library
-
jnix
High-level extensions to help with the usage of JNI in Rust code
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
indicator
Abstractions for stream aggregation, we call them
Indicator
s -
rust-quiz
Medium to hard Rust questions with complete explanations
-
lmml
LMML Music Macro Language
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
carboxyl
functional reactive programming
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
tokenlock
cell types that decouple permissions from data
-
coi
Dependency Injection library
-
quick-error
A macro which makes error types pleasant to write
-
rst-common
A shortcut to common Rust crates
-
format-bytes
A macro to format bytestrings
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
cexpr
A C expression parser and evaluator
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
async-iterator
An async version of iterator
-
scale-typegen
Type Generation for SCALE encoded Rust Types
-
file_rw
high-performance, memory-mapped file I/O utilities
-
refined_type
imbuing rules into types and elevating them to more robust types
-
windows-targets
Import libs for Windows
-
bash-builtins
implement loadable builtins for bash
-
naan
A fast, easy, and tasty functional programming prelude
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
as-is
An abstraction over ownership
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
sitrep
Frontend-agnostic progress reporting
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
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
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
xx
A collection of useful Rust macros and small functions
-
byondapi
Idiomatic Rust bindings for BYONDAPI
-
derive_destructure2
Destructure structs that implement Drop
-
iter-comprehensions
iterator comprehensions
-
ort_custom_op
writing custom operators for the onnxruntime in Rust
-
leptos-mview
A concise view macro for Leptos
-
vcell
Cell
with volatile read / write operations -
portaldi
An ergonomic lightweight compile-time depencency injection library
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
cast
Ergonomic, checked cast functions for primitive types
-
unwind-context
Macro to add colored panic context to your functions
-
capnp_conv
capnp write/read traits to convert from structs to readers/builders
-
auto_ops
Macros for easy operator overloading
-
applying
Apply functions in method-position
-
tinyvec_macros
Some macros for tiny containers
-
nolife
open a scope and then freeze it in time for future access
-
structre
Static-checked parsing of regexes into structs
-
fp_rust
Implement fp features for Rust
-
nightly2version
#[no_std]
and fast crate a Rust version to a timestamp and vice-versa (along other things) -
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
structz
Anonymous struct implementation in rust
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
dynamodel
derive macro to implement conversions between your object and
HashMap<String, AttributeValue>
-
oxrdf
providing basic data structures related to RDF
-
string_templater
A string templater to inject values in a string template
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
bilge
Use bitsized types as if they were a feature of rust
-
tri_ton
A Macro for Handling Exceptions
-
collate
Traits and a data structure to support collation and bisection
-
oco_ref
A smart pointer for storing immutable values with relatively-cheap cloning. (Like a
Cow
meets anRc
!) -
simpl_cache
caching tools
-
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
fauxgen
write your own generators in stable rust
-
univec
A vector that can hold elements of any single type
-
packetize
encode and decode your packet with stream channel
-
dpc-pariter
Parallel iterator processing
-
olis_string
Small-string optimization for Rust, aims to replace std::string::String
-
pegination
cursor pagination
-
never
A stable version of the unstable never type (!)
-
crustal
generating C/C++ code
-
rrplug
framework for R2Northstar plugins
-
pyo3_special_method_derive
Automatically derive Python dunder methods for your Rust code
-
egui_struct
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
ffi_helpers
help make working with FFI easier
-
explicit-endian
Transparent traits to explicitely declare in-memory endianness for a virable or struct record
-
ghost
Define your own PhantomData
-
igc_parser
A high-level parsing/deserializing crate for IGC flight recorder files
-
cursive-extras
Extra views for the Cursive TUI library as well some helper functions and macros
-
bloom-core
A react-like framework for descriptive UIs. Renderer Agnostic but built with HTML in mind.
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
certain-map
A typed map which can make sure item exist
-
numtest
Unit testing for numerical methods
-
bellframe
Fast and idiomatic primitives for Change Ringing
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
rtoolbox
functions for other crates, no backwards compatibility guarantees
-
log_limit
A rate limiting logging crate
-
ra_ap_hir_expand
Macro expansion for rust-analyzer
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
enum_handler
A macro to generate a handler trait for enums variants
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
nameof
macro to determine the string name of a binding, type, const, or function
-
structx
Simulating anonymous struct and named arguments in Rust
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
slice-diff-patch
providing utility functions for diff and patch of slices
-
http-request-derive
Use derive to create HTTP requests
-
twitch_types
common types for Twitch
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
miden-thiserror
derive(Error) with no-std support
-
cbor-data
using CBOR as in-memory representation for working with dynamically shaped data
-
vector-traits
Rust traits for 2D and 3D vector types
-
size-of-trait
determine the size of a future or trait impl at compile time
-
iterator-sorted
Stable functions for checking iterator sorting
-
soulog
polished, clean and colourful console logging and error handling
-
maybe-single
A singleton. Maybe.
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
merge
multiple values into one
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
variadiz
Variadic function support for rust
-
random_variant
To be used with all variant, contains the derive macro
-
tevec
provide quantitative analysis functions for vec | ndarray | polars backend
-
derive-ctor
Adds
#[derive(ctor)]
which allows for the auto-generation of struct, enum, and union constructors -
generics
macros for parsing generics (with optional where clause) in
macro_rules!
-
traitreg
Create a registry of implementations of a trait
-
padder
Highly efficient data and string formatting library for Rust
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
phantom-type
A
PhantomData
analog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData
-
condtype
Choose types at compile-time via boolean constants
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
ml-distance
Distance-based methods for vector comparison and analysis. (Porting of the JS/TS pkg
ml-distance
to Rust) -
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
tor-basic-utils
General helpers used by Tor
-
deptypes
Dependent types
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
nade
Adding named and default arguments to Rust functions
-
thiserror_string_context
Adds context string to error enums generated with thiserror
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
copstr
COpy STRing module
-
enum_cycling
Small macro for working with enums
-
sod
Service Oriented Design
-
named-tup
Create named tuples using the tup!() macro
-
const-default
A const Default trait
-
suricata
network IDS and NSM engine Rust code
-
simple_detailed_error
Stack and specify errors explainations saying what happened, why, how, where, how to solve it and its causes
-
dilib
A dependency injection library for Rust
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
sodium
FRP (Functional Reactive Programming)
-
sized-dst
Owned container for dynamically-sized types backed by inline memory
-
enum_downcast
Safe downcasting for enums
-
one_two_eight
typed 128-bit identifiers
-
shared_singleton
trait provides singleton pattern state management with shared container
-
ecksport-core
Defs for frame types, traits, topics, error codes, etc
-
value-box
Allows developers to pass Rust-allocated structures over ffi
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
nu-std
The standard library of Nushell
-
dyn-context
mechanism for lifetimes erasing
-
binread
helping read structs from binary data using ✨macro magic✨
-
zzz
Fast progress bar with sane defaults
-
hex_lit
Hex macro literals without use of hex macros
-
hlist2
Compile-time heterogeneous list implementation
-
capture-it
Modern c++-ish capture syntax for rust
-
cumulus-primitives-timestamp
timestamp related functionality for parachains. (polkadot v1.15.0)
-
preprocess
Preprocesses a struct with built-in preprocessors
-
sqler
way for writing SQL queries using some of Rust syntax
-
cooked-waker
A safe interface for creating async Wakers
-
borrowme
The missing compound borrowing for Rust
-
rs_envflag
An easy way to define flags by environment variables
-
crony
cron runner that spawns another thread to run your cron jobs
-
linearity
providing various operations commonly found in branchless programming
-
syrette
The convenient dependency injection framework
-
hermit-sync
Synchronization primitives for kernels
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
phnt
Rust bindings to the System Informer’s (formerly known as Process Hacker)
phnt
native Windows headers -
enumerable
helping you to enumerate all possible values of a type
-
extruct
proc-macro library that provides tools for listing named struct fields and implementing conversion from a larger struct containing fields with same names
-
intertrait
Allow for inter-trait casting
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
better_any
Type id and Any for non static types
-
tighterror
A minimalistic error representation framework
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
rempl
creating html components directly in your source
-
cprint
Cargo-like print
-
safe-discriminant
A minimalistic,
no_std
compatible trait and procedural macro for extracting discriminants from enums at zero cost -
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
redb_model
Redb model derive macro and DTO type conversion
-
irox-enums
Traits for better Enumerated Types
-
crevice_notan
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
fiberplane-pdk
Fiberplane Provider Development Kit
-
stackstack
A singly linked list intended to be chained along stack frames
-
copyvec
A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy
-
range_checker
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
easy-error
error utilities
-
not-found-error
Convert Option to Result using convenient functions
-
duplicate_macrotest
Fork of the macrotest crate specifically to test the duplicate crate
-
swift-bridge-build
Parse Rust files for swift-bridge modules and generate the corresponding Swift and C code for them
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
re_types_blueprint
The core traits and types that power Rerun's Blueprint sub-system
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
transient
Reimplementation of
std::any::Any
with support for non-'static
types -
soa_derive
Automatic Struct of Array generation
-
home-prelude
Prelude library to support home applications
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
linear_type
Linear types for rust
-
ref_wrapper
Wrapper of dynamically borrowed data
-
mapcomp
Python-like list comprehensions for standard containers
-
drop_bomb
A runtime guard for implementing linear types
-
loupe
Profiling tool for Rust
-
c-types
Re-exports of cross-platform types, gathered from libc and winapi
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
focusable
A trait for types that can be focused
-
dyn-clonable
Attribute wrapper for dyn-clone
-
cfg-iif
A macro for defining
#[cfg]
if-else
functions -
rc-box
Known unique versions of Rc and Arc
-
relax
Traits for TypeScript-like partial (“relaxed”) types
-
functor_derive
A derive macro to derive a functor for a type
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
libabort
A abort function that doesn't require the standard library
-
outref
Out reference
-
pergola
abstract types for join-semilattices
-
benri
Convenient macros wrapping the standard library
-
io-arrays
Random-access I/O
-
better_scoped_tls
scoped-tls, but with good error message
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
aws-resource-id
Copyable AWS resource IDs
-
rust_examples
rust 的学习中的一些例子
-
prima_bridge
implement the bridge pattern
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
scoped_thread_local
Highly flexible Scoped thread local with HKT builtin
-
rcss
Rust CSS embedding library
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
sbpf-asm-macros
Ergonomic macros for low-level sBPF ASM functionality
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
micro_errors
deal with errors without taking the derive macro approach
-
tany
Type-erased container with inline storage for small values
-
golem-rust
Golem Rust tooling library that facilitates writing Golem backends in Rust
-
namewise
Derived trivial name-wise conversions for Rust types
-
kinded
Generate enums with same variants, but without data
-
timelang
A DSL (Domain Specific Language) and grammar for parsing and rendering human-readable date/time and duration values
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
dylint_linting
writing Dylint libraries
-
pipe-trait
possible to chain regular functions
-
flipflop
Stress-tester for double-ended iterators
-
suitest
quality of life test suites
-
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
indices
macros and methods for safely retrieving multiple mutable elements from a mutable slice, addressing scenarios where slice elements would typically require
RefCell
orCell
(interior mutability approach) -
code-path
A code path macro
-
coordinator
load balance tasks into task runners
-
gazebo
A collection of well-tested utilities
-
ff_ce
building and interfacing with finite fields
-
lava
Rust wrapper to manipulate Vulkan more conveniently than with bindings
-
untrusted_value
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
ruut-functions
parse math functions from string (1D,2D,3D,ND) and perform symbolic derivation, gradient, hessian
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
rawpointer
Extra methods for raw pointers and
NonNull<T>
. For example.post_inc()
and.pre_dec()
(c.f.ptr++
and--ptr
),offset
andadd
forNonNull<T>
, and the functionptrdistance
. -
index-ext
Index slices with arbitrary ints and as arrays
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
binf
that adds utilities for dealing with binary flags
-
objio
traits for reading and writing objects
-
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)
-
struct-field-names-as-array
generating the field names of named structs as constants
-
transitive
derive macros for Rust
-
steel-core
Core compiler and VM implementation for steel
-
openapi_type
OpenAPI type information for Rust structs and enums
-
unescape_zero_copy
Unescape strings without allocating memory
-
gen_ops
Macros for operator overloading for generic types
-
custom_derive
(Note: superseded by
macro-attr
) This crate provides a macro that enables the use of custom derive attributes -
cargo-cabal
that helps you to turn in one command a Rust crate into a Haskell Cabal library
-
macro-bits
performing macro-based bit manipulation
-
quick-error2
A macro which makes error types pleasant to write
-
amonoid
A general-purpose monoid library
-
simple-logging
logger for the log facade
-
dyn_std
Dynamic (object-safe) version of std traits
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
yerevan
Small Rust crate that brings computation expressions idea from F# for help you to work easier with functors and monads
-
evcxr_repl
A REPL for Rust
-
problem
Error handling for command line applications or prototypes
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
downcast
Trait for downcasting trait objects back to their original types
-
static_assertions_next
Compile-time assertions to ensure that invariants are met
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
io-close
An extension trait for safely dropping I/O writers such as File and BufWriter
-
append-only-bytes
Shareable append-only bytes
-
custom-format
Custom formatting for Rust
-
pathbuf
A macro to conveniently build PathBufs
-
conerror
macro that automatically adds context to errors
-
heapsz
calculating the heap usage of a data structure
-
arcstring
Atomically reference-counted thin string type with SSO
-
fallback-if
Fall back to an alternative given some predicate
-
ref-ops
An escape hatch for implementing
ops
traits for references to newtypes -
copy_from_str
An extension trait to copy a string into another string
-
rust2fun
functional programming in Rust
-
token-ref-cell
Interior mutability cell using an external token to synchronize accesses
-
cast_checks
A procedural macro to check for invalid casts
-
tracked
A stringly-typed Error that includes
#[track_caller]
information -
case_insensitive_string
A case insensitive string struct
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
tlns-google-oauth2
An enshitificated Google OAuth2 Server Side support for Rust with built in Scopes enum
-
primitive-from-enum
macros for get primitive enum from complex
-
cond
Rust macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
anthill-di
Rust di containers system
-
reductor
Generic abstractions for combining and nesting reduction patterns for iterables
-
rustdoc-prettier
Format
//!
and///
comments with prettier -
inline-python
Inline Python code directly in your Rust code
-
cplex-rs
Binding of IBM Cplex library
-
mode
A behavioral state machine library written in Rust
-
chainerror
Make chaining errors easy
-
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
-
plain_hasher
Hasher for 32-byte keys
-
pyo3-error
Unified error causality chains across Rust and Python
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
pareg
useful tools for command line argument parsing
-
hax-lib
Hax-specific helpers for Rust programs
-
combin-iterator
Some usefull facilities for combining iterators
-
rustrix
Supports macro and basic operations for matrix
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
isclose
A collection of trait and macros for comparing approximate equality
-
cubob
Structured output helpers for display mode
-
orfail
Error handling library for portable unrecoverable errors
-
lowbulls
lowbull is a Rust crate facilitating message handling and event monitoring
-
ctor-lite
Run code at program startup or shutdown
-
typeables
type aliases. By SixArm.com.
-
subplotlib
functions and types for
subplot codegen
generated Rust based test suites. Relies onsubplotlib-derive
for associated macros. -
impls
Determine if a type implements a logical trait expression
-
airbag
handling errors and panics using 3rd party services
-
assert-eq-float
assert_eq_float!
macros that support floats -
jnat
A wrapper around the jni crate
-
simple_parse
A declarative converter for Rust type to and from binary
-
advancedresearch-path_iter
A cocategory enumeration library based on path semantics
-
option-ext
Extends
Option
with additional operations -
processmanager
manage process lifecycles, graceful shutdown and process faults
-
teleparse
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
b-x
The stupidest boxed error ever
-
valued-enums
Macros collection and specify trait for creating valued or python-like enums
-
anyerror
A type of any error for transport
-
simplicio
Gets rid of the boilerplate in rust
-
bit_roles
Granular role management based on bit flags
-
re_tuid
128-bit Time-based Unique Identifier
-
partial_application
partial function application via the partial! macro
-
native_api_1c
Main library for Native API 1C
-
egui-probe
Trait and derive macro for exposing value editing in egui
-
checked-float
making invariant-enforcing floating point wrappers
-
tca-rs
The Composable Architecture (TCA, for short) is a library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind
-
chasa
A parser combinator with
many
taking iterator, conditional branching, and method chain -
bty
Streamlined definition and usage of branded types in Rust
-
genrc
refcounted pointer type that allows subobject pointers
-
peeking-iter
An iterator adapter that allows infinitely-deep peeking
-
take-until
A take_until extension for iterators
-
safecast
Traits to define safe casting between types
-
mod
project that provides two simple and useful utility functions for converting between Option and Result types
-
hexchat-plugin
Lets you write HexChat plugins in Rust
-
mini-config
Minimalistic Dynamic Configuration Library for Rust
-
sod-actix-web
Service Oriented Design - Actix Web
-
funcmap
Derivable functorial mappings for Rust
-
portrait
Fills an
impl
with the associated items required by the trait -
opaque_typedef
Supports defining opaque typedefs
-
string_error_wrap
providing a macro for an error type wrapping a String
-
monadic
macros to define Haskell style monadic action blocks for IntoIterators, Reader, Writer, State, and macros for the transformers ReaderT and WriterT over Vec, LinkedList and VecDeque
-
positional
author/parse positional files
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
game_inventory
An inventory system independant of item data
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
function-compose
lib to allow composition of sync and async rust functions
-
vsprintf
Rust bindings to the libc vsprintf function
-
soapy
Structure-of-arrays derive macro
-
tiny-input
Tiny input macros
-
char-device
Character Device I/O
-
surrealdb-extras
additional functionality for working with SurrealDB
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
enum_ext
procedural macro that enhances enums with additional methods and conversions
-
drop_guard
enables you to implement the Drop trait on any type. So you can run a closure on any value running out of scope
-
cfgenius
Conditional compilation with macro support in Rust
-
tokio-inherit-task-local
Task local variables for tokio that can be inherited across a spawn
-
type-sets
Sets implemented in the rust type-system
-
swimos_model
SwimOS Generic Representation of the SwimOS Serialization Model
-
tiny-ordered-float
Tiny version of OrderedFloat
-
goof
A reusable, composable, aggregate and
no_std
-friendly error library -
rombok
boilerplate generation macros like lombok
-
doc-search-dsl
procedural macro for creating complex regex patterns using a Domain-Specific Language (DSL)
-
netherite
A tokio implementation of the Minecraft Protocol with derive macros
-
uwuizer
Rust Macro to UwUize your text. UwU.
-
trot
Trait library
-
rt-format
Fully-runtime equivalent of the format! macro
-
erasable
Type-erased thin pointers
-
ubits
Bit fields and masks
-
cew
Personal Rust utility library
-
dispose
wrapper for values that must be consumed on drop
-
iter_fixed
Iterator of fixed length
-
uints
Unsigned Integer Properties
-
num_bound
Add bounds fn to anything implementing
Ord
that bounds a number to a range -
algorithmify
Create specifications for algorithms defined using Rust code
-
non_structural_derive
nonstructural derives for auto traits
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
typed-sql
A strongly typed sql serialization/deserialization framework
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
term_grid
formatting strings into a grid layout
-
aoko
extension library
-
git-ref-format
Everything you never knew you wanted for handling git ref names
-
scope-functions
Kotlin-inspired scope functions for use in almost any situation
-
bitmask
generator for enum scoped bit flags
-
string_from
A three-letter macro for String::from
-
unwrap-overflow-ops
arithmetic operations that always panic on overflow
-
brug
enum command generation for implementation blocks
-
fieldx
Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax
-
more-itertools
python more-itertools
-
complex-bessel-rs
compute Bessel functions
-
materially
A macro for material implication
-
ez_log
logging library for Rust
-
typeful
A collection of helper derive macros for type patterns
-
scratchstack-aws-principal
Principal types for AWS/AWS-like services
-
fmu_from_struct
A derive macro for automatically setting up FMU models in Rust
-
mongo_indexed
derive macro to declaratively index mongo collections
-
elain
Set a type's minimum alignment with const generics
-
deadlocker
Bringing builder pattern to defeat deadlocks
-
dims_macro
Macros for Generating Systems of Units
-
cstr-argument
A trait for converting function arguments to null terminated strings
-
prange2
Parse numeric ranges for indexing
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
tc-error
TinyChain's generic error struct
-
prev-iter
Iterator which allows you to view the previous element
-
enumeration
An extension to rust enum
-
init-once
Concurrent, non-blocking lazy initialization of values
-
closure
A macro for capturing variables on a per variable basis
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
apply
A tiny library for chaining free functions into method call chains
-
sumtype
Generate zerocost sumtype of iterators or closures
-
wrappr
A libary for some useful wrapping traits
-
type_cell
Attach values statically to a type using static get/set methods
-
mfem
A high-level Rust wrapper for MFEM
-
metw-locales
Locales for metw.cc
-
tf2-sku
SKU parser for Team Fortress 2 items
-
cifg
A macro for defining #[cfg] if/else blocks; alternate to cfg-if
-
accountable-refcell
A RefCell wrapper that provides actionable information for dynamic borrow failures
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
taskchampion-lib
Personal task-tracking
-
rusty-cmd
creating custom line-oriented command interpreters in Rust
-
mstr
2-word, immutable Cow<str>
-
error_set
An error set macro that simplifies error management by providing a streamlined method for defining errors and easily converting between them. Inspired by Zig's error set type.
-
refl
refl
encoding which you can use to provide a proof witness that one type is equivalent (identical) to another type. You can use this to encode a subset of what GADTs allow you to in Haskell -
fracpack
Convert to and from the fracpack format
-
glam-traits
Traits for the vectors in glam
-
tentacli-traits
Traits and types for tentacli and related projects
-
janus-plugin
creating plugins for Janus, the WebRTC gateway
-
rsconnect
Fine-grained reactivity in Rust
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
diffuser-edit
Edit diffuser models without GPU and Python
-
ordes
treating arrays and tuples a little bit more like vectors
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
panda-re
The official library for interfacing with PANDA (Platform for Architecture-Neutral Dynamic Analysis)
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
as_num
Checked conversions between Rust's numeric types
-
genmesh
A package for generating 3D meshes
-
random-number
Generate random numbers quickly
-
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
erreport
A Result helper to catch all the Err propagation path for Rust
-
typederror
A wrapper around anyhow that allows for a primary error 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
-
communication-layer-request-reply
dora
goal is to be a low latency, composable, and distributed data flow -
frunk_utils
working with frunk
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
pi_null
define trait is named Null. u8,u32,u64,Option...is implements Null
-
persian-rug
Framework for bringing together disparate objects with inconvenient relationships
-
tmux-lib
Tmux helper functions
-
aquamarine-demo-crate
A demo crate for aquamarine -- the mermaid.js integration for rustdoc
-
smol-symbol
compile-time globally unique, 25-character, 128-bit symbols similar to the Symbol type in Crystal Lang
-
c8str
String types that are both utf-8 and null terminated
-
syllogism
allow for some specialization using stable Rust
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
cock-lib
Measure the power level of a peen
-
elicit
SmartPointer-like structure for polymorphism
-
funkjon
One of the worst macros this world has ever been (dis)graced with
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
interning
Thread-Lcoal and Global Interning Library
-
zip_clone
Zip an iterator to a repeately cloned object
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
intrepid
Manage complex async business logic with ease
-
rust-decouple
ease the process of parsing environment variables
-
stem-cell
project to demonstrate the cross-platform release management process I use for my open source work
-
peekable-fwd-bwd
Iterator Peekable with multi-forward-peek and multi-backward-peek
-
doxed
making Rust doc strings available at runtime
-
direction
Representations of directions
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
mvutils
made from commonly used functions in my projects
-
rtlola-hir
A high-level intermediate representation for RTLola specifications
-
str_assert
Thin wrapper around stdlib assert_eq macros using dissimilar as the comparison. (Only for strings)
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
kurtbuilds_regex
Wraps the regex library to also provide macros
-
greattraits
My own collection for traits extending standard library types
-
bytestream
convenient way of writing binary data to a buffer
-
burrtype
A framework for exporting types to other languages
-
kittycad-execution-plan-traits
Types for KittyCAD execution plans
-
mudra
Currencies as distinct structs
-
pipelight_error
Pipeligh Error types
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
io-window
Seekable I/O adapter that limits operations to a byte range
-
cisness
Runtime 'live witness' of two types being the same
-
onechatsocial-result
Revolt Backend: Result and Error types
-
cdc
performing Content-Defined Chunking (CDC) on data streams
-
elor
Base generic implementation of an Either type
-
gilder
Golden testing library
-
macroex
An extractor based low level macro parsing crate that provides high level parsing support through derive macros
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
mazer-macros
A minimal, simple math markup language that compiles to HTML, written in Rust
-
gerber-types
Types and code generation for Gerber files (RS-274X)
-
piglog
beautiful way to print out log messages in the terminal
-
ux2
Non-standard integer types like
u7
,u9
,u10
,u63
,i7
,i9
etc -
sendable
Rc and Option equivalents that facilitate sending data between threads
-
yadir
Dependency Injection Registry for Rust
-
tuple_list
macro-free variadic tuple metaprogramming
-
inline_dyn
A container type for storing dynamically-sized types inline
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
entrypoint
opinionated application framework/wrapper that eliminates main function boilerplate
-
humane_commands
Allows you to write more shell-like Commands
-
autofolder
Single-element folding wrapper
-
windows-syscall
Windows inline syscalls for Rust
-
enumcapsulate
Safe casting for newtype enums and their variants
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
rcolors
terminal colorization/style tool written in Rust
-
maelstrom-test
Test macros for Maelstrom
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
composable-utils
functions for Option<T>, Option<Result<T, E>>, and Result<Option<T>, E>
-
struct-metadata
Macros for attaching metadata to structs
-
stack-vm
A generic, reusable, stack-based virtual machine
-
enum-rotate
Rotate and iterate your enums
-
hierr
RUST Error
-
transactional_iterator
Iterator that allows to commit or abort progress
-
typology
Type derivation for foreign use
-
fixnum
Fixed-point numbers with explicit rounding
-
singleton-manager
A programatical singleton manager
-
zoc
Z-order curve based multidimensional range search
-
bfbackend
Compiler backend for brainfuck
-
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
html_tag
An Enigmatic Way to use HTML in Rust
-
lucchetto
easily call a rust function without holding the GVL lock
-
tacit
macro to make newtypes easier to create
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
qm-utils
functions and macros
-
egui_animation
Experimental animation utilities for egui, including easing functions and a collapse view
-
perhaps
Maybe monad implementation with a more intuitive name. Using Certain and Dubious instead of Just and Nothing
-
round
your floats with precision from 1 to 10
-
hyperide
Builds strings from embedded HTML in Rust
-
closure_example
A short description of my package
-
add_macro
more additional macros to help you write code faster!
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
crates-io-macro-crate
An example macros-by-example crate for demonstrating a regression
-
asm_block
Translate tokens to string for Rust inline assembly
-
throw_error
wrapping, throwing, and catching errors
-
air-macros
Macros for the TNJ Assembly Intermediate Representation (AIR)
-
temp-inst
safe lifetime-erased representations for objects with lifetime parameters. Can be used to pass an object across an API where lifetime parameters would prevent it.
-
str-macro
The str!() macro, similar to vec![] but for strings
-
cfg-or-panic
Replace function bodies with
unimplemented!()
when condition is not met -
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
tuppipe
pipe operator-like implementation using tuples in Rust
-
unwinder
Call stack spoofing for Rust
-
terra-items
enum contatining terraria items and prefixes
-
ex_em_ell
Provide macros for serializing and deserializing XML
-
error-iter
Error::sources on stable Rust
-
exec-rs
that provides utility traits for task execution and, if the sync feature is enabled, the ability to synchronise tasks based on the value of a key
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>
to simplify your code -
flaky_test
atttribute macro for running a flaky test multiple times
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
ointer
Steal the high bits of a pointer to store an extra value
-
nightly-quirks
A basic set of utilities that mimic nightly behaviour in stable Rust, with the possibility of using nightly implementation with the nightly feature
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
objectionable
storage of unsized types inline inside allocated objects
-
chalk-macros
Macros for Chalk
-
field33_rdftk_names_temporary_fork
set of modules that contain the
IRI
s andQName
strings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
rsjsonnet-front
A Jsonnet front end (source loading and error printing) library
-
timed
Macros to time function execution
-
seqgen
Sequence generation library
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
inherent
Make trait methods callable without the trait in scope
-
mck
Type/operation utility crate for the formal verification tool machine-check
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
derive-merge-struct
A derive macro to partially update a named struct
-
rama-error
error types and utilities for rama
-
exhaustive
The trait for generating all values of a type, and a property-based test macro
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
scopefn
Scope functions for Rust
-
kusprint
A set of macros for printing objects to stdout without having to specify a template literal
-
try_default
A trait to optionally get the Default if present, or None if there is no Default
-
builder-pattern
A derivable macro for declaring a builder pattern
-
eventmill
Event sourcing and CQRS for Rust applications
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
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…
-
libipld-macro
ipld macro
-
chik-puzzles
Chik primitives needed for building wallets
-
gull
type generation
-
iter-n
functions returning impl Iterator to return one of several distinct types
-
json-query
Run jq programs to extract data from json strings
-
rtml
(r)ust macros for h(tml) expansion => rtml. (r)ust type safe (css) => rcss
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
re_error
Helpers for handling errors
-
oi-unwrap
unwrap without unwrap
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
sbse
skylar's simple errors
-
const_struct
macro that allows const structures to be passed as const generics
-
super_cell
A super (unsafe) cell that also implements send and sync regardless of the inner type's send/sync
-
lazy-init
Lazy initialization
-
gur
A undo-redo framework
-
match_cfg
A convenience macro to ergonomically define an item depending on a large number of
#[cfg]
parameters. Structured like match statement, the first matching branch is the item that gets emitted. -
loopcell
cell for multiple routes of access that are only used one-at-a-time in sequence
-
thiserror-ext
Useful extension utilities for
thiserror
-
coded
concrete error type with an
ErrorKind
enum matching Google’s “canonical error codes” -
lazyinit
Initialize a static value lazily
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
instancebuilder
Convenient way of managing dependency injection
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
retoken
Build &str tokenizers using regex
-
dbg_unreachable
Switch between unreachable! and unreachable_unchecked with a single macro
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
defer-rs
Deferred execution Rust utilities
-
rustpython-literal
Common literal handling utilities mostly useful for unparse and repr
-
retrying
General-purpose retrying library for Rust with macros and functions
-
rust-witness
Build a circom witness in Rust
-
effing-mad
The hottest algebraic effects library in Rust
-
openai-magic-instantiate
Use LLMs to instantiate well-typed values
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
tao-of-rust
《Rust编程之道》随书源码
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
hictor
declarative macro for __attribute__((constructor))/__attribute__((destructor))
-
cmdstruct
A lightweight macro for implementing commands with a struct
-
string_cache_codegen
A codegen library for string-cache, developed as part of the Servo project
-
fixed-macro-types
Macro aliases used in the
fixed-macro
crate -
assume
Macro for stating unsafe assumptions in Rust
-
consclr
console text colorful
-
iter-progress
Calculate progress of your iterators
-
quasi_iter
that contains supplementary iterator objects and methods
-
colourado-iter
A small and minimalistic library to generate a random color palette of infinite size
-
lemurs-8080
An emulator for the Intel 8080 microprocessor
-
k8s-controller
lightweight framework for writing kubernetes controllers
-
lawn-constants
error and logging types, traits, and codes for Lawn
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
accursed-unutterable-type-id
A worse version of std::any::TypeId
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
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
-
derive_variants
derives an additional enum from a nested enum that contains only variants and no nested fields
-
defile
Proc-macro helper to ungroup macro metavariables
-
entrance
A command line argument parser library which provides type assisted tools
-
nonicle
Tools for type-safe, canonical data representations
-
jkcenum
Rust enum library
-
eventually
using Event Sourcing in Rust applications
-
greedy_enum
derive macro of FromStr for enum
-
mac
A collection of great and ubiqutitous macros
-
market
Infrastructure for producers and consumers
-
control-flow
A hack to control control-flow outside closures
-
frayed
Unfused and unashamed iterators
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
kathy
Const-evaluated swift-style keypaths
-
grit-util
functions for GritQL and associated tools
-
variadics
Variadic generics on stable Rust using tuple lists
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
ambient-authority
Ambient Authority
-
physical-quantity
dimension and unit system for general physical physical quantities
-
ground-env
Parse env variables by defining a struct
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
std_nightly_to_stable_3db085279c83
-
named-block
Macro implementing early-exit-from-any-block
-
autoproto
Replacement derive macros for
prost::Message
, and supporting traits and types to make implementing this trait easier -
grouping_by
allows the user to group an iterator by various ways
-
parser_fuck
parser combinator library
-
deltoid
calculate and apply deltas to structs and enums
-
teo-teon
Object notation for Teo
-
flip-flop
implements the flip-flop operator from Perl and Ruby as a Rust macro
-
bitty_write_macro
A drop-in
write!
replacement that optimizes non-formatting writes for code size -
apparat
A lightweight event-driven behavioral state machine
-
enum-ptr
Ergonomic tagged pointer
-
roopert
object-oriented toolkit for Rust
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
prost-dto
Data transfer object conversion macros for prost
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
standalone-syn
Fork of syn that turns of the proc-macro feature in proc-macro2 and standalone-quote so as to remove the rustc dylib dependency
-
vmprotect
Unofficial VMProtect SDK for Rust
-
liftor
Functors for Rust lifetimes
-
runestr
User-perceived characters related types and data structures
-
enumx
Ad-hoc enum extension
-
fnrs
some useful functions i like
-
warrant
A Swift-guard-like macro for Rust
-
separator
Formats numbers into strings with thousands separators for readability
-
panic-message
Get a panic message from a panic payload
-
errify
Function error context provider
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
wext
web-sys extension traits, convenience functions and types
-
memtable
Inmemory tables for use in Rust
-
defmac
A macro to define lambda-like macros inline
-
internal
fields in Rust
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
despatma
Design Pattern Macro like Loki
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
fallible_map
fallible mapping over
Option
and iterators using functions that can returnResult
s -
any_cmp
Support dynamic type comparisons
-
degeneric-macros
Hides struct generics into trait associated types
-
labview-interop
Types and wrappers for interperating with LabVIEW when called as a library
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
macroland
macro shorthands of various types in Rust
-
tea-time
Time related dtypes for tevec
-
pathext
A small path trait extension with some convenience methods
-
terror
Uniform REST error response body, tailored for JSON
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
enum-derive-2018
macros for deriving additional functionality for enums
-
crosstrait
Cast from
dyn Any
to other trait objects, with no_std, no alloc support -
iterpipes
Compositional, pipes-style stream processing
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
async_timing_util
tokio async functions for waiting until even intervals (on 1 min, 5 min, 30 min, etc), or waiting until a specified timestamp
-
gobble
A Combinator based parser for strings that gets out of the way, and leaves your code looking like a grammer
-
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
ieee-apsqrt
Square root functions for IEEE floats using rustc_apfloat
-
multer-derive
derive for constructign type from multer Multipart
-
tyco
Macro for generating scoped TYped COntexts
-
com-scrape-types
Support code for bindings generated with com-scrape
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
sawp-ffi
FFI helper macros and traits
-
panicking
std::thread::panicking
analog available in theno_std
context -
chassis
Compile-time dependency injection framework
-
handle_errors
just a macro to get the thiserror with colors and the error place
-
thisctx
Easily create error with contexts
-
windows-helpers
Helpers for the windows crate
-
byteflags
A macro to generate bitflag-like structures with u8 flag values
-
singleton-attr
singleton procedural attribute and derive macro
-
hrbf
Hermite Radial Basis Functions with higher order derivatives
-
poison-guard
maintaining sane state in the presence of panics and failures
-
objid
Generate a random object identifier
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
messages
Runtime-agnostic actor library
-
type_utilities
Implementing more methods to rust type primitives
-
snowflaked
creating and working with snowflake ids
-
bloc
A state management library
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
macroquest
Write MacroQuest plugins in Rust
-
oberst
A type-safe command parser and dispatcher inspired by Brigadier and written in Rust
-
scope-lock
Safely extend lifetimes
-
box-dyn
Macro to derive the implementation of Trait for Box<T: Trait>
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
kitty_table
Very small and barebones library for printing tables of data
-
ty_map_gen
A type projecting map generator
-
light_enum
provide a derive keyword to generate a light enum
-
macro-dep-test
testing version resolution for associated macros
-
impl_ops
Macros for easy operator overloading
-
collection_literals
macros for initializing std::collections
-
squote
A clone of the quote crate that uses a String as its backing store
-
ifc_rs
IFC standard
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
is-odd
Returns true if the given number is odd
-
core_io
copy of libstd::io with all the parts that don't work in core removed. Most importantly, it provides the Read and Write traits. This crate is (mostly) automatically generated from the rust git source…
-
cgp-sync
Async-generic primitives to support both sync/async in context-generic programming
-
recvmsg
Traits for receiving datagrams reliably, without truncation
-
implementation
The implementation crate
-
slice-utils
A collection of slice utils, like itertools
-
shoogah
Add some syntactic 'shoogah' to Rust
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
ident-mash
Mash idents together inside macro_rules!
-
trait_cast_rs
Get your own Any with support for casting to trait objects
-
str_crypter
A macro library for XOR encryption and decryption of strings at compile time, meaning no cleartext strings will be in your release binary (when using the macro). The encrypted strings will be decoded at runtime.
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
readonly
Struct fields that are made read-only accessible to other modules
-
piston-float
Traits for generic floats in game development
-
ljmrs
LabJack LJM Bindings for Rust
-
oop
Object-Oriented Inheritence in Rust
-
stackbox
&own
ing references in stable Rust - no_std-friendly Box -
byte_set
Efficient sets of bytes
-
typestate
A proc macro DSL for typestates
-
dyncast
Downcasting made easy
-
is_empty
Easily check if the struct is empty
-
notzero
macro for constructing
std::num::NonZero*
from constants -
partial_derive2
makes all the properties of a struct type an optional property
-
pack1
Byte array newtypes for different primitive types
-
concat-string
macros for concatenating string slices into owned strings
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocal
type as an alternative tostd::thread_local!
that allows per-object thread-local storage, while providing a similar API… -
maflow
Flow macros: basically unwrap for return, continue and break
-
will_exit
work on program will exit
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
int-to-c-enum
TryFromInt - A convenient derive macro for converting an integer to an enum
-
kube-core
Kube shared types, traits and client-less behavior
-
dbus-strings
Rust native implementation of different D-Bus string types
-
partial-borrow
Partially borrow a struct
-
traitsequence
Traits to abstract over sequences
-
const-units
that lets you check the dimensions of your quantities at compile time and run time
-
hxdmp
A small utility to create hexdump output from byte slices
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
merge-hashmap
Merge multiple values into one
-
bossy
Opinionated convenience wrappers for
std::process::Command
and friends -
reax
A reactivity system for Rust that infers dependencies between functions
-
standback
New standard library, old compiler
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
savvy-bindgen
Parse Rust functions, and generate C and R code
-
koute/nes
emulator written in Rust
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]
macro for clearer debugging -
leptos_datatable
A leptos component for creating tables with data validation
-
min-max
max! and min! macros
-
word_iter
Iterator over all words in a string
-
fnichol-cime
A demonstration of a Rust CI build/test/release workflow supporting multi-platform testing, binary builds, Docker image building, and Crates.io publishing
-
typemap-meta
compile-time macro to create type-to-value maps
-
jmespath_community
JMESPath is a query and transformation language for JSON
-
azalea-brigadier
A port of Mojang's Brigadier command parsing and dispatching library
-
arc-interner
An interner that deallocates unused values
-
kmacros
Useful macros
-
steel-gen
Code generation crates for use within steel
-
tlns-google-oauth2-traits
A bunch of traits for
tlns-google-oauth2-traits
-
python-packaging
Python packaging primitives implemented in Rust
-
golangify
published at 01.04.2024 this crate brings familiar flavor for newcomers from golang
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
konst_macro_rules
detail of the konst crate
-
xselfref
Fork of the selfref library, with some additions
-
filters
Build filters/predicates with the builder pattern
-
vec_vec
When dealing with
Vec<Vec<T>>
is unavoidable -
dioxus-shareables
Hooks for sharing structures between components
-
illicit
An implicit thread-local environment which is indexed by type
-
type-layout-syn2
Derivable trait to view the layout of a struct, useful for debugging. Patched for syn 2.
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
nan-tag
NaN-tagged pointers in Rust, storing an f64 in the same space as a pointer
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
cadeau-sys
FFI bindings to Cadeau library, performance primitives and media foundation functions
-
shoulda
derive macro for test assertions
-
catch-unwind
Wrappers for catch_unwind that handle the edge case of the caught panic payload panicing
-
aspect
Toolkit for Rust
-
to_snake_case
that transforms strings to snake_case
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
selfref
Semi-pain-free self-referential pinned types
-
river-layout-toolkit
Write River layouts in Rust with ease
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
symbolism
Unique symbols made from human readable tags
-
eeric-interpreter
A front-end abstraction layer over eeric
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
matr
A metaprogramming library for Rust
-
string-config-parser
configuration file parser for Rust
-
kstring
Key String: optimized for map keys
-
imgref-iter
A small crate for iterating over the rows or columns of
imgref
buffers -
fast_delegate
delegate struct easy
-
ferrite-session
Session Types DSL for Rust
-
regex-macro
A macro to generate a lazy regex expression
-
frust
Functional Programming in Rust
-
nz
Collection of 100% safe macros for creating non-zero integers more easily
-
flexible-io
Wraps values such that dyn-safe IO traits need not appear as static bounds
-
defvar
A macro that makes defining environment variables easy
-
zerror
error interface for context-aware error-reporting
-
stringreader
wrapper for strings so that they can be consumed via the std::io::Read trait
-
simple_scan
Iterator extensions for simple scan operation
-
itermap
Iterator tools for maps (
HashMap
,BTreeMap
, etc.) -
quack
Duck typing traits
-
assert_unordered
A direct replacement for
assert_eq
for unordered collections -
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
inline-c
Write and execute C code inside Rust
-
helper
provided some useful proc macros for Rust
-
almost
comparing floating point numbers
-
incrstruct
Build self-referencing structs using two-phase initialization
-
advise
User-friendly status reporting
-
rsor
Reusable slice of references
-
jealousy
A wrapper arount the envy crate, providing an easily implementable trait
-
cflp
A context-free-language parser generated by procedural macros
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
ownedbytes
Expose data as static slice
-
redb_model_trait
Redb model trait
-
qed
Compile-time assertions
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
include_data_uri
include a file as a data uri
-
cli_input
Various functions for gathering user input in the terminal
-
tuplemagic
manipulating tuples through various operations like mapping, filtering, nesting, and reducing
-
delfi
Conveniently writing data to csv-files
-
prometheus-metric-storage
Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code
-
hado
Monadic do notation using a macro
-
tor-async-utils
Async/futures helpers for use with Tor
-
fancy-default
A better
derive(Default)
implementation -
yansongda-utils
rust 中一些关于我自己的常用工具
-
read_lines_into
Read lines (from a Path, File, etc.) into a struct (a String, a Vec<String>), and with various ways to handle line endings and whitespace
-
lexi-matic
A Lexer Library
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
progress-streams
Progress callbacks for types which implement Read/Write
-
xconstants
Adds preliminary support for enum const generics
-
rnet
Easily call into Rust from C# or other .net langauges
-
swapbytes
swapping the endianess of structures
-
borrow-or-share
Traits for either borrowing or sharing data
-
ironcalc_base
The democratization of spreadsheets
-
iter_accumulate
An iterator adaptor that accumulates the elements and yields the current accumulated value for each iteration
-
rbtag
A procedural macro to add build DateTime and git commit information at compile time
-
ftkit
A small set of utilities for newcomers learning Rust
-
anonymous-trait
Anonymous trait implementation with capturing the environment
-
tenacious
[RETIRED: Will not work with MIR] A plugin to prevent certain types from being moved
-
get-field-by-type
Get a value of field, based on the type of a field
-
intern-all
A safe and predictable interner for data of mixed and arbitrary type
-
posix-errors
Posix error codes and handy functions for using them
-
accompany
with
-like macro for Rust -
shvar
POSIX-compliant shell variable substitution routine
-
tosserror
derive(Toss)
-
hallib-rs
General types and functions that I use a lot
-
conv2
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
unwrap-enum
generate methods to access enum variants
-
partial_function
A clean way to define function as a set of subfunctions where each has defined start and end bounds
-
sid
Id. Tiny crate providing strongly typed ids and an id-based vector.
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
rancor
Scalable and efficient error handling without type composition
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
bidir_iter
Bidirectional iterators
-
osu-file-parser
parse an osu! beatmap file
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
apply_conditionally
Chain and apply methods on objects conditionally
-
cantor
A general toolkit for working with types that have a small number of values
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
tracerr
Custom compile-time captured error tracing
-
sqlx_query
Expands to either sqlx function
query
or macroquery!
call depending onsqlx_compiletime_checks
has been enabled during the build -
xreflect
Basic macros for dynamic reflection of structs/enums
-
error_handling
Macro used to clean and centralize error handling within async processes
-
kuchikiki
(口利き) HTML tree manipulation library
-
proptest_async
proptest macro supporting async tests
-
trait-gen
Trait implementation generator macro
-
dyn-error
Error-related utilites for Rust
-
nanoval
A nan-tagged value for representing f64, i32, u32, booleans, null and arbitrary pointers
-
diesel_derives_traits
Traits for diesel_derives_extra
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
macro-utils
Some macros to make code writing more elegant and funny
-
pusherator
Push-based version of Rust iterators
-
string-newtype
New Type idiom helper for string-like types
-
lurk-ipld-macro
lurk-ipld macro
-
sod-crossbeam
Service Oriented Design - Crossbeam
-
dev_bestia_url_utf8
url utf8 encode/decode
-
no_std_strings
no_std version of crate fixedstr: strings of constant maximum size that can be copied and stack allocated
-
value_unit
every unit imaginable. Also contains a handy macro
-
custom_float
Custom floating-point types
-
simple-di
dependency injection for Rust
-
pad-adapter
that provides pad adapter
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
delegare
delegate struct easy
-
curerr
easy error handling
-
lootr
RPG-like looting system
-
unroll_range
Repeats a block of code for each number in a specified range
-
brain_flak_macro
Brain-Flak macro
-
ad-hoc-iter
Ad-hoc exact size owning iterator macro and other optional utils
-
pretty_panics
pretty panic messages
-
dyn-hash
Hash trait that is object-safe
-
nanocl_error
Nanocl error types
-
vnum
Create enums with a constant value associated to every variant
-
interpolate
form of string interpolation
-
macro_lisp
Lisp-like DSL for Rust language
-
slice-copy
Go style copying for slices
-
try_as
Macros and traits to ease using enums whose sole purpose is to enumerate a set of types
-
asset-derive
asset handling derive macro for enums, and a proc-macro learning resource!
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
enum_macro
Useful macro for enum
-
lateinit
Unsafe late-initialization for statics
-
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
-
clone_cell
A Cell that works with a restrictive form of Clone
-
rcss-layers
Part of Rust CSS embedding library that allows saving styles as seperate layers
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
wrapping-macro
wrapping macro
-
nofmt
nofmt::pls
, a macro that does its best at preventing a code block from being mangled -
macro_error
A macro to display error message
-
string-join
A python-like way to join items in an iterator with a separator
-
projecture
Easy arbitrary type projections without proc macros
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
wasmer-wit-bindgen-gen-core
wit-bindgen-gen-c
-
vm6502
A 6502 virtual machine backend
-
sails-macros-core
Implementations of procedural macros for the Sails framework
-
close-err
Add .close() to file-like types, for error handling
-
throw
Efficiently add statically-calculated stack traces to errors
-
metaprogramming
Port C++ metaprogramming to Rust
-
tupley
Extension for primitive tuple (Hlist based on recursive structure)
-
num-sign
enum Sign { Positive = 1, Negative = -1 }
-
nanopre
A a zero-dependency, no-unsafe implementation of a minimal C-style text preprocessor
-
casual
parsing user input
-
uni_tmp_jni
It's temporary fork for https://crates.io/crates/jni. Don't use!
-
fmap
Functors in Rust
-
vmm
A math library focused on vectors and square matrices
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
remit
Rust generators implemented through async/await syntax
-
racros
Collection of rust macros
-
asserteq_pretty
An assert_eq macro that prints more helpful diffs on mismatch
-
astr
A const lenght stack str
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
cast_trait_object
Cast between trait objects using only safe Rust
-
htmxpress
Procedural macros for generating htmx strings
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
printc
Print-clean macro. Like
println!
but cleaner input. -
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
ghost-lite
custom PhantomData types
-
veccell
variant of Vec with interior mutability
-
beetle-nonzero
Combines the std
NonZero
structs into one struct -
retry-error
An error type for an operation that can fail more than once
-
throwing
Create explicit errors easily with a handy macro
-
rustils
Utilities for rust
-
hereditary
Procedural macros for emulating OOP Inheritance in Rust
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!
,include!
, orconcat_idents!
) -
const_sort_rs
Sort slices in const items
-
wgsl-types
WGSL Types
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
ptrplus
Additional funtionality for pointer types
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
bronzeflow
Bronze: A workflow scheduler in rust
-
nougat
(lifetime) GATs on stable Rust
-
tcs-dhbw
Modules for a model traffic control system project at DHBW Stuttgart
-
pyadvreader
Split text file into text sequences, strings and (line) comments
-
aoc-util
function for aoc
-
tugger-snapcraft
Snapcraft packaging primitives
-
dyn_traits
Magically derive non-object-safe traits
-
fold-license
Folding licenses from multiple dirs with
cargo
/Cargo.toml andyarn
/package.json -
pluck
Extract values conveniently
-
trigram
Trigram-based string similarity for fuzzy matching
-
enum_pipeline
way to use enums to describe and execute ordered data pipelines
-
introspect-core
containing the core functionality used for
introspect
and supporting crates -
filterable-enum
generating filterable enums (Combining bitflags and discriminated unions)
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macros
when automatically deriving types -
vector3d
3D vector type
-
symbol
globally interned strings
-
ip-family
IP family enum with functions to get special ips of the right family
-
knife
An iterator that divides things evenly
-
name-it
Give a name to async fn return types
-
pyspark-arrow-rs
Derive macros to be used to add some helper functions to Rust structs to make them useable in Pyspark's mapInArrow
-
type_reflect
Extensible runtime reflection through a Derive macro
-
min-specialization
Experimental implementation of specialization
-
valid
Validate custom types by composing primitive validation functions. Use one common API for validating all kind of business rules including aspects of the application state. One common error type for all…
-
drop-bin
Defer running expensive destructors until later
-
crdts_macro
CRDTs proc_macro
-
unwind-unsafe
Zero-sized marker types which do not implement UnwindSafe or RefUnwindSafe
-
termal_core
contains implementation for the termal library
-
tuplify
Generic hlist/tuple library
-
smartcow
a cow for smartstrings
-
roadblk
Validator integration
-
repeated
Allows you to repeat a block of code a number of times
-
rhizo-types
A collection of common Structs and Enums used in the software components that comprise the Rhizo network
-
try-partialord
Safe failable sort, min, max, binary_search functions for PartialOrd. No need to wrap f32, f64 to sort any more.
-
stringlit
A macro to convert from str to String
-
standalone-proc-macro2
Fork of proc-macro2 that uses rustc-ap-proc_macro so as to remove the rustc dylib dependency
-
anony
Anonymous struct
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
procedural-masquerade
macro_rules for making proc_macro_derive pretending to be proc_macro
-
iex
Idiomatic exceptions
-
tryvial
Small crate for ok-wrapping and try blocks
-
sconcat
String concatenation
-
failsafe
A circuit breaker implementation
-
onlyerror
Obsessively tiny error derive macro
-
ucsi
SI-based unit typing system
-
pluginop-rawptr
Safe abstractions atop raw pointers
-
mod_use
pub mod xxx; use xxx::*;
-
strck
Checked owned and borrowed strings
-
zoomer
Making Rust a true modern language™️ with revolutionary macros
-
swimos_num
SwimOS Numeric Helper Macros
-
mightrix
treat continous memory as a matrix
-
type-variance
Marker traits for subtype variance
-
to_tokenstream
An interface for creating a compiler within a Rust macro
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
wtflip
A language in a Rust macro... or something.
-
adventage
Advent of Code, easier!
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
enum-unitary
Trait and macro for unitary enums
-
early_returns
Macros to make early returns easier to work with in Rust
-
mathelogos
as a functional programming language
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
turbostate
Finite State Machine
-
enums_arena
enums_arena
is an arena that enums can be stored efficiently -
anymap3
A safe and convenient store for one value of each type
-
tailsome
Blanket traits providing
.into_ok()
,.into_err()
, and.into_some()
for happier method chaining -
io-read-line-prototype
Prototype for io::read_line
-
err-convert-macro
Errors converting macros
-
smurf
SMall Useful Rust Functions
-
darkly
scanf-style scanner
-
string_morph
string case transformations with an emphasis on accuracy and performance. The case conversions are available as functions as well as traits on String types.
-
let_clone
Declarative macro to clone multiple values at once
-
lexington
A very simple library for lexing / parsing
-
lazy_thread_local
Lazily initialised per-object thread-local storage
-
todo_using
A super small crate only exporting a single macro to "use" parameters
-
except
The only one
Error
-
multi_stack_queue
Abstraction layer for a stack-allocated multi-queue with bounded length. WIP
-
target-cpu-fetch
Exposes a method for querying the CPU name from the current target specification JSON file
-
oneshot-fused-workaround
Fused wrapper for futures::channel::oneshot
-
easy-min-max
Easy to use macros for min, max and clamp. Works with no_std
-
strongly
A proc macro to create strongly-typed primitives
-
forkable
Fork-able iterators and asynchronous streams
-
regi
Regi
-
comp
Pure-macro Do notation and List-comprehension for Option, Result and Iterator
-
retryiter
A wrapper lib on top of rust Iterator with added retry support
-
navigator
A Macro-heavy Domain-Specific Language for console apps with menu systems
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
gha_main
Convenience macros for writing GitHub Actions in Rust
-
destruct
structs and enums for simpler combinator implementation
-
iter_from_fn
Create iterator from repeatedly aplying a function that takes no parameters
-
rustc_utils
working with the Rust compiler
-
cryo
Extend the lifetime of a reference. Safely.
-
opera
Marker types that are easy to understand
-
irox-types
Enums and structs to describe Rust's basic type system
-
eiffel-macros
Eiffel is a library for Eiffel language inspired guard clauses with Rust macros. This is the macro rules part of the library.
-
ddi
Dynamic dependency injection library for rust
-
another-visitor
Lets you derive visitor pattern implementations
-
bilk
Miscellaneous convenience functions and traits
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
rerast_macros
Macros for use in Rerast rules
-
simple-dmenu
macro to call dmenu
-
cudd-sys
Bindings for CU Decision Diagram library (CUDD)
-
enum_derive
macros for deriving additional functionality for enums
-
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… -
ever
Print the build information of your program with minimal boilerplate
-
bparse
parsing bytes
-
rexpr
Rust Json Object access Runtime
-
buco
A compile-time builder pattern implementation for Rust
-
genesis
generating statically-typed ECS worlds
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
tokio-go
a golang like macro: go! (closure) backed by tokio. Supports threadpool dedication.
-
sha2-derive
exporting a derivable
Hashable
trait that works withsha2
-
xkcd_unreachable
macro xkcd_unreachable!() inspired by https://xkcd.com/2200/
-
dyn_ord
Equality and ordering for trait objects
-
try_utils
The try! macro descends into an enum variant. It's more flexible than ? and unwrap(), and it works with your enum, too!
-
callable
closures implementing PartialEq and argument operations
-
tailwag_macro_inline
The logic for A collection of macros to support the tailwag crate
-
mcurry
Macros for creating curried functions
-
redis-om
Redis ORM-style library that simplify the development process and reduce the amount of boilerplate code needed to build programs that leverage [redis] powerful capabilities and use cases
-
generic-mutability
Allows the creation of APIs that are generic over mutability
-
guest_cell
Storage space for externally-owned private data
-
const_power_of_two
working with constant generics that are powers of two
-
linq
Language Integrated Query in Rust
-
nias
closure generator library
-
extended-primitives
providing primitive-like types for use
-
to-syn-value
Defines a derive macro to implement a trait converting values to instances of syn::ToDeriveInput
-
n-functor
Faux-derive a
map
function for types with one or more type parameters -
hb_error
Useful macros and traits for creating and handling errors
-
win9x-sync
Windows 9x compatible synchronisation primitives for Rust
-
syn-test-suite
Test suite of the syn crate
-
batch_oper
some batch operation macro for some operations
-
pattern_code
Given a path patterm matched source code
-
range_check
bounds-checking and range helpers
-
laby_common
Shared code required by laby
-
log_err
Log error messages from Unwrap and Expect with log crate
-
string-eyre
Convenience traits for dealing with errors that don't want to eyre
-
rs_transducers
transducers for Rust
-
oofs
Error handling library that generates and injects context for you
-
iter_ref
Traits for iterating over referenced data without consuming the iterator
-
std_io_iterators
An iterator for
STDIN
and a wrapper forSTDOUT
. Allows easy piping, and graceful closing of application if pipe breaks -
split-iter
Allows splitting of iterators
-
const-chunks
Extension trait to chunk iterators into const-length arrays
-
pisserror
A golden rip-off of thiserror
-
avocado-schema
A schema DSL which can be interpreted to implement multiple purposes
-
rustility
A collection of utilities I often find myself using in Rust
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
similarity
calculating similarity between numerical slices
-
ordered_iter
Ordered iterators
-
bogdan_hello_macro
adds the method hello_macro that generates a greeting based on the name of the struct
-
prompt-organizer
better manage AI prompts in your Rust code
-
instruct-macros-types
Instructor Macro Types are a collection of simple types that we export to work with the instruct-macros crate
-
dependent_ghost
Matt Noonan's 'Ghosts of Departed Proofs'
-
repr-trait
Traits to represent Rust reprs
-
heimdall_errors
Macros for From trait errors
-
linux-errnos
A list of error numbers
-
persian_str_rs
functions for working with Persian strings in Rust
-
displaythis
derive(Display)
-
iter-skak
Combines std::iter::Skip and std::iter::Take into one
-
dry-mods
Macros to make your module management DRY
-
page-turner
A generic abstraction of APIs with pagination
-
makepad-internal-iter
Internal iterators
-
etest-impl
etest's proc_macro part
-
vec_filter
Vec Filter is a Rust library to filter a vector of structs based on a query string. It allows you to specify filter conditions on struct fields with a simple query syntax. The library provides a custom derive macro…
-
dyn-any
An Any trait that works for arbitrary lifetimes
-
tyenum
Attribute macro for type enums
-
pin-init
Safe pinned-initialization in Rust
-
panda_pile
Traits for lazily producing and consuming sequences
-
lup
A custom indexed loop macro library for Rust
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
retry-block
retry operations that may fail with configurable backoff behavior using macros over blocks of code
-
btl
shell scripting in rust. Github Repo: https://github.com/znx3p0/btlsh
-
prost-unwrap-core
A procedural macro implementation for prost-unwrap library
-
either_n
An Either enum with N variants
-
fluent-asserter
write tests assertions with a fluent interface
-
macon_api
builder macro-based generator with its own idioms
-
into-bytes
For converting into Vec<u8>
-
splop
Helper functions to determine the first/last repetition of something
-
okey
Everything is Result::Ok
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
enum_index
Trait and macros for extracting Enum variant index
-
rust_c
Write C code inline in your rust code (hacky fork of rust-cpp / cpp crate)
-
enum-assoc
Procedural macro to associate constants with enum variants
-
disuse
The way to notify the implementation which return value is disuse
-
amass
Automatically generate
From
impls for nested enums, even across crates -
type-factory
unique opaque types
-
mapper-api
Api of the
mapper
crate -
forsyde-io-libforsyde
The LibForSyDe trait hierarchy and their functions, built on top of the Rust ForSyDe IO supporting library
-
kvtree
Heterogenous in memory key value tree storage
-
internship
Interned string and more
-
ssi-core
Core types and traits for the ssi library
-
agoraui-runtimes
AgoraUI reactive runtimes
-
benda
Use Bend language functions and capabilities in Python!
-
for-loop-iterator
Iterators like traditional for loops
-
fn_macro
函数宏
-
loop_chain
Macro for writing nested Loop expressions
-
iter_all
Iterate all enum vases
-
type-handle
Regular and reference-counted type handles
-
detour2
A cross-platform detour library written in Rust
-
serde_type_name
lookup name of type for any struct or enum that derives serde Serialize
-
furtif-core
Flexible User-oriented Rusted Toolbox for Information Fusion: a data fusion toolbox based on asynchronous and interacting processes, particularly focused on belief functions fusion
-
anxious
panic-free dialect of Rust
-
wave_func_collapse
wave function collapse algorithm
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
stupiderators
Iterators for Indeedee, mostly
-
ctrlgen
Generate enums for message-passing services
-
libmw
constructing a pipeline of middleware functions
-
bytecoding
Derive macro for encoding and decoding instructions and operands as bytecode
-
tournaments
running tournaments
-
fullypeek
Peek forward in an iterator as far as you'd like, memory allowing!
-
repeater
Proc-macro for repeating tokens
-
breakable-block
A shim library for a stable implementation of what is proposed in RFC 2046
-
quantified
Specify the universe: None, Some, Excluding, and All
-
bystr
macro to create compile-time, fixed length, byte array from a string
-
wrapping_macros
A macro for wrapping arithmetic
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
eth2_ssz_types
types with unique properties required for SSZ serialization and Merklization
-
multiple_errors
Propagate multiple errors instead of just the first one
-
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox
. -
cron_macro
cron macro
-
structinator_traits
traits allowing transfer of data from iterators to structs
-
rust_jsc_sys
Low-level bindings to JavaScriptCore
-
grade
A convenience macro for gtk-rs
-
value-bag-sval2
detail for value-bag
-
flagged
Bitflag-based warning type
-
cast_checks_convert
-
these
A three-way enum capturing This, That, or Both. Inspired by the Haskell package https://hackage.haskell.org/package/these
-
timed-locks
Smart pointers to
tokio::sync
locks that either panic or error after a timeout -
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
reinterpret
Low level utility functions to reinterpret arrays of data
-
temp-stack
A data structure for contexts or similar stack structures that are allocated on the call stack, using the temp-inst crate for lifetime erasure
-
lens-rs
lens implemented in rust
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
vec-utils
vector utilities
-
ref_thread_local
A macro for declaring thread-local
static
s like using both oflazy_static!
andRefCell
-
thisisplural
#[derive(Plural)] for creating frictionless new types with any collection type like Vec or HashMap
-
rs-std-ext
An extension for the standard library
-
thiserror-nostd-notrait
derive(Error)
-
serenum
Generate string representation for a enum
-
crashreport
Automatic GitHub crash reporting system for any Rust crate
-
ferment
Syntax tree morphing of FFI-compatible stuff
-
amethyst-inspector
unity-like inspector for amethyst
-
resultit
Iterator adapters for iterators over results
-
variant_count
Derive macro for enum which adds to it the count of variants
-
const-ft
Macro for wrapping const fn in a feature gate
-
scan-rules
some macros for quickly parsing values out of text. Roughly speaking, it does the inverse of the print!/format! macros; or, in other words, a similar job to scanf from C.
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
termcolor_output
Interface crate for styled output to termcolor through macro
-
iter-diff
Differences between iterators
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
char_combinator
An iterator to create all combination of a given char range
-
shoggoth
Generic and type-level programming for Rust
-
open-ambient
Open files and directories with constant paths
-
teloc
compile-time DI framework for Rust
-
struct_iterable
providing a proc macro to make a struct iterable
-
as-result
Traits for converting types which may be interpreted as or into a result
-
zkp-macros-decl
Procedural macros
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
rsyntax
-
dev_bestia_string_utils
string manipulation
-
try_map
try_map
andflip
methods forOption
. These allow more ergonomic error handling when mapping functions that returnResult
overOption
. -
quick_io
facilitate input and output within programs, with a set of macros
-
adhocerr
construction of efficient single use static/dynamic error types per callsite
-
versioned-file
adding versions and upgrade schemes to files
-
easy_switch
A macro for traditional C-style switch statements
-
rangecutter
working with adjacent ranges
-
validus
A string validation library
-
context-rs
Pass values down the async call stack, with no_std and no_alloc support
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
simplify
simplify-js port to rust
-
gitoxide-core
implementing all capabilities of the gitoxide CLI
-
hs-bindgen-traits
traits behind hs-bindgen ergonomics
-
iprint
debugging utility that prints indented text based on function call depth
-
escher
Self-referencial structs using the async/await transformation
-
jni-mangle
Mangle Rust functions for use with JNI
-
genztools
Tools for readability of Result and Option types for zoomers
-
multi_try
Safely combine results
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
todo
Minuscule
TODO!
macro that lets you type-check and test but prevent compiling in release mode -
write-to-file
Write to a file, simple helper fn and traits lib crate
-
tinypointers
Pointer implementations that take 8 or 16 bits
-
r4
A compact macro that generates iterators using for comprehensions and natural Rust syntax
-
std_prelude
prelude that the rust stdlib should have always had
-
common_macros
common macros like
hash_map!
orhash_set!
(WIP) -
curmacro
usefull macros like struct getters and setters creation macros
-
en
The easiest numeric traits!
-
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
only_every
rate-limiter macro: only_every!(Duration::from_millis(200), expensive_expression)
-
garando_pos
Backport of libsyntax_pos
-
readfilez
Quite fast file to slice reading
-
clap-adapters
Neat adapters for parsing config files with clap
-
fungus
reduce code verbosity
-
asyncsync
Runtime-agnostic synchronization primitives for asynchronous Rust
-
ld_preload_helpers
Macros to run code at load time and override C functions
-
r3bl_redux
Redux library built using Tokio, concurrent & parallel
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
type_enum
Create tagged unions consisting of different types
-
binstring
Binary strings
-
superstruct
Versioned data types with minimal boilerplate
-
sod-log
Service Oriented Design - Log Integrations
-
fb_cloned
Cloned macro
-
noders
NodeJS-like event loop environment for Rust
-
stringedits
Edit trait and associated iterators for small edits to strings
-
phantomdrop
Go-like deferring of function calls
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
impl-tools-lib
Helper macros: autoimpl
-
scalar_map
map
for scalar types -
inter-struct
Automatically generated traits for arbitrary structs
-
try-iterator
Adds a few fallible methods to iterators
-
reglex
lexer generator using regex
-
pingora-error
Error types and error handling APIs for Pingora
-
geo-aid-internal
Internals of Geo-AID. Can be used for creating alternative interfaces.
-
algebloat_macros
RustAlgebloat utility macros
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
cmd_error
print an error message and exit while unwrapping Options and Results
-
namedarg_hack
namedarg main package
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
string-utility
substring implementation (with the RangeBound trait), keep string before or after a specified string, etc
-
bail_macros
Bail macros for Options, Results and more
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
rust-enum-derive
(and program) for generating rust enums and associated traits from text files
-
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 -
components-arena-traits
Does not intend for direct use
-
function_overloading
that adds function overloading
-
bitbag
A useful struct for dealing with bit flags
-
even_bigger_s
Better String Literal
-
targets
Some helpers to get you started with declarative programming in Rust
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
slots-slice
manipulating slices of optional values
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
using
A macro for simpler builders with method cascading
-
traverse
Proof-of-concept trait for internal iterators called traversals
-
cxx-symbols
detail of the
cxx
crate -
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
whaterror
Customizable handling for fallible main
-
oxydized-money-macros
Companion library to oxydized-gains providing convenience macros
-
herbie-lint
A rustc plugin to check for numerical instability
-
chisel-common
Chisel common macros, types and functions
-
ident-util
macro to determine the string name of a binding, type, const, or function
-
buffer
Safe, write-only, generics-free buffer abstraction
-
nyavascript
Lisp implementation. Called NyavaScript because I'm a monster
-
max_values
Struct and iterator extension trait for getting max values out of given
-
conventus
Traits for assembling and disassembling items
-
pre
Compile-time assistance for working with unsafe code
-
retry-policy
Retry Policy
-
ataraxy
Discord slash commands framework for Serenity
-
phtm
Re-exports for common uses of
PhantomData
-
parse-format
Format string parser used by rustc
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
pretty-error-debug
Write out the
Error
message and chain -
fat_type
A type which permits thin references to arrays and dynamic types
-
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…
-
chandeliers-err
Internal error message generators for the Chandeliers project
-
memory-size-type
A data type for dealing with memory sizes
-
enum-lexer
A proc_macro lexer generator. using
enum
-like syntax. -
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
switch_statement
switch statement macro
-
for_each_repeat
Iterator::for_each
that can repeat current iteration -
racer-interner
thread-local string interner for racer-rust
-
input-macro
No-nonsense input!(...) macro for Rust
-
ruroonga_command
A tiny Groonga query builder and generator
-
type_description
Machine-readable type descriptions
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
atruct
macros for anonymous structs in Rust
-
pfn
Provide fn_trait’s
call
,call_mut
, andcall_once
on Stable Rust -
eager
macro expansion
-
lua-macros
Useful macros to join Lua with Rust
-
flexpiler
Deserialiser aiming at high customizability
-
itermacros
Some useful macros related to iterators
-
constrained_type
On the fly value objects in Rust
-
closure_capture
Capture variables are moved into closure or async block
-
sh-inline
Macros to run inline shell (bash) script
-
namedarg_rustc_macro
namedarg main package
-
sycamore-state-core
sycamore-state core types and trait definitions
-
mat-rs
no_std implementation of mathematical matrix types
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
qwutils
some utilities
-
py-comp
A macro implementing a Python-like generator expression
-
never-say-never
The never type (the true one!) in stable Rust
-
iota-rs
macro for other Go refuges who miss const blocks and iota
-
slid
labeled IDs
-
wgpu_bind_dsl
An experimental macro dsl for describing Bind layouts in wgpu-rs
-
dynstack
A stack for trait objects that minimizes allocations
-
size
expressing, formatting, and interacting with file sizes
-
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
concat_strs
Macro for quickly building a String from components
-
stack-tokens
stack token implementation for convenient TLS borrowing
-
dyn_partial_eq
PartialEq macros for trait objects
-
derive-attribute
A set of macros to automatically deserialize standard attributes
-
schemars-zod
A few functions to aid Zod schema generation from rust types annotated with schemars
-
io-extra
An extension trait for
std::io::Error
, with shorthand constructors for variousstd::io::ErrorKind
s -
iter-tee
Make several clones of an iterator
-
ambience
Lightweight library for passing ambient parameters
-
makero
A
macro_rules!
macro to aid in the creation of complexmacro_rules!
macros -
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
polimorphism
Function overloading via a procedural macro
-
rassert-rs
macro for expressing Result-returning assertions
-
therror
derive(Error) with a twist (based on thiserror)
-
err-per-field
A more fine-grained control over field-level error handling
-
ts_quote
Procedural macros for quasi-quoting TypeScript from Rust
-
vector_calculus
A single easy-to-use library for all vector calculus computations
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
ejni
working with JNI more pleasant
-
negative-impl
Negative trait implementations on stable Rust
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
csharp_binder
generate C# bindings for a Rust foreign function interface (FFI)
-
boolinator
trait, which lets you use Option and Result-style combinators with bools
-
haz
A thin abstraction over polymorphic environments
-
safe_unwrap
allows unwrapping and annotating that the unwrap will never fail. Does not require
std
. -
common_regex_rs
Set of common regex for Rust
-
cex
Checked exception simulation
-
nstd_env
NSTD env crate
-
fs_util
A package providing a few useful functions that std::fs does not
-
new_type
Experimental implementation of newtypes by type level logic
-
find_all
A (nearly) identical alternative for
Iterator::find
which returns anOption<Vec<usize>>
containing all elements which meet a given predicate (instead of just the first) -
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
coercible_errors
Zero-cost error handling for generic traits
-
mapstruct
Create refactor safe derivatives of Structs with proc-macros
-
alrulab-core
Alrulab Core Library
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
err-context
Lightweight context layers for stdandard library errors
-
c-emit
Polished builder API to write C Code
-
detach
helper type for being able to detach/reatach a member item
-
mods
Simpler module declaration
-
proc-easy
Macros to make writing proc-macro crates easy
-
assure
macros for Rust runtime checks and error handling
-
orderless
Orderless/named functions in Rust.
add!