-
zerocopy
makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
-
bitflags
A macro to generate structures which behave like bitflags
-
anyhow
Flexible concrete Error type built on std::error::Error
-
http
A set of types for representing HTTP requests and responses
-
derive_more
Adds #[derive(x)] macros for more traits
-
generic-array
Generic types implementing functionality of arrays
-
once_cell
Single assignment cells and lazy values
-
ordered-float
Wrappers for total ordering on floats
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
predicates
boolean-valued predicate functions
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
utoipa
Compile time generated OpenAPI documentation for Rust
-
shellexpand
Shell-like expansions in strings
-
thiserror
derive(Error)
-
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…
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
signal-hook
Unix signal handling
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
bytes
Types and traits for working with bytes
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
human-panic
Panic messages for humans
-
snafu
An ergonomic error handling library
-
enumflags2
Enum-based bit flags
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
approx
Approximate floating point equality comparisons and assertions
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
typed-builder
Compile-time type-checked builder derive
-
similar-asserts
assert_eq! like macros with colorized diff output
-
headers
typed HTTP headers
-
pyo3-stub-gen
Stub file (*.pyi) generator for PyO3
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
enum-map
A map with C-like enum keys represented internally as an array
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
inventory
Typed distributed plugin registration
-
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.
-
string_cache
A string interning library for Rust, developed as part of the Servo project
-
rustdoc-types
Types for rustdoc's json output
-
az
Casts and checked casts
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
nonempty
Correct by construction non-empty vector
-
smol_str
small-string optimized string type with O(1) clone
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
zerovec
Zero-copy vector backed by a byte array
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
pin-project
safe and ergonomic pin-projection
-
arrayref
Macros to take array references of slices
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
bitfield
macros to generate bitfield-like struct
-
dlopen2
opening and operating on dynamic link libraries (also known as shared objects or shared libraries)
-
facet
Reflection for Rust: introspect types at compile time with metadata for serialization, pretty-printing, CLIs, and more
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
extendr-api
Safe and user friendly bindings to the R programming language
-
base62
encoding/decoding library
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
volatile
wrapper types for raw pointers
-
rustc_apfloat
Rust port of C++ llvm::APFloat library
-
float-cmp
Floating point approximate comparison traits
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
nutype
The newtype with guarantees
-
by_address
Wrapper for comparing and hashing pointers by address
-
pact_consumer
Pact-Rust module that provides support for writing consumer pact tests
-
assert_matches
Asserts that a value matches a pattern
-
memoffset
offset_of functionality for Rust structs
-
konst
Const equivalents of std features: comparison, destructuring, iteration, and parsing
-
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… -
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
tap
Generic extensions for tapping values in Rust
-
atomic_refcell
Threadsafe RefCell
-
dyn-clone
Clone trait that is dyn-compatible
-
io-lifetimes
A low-level I/O ownership and borrowing library
-
derive-where
Deriving with custom trait bounds
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
writeable
A more efficient alternative to fmt::Display
-
aide
A code-first API documentation library
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
bounded-collections
Bounded types and their supporting traits
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
testresult
type for concise and precise test failures
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
codegen
generating Rust code
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
const-gen
generating (relatively) complex compile-time constants in rust
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
oxc_index
Newtype-style helpers for
Vecandusize -
swift-rs
Call Swift from Rust with ease!
-
dynosaur
Dynamic dispatch for return position impl traits and async in Rust
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
jsonptr
Data structures and logic for resolving, assigning, and deleting by JSON Pointers (RFC 6901)
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
fallible_collections
adds fallible allocation api to std collections
-
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
-
easy-cast
Type conversions which are expected to succeed
-
rootcause
A flexible, ergonomic, and inspectable error reporting library for Rust
-
constcat
concat! with support for const variables and expressions
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
bilge
Use bitsized types as if they were a feature of rust
-
orchestra
Generate an orchestra of subsystems from a single struct
-
rustc-literal-escaper
code to unescape string literals
-
pinned-init
facilitate safe pinned initialization
-
bounded-integer
Bounded integers
-
unwinding
in Rust and for Rust
-
ptr_meta
A radioactive stabilization of the ptr_meta rfc
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
arrow-buffer
Buffer abstractions for Apache Arrow
-
bevy_reflect
Dynamically interact with rust types
-
tlua
Zero-cost high-level wrapper for Tarantool-LuaJIT
-
sugar_path
Sugar functions for manipulating paths
-
as-any
provide the AsAny trait
-
index_vec
Newtype-style helpers for
Vecandusize -
n0-error
ergonomic errors with call-site location
-
recursion
cache-aware stack safe recursion
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
tuples
many useful tools related to tuples
-
enclose
A convenient macro, for cloning values into a closure
-
async-trait
Type erasure for async trait methods
-
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 -
text-size
Newtypes for text offsets
-
rustrict
profanity filter for Rust
-
merge
multiple values into one
-
hyperlight-guest
only the essential building blocks for interacting with the host environment, including the VM exit mechanism, abstractions for calling host functions and receiving return values, and…
-
reflectapi
code-first web service API declaration and corresponding clients code generation tools
-
comparable
comparing data structures in Rust, oriented toward testing
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
tiny-fn
Type erased closures on stack
-
shape
A portable static type system for JSON-compatible data
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
whereat
Lightweight error location tracking with small sizeof and no_std support
-
safelog
Conditionally suppress confidential information from logs
-
oxc-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
deno_error
Error representation to JavaScript for deno
-
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… -
io-extras
File/socket handle/descriptor utilities
-
multimap
A multimap implementation
-
generativity
Generation of unique invariant lifetimes
-
axum-valid
validation extractors for your Axum application, allowing you to validate data using validator, garde, validify or all of them
-
orion-error
Struct Error for Large Project
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
tynm
Returns type names in shorter form
-
fallible-streaming-iterator
Fallible streaming iteration
-
fragile
wrapper types for sending non-send values to other threads
-
error-code
Error code
-
buffered-reader
A super-powered Reader
-
docify
allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
kinded
Generate enums with same variants, but without data
-
counter
package to count generic iterables
-
async-fn-stream
Lightweight implementation of
async-streamwithout macros -
bitflagset
Enum and positional typed bitsets with Set API
-
cap-std-ext
Extension APIs for cap-std
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
const_panic
const panic with formatting
-
erasable
Type-erased thin pointers
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
stdext
Extensions for the Rust standard library structures
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
async-once-cell
Async single assignment cells and lazy values
-
qubit-function
Functional programming traits and Box/Rc/Arc adapters for Rust, inspired by Java functional interfaces
-
outref
Out reference
-
if_chain
Macro for writing nested
if letexpressions -
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
reborrow
Emulate reborrowing for user types
-
egui-probe
Trait and derive macro for exposing value editing in egui
-
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
fallible-iterator
Fallible iterator traits
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
documented
Derive and attribute macros for accessing your type's documentation at runtime
-
as_variant
macro to convert enums with newtype variants to
Options -
la-arena
index-based arena without deletion
-
float-ord
A total ordering for floating-point numbers
-
better_any
Type id and Any for non static types
-
safe-transmute
A safeguarded transmute() for Rust
-
gix-error
gitoxide project to provide common errors and error-handling utilities
-
iced_anim
creating animations in Iced
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
static_cell
Statically allocated, initialized at runtime cell
-
formatx
A macro for formatting non literal strings at runtime
-
lazyinit
Initialize a static value lazily
-
doc-comment
Macro to generate doc comments
-
netcdf3
A pure Rust library for reading and writing NetCDF-3 files
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
try_match
Fallible pattern matching with a function-like syntax
-
exn
A context-aware concrete Error type built on
core::error::Error -
tryhard
Easily retry futures
-
field-offset
Safe pointer-to-member implementation
-
thiserror-no-std
derive(Error)
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
core_maths
Extension trait for full float functionality in
#[no_std]backed bylibm -
impl-more
Concise, declarative trait implementation macros
-
query-flow
A high-level query framework built on whale for incremental computation
-
cpubits
Compile-time detection heuristics for the optimal word size to use for the target CPU, which in some cases may differ from its address size a.k.a.
target_pointer_width. Implemented asmacro_rules! -
async-recursion
Recursion for async functions
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
optional_struct
defining a macro that will generate, from a structure, another structure with only Option<T> fields
-
stillwater
Pragmatic effect composition and validation for Rust - pure core, imperative shell
-
pack1
Byte array newtypes for different primitive types
-
beef
More compact Cow
-
nu-engine
Nushell's evaluation engine
-
retry
retrying operations that can fail
-
gen-lsp-types
LSP types generated from the official metamodel
-
masterror
Application error types and response mapping
-
fieldx
Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax
-
maybe-owned
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
loupe
Profiling tool for Rust
-
rustica
functional programming library for the Rust language
-
float8
8-bit floating point types for Rust
-
rust_info
Extracts the current rust compiler information
-
rudo-gc
A garbage-collected smart pointer with automatic cycle detection using BiBOP memory layout and Mark-Sweep collection
-
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…
-
speculoos
Fluent test assertions
-
rc-box
Known unique versions of Rc and Arc
-
joinery
A small crate for generically joining iterators with a separator
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
failsafe
A circuit breaker implementation
-
n0-snafu
Utitilities for working with snafu
-
with_locals
Function attribute to return references to locals by using CPS
-
enum-display
A macro to derive Display for enums
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
uniplate
boilerplate-free operations on tree-shaped data types
-
econf
Load environment variables into your struct members in one shot
-
octseq
Abstractions for types representing octet sequences
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
converge-provider
The capability and backend selection contract for Converge providers
-
speare
actor-like thin abstraction over tokio::task and flume channels
-
cryptify
A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.
-
chasa
A parser combinator focused on rollback/commit, streaming inputs, and composable method chains
-
stackfuture
wrapper around futures that stores the wrapped future in space provided by the caller
-
strck
Checked owned and borrowed strings
-
protest
An ergonomic, powerful, and feature-rich property testing library with minimal boilerplate
-
sealed
Macro for sealing traits and structures
-
sqry-lang-elixir
Elixir language plugin for sqry
-
pusherator
Push-based version of Rust iterators
-
error_set
Quick error declarations and automatic conversions between errors for precisely typed error handling. Inspired by Zig's error set type.
-
auto_enums
allow multiple return types by automatically generated enum
-
leo3
Rust bindings for the Lean4 theorem prover
-
fixnum
Fixed-point numbers with explicit rounding
-
more-di
support for dependency injection (DI)
-
sdl3-main
Tools for using SDL's main and callback APIs
-
hot_reload
Trait and service definition of periodic hot reloader and notifier for config-file, KVS, etc
-
orx-pinned-vec
PinnedVectrait defines the interface for vectors which guarantee that elements added to the vector are pinned to their memory locations unless explicitly changed -
result-like
Option/Result-like monad interface for your own enum
-
dprint-swc-ext
Functionality to make swc easier to work with
-
oxrdf
Basic data structures related to RDF
-
ensembler
running commands and reporting progress
-
gofer
Gofer.rs makes it easy to fetch data from any URL
-
strong-type
Procedural macros for naming and strong-typing primitives and strings
-
thiserror-ext
Useful extension utilities for
thiserror -
alef-backend-zig
Zig backend for alef
-
rancor
Scalable and efficient error handling without type composition
-
goish
— write Rust using Go idioms. Ports Go's standard library and syntax so Go programmers can write Rust code that reads and feels like Go.
-
dioxus-router
Cross-platform router for Dioxus apps
-
derive_generic_visitor
Boilerplate for building rust visitors
-
rfluids
🦀 Rusty CoolProp wrapper
-
garnish_lang_traits
Shared traits for garnish core libraries
-
anymap3
A safe and convenient store for one value of each type
-
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
spire_enum
Procedural macros to facilitate enum usage, such as when delegating implementations, extracting variant types, or creating enum tables
-
indoc
Indented document literals
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
sigil-stitch
Type-safe, import-aware, width-aware code generation for multiple languages
-
environmental
Set scope-limited values can can be accessed statically
-
panic-halt
Set panicking behavior to halt
-
pilgrimage
A Kafka-like message broker in Rust
-
better_scoped_tls
scoped-tls, but with good error message
-
base-traits
base traits (for Rust)
-
problem
Error handling for command line applications or prototypes
-
sabi-rust
A small framework to separate logics and data accesses for Rust application
-
clap-sort
Validate that clap Subcommand enums are sorted alphabetically
-
typed-arrow
Compile-time Arrow schemas for Rust
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
cbor-data
using CBOR as in-memory representation for working with dynamically shaped data
-
macro-asm-builder
macro-assemblers
-
morphix
Observing and serializing mutations
-
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
dtype_dispatch
Macro builder for working with data types
-
component_model
Revolutionary type-safe component assignment for Rust. Build complex objects with zero boilerplate using derive macros and type-driven field setting. Perfect for configuration builders…
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
wasmtime-internal-core
INTERNAL: Wasmtime's core utilities and helpers with minimal dependencies
-
bytes-str
A string type that is backed by bytes crate
-
fixed-hash
Macros to define custom fixed-size hash types
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
istring
A replacement for String that allows storing short strings of length up to sizeof<String>() - 1 without a heap allocation
-
fatality
extension to
thiserror::Error -
errs
handling errors with reasons
-
bevy_gauge
A flexible attribute and stat system for Bevy
-
runtara-dsl
DSL for agent metadata definitions in runtara workflows
-
patchable
Automatically derive patch types for Rust structs to enable efficient partial updates with zero runtime overhead
-
helios-fhirpath-support
serves as a bridge module that provides essential types and traits for integration between the FHIRPath evaluator, it's associated functions, and also the FHIR model code in the fhir module…
-
condtype
Choose types at compile-time via boolean constants
-
variadics
Variadic generics on stable Rust using tuple lists
-
simple-zanzibar
A simplified Rust implementation of Google's Zanzibar authorization system with DSL support
-
oxirush-nas
5G NAS Message encoder/decoder library
-
tools_core
Core functionality and schema generation for the tools collection system
-
cel-cxx
A high-performance, type-safe Rust interface for Common Expression Language (CEL), build on top of cel-cpp with zero-cost FFI bindings via cxx
-
qubit-progress
Generic progress reporting abstractions for Qubit Rust libraries
-
moddef
Macro for convenient module declaration. Each module can be put in a group, and visibility can be applied to the whole group with ease.
-
eio-okta-data
Data Types for Okta
-
lazy_format
lazily formatting values for later
-
dync
An efficient alternative to
dyn Traitfor containerized types -
lazycell
providing a lazily filled Cell struct
-
wherror
The same derive(Error) macro thiserror provides + the features you want!
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
racer
Code completion for Rust
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
corophage
Algebraic effects for stable Rust
-
rdftk_names
set of modules that contain the
IRIs andQNamestrings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
moosicbox_assert
MoosicBox assert package
-
awint_macro_internals
Internal macro utilities for the
awintsystem of crates -
cljrs-interp
Tree-walking interpreter for clojurust (special forms, macros, destructuring)
-
eventcore
Type-driven event sourcing library for Rust with atomic multi-stream commands
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
std-next
Opinionated utilities and polyfills
-
oxilangtag
fast implementation of language tag normalization and validation
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
enum-assoc
Procedural macro to associate constants with enum variants
-
utoipa-axum
Utoipa's axum bindings for seamless integration for the two
-
random-number
Generate random numbers quickly
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
autofolder
Single-element folding wrapper
-
spark-signals
A standalone reactive signals library for Rust - fine-grained reactivity for any application
-
ploidy-pointer
JSON Pointers for strongly-typed data structures
-
among
A general purpose sum type with three cases: the enum
Amongwith variantsLeft,MiddleandRight. A three-way counterpart toEither, withno_std,serde,futuresandtokiointegrations. -
async-bb8-diesel
async bb8 connection manager for Diesel
-
processmanager
manage process lifecycles, graceful shutdown and process faults
-
makepad-widgets
Makepad widgets
-
tools-rs
Core functionality for the tools-rs tool collection system
-
virtue-next
A sinless derive macro helper
-
haskelujah-typing
Kind inference, type inference, and exhaustiveness checking for the Haskelujah compiler
-
rama-error
error types and utilities for rama
-
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
chaos_theory
Modern property-based testing and structure-aware fuzzing library
-
qubit-datatype
Runtime data type descriptors and conversion utilities for Rust
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
shopify_function_wasm_api
High-level interface for interfacing with the Shopify Function Wasm API
-
euxis-commons
Shared Rust utilities and common patterns for the ecosystem. Provides reusable components for error handling, configuration, logging, validation, retry logic, and more
-
cynic-parser
A fast, correct and easy to use GraphQL parser
-
value-trait
Traits to deal with JSONesque values
-
noos
Reliability layer for Rust LLM agents: scope drift, cost circuit breaks, and procedural correction memory as event-driven Decisions
-
cumulo-dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
creusot-std
Standard library of Creusot: provides specification macros, contracts for Rust standard library and logic helpers
-
oni-comb-parser
Rebooted parser combinator library
-
pin-utils
pinning
-
kindle
A continually self-training RL agent that starts from a cold network and kindles its own intelligence from environment-agnostic primitives
-
uni_error
universal error type for Rust
-
linked_list_r4l
Linked lists that supports arbitrary removal in constant time
-
better_collect
composable, declarative way to consume an iterator
-
v-storage
Storage layer for the veda platform
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
sugars
An useful collection of macros to make tasks easier
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
fauxgen
write your own generators in stable rust
-
assert-eq-float
assert_eq_float!macros that support floats -
shaku
Compile Time Dependency Injection for Rust
-
overload
macro to simplify operator overloading
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
expunge
redact and transform struct fields declaratively
-
retry-error
An error type for an operation that can fail more than once
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
pasta_dsl
Pasta DSL - Independent DSL parser and AST definitions
-
morok-schedule
Optimization passes and pattern engine for the Morok ML compiler
-
collection_literals
macros for initializing any collection
-
karpal-core
HKT encoding, Functor, Semigroup, Monoid for the Industrial Algebra ecosystem
-
const-field-offset
Derive macro providing const field offsets using core::mem::offset_of!
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
pingora-error
Error types and error handling APIs for Pingora
-
emergent-client
Client library for Emergent event-based workflow platform
-
derive-io
derive macros for
std::io::{Read,Write},tokio::io::{AsyncRead,AsyncWrite}and more -
culpa
error-handling syntax in Rust
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
err_trail
Add context to errors through logging
-
deriving_via
DerivingVia
-
log_limit
A rate limiting logging crate
-
case_insensitive_string
A case insensitive string struct
-
eros
Error handling that is precise, no boilerplate, ergonomic, context aware, and performant
-
taurpc
A type-safe IPC layer for tauri commands
-
valq
macros for querying semi-structured data with the JavaScript-like syntax
-
devela
A development layer of coherence
-
cluFullTransmute
Extended, no-constraint type transmutation API, featuring safe checks and const-ready logic
-
axum-conf
simplify the use of Axum, Tokio and Postgres together using configuration. It comes with batteries included and many features can be feature activated.
-
jemmy
This package provides a coherent set of manual accessor macros
-
clash-prism-plugin
Plugin system with lifecycle hooks, multi-component architecture, and cron scheduling
-
ra-ap-rustc_parse_format
Automatically published version of the package
rustc_parse_formatin the rust-lang/rust repository from commit ba0949ab745985a442e274ba52e8fb348cb0c662 The publishing script for this crate lives at:… -
qml_static_analyzer
A static analyzer for QML files
-
cf-types-registry-sdk
SDK for types-registry module: API trait, GTS entity types, and error definitions
-
mac
A collection of great and ubiqutitous macros
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
wegglix
weggli is a fast and robust semantic search tool for C and C++ codebases. It is designed to help security researchers identify interesting functionality in large codebases.
-
tstr
type-level strings on stable
-
model-mapper
Derive macro to map between different types
-
mlua-extras
Extra helpers and functionality built on top of mlua for embedded lua development
-
tyrx
Typed, ergonomic regular expression library
-
valitron
ergonomics, functional and configurable validator
-
pyinrs
type library that is as easy to use as Python built-in types
-
valico
JSON Schema validator and JSON coercer
-
munge
Macro for custom destructuring
-
nameof
macro to determine the string name of a binding, type, const, or function
-
borrow-or-share
Traits for either borrowing or sharing data
-
atoman
static data that can be accessed safely and concurrently from any part of your program
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
one_err
OneErr to rule them all
-
as_repr
Rust trait for constant
#[repr(T)]conversions -
facet-solver
Constraint solver for facet - resolves type shapes from field names
-
swamp
script language for embedding
-
scah-query-ir
Internal query IR used by the scah selector and macro crates
-
derive_tools
A collection of derive macros designed to enhance STD
-
psl-types
Common types for the public suffix implementation crates
-
const_struct
macro that allows const structures to be passed as const generics
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
components-arena
creating complex domain-specific self-referential data structures
-
compile_time_sort
Sort arrays and slices of primitives in const contexts
-
errortools
Quality of life utilities for error handling in Rust
-
printer_event_handler
A cross-platform printer status monitoring library for Windows and Linux
-
frunk_proc_macro_helpers
Common internal functions for frunk's proc macros
-
mir-php
Fast PHP static analyzer
-
sptr
Strict Provenance Polyfill
-
loga
Combined logging and error handling
-
service-daemon
A declarative Rust framework for automatic service management, event-driven triggers, and compile-time dependency injection
-
axum-openapi3
Facilitate the generation of OpenAPI 3.0 documentation for axum applications
-
doku
A framework for documenting Rust data structures
-
try-specialize
Zero-cost specialization in generic context on stable Rust
-
yerevan
Small Rust crate that brings computation expressions idea from F# for help you to work easier with functors and monads
-
inline-python
Inline Python code directly in your Rust code
-
tracerr
Custom compile-time captured error tracing
-
k8-client
Core Kubernetes metadata traits
-
impls
Determine if a type implements a logical trait expression
-
inplace_containers
In-place, fixed-capacity containers with optional features
-
peel-off
Peel off a specific variant from a Rust enum, splitting it into the extracted variant and the residual
-
tinyvec_macros
Some macros for tiny containers
-
problemo
Problemo
-
handle-this
Ergonomic error handling with try/catch/throw/inspect/finally syntax and automatic stack traces
-
cexpr
A C expression parser and evaluator
-
mydi
MyDI. Dependency Injection library
-
ownedbytes
Expose data as static slice
-
invoice-gen
SDK for generating invoices in schemas FA (2), FA (3), PEF (3), PEF_KOR (3) and FA_RR (1)
-
ax-linked-list-r4l
Linked lists that supports arbitrary removal in constant time
-
assert_approx_eq
assert approximately equal
-
fn-ptr
introspecting and rewriting function pointer types at compile time
-
platform-num
Numbers for linksplatform
-
leptos-mview
A concise view macro for Leptos
-
aranya-capi-core
Aranya's C API tooling
-
lightcycle
Consistent and rendezvous hash rings with optimized hash functions
-
pai_governance_daemon
Constitutional governance daemon for PAI-Kernel · invariant enforcement substrate per PAI-CD v2.2 Freeze Edition
-
ref-map
Helper trait for Option and Result to map references
-
metered
Fast, ergonomic metrics for Rust!
-
sc
Raw system calls
-
borrow
Zero-overhead, safe implementation of partial borrows. This crate allows you to borrow selected fields from a struct and split structs into non-overlapping sets of borrowed fields.
-
oxur-smap
Source mapping for Oxur language - tracks code transformations for error reporting
-
spacetimedsl
The SpacetimeDB Rust Server Module meta-framework
-
resman
Runtime managed resource borrowing
-
tairitsu-style
Type-safe CSS property builders for Tairitsu framework
-
error2
error handle library for Rust
-
compio-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…
-
variadics_please
Implement things as if rust had variadics
-
blanket
macro to derive blanket implementations for your traits
-
mago-php-version
Modeling PHP versions (major.minor.patch), with built-in checks for feature support and deprecations across different PHP releases
-
cfg-elif
Formatter-friendly conditional compilation at item and expression positions
-
cadd
Painless checked arithmetics and conversions
-
belt
A fast, cross-platform Factorio benchmarking tool
-
axtra
building web applications with Axum and Astro providing utilities for error handling, notifications, and more
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
dioxus-config-macros
Macros used internally by codegen
-
sinktools
Extra sink adaptors and helpers
-
sitrep
Frontend-agnostic progress reporting
-
prometheus-metric-storage
Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
gerber-types
Types and code generation for Gerber files (RS-274X)
-
error-rail
ErrorRail is a no_std compatible Error Handling library for the Rust language
-
plexus-core
Core infrastructure for Plexus RPC: Activation trait, DynamicHub, schemas
-
autofloat
Pure Rust library for efficient automatic differentiation
-
dtype_variant
Enables type-safe enum variants with shared type tokens across multiple enums, allowing for synchronized variant types and powerful downcasting capabilities between related enums
-
special-fun
Special functions for Rust by binding to the Cephes library
-
hex-display
Display impl for byte slices which provides a hexdump
-
defer
excecution of code, inspired by go's defer statement
-
intern-arc
An interner that deallocates unused values
-
orx-meta
Meta structures such as statically typed queues of heterogeneous elements
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
parsanol
High-performance PEG parser library with packrat memoization and arena allocation
-
perfectionist
Additional linting rules for Rust projects
-
genies_dapr
整合DDD与Dapr 的 dapr 库
-
linear_type
Unique linear types for rust
-
eventql-parser
EventQL Lexer and Parser
-
ungrammar
A DSL for describing concrete syntax trees
-
typestate-pipeline
Easy, safe typestate pipelines and builders for Rust
-
prima_bridge
implement the bridge pattern
-
openapi_type
OpenAPI type information for Rust structs and enums
-
tlq-fhirpath
FHIRPath engine
-
crustal
generating C/C++ code
-
agentkit-compaction
Transcript compaction triggers, strategies, pipelines, and backend hooks for agentkit
-
mod_use
pub mod xxx; use xxx::*;
-
willow-data-model
The core datatypes of Willow, an eventually consistent data store with improved distributed deletion
-
postmortem
A validation library that accumulates all errors for comprehensive feedback
-
fsmy
A finite state machine library
-
overture-core
overture library
-
banish
A declarative framework for rule-based state machines
-
dynify
Add dyn compatible variant to your async trait
-
anyhow2
（Fork of anyhow that adds the location where the error first occurred）Flexible concrete Error type built on std::error::Error
-
defaulted
Trait and derive macro for testing whether a value equals its default state, with per-field customization and optional serde integration
-
terni
Ternary error handling: Success, Partial with measured loss, Failure. Because computation is not binary.
-
inline-c
Write and execute C code inside Rust
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
signaled
A lightweight reactive programming library for Rust, providing a signal-slot mechanism
-
facet_generate
Generate Swift, Kotlin and TypeScript from types annotated with
#[derive(Facet)] -
dupe
Marker for types which are cheap to clone
-
ferment
Traits for FFI conversions and some helper methods
-
lowdash
A Lodash inspired utility library to manipulate array and object for Rust
-
dill
Runtime depenency injection library
-
cascade
Dart-like cascade macro for Rust
-
str-macro
The str!() macro, similar to vec![] but for strings
-
direction
Representations of directions
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
meticulous
Result extension to add more meaning to unwrapping
-
pi_null
define trait is named Null. u8,u32,u64,Option...is implements Null
-
contained
works to provide several macros and interface for transparent wrapper types in Rust
-
sparkles
Capture execution flow of your Rust application with CPU cycle precision!
-
metrique-writer
wide event metrics - writer-side interface
-
uy
A typesafe, flexible, simple, and user-friendly unit system library for Rust that has good error messages
-
buildstructor
Macro to derive a builder from a constructor function
-
aspect-core
Core traits and types for aspect-oriented programming in Rust
-
err_tools
Helper traits and functions for building errors in rust
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
microcad-lang
µcad language
-
fastapi-openapi
OpenAPI 3.1 types and schema generation for fastapi_rust
-
rudof_iri
RDF data shapes implementation in Rust
-
nonbox
NaN boxing without boxing
-
flex-error
Flexible error definitions using macros and traits
-
pretty-name
Get the human-friendly name of types, functions, methods, fields, and enum variants in a refactoring-safe way
-
smarterr
Smart error handling library
-
semigroup
Useful semigroup trait
-
anyhow_serde
Flexible concrete Error type built on std::error::Error with serde support
-
flense
Purpose-oriented lensing
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
datafusion-comet-spark-expr
DataFusion expressions that emulate Apache Spark's behavior
-
approxim
Approximate floating point equality comparisons and assertions
-
atlas-program-log
Lightweight log utility for Atlas programs
-
validated
The cumulative sibling of
ResultandEither -
erratic
Handling errors in an efficient way
-
derive_aliases
#[derive]aliases for reducing code boilerplate -
env_home
Get the user home directory in a cross-platform way
-
join_me_maybe
an async
join!macro withselect!-like features -
numdiff
Numerical differentiation via forward-mode automatic differentiation and finite difference approximations
-
bcf_reader
a small, lightweight, pure-Rust library to allow efficient, cross-platform access to genotype data in BCF files
-
resext
lightweight error handling crate for Rust
-
ready-active-safe
Lifecycle engine for externally driven systems
-
const_soft_float
Const Soft Float Point
-
includium
A complete C preprocessor implementation in Rust
-
socketpair
Cross-platform socketpair functionality
-
generic-container
Abstract over "containers" that hold a T, such as a T itself, Box<T>, or Arc<Mutex<T>>
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
atomr-agents-callable
Callable trait unifying agents, workflows, tools, and harnesses
-
arri_repr
Rust representations of Arri types
-
scadman
Code generator for OpenSCAD
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
capacity_builder
Builders where the code to calculate the capacity is the same as the code to write what's being built
-
pawc
🐾 PawScript interpreter
-
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
rugen
generating random data based on a data description written in Rune
-
wry-bindgen
Native desktop implementation of wasm-bindgen APIs using wry
-
shive
lightweight IOC service container writen for the Rust applications
-
anomalies
Structured, categorized error handling inspired by Cognitect's anomalies
-
walle-core
OneBot lib in Rust
-
sigma-compiler
automatically generating code for sigma zero-knowledge proof protocols of more complex statements than are supported by the sigma-proofs crate. The statements given to this crate are…
-
trait-kit
Module Standard Interface and Capability Management Center — A lightweight Rust library that provides a standard interface for module definition and Kit capability management
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
protocol
Easy protocol definitions
-
neuer-error
Ergonomic error handling for machines and humans
-
pretty-error-debug
If the process ends with an
Error, write out theErrormessage and chain -
multitype
Arithmetic type traits
-
emboss
Macros to embed metadata as an ELF/Mach-O section in your final binary
-
suzunari-error
A highly traceable and noise-free error system that propagates error locations as error contexts and minimizes information output to the log
-
annotate
Annotation framework for Rust functions and modules
-
chapa
Bitfield structs, batteries included!
-
hexga_map_on
Define the map_on! macro that can be used to impl a lot of trait quickly using macros
-
layer0
Protocol traits for composable agentic AI systems
-
yule_log
A streaming parser for PX4 ULOG files
-
current
setting current values for stack scope, such as application structure
-
variant_count
Derive macro for enum which adds to it the count of variants
-
gstuff
Small macro and trinkets that make my life easier
-
plist-macro
Macros and utilities for manipulating plists
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
for_build_rs
lexer for Rust's build.rs
-
hodgepodge
Lightweight dataset crate of enums for prototyping, teaching, and experimentation
-
teaql-core
TeaQL core, SQL, runtime, dialect, and macro crates for model-driven data access
-
statum
Represent workflow and protocol state correctly in Rust by making invalid states unrepresentable
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
harrow-io
Runtime-agnostic I/O primitives for Harrow: buffer pool and I/O traits
-
pud
Generate typed, composable, no-std-friendly modifications (“puds”) for Rust structs
-
goof
A reusable, composable, aggregate and
no_std-friendly error library -
typed-measurements
handling physical measurements with units
-
eira
Ansi-colored error reporting output
-
gerber_viewer
A cargo crate for rendering Gerber files
-
quasiquodo
Compile-time quasi-quoting for typed languages
-
guarden
Zero-cost abstractions for scoped guards, deferred execution, and async task detachment
-
pipe-trait
possible to chain regular functions
-
off64
Read from and write to byte slices with u64 offsets
-
tokenlock
cell types that decouple permissions from data
-
seal-the-deal
Attribute to use on the
traitmethods (or associated functions) that you wish to “seal”, a.k.a., render themfinal -
jigs
A small Rust framework for explicit, composable, traceable processing pipelines
-
index_type
Type-safe newtype indices for Rust
-
macron
Comprehensive Rust macros toolkit for everyday development tasks. Includes convenient string formatting (str!), regex pattern matching (re!), streamlined collection creation, and custom derive macros for Display…
-
describer
Struct describing helper
-
nutype-enum
Helper macro to create a nutype that behaves like an enum
-
iart
The Infomation and Result Trace crate
-
dioon
RFC-013: The Timing/Organic Layer. Organic patience, niche-window decision making, and 128-bit metabolic rhythm for the Aicent Stack 2026. Aligned with RFC-014 (PICSI).
-
relative-duration
Duration with negative capabilities
-
shadow_counted
An iterator that counts every iteration in a hidden counter, nested iterators may commit the count to parents
-
cast_trait_object
Cast between trait objects using only safe Rust
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
explicit-error
Explicit concrete Error type for binary crates
-
directed
Evaluate programs based on Directed Acyclic Graphs
-
bittorrent-primitives
Foundational BitTorrent primitive types for Rust projects
-
redb_model
Redb model derive macro and DTO type conversion
-
rudi-dev
Rudi - an out-of-the-box dependency injection framework for Rust
-
typesafe_builder
A procedural macro to generate type-safe builder patterns for Rust structs
-
ptxr
unifies *const/*mut pointers using the trait system
-
afia-component
A high-level Rust wrapper for
libafia_component -
pulumi_gestalt_rust
UNOFFICIAL Rust Pulumi support based on Pulumi Gestalt
-
rustfix
Automatically apply the suggestions made by rustc
-
bits-io
Bit-level IO operations
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
dynamic-plugin
Write compile-time-checked, dynamically-loaded plugin libraries for your Rust software
-
kozan-primitives
Foundational types for the Kozan UI platform: geometry, color, units
-
polymorph
A few utilities to better enable polymorphic behavior in Rust
-
rslint_errors
Pretty error reporting library based on codespan-reporting built for the RSLint project
-
either_of
working with enumerated types that contain one of 2..n other types
-
builder-pattern
A derivable macro for declaring a builder pattern
-
reaktiv
A standalone, flexible fine-grained reactivity library
-
assume
Macro for stating unsafe assumptions in Rust
-
luhtwin
A beta horrible Rust error handling library with AnyError and context macros
-
dirk_events
Event system for DirkEngine
-
size_hinter
Iterator adaptors allowing overriding or specifying size_hint
-
pipeline-dsl
Pipeline DSL types and re-exports of #[pipeline]/#[stage]
-
qubit-spi
Typed service provider registry infrastructure for Rust
-
void
The uninhabited void type for use in statically impossible cases
-
mcp-router
An MCP Router for the masses. Inspired by the myriad of difficult to use, limited use cased libraries currently available
-
gpui_refineable
A macro for creating 'refinement' types that can be used to partially initialize or mutate a complex struct
-
opentalk-types-signaling-automod
Signaling types for the OpenTalk automod module
-
api-error
A derive macro for attaching HTTP status codes and user-facing messages to Rust error types
-
qraft
Typed Rust query builder with CTE and soft-delete support
-
multiple_errors
Propagate multiple errors instead of just the first one
-
app-error
Error type for applications
-
errgonomic
Macros for ergonomic error handling with thiserror
-
bento-kit
A bento box of common Rust utilities: id generation, timing, masking
-
overengineered_hkts
Expiremental crate of higher-kinded types integrated with lifetimes and matching function types and optional cloning and supporting no_std
-
evcxr_repl
A REPL for Rust
-
cada
A monadic Chest<T> container and universal for-comprehension macro for Rust
-
forgeconf
Declarative configuration loader for Rust structs powered by attribute macros
-
t-ree
AST definitions for the T programming language
-
parquet-variant
Apache Parquet Variant implementation in Rust
-
typeid
Const TypeId and non-'static TypeId
-
qtbridge
Meta-package for Qt Bridge
-
include-utils
mdBook-like include macro as the powerful replacement for the standard
include_strmacro -
rspack_macros_test
rspack macros test
-
tighterror
A minimalistic error representation framework
-
pareg
useful tools for command line argument parsing
-
cast
Ergonomic, checked cast functions for primitive types
-
cli_utils_hoijui
A tiny CLI utilities library, providing functions and constants useful in many CLI tools
-
bint
Bounded Integer in Rust
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
once-list2
A single linked list which is backed by
OnceCell. You can append the value to the non-mutableOnceList. -
reborrow-generic
Generalized reborrowing traits and an optional derive macro
-
spacetimedb-primitives
Primitives such as TableId and ColumnIndexAttribute
-
erdp
display an error and its nested errors
-
newtypes
Macros that ease the implementation of the Newtype pattern
-
blf_lib
Multi-purpose Blam-File library
-
c2pa-c-ffi
C language FFI base for c2pa crate to create bindings
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
corroded-rs
that bypasses Rust's safety features
-
tpuf_zerovec_0115
Zero-copy vector backed by a byte array
-
cynic-codegen
Procedural macro code generation for cynic - a code first GraphQL client for Rust
-
typeshaper
TypeScript utility-type idioms (Omit, Pick, Merge, Partial…) for Rust structs — one-line type algebra expressions
-
cocoon-tpm-utils-common
Cocoon TPM project - common utilities
-
tuple
Element-wise operations on tuples
-
stackerror
A pragmatic error handling library for Rust that provides helpful strings for debugging, and structured data for runtime error handling
-
floats
f16 and f128 floating point types for compatibility with future Rust versions
-
nu-test-support
Support for writing Nushell tests
-
file_rw
high-performance, memory-mapped file I/O utilities
-
makers
a POSIX-compatible make implemented in Rust
-
skerry
Super Kool ERRors Yoh - A type-safe, zero-boilerplate error management framework
-
axerrno
Generic error code representation
-
display-more
helper to display various types
-
overlay-file
OverlayFile used to define overlays in OCA
-
witnesscalc-adapter
run witnesscalc in rust
-
devnagari
Code in Devanagari (Hindi/Sanskrit) — type aliases, macros, and keyword translation for Rust
-
edgee-sdk
The full-stack edge platform for your edge oriented applications
-
swift-rs-leap
Call Swift from Rust with ease!
-
polars-rows-iter
easy and convenient row iteration of polars dataframes
-
superstruct
Versioned data types with minimal boilerplate
-
rusttyc
writing type checkers with a lattice-like type system in rust
-
rev_slice
A newtype for operating on a reversed view of a slice
-
bignumbe-rs
Large, medium-precision numbers
-
powerletters
Concise spellings of common Rust operations
-
sqllineage
Extract table and column-level lineage from SQL
-
binread
helping read structs from binary data using ✨macro magic✨
-
no-break
Typesafe extraction of continuation values from unbreakable control flows
-
tiff-forge
working with TIFF and BigTIFF files
-
turso-mappers
Row mappers for turso
-
origin-lang
Every value is origin, at a boundary, or contents. The compiler knows which.
-
hoicko_lib
Hoicko library
-
fmu_from_struct
A derive macro for automatically setting up FMU models in Rust
-
fp_rust
Implement fp features for Rust
-
sosecrets-rs
Secretwrapper type that reveals the secret at mostMEC: typenum::Unsignedtimes with compile time guarantees -
greentic-runner-desktop
Developer desktop runner harness for Greentic packs
-
tauri-plugin-scoped-storage
Tauri 2 plugin for user-approved scoped folder access on Android and iOS
-
spade-types
Helper crate for https://spade-lang.org/
-
leptix-core
Core utilities for Leptix UI components
-
absolute_unit
A unit system for Rust's type system to catch unit errors in your physical calculations
-
hlist2
Compile-time heterogeneous list implementation
-
sdre-stubborn-io
Forked from https://github.com/craftytrickster/stubborn-io. io traits/structs that automatically recover from potential disconnections/interruptions.
-
rust-memory-safety-examples
Comprehensive educational examples demonstrating memory-safe programming patterns with CVE case studies and benchmarks
-
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
rust-texas
generate latex documents
-
matched_enums
A macro that provides the option to bin enum attribute to match-statements. This makes it easier to convert values into enums.
-
dioxus-stores
Server function macros for Dioxus
-
zerror
error interface for context-aware error-reporting
-
tensorism
easy tensor manipulation on top of ndarray
-
state-machines
Type-safe state machines with hierarchical states, guards, callbacks, and async support - Rust port of Ruby's state_machines gem
-
cast-spec
Experimental: Compile-time architectural annotations for Rust — function-shaped macros that name concepts, rules, anti-patterns, and pipelines, plus an opt-in static analyzer that validates them with rust-analyzer
-
similarity-trait
Similarity trait Rust crate: compare input values, such as two or more items, then return an output value, such as a mesure of similarity, or correlation, or overlap
-
hex_lit
Hex macro literals without use of hex macros
-
rs95
implementing the ISA-95 domain models
-
doless
macro to simplify struct mapping , injects cache lookup logic directly into your functions ,and function utilities
-
simple-error
error type backed by a string
-
pgrx-pg-sys
Generated Rust bindings for Postgres internals, for use with 'pgrx'
-
tola-caps
Capability system enabling type-level state tracking, trait detection, and stable specialization
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
tldr-traits
Abstractions for TL;DR summarization using the five Ws: who? what? when? where? why?
-
lerpable
a derive macro for combining ADTs
-
rs-cor
A compile-time Chain of Responsibility pattern library for Rust
-
enumerable
helping you to enumerate all possible values of a type
-
explainable
A zero-overhead educational layer for Rust libraries
-
prudent
Help you make Rust code safer. For both authors and reviewers.
-
smox
Box that stores small objects inline and bigger objects on the heap using Box, Rc or Arc, with CoW semantic
-
portrait
Fills an
implwith the associated items required by the trait -
bizerror
standardized approach for defining and managing business-related errors
-
error_plus
Structured error handling with semantic context trees. Zero proc-macros. Zero backtrace overhead.
-
bhc-types
Type system, type inference, and type representations for BHC
-
eggplant
High-Level Rust API crate for Egglog
-
span-core
A span to span
-
finit
defining sets of data, and then performing set operations on them. It is designed to be used for permission systems, but can be used for any kind of data that can be represented as a set.
-
functionality
Rust |> Functional programming = 💖. Useful traits, functions and macros for prettier code.
-
cf-modkit-canonical-errors
ModKit canonical error types based on Google AIP-193 error model
-
bhc-span
Source location tracking and span management for BHC
-
measures-rs
macro to generate a library to statically encapsulate numbers in objects having a unit of measurement, allowing any meaningful operation, but statically forbidding meaningless operations with them…
-
el_roi
simplify reading user input
-
filecoin-hashers
Hashers used in filecoin and their abstractions
-
errorstash
collecting multiple related errors, and reporting them together
-
seasick
Tools for implementing and transcribing C APIs
-
slice-diff-patch
providing utility functions for diff and patch of slices
-
frunk_laws
contains laws for algebras declared in Frunk
-
subplotlib
functions and types for
subplot codegengenerated Rust based test suites. Relies onsubplotlib-derivefor associated macros. -
recallable
Traits (
Recallable,Recall,TryRecall) and macros for defining Memento pattern types and their state restoration behaviors -
reinhardt-di
Dependency injection system for Reinhardt, inspired by FastAPI
-
revolt-result
Revolt Backend: Result and Error types
-
match_opt
A macro for turning a partial match into a full match returning an option
-
redacted-error
Stable public error messages with debug-only diagnostic detail
-
luau-parser
A blazingly fast Luau parser with robust error recovery
-
intrusive-doubly-list
efficient, zero-allocation circular intrusive doubly linked list in Rust. Features safe, lifetime-bounded iterators, unified ownership validation using a link_state flag to prevent node reuse bugs across multiple lists…
-
cdumay_core
standard code
-
osom_lib
Top-level crate that re-exports the osom_lib workspace crates
-
traitsequence
Traits to abstract over sequences
-
anystack
Flexible and comprehensive error handling
-
fx-callback
A subscription based callback to inform subscribers about relevant data events within structs
-
entrait
Loosely coupled Rust application design made easy
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
rhai-rusp
Rhai bindings for the Rust USP toolkit
-
tuplex
Rust tuple extension
-
tlns-google-oauth2
An enshitificated Google OAuth2 Server Side support for Rust with built in Scopes enum
-
stdio-override
overriding Stdin/Stdout/Stderr with a different stream
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
cursive-extras
Extra views for the Cursive TUI library as well some helper functions and macros
-
luduvo-dom
manipulating luduvo’s
.ldvfiles -
struct-to-enum
Derive macros to generate enums from struct fields - compile-time safe field selection and dispatch
-
beetle-nonzero
Combines the std
NonZerostructs into one struct -
moveit2
safe, in-place construction of Rust (and C++!) objects
-
hoicko_rows
Hoicko library
-
conflate
Merge multiple values into one
-
rs_ervice
service manager for vanilla or Tokio runtime
-
gen_ops
Macros for operator overloading for generic types
-
smooai-smooth-plugin
Smooth Plugin — trait-based plugin system for extending Smooth with CLI commands, API routes, TUI views, and operator tools
-
dyn-hash
Hash trait that is dyn-compatible
-
midi-toolkit-rs
ultra high performance MIDI operations, designed for black MIDI. The library isn't perfect
-
generic-upper-bound
Stable workaround for internal uses of generic-const-exprs
-
rig-cat
LLM agent framework built on comp-cat-rs: typed effects, no async, categorical foundations
-
inferni_bitstream
Bitstream implementation for Inferni
-
fierros-graph
Typed graph runtime primitives for Fierros
-
irys
Compile-time trait reflection for Rust
-
directed-visit
Visitor pattern with interchangable implementations for both the visit algorithm and node object traversal
-
proc-bitfield
expressively declare bitfield-like structs
-
soupa
macro allowing expressions to be eagerly evaluated before a scope
-
reda-unit
physical units
-
dyngo
Type-safe dynamic (type-erased) generic outparams
-
decycle
Solve circular trait obligation
-
chrono_machines_native
Ruby FFI binding for chrono_machines
-
hax-frontend-exporter-options
The options the
hax-frontend-exportercrate is sensible to -
anyhow-http
Customizable HTTP errors built on anyhow
-
organism-adversarial
Adversarial review for Organism — challenges, skeptics, governance signals
-
metastruct
Abstractions for iterating and mapping over struct fields
-
env_cfg
derive macro library for loading configuration structs from ENV variables
-
struct-field-names-as-array
generating the field names of named structs as constants
-
cfg_rust_features
Set cfg options according to probing for Rust compiler, language, and library features
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
rutie
The tie between Ruby and Rust
-
windmark-titanesque
An elegant and highly performant async Gemini server framework
-
unwrap_or_ai
providing AI-powered error handling using procedural macros
-
matchmaker-lib
A fuzzy finder for the terminal, powered by nucleo
-
enumeration
An extension to rust enum
-
protoschema
📐 Programmatically define protobuf contracts using flexible, modular and reusable elements
-
marlin-verilog-macro-builder
🦀 No nonsense hardware testing in Rust 🛠️
-
bauer
A derive macro for automatically generating builders
-
deref
dereferencing types
-
pattern-wishcast
Pattern types emulation for conditional variants using conditional never types
-
hamon
A zero-cost, type-level static decorator and pipeline builder
-
cjc-data
Tidyverse-inspired data manipulation: DataFrame, filter, group_by, join
-
stupid_utils
that provides some simple and maybe stupid or useful tools
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
mau
procedural macro library for memoization with MauQueue optimization
-
sync_select
A short-circuiting
std::thread::scope -
fierros-core
Provider-neutral core primitives for Fierros
-
mongo_indexed
derive macro to declaratively index mongo collections
-
sfo-result
Result type for Rust
-
named-generics-bundle
Convenience macros to help with the "bundle multiple generic params with a helper trait" pattern
-
eoe
exiting processes on errors gracefully
-
stilltypes
Domain-specific refined types for the Rust and Stillwater ecosystem
-
hexga_number
Provide basic trait and constant for number, and the macro map_on!
-
newstr
macros for declaring String-base new types
-
round
your floats with precision from 1 to 10
-
intern-mint
byte slice interning
-
plonky-cat-code
Error-correcting codes: Reed-Solomon, tensor-RS, Reed-Muller
-
potential-well
Atomic boxes
-
waker_tables
custom raw waker logic
-
tupa-core
Core types and pipeline definition macro for Tupã
-
devo
Generate and run tmux workflows from a small YAML DSL
-
rawpointer
Extra methods for raw pointers and
NonNull<T>. For example.post_inc()and.pre_dec()(c.f.ptr++and--ptr),offsetandaddforNonNull<T>, and the functionptrdistance. -
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
despatma
Design Pattern Macro like Loki
-
macon
builder macro-based generator with its own idioms
-
amos-bessel-rs
An idiomatic rust translation of Amos algorithm for calculating bessel functions
-
lunka
Pretty thin bindings to Lua 5.4
-
enum-update
representing state changes as enums
-
lighty-event
Event system for LightyLauncher
-
prism3-function
Common functional programming type aliases for Rust, providing Java-style functional interfaces
-
cast_checks
A procedural macro to check for invalid casts
-
isnt
Inverted versions of boolean-valued stdlib functions
-
rsgenetic
providing genetic algorithm execution
-
rs-bean
A lightweight Rust library for bean management
-
conerror
macro that automatically adds context to errors
-
soa_derive
Automatic Struct of Array generation
-
code-gen
aids in code generation
-
sanitizers
Interfaces and FFI bindings for the sanitizers interfaces
-
rserror
zero-dependency error handling library for Rust — wrap, context, and propagate errors with minimal boilerplate
-
orpc
Type-safe RPC framework for Rust, inspired by oRPC
-
vize_croquis
Croquis - Semantic analysis layer for Vize. Quick sketches of meaning from Vue templates.
-
zeph-commands
Slash command registry, handler trait, and channel sink abstraction for Zeph
-
hexga
include all other console hexga crate in one !
-
dustdata
A data concurrency control storage engine to Rustbase
-
early_returns
Macros to make early returns easier to work with in Rust
-
unescape_zero_copy
Unescape strings without allocating memory
-
rbx_types_ops
Adds operation methods to rbx_types
-
data-rw
io buffer write reader
-
universal-time
Cross-platform time primitives with compile-time guarantees — no runtime panics!
-
errcode
simplified error handling
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values, their discriminant or their name; inspired by Java
-
elain
Set a type's minimum alignment with const generics
-
garray2d
Game development focused 2d array with signed index and offset support
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
derive-ctor
Adds
#[derive(ctor)]which allows for the auto-generation of struct, enum, and union constructors -
sqry-lang-python
python language plugin for sqry
-
qenv
Define environment variables with macros and access them easily
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
nexcore-error
Zero-dependency error handling for NexVigilant Core ecosystem
-
rustversion
Conditional compilation according to rustc compiler version
-
traitreg
Create a registry of implementations of a trait
-
dcc-lsystem
Lindenmayer system together with some rendering tools
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
dragonfly-plugin
Dragonfly gRPC plugin SDK for Rust
-
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
alloc-checked
Collections that don't panic on alloc failures
-
parenv
Environment variable parser with a clap style derive macro and elm style error reporting
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
field_path
Type-safe, no-std field access and reflection utilities
-
branch_hints
that provides likely and unlikely branch hint functions in stable Rust
-
sge_math
Macro functionality for SGE
-
fluent_result
Fluent postfix helpers for Rust's Result and Option types
-
oni-comb-crond
Cron expression parser and scheduler built on oni-comb-parser
-
reify-reflect
Unified reification and reflection ecosystem for Rust
-
fastboop-core
Core profile matching and boot orchestration primitives for fastboop
-
structural-typing
Type-level field presence tracking for Rust structs, inspired by TypeScript
-
compare_variables
procedural macro for comparing the ordering of variables and creating useful error messages
-
panicking
std::thread::panickinganalog available in theno_stdcontext -
re_string_interner
string interning library
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
duration-extender
Adds fluent, highly readable methods (like .minutes(), .hours()) directly to integer types (u32, i64, etc.) to easily create std::time::Duration
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
stream_assert
Macros to simplify testing of
Streambased APIs -
thiserrorctx
A wrapper around thiserror, giving you the ability to add context
-
persisted
Persist arbitrary program state quickly and easily
-
type-const
Type-level associated consts
-
elm-client-gen-http
HTTP endpoint metadata for elm-client-gen. Pairs with #[elm_endpoint] to register handlers for Elm request-function generation.
-
clash-prism-dsl
Prism DSL parser for .prism.yaml configuration files
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
typewriter-plugin-dart
Dart/Flutter emitter plugin for typewriter
-
trait_mux
Proc macro library for generating enums that can multiplex different trait objects
-
async-injector
Reactive dependency injection for Rust
-
vsprintf
Rust bindings to the libc vsprintf function
-
auto_ops
Macros for easy operator overloading
-
rialo-aggregators-utils
Rialo Aggregators Utils
-
tan
language
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
async-retry
Async Retry
-
schematic_types
Shapes and types for defining schemas for Rust types
-
dioxus-use-js
A macro that generates Rust bindings to JavaScript or TypeScript functions, with compile time checks. For use with Dioxus.
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
clone_cell
A Cell that works with a restrictive form of Clone
-
recovery
Trait and derive macros to declare how errors should be retried
-
yulang-infer
Type inference engine for Yulang, including Simple-Sub-style subtyping and row-like algebraic effect inference
-
protobuf-core
A primitive utility library for Protocol Buffers in Rust
-
drop_bomb
A runtime guard for implementing linear types
-
eventbus-core
Object-safe event bus contract traits and types
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
zuit-core
Core traits, types, semantic index, engine, and registry for zuit
-
devirt
Transparent devirtualization for Rust trait objects via witness-method dispatch
-
certain-map
A typed map which can make sure item exist
-
SCLP
Command Line Parser Built with Rust
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
nix-bindings
Rust binding for Nix, the build tool
-
sod-actix-web
Service Oriented Design - Actix Web
-
ra_ap_limit
A struct to enforce limits for rust-analyzer
-
spade-diagnostics
Helper crate for https://spade-lang.org/
-
rust-asm
ObjectWeb ASM implementation in Rust
-
dyson_boot
Dyson Quick Startup Crate
-
easy_node
Smart pointer for graph nodes
-
xccute
type safe declarative builders for shell commands in rust
-
delegation
Macro-based delegation for enums and structs
-
kti_cqrs_provider_rs
CQRS provider with ioc container
-
surreal_devl
Contains core logic of surreal derive
-
cinderblock-core
Resource trait definitions, CRUD operations, runtime context, and in-memory data layer for cinderblock
-
custom-display
A trait for implementing custom formatting logic for types
-
wasm-bindgen-threads-xform
Support for threading-related transformations in wasm-bindgen
-
nonany
Integer types with customizable niche values
-
quickfig
Replace boilerplate in apps that read from user configuration files
-
downcast
Trait for downcasting trait objects back to their original types
-
u16cstr
A macro for creating c-style u16 wide strings at compile time
-
topo-core
Domain types, traits, and error types for Topo
-
restructed
Quickly derive subsets of your structs
-
open-formula
A spreadsheet formula parser and evaluator that conforms to the Open Document Format for Office Applications Version 1.4 Format
-
execution-time
way to measure and display the execution time
-
erreur
A tiny crate that facilitates error handling, including tracing line numbers, customizing and propagating error messages
-
optional-numeric-index
Traits and macros for creating compact optional numeric indices
-
klieo-bus-nats
Production NATS JetStream + KV impls of klieo-core's bus traits
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
bhc-arena
Arena allocators for efficient compiler data structure allocation
-
menv
Pulling in arguments from environment variables
-
mir-analyzer
Analysis engine for the mir PHP static analyzer
-
wrapper-lite
Helper macro for building a wrapper type and implementing common traits for it
-
indigauge-core
Core primitives for the Indigauge Rust SDK: event macros, tracing layer, and helpers
-
orx-closure
An explicit closure with absolute separation of the captured data from the function
-
module_path_extractor
Derive a Rust module path from a macro call-site span
-
witnessed
Type-level witness wrapper for carrying validated invariants
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
notizia
Frictionless message passing for the Tokio runtime
-
bytestream
convenient way of writing binary data to a buffer
-
rknn-rs
rknn rust binding
-
type-signature
Compile-time stable structural hash of a Rust type, via a derive macro
-
quither
A flexible enum-based utility for representing values that may be on the left, right, neither, or both sides
-
glam-traits
Traits for the vectors in glam
-
sbe_gen
Binary Encoding (SBE) code generator for Rust using zerocopy
-
oofs
Error handling library that generates and injects context for you
-
noema
IOC and DI framework for Rust
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
marked-path
Type-safe path wrappers with compile-time absolute/relative guarantees
-
devela_base_core
base shared functionality for devela
-
mangle-common
Mangle, a logic programming language
-
rustfmt-nightly
find and fix Rust formatting issues
-
type-state-builder
Type-state builder pattern derive macro with compile-time safety and enhanced ergonomics
-
no_drop
wrapper type that guards against a value being automatically dropped
-
elicit
SmartPointer-like structure for polymorphism
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
arr_macro
Initialize arrays with ease!
-
rialo-sol-lang-idl
Sol framework IDL
-
optics
A no_std-compatible optics library providing composable lenses, prisms, isomorphisms, and fallible isomorphisms
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
blinc_router
Cross-platform routing with deep linking for Blinc UI framework
-
hash-injector
Hasher+BuildHasher to inject particular hash
-
rust-i18n-derive
derive macro for internationalization (i18n) support
-
typed_tuple
Type-safe access, isolation and mutation of primitive tuple segments and elements
-
zerust
Zero-cost Zinx for Rust
-
inew
Macros for constructor generation
-
changeset-saga
Saga pattern for atomic multi-step operations
-
cjc-mir
Mid-level IR with CFG, SSA, dominators, and optimization passes
-
dispose
wrapper for values that must be consumed on drop
-
roketok
way to simply set up a tokenizer and use it. Not recommended for simple tokenizers as this crate adds a bunch of stuff to support many if not all kinds of tokenizers
-
borrowme
The missing compound borrowing for Rust
-
nvec
N-vectors and N-strings
-
rangetools
Extending the Rust Range structs found in std::ops
-
convention-lint
File-naming convention linter configurable via Cargo.toml metadata — use as
cargo convention-lintor embed as a library -
noprocess
A lightweight Rust library for managing long-running processes with graceful shutdown, restart capabilities, and error handling
-
ijzer
Main crate for IJzer. Provides a macro for using IJzer in a rust project, and a prelude with dependencies..
-
syllogism
allow for some specialization using stable Rust
-
xopsy
Structural pattern matching DSL for JSON. Perform declarative diagnostics and surgical in-place updates on dynamic data.
-
fast-uuid-v7
A high-performance Rust library for generating UUID v7 compatible identifiers
-
lithium
Lightweight exceptions
-
wiremock-grpc
Mock gRPC server to test your outgoing gRPC requests
-
teloxide-plugins
Smart plugin system for Teloxide bots
-
rootfinder
Root-finding methods for both univariate, scalar-valued functions and multivariate, vector-valued functions
-
easy-error
error utilities
-
expressive-cron
A fluent builder for cron expressions, inspired by Laravel
-
facet-error
thiserror replacement powered by facet - derive Error trait from doc comments
-
type_reflect
Extensible runtime reflection through a Derive macro
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
ersa_lsp_core
LSP core for the GPC Scripting language. Intended to be used as a library.
-
ckg-core
Shared types, errors, and traits for ckg
-
error-enum
Provide a easy way to define an enum that represents errors with error codes, document comments and several other functionalities
-
chainerror
Make chaining errors easy
-
typeables
type aliases. By SixArm.com.
-
docbert-plaid
PLAID-style multi-vector index for docbert (ColBERT late-interaction)
-
oors
Adding cross-crate inheritance features to Rust structs
-
re_error
Helpers for handling errors
-
philharmonic-connector-impl-api
Trait-only API crate between the philharmonic-connector-service framework and per-implementation connector crates. Non-crypto; holds the Implementation trait and re-exports from philharmonic-connector-common.
-
non-empty-slice
Non-empty slices
-
trisult
An accumulating alternative to standard
Result<T, E> -
hcp
running and subprocess and pinging healthchecks.io with result
-
atomr-agents-strategy
Strategy traits and combinators for atomr-agents
-
nounwind
A attribute macro to prevent panics from unwinding, similar to C++ noexcept
-
mono-changeset
Mono repository changeset utilities
-
isclose
A collection of trait and macros for comparing approximate equality
-
accessorise
Add accessors to your struct and trait implementations
-
medi-rs
mediator library for Rust
-
autowrap
Ergonomic smart pointer and interior mutability extensions
-
cache_diff
Generate clean, human readable diffs between two cache structs
-
nnn
Generate your newtypes from a single macro
-
const-tools
help write safe const fns such as destructuring and array operations
-
indicator
Abstractions for stream aggregation, we call them
Indicators -
mode
A behavioral state machine library written in Rust
-
ferrous-di
Type-safe, performant dependency injection for Rust, inspired by Microsoft.Extensions.DependencyInjection
-
beekeeper
A full-featured worker pool library for parallelizing tasks
-
card-stack
The Stack for card games
-
nifioxide
Write HTTP processors for NiFi in Rust
-
deep_causality_haft
HKT traits for for the deep_causality crate
-
embed_it_utils
The utils for [
embed_it] -
cranelift-assembler-x64
A Cranelift-specific x64 assembler
-
unwrap-enum
generate methods to access enum variants
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
cee-scape
access to
setjmpandsigsetjmpfunctionality -
parsable
A trait to easily parse data structures
-
spade-codespan-reporting
Beautiful diagnostic reporting for text-based programming languages
-
partial_derive2
makes all the properties of a struct type an optional property
-
bitflag
A macro to generate bitflags structures from C-like enums
-
function-compose
function composition library for rust
-
resiter
Helper crate for handling iterators over result
-
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
-
brk_traversable
Traits for Vecs structs throughout BRK
-
kismesis
A static site generator with plugins and a custom markup language
-
uor-prism-verify
The Prism replay façade: a thin verification surface re-exporting
certify_from_trace,Certified, and the wire-format types defined byuor-foundation -
never
A stable version of the unstable never type (!)
-
chemrust-core
The core modules defining the flow and structs of data in computational chemistry routines
-
vs-plugin-api
Shared plugin models and traits for the vs runtime manager
-
provekit_bn254_blackbox_solver
Solvers for black box functions which are specific for the bn254 curve
-
my-utils
Utilities
-
cmporder
macros for prioritized Ord/PartialOrd
-
msft-typelib
Allocation-free parser for MSFT-format type library (.tlb) files
-
error-combinator
Type-driven error composition with functional combinators
-
gamelan-kernel
Proved kernel functions for composable agent systems
-
haste-fhir-operation-error
Haste Health FHIR operation error handling
-
condition-matcher
A flexible and type-safe condition matching library with automatic struct field access
-
puniyu_task
Puniyu 定时任务管理库，提供基于 Cron 表达式的任务调度功能
-
cl-format
Use Common Lisp format in Rust
-
pyo3-error
Unified error causality chains across Rust and Python
-
dyn-eq
Test equality between trait objects
-
quad-url
Plugin for macro-, mini-quad (quads) to do anything with url
-
crispii_errors
CrispiiError enum to be returned by any failing crispii functions
-
dlopen
opening and operating on dynamic link libraries (also known as shared objects or shared libraries). This is a modern and more flexible alternative to the already existing libraries like libloading or sharedlib
-
arm64jit
Spec-driven AArch64 JIT assembler for Rust
-
ros_msgs_include
Build script macro for including ROS 2 message types generated by rosidl_generator_rs via the AMENT_PREFIX_PATH
-
structz
Anonymous struct implementation in rust
-
emixcollections
Collection utilities including generic range types with iteration, clamping, and overlap detection
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
ra-ap-rustc_lexer
Automatically published version of the package
rustc_lexerin the rust-lang/rust repository from commit ba0949ab745985a442e274ba52e8fb348cb0c662 The publishing script for this crate lives at:… -
as-is
An abstraction over ownership
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
tree-sitter-lift
Tree-sitter grammar for the Lift migration DSL
-
traversable
Visitor Pattern over Traversable data structures
-
omniblack-cprint
A set of macros similar to
print!,println!,write!, andwriteln!, that color output -
dkg
Distributed key generation over ff/group
-
bool-enum
A macro for generating boolean-like enums that support bitwise and boolean operations
-
to-query-params
A procedural macro and trait for easy use of arbitrary structs as query parameters in Hyper
-
localtrace
A local tracing library for Rust
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
rst_lex
lexer for Rust
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
thread_local_scope
Scoped access to thread local storage
-
key-paths-core
Keypaths, ReadableKeyPath, WritableKeyPath and EnumKeypath for struct and enums in Rust
-
value-traits
By-value slices and iterators
-
biosyn
Mad Science Crate for working with
syn -
fyi_ansi
Compile-time ANSI formatting macros for FYI
-
applying
Apply functions in method-position
-
kmod-tools
Reexported tools for working with kmod macros
-
lox-test-utils
Testing utilities for the Lox ecosystem
-
pyenum
Expose Rust enums to Python as real enum.Enum subclasses via PyO3
-
tagu
Write SVG / HTML / XML programmatically
-
xproc
run shell commands with first class interpolation
-
funty
Trait generalization over the primitive types
-
binmarshal
Pack and unpack structs and enums into and out of binary data streams
-
cell_wrappers
set of macros for ergonomically working with TCells and TLCells from the qcell crate
-
wordnet-types
Shared types and part-of-speech enums for WordNet data
-
refineable-gpui-unofficial
A macro for creating 'refinement' types that can be used to partially initialize or mutate a complex struct
-
philiprehberger-guard-clause
Early-return guard clause macros for cleaner control flow
-
errors
std::error::Error utilities
-
env-flags
A convenience macro for declaring environment variables
-
advanced-pid
An advanced PID control library implemented in Rust
-
flat_error
Error wrapper to ensure Clone, Debug, and PartialEq
-
s3-bucket
wrapper around aws-sdk-s3
-
std-traits
Traits for types in the standard library
-
arr_ty
Macros for smart array initialization
-
minimer
error manager
-
mappings
Get the mappings of a process (currently only on Linux)
-
cgp-error
Context-generic programming error components
-
rayon-join
macro to call join from rayon with more than 2 arguments
-
rustdoc_copy
Rustdoc comment copy helper
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
ubits
Bit fields and masks
-
anymore
AnyDebug: Dynamically typed values which can be inspected
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
seekable-iterator
Traits for iterators and lending iterators with seeking capabilities
-
cfgenius
Conditional compilation with macro support in Rust
-
wd_log
A practical log crate for rust
-
fn_meta
Returns metadata about a function at runtime
-
rustc-ap-rustc_expand
Automatically published version of the package
rustc_expandin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
bubble
Enterprise-level development framework
-
aerosol
dependency injection for Rust
-
ouroboros_examples
Examples for the ouroboros crate
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
arrays
Construct an array from an iterator
-
globals
Painless global variables in Rust
-
error-accumulator
easier for developers to write input validation
-
regexpr
Regular expresions
-
secded
Single Error Correction, Double Error Detection Codes for Everyone
-
anony
Anonymous struct
-
tagset
Easily create trait-dispatching sum types
-
crashlog
Panic handling for humans
-
concat-with
Extend the function of the
concat!macro instd -
merge2
Merge structs into single by values
-
unchecked-std
Fast, unchecked variants of common std methods
-
baxe
that simplifies error handling in Axum
-
prehook
hooking and overriding functions using LD_PRELOAD. Useful for binary modding.
-
myutil
Rust Util Collections
-
deaf
parsing and modifying ELF binaries
-
philiprehberger-result-ext
Extension traits for Result and Option with tap, map, and error accumulation
-
error_mancer
Quickly define custom error enums for a function
-
noobase
Foundational pure-function utilities for astronomy analysis
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
timeout-tracing
Returns stack and span trace when the future hits a timeout
-
cdumay_error
define standard errors
-
repr-discriminant
Trait to retrieve the discriminant of an enum variant with a repr(T) at runtime
-
mers_lib
mers language in other projects
-
indices
macros and methods for safely retrieving multiple mutable elements from a mutable slice, addressing scenarios where slice elements would typically require
RefCellorCell(interior mutability approach) -
cbsk_mut_data
ref mut tool
-
re_tuid
128-bit Time-based Unique Identifier
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
bytelike
Common types and functions for byte size handling
-
limnus-local-resource
local resource storage
-
dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
miniffi
but opinionated FFI system
-
blf_lib-derivable
Shared traits used by blf_lib and blf_lib-derive
-
wot-td
Web of Things (WoT) Thing Description manipulation
-
sdl-main-wrapper
Wrapper over SDL's callback-based app loop
-
peeking_take_while
Like
Iterator::take_while, but calls the predicate on a peeked value. This allows you to useIterator::by_refandIterator::take_whiletogether, and still get the first value… -
fieldx_plus
Design patterns built on top of fieldx crate
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
tuple_list
macro-free variadic tuple metaprogramming
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
dynamodel
derive macro to implement conversions between your object and
HashMap<String, AttributeValue> -
galaxy_save_core
Defining common types and traits used in the save data of Super Mario Galaxy and Super Mario Galaxy 2
-
furmint-registry
Registry abstractions for
furmint -
capsec
Compile-time capability-based security for Rust
-
klieo-embed-common
Shared Embedder trait + dummy/fake impls for klieo memory backends
-
structx
Simulating anonymous struct and named arguments in Rust
-
store_by_enum
Type-safe data stores addressed and accessed using enums (in any order)
-
karpal-optics
Profunctor optics (Lens, Prism) for the Industrial Algebra ecosystem
-
okerr
Ergonomic result / error handling helpers built on anyhow and thiserror
-
ferrunix
A lightweight run-time dependency injection framework for Rust
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
const-destructure
Destructuring in const contexts on stable Rust
-
jkcenum
Rust enum library
-
raws-error
RAWS common error type
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
small_type_id
generation constant 32 bit nonzero unique identifiers for types
-
raz-common
Common utilities and shared types for the raz project
-
retry-policy
Retry Policy
-
poise_error
An opinionated plug-and-play library for error handling in Discord bots made with poise
-
xwt-erased
Type-erased wrappers for the
xwt-dyntraits -
asm_block
Translate tokens to string for Rust inline assembly
-
ps-uuid
An opinionated UUID implementation
-
drasi-ffi-primitives
Core FFI-safe types and vtable generation macros for the Drasi plugin boundary
-
utilities_rs
A small library of Rust utilities
-
sumtype
Generate zerocost sumtype of iterators or closures
-
ptr-arrow
A macro to emulate C-style arrow syntax
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
illumos-nvpair
Idiomatic Rust bindings for illumos libnvpair
-
taskflow-macros
Procedural macros for the taskflow DAG framework
-
gramex
common language for advance parsers
-
stackaroo
Swap out of the OS-provided stack
-
tryx-checked
Checked finite floating-point outcome types for tryx
-
custom-format
Custom formatting for Rust
-
backtrace-error
wrap errors with automatic backtrace capture and print-on-result-unwrap
-
codama-nodes
Node specifications and helpers for the Codama standard
-
endian-cast
generic functions and traits for accessing big-endian and little-endian versions of data types with a cheap abstraction that is zero-cost when the platform endianness matches the desired endianness
-
nu-std
The standard library of Nushell
-
derive-defs
generating derive preset macros from TOML configuration
-
nenyr
initial version of the Nenyr parser delivers robust foundational capabilities for interpreting Nenyr syntax. It intelligently processes central, layout, and module contexts, handling complex variable…
-
inpupy
Tiny Python-like input macro for Rust
-
hush-plugin
Macro for building Hush workflow op plugins as cdylib crates
-
rex-typesystem
Rex: A strongly-typed, pure, implicitly parallel functional programming language
-
wiwi
Stuff™
-
scheduled-task
对tokio-cron-scheduler库的增强
-
easy-ssh
A user-friendly SSH client wrapper for Rust, designed with a focus on ergonomics and safety
-
shards
rust bindings and utility in order to use shards
-
tauri-plugin-keygen-rs2
Tauri plugin for Keygen.sh licensing, based on keygen-rs
-
molcrafts-molrs-compute
Trajectory analysis for MolCrafts (RDF, MSD, clustering, gyration tensor)
-
sonos-sdk-state
Internal reactive state management for sonos-sdk
-
singlemap
rust single map a macro
-
intertrait
Allow for inter-trait casting
-
ruru
Native Ruby extensions in Rust
-
elm-client-gen-core
Core types and trait for generating Elm code from Rust types
-
nanokit
A collection of tiny, reusable utility methods that reduce code size and improve performance
-
opentalk-types-signaling-timer
Signaling types the OpenTalk timer module
-
fourcc-rs
Types and macros for working with Four-Chracter Codes (fourcc)
-
syn-locator
A source code locator for syn crate
-
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
-
bitsong
Fast
#[no_std]macro-based serialization/deserialization -
niloecl
axum handler pattern for twilight interactions
-
no-link
intentionally break any linking (linking stage)
-
cloneable_errors
similar to anyhow, that allows the errors to be cloned, shared, cached and even sent over the network
-
yzy-prom
A macro crate for defining prometheus metrics
-
egui_struct
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
utf8proj-parser
Parser for utf8proj native DSL (.proj files)
-
oneline-eyre
A fork of
simple-eyrewhich outputs errors on a single line -
dizzy
Macros for safely interacting with DST newtypes
-
enum_discriminant
Procedural macro to add functions on enum types to get discrimnant value from variant or create unit variant from discriminant value
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
prosaic-common
Shared type metadata for prosaic-core and prosaic-derive: ValueType, PipeSpec registry, and const-eval schema helpers
-
instability-example
Example crate demonstrating instablity usage
-
cf-resource-group-sdk
SDK for resource-group module: API trait, types, and error definitions
-
static-env-var
A macro for loading the env vars statically in a
LazyLock -
truc_runtime
Rust code generator for safe, fixed size, evolving records - runtime
-
unwinder
Call stack spoofing for Rust
-
orx-self-or
Defines SoR (self-or-ref) and SoM (self-or-mut) traits that are useful in reducing code duplication and pushing forward the ownership transfer decision from the type designer to the consumer
-
errorstack
A derive-based typed error system with first-class error stack building
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
entropium
Information-theory primitives: entropy, joint entropy, conditional entropy, and mutual information
-
per-thread-object
Efficient per-object thread-local storage implementation
-
runestr
User-perceived characters related types and data structures
-
hexkit
Lightweight boundary traits for hexagonal architecture in Rust
-
ffi_helpers
help make working with FFI easier
-
rumbok
Lombok-like derive macros (Getter, Setter, Data) for Rust
-
helper
provided some useful proc macros for Rust
-
precept
A testing utility for fuzzing and fault injection to discover erroneous and interesting states
-
binoc-sdk
Plugin SDK and ABI for Binoc dataset-diff plugins
-
depends
Ergonomic, performant, incremental computation between arbitrary types
-
chillpill
A more powerful (and more restrictive)
std::panic::catch_unwind -
oco_ref
A smart pointer for storing immutable values with relatively-cheap cloning. (Like a
Cowmeets anRc!) -
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
code-spells
Aliases some common (and less common) code snippets to macros named after thematically appropriate spells from Harry Potter, so that instead of calling drop(x), you can cast obliviate!(x)
-
qm-utils
functions and macros
-
handle_trait
A trait for types that represent handles to shared resources
-
specmc-protocol
parsing Minecraft protocol specification
-
tee_output
'tee' functionality for the current process
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
error-envelope
Structured, consistent error responses for Rust APIs. Framework-agnostic with Axum support.
-
aspect-std
Standard aspects library for aspect-rs AOP framework
-
conv2
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
alkahest
Fantastic serialization library with zero-overhead serialization and zero-copy deserialization
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
more-convert
adds macros for various conversions
-
separator
Formats numbers into strings with thousands separators for readability
-
flex
Flexible borrowing and ownership for Rust
-
idc
A lightweight crate for propagating errors
-
fluxo-typestate
Zero-cost type-state pattern via procedural macros
-
hzrd
Shared mutability containers based on hazard pointers
-
deploy-temp-fringe
safe, lightweight userland context switches
-
ai-quick-error
A no_std fork of quick-error
-
isr-macros
Macros for ISR
-
pared
Projected reference counted pointers
-
collate
Traits and a data structure to support collation and bisection
-
result-transformer
Traits, macros and utilities for transforming Result values
-
alef-backend-php
PHP (ext-php-rs) backend for alef
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
colorbrewer
providing colors from ColorBrewer
-
msica
Windows Installer Custom Actions
-
enum_cycling
Small macro for working with enums
-
graphql-starter
GraphQL starter kit
-
shufti-matcher
shufti table based string matcher
-
komadori
Multi-reduction library. Provides a composable, declarative way to consume an iterator
-
optifier
Rust macros for deriving optional types
-
bhc-diagnostics
Error reporting and diagnostics for BHC
-
emmy_dap_types
Rust types for Debug Adapter Protocol (DAP) - forked from dap-rs with cross-editor compatibility enhancements
-
deverr
Opinionated error handling for developers
-
stormchaser-dsl
A robust, distributed workflow engine for event-driven and human-triggered workflows
-
rship-entities-nodes
Binding node execution system and scene graph entities for rship
-
derive_hash_fast
A faster replacement for
#[derive(Hash)]for types without padding -
error-stack-macros2
Community-made procedural macros for error-stack
-
c8str
String types that are both utf-8 and null terminated
-
macro-attr
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
qbice_stable_hash
The Query-Based Incremental Computation Engine
-
elixirgen
Elixir generator
-
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
-
mdnt-groups-support
Support traits for the
picus::groupmacro -
deltoid
calculate and apply deltas to structs and enums
-
kubetsu
distinguish value type of other struct
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
bitrange
plugin to map bits in integer values to fields
-
singleton-manager
A programatical singleton manager
-
ezinit
Initialize structs with a generated new() function based on modifiable rules
-
untrusted_value
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
reda-lef
Lef file library
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
swift-rs-hatter-fork
Call Swift from Rust with ease!
-
cdumay_error_json
JSON error
-
translatable
A robust internationalization solution for Rust featuring compile-time validation, ISO 639-1 compliance, and TOML-based translation management
-
thiserror-nostd-notrait
derive(Error)
-
rx_core_operator_error_boundary
error boundary operator for rx_core. ensures at the type level that no errors are coming from upstream.
-
vvariadics_please
Implement things as if rust had variadics
-
control-flow
A hack to control control-flow outside closures
-
gull
type generation
-
nanocl_error
Nanocl error types
-
arid
An ergonomic object-model for Rust
-
combined_str
Zero-copy, const-generic string combinator for no_std environments
-
hierr
RUST Error
-
safe-manually-drop
ManuallyDrop“owned field” pattern with nounsafe, no.unwrap()s, no macros -
xiaoyong-value
Collection of sharing state primitives for async contexts (both Sync and !Sync)
-
merge-hashmap
Merge multiple values into one
-
error-graph
Allows non-fatal errors in a tree of subfunctions to easily be collected by a caller
-
autoerr
Very opinionated helper to declare error types
-
luhproc
A lightweight background process manager
-
pathbuf
A macro to conveniently build PathBufs
-
clash-prism-script
Script engine with rquickjs sandbox for Prism Engine
-
kv-derive
Derive struct conversions from and to key-value vectors
-
field-kinds
Derive macro for compile-time struct field type introspection
-
context_error
create rich errors to help users understand what the error was and how to fix it
-
rebounded
Bounded types
-
candied
that provides macros to reduce code size and adds syntactic sugar
-
dataloader-rs
High-performance DataLoader for Rust with a PyTorch-like interface
-
mig-types
Generated MIG-tree types for EDIFACT messages — shared segments, composites, enums, and PID-specific compositions
-
shovel
A declarative, fast CLI parsing library with derive macros, no_std support, and zero-cost abstractions
-
vantage-csv
Vantage extension for CSV files
-
cock-lib
Measure the power level of a peen
-
strided-traits
Shared traits for strided-rs: element operations, scalar bounds, and type-level composition
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
gc_plugin_abi
Gridcore Plugin API
-
static-dispatch
Implement a trait for an enum, where all variants implement the trait
-
backtrace-ext
minor conveniences on top of the backtrace crate
-
fastn-resolved
fastn: Full-stack Web Development Made Easy
-
cudd-sys
Bindings for CU Decision Diagram library (CUDD)
-
rust-code-analysis-web
Run a web service to compute and export code metrics
-
simple_impl
macros to make impls ergonomic, dense, and manageable
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
nzliteral
Macro simplifying use of NonZero literals
-
finum
A numeric type of variable length (20 decimal digits)
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
qubit-argument
Argument and state validation helpers for Rust applications
-
trait-cast
Get your own Any with support for casting to trait objects
-
or-die
deterrent methods for unwrapping a value from Options and Results with better parametrization
-
basic-oop
OOP for Rust
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
eventcore-types
Shared vocabulary types and traits for EventCore event sourcing library
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
try-partialord
Safe failable sort, min, max, binary_search functions for PartialOrd. No need to wrap f32, f64 to sort any more.
-
tramli
Constrained flow engine — state machines that prevent invalid transitions at build time
-
loose_enum
A macro for defining loose repr enums
-
ser_mapper
Mapped DTO serialzation wrapper for DBO/Model
-
facet-core
Core reflection traits and types for the facet ecosystem - provides the Facet trait, Shape metadata, and type-erased pointers
-
re_span
An integer range that always has a non-negative length
-
zerortt-api
Primitive types and traits for zerortt
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
einstellung
Configuration Parser
-
simple-logging
logger for the log facade
-
injection
A lightweight dependency injection container for Rust applications
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
functora
Missing pieces of the Rust standard library
-
focusable
A trait for types that can be focused
-
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
typederror
A wrapper around anyhow that allows for a primary error type
-
anyhow-auto-context
Automatic context for anyhow errors based on scope and location
-
bias-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
luminos-container
Luminos Container
-
thiserror-core
derive(Error)
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
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…
-
bouncy-browse
Stateful browser primitives for bouncy: open / click / fill / submit / read with structured page snapshots. Powers
bouncy browseand thebouncy_browse_*MCP tools. -
poly_it
A no-std library for manipulating polynomials with slice support and minimal allocation
-
ctrlgen
Generate enums for message-passing services
-
kurtbuilds_std_ext
Standard library extensions
-
moxy
A set of helpful macros for day to day quality of life tasks
-
aver-memory
NaN-boxed arena memory for the Aver language
-
enum-ptr
Ergonomic tagged pointer
-
bytify
macro that can write given const-expr values into a continuous byte array
-
ps-util
aims to provide generally helpful utility functions and traits
-
pi_slot_wheel
Multilayer timing wheel with constant generics
-
rusty-cmd
creating custom line-oriented command interpreters in Rust
-
parsy
efficient parser combinators library
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
identity-diff
Difftrait to compute and merge data structure differences -
stackbox_2
&owning references in stable Rust - no_std-friendly Box -
swaswa-shared-lib
Shared types and errors for the swaswa-* crate family
-
extend_mut
extending exclusive references
-
stylish-html
stylishhelpers for writing styles as HTML elements -
axum-error-handler
error handler for axum
-
fromsoftware-shared
Helpers for dealing with pointers and other common stuff across games
-
rust-box
odd set of tools for Rust programming
-
std-ext
Extend the standard library functionality
-
typed_use_cases
Formalize use cases at the type level. Zero runtime overhead. Experimental proof-of-concept.
-
str_array
Fixed-size
strandCStrtypes backed by an array -
cooked-waker
A safe interface for creating async Wakers
-
age-setup
that creates X25519 key pairs and uses age as its foundation and is very easy to use
-
prost-dto
Data transfer object conversion macros for prost
-
lwxm
lightweight extensible macros (universal macros for every language)
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
try-next
A minimal synchronous trait for fallible, pull-based item sources
-
macro-toolset
Some useful macros
-
crony
cron runner that spawns another thread to run your cron jobs
-
poison-guard
maintaining sane state in the presence of panics and failures
-
named-tup
Create named tuples using the tup!() macro
-
guard-clause
Syntactic sugar for writing simple guard clauses
-
io-streams
Unbuffered and unlocked I/O streams
-
decimal_scaled_macros
Compile-time decimal literal proc-macros (
d9!,d18!,d38!,d76!,d153!,d307!) for the decimal-scaled crate -
erio-core
Core types, traits, and error handling for the Erio agent runtime
-
calc_lib
calculating things with correct order of operations
-
nexus-stratum-css
CSS-in-Rust system for NexusStratum
-
pleme-error
Unified error handling library for Pleme platform
-
deterministic_default_hasher
A deterministic initialisation of the stdlib default hasher
-
linreg
Calculates linear regresssions of two-dimensional data. Does not use stdlib, only depends on numeric traits.
-
state-shift
Macros for implementing Type-State-Pattern on your structs and methods
-
mall-portrait-common
Common utilities and types for mall portrait projects
-
capture-it
Modern c++-ish capture syntax for rust
-
tentacli-traits
Traits and types for tentacli and related projects
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
lex-just-parse
lexing and parsing crate for Rust. It provides a fast, stream-based lexical analyzer (Lexer) and combinator-style parser utilities (Parser) to assist in developing custom programming languages…
-
include-first
Proc macro to evaluate include_str! macros early
-
histo
histograms with configurable buckets
-
static-conduit
A type-safe, zero-cost recursive pipeline engine for data transformation
-
alef-backend-rustler
Elixir (Rustler) backend for alef
-
arri_common
Common types and utilities shared across Arri crates
-
debug3
Space Efficient Pretty Printer
-
deptypes
Dependent types
-
use-rust
Composable Rust ecosystem primitives for RustUse
-
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
-
get_set_macro
Procedural macro to generate customizable getters and setters in Rust
-
dioxus-keys
An unified DataKey interface coupled with a few helper macros to help you make global keys
-
variadiz
Variadic function support for rust
-
lstring
Key String: optimized for map keys
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
sqry-lang-rust
Rust language plugin for sqry
-
pyspark-arrow-rs
Derive macros to be used to add some helper functions to Rust structs to make them useable in Pyspark's mapInArrow
-
try_create
A small library providing generic traits for fallible and infallible object creation
-
powdr-constraint-solver
powdr tools to analyze and solve algebraic constraints
-
typed-arrow-dyn
Dynamic Arrow facade for typed-arrow (runtime schema/builders)
-
pbni-rs
PBNI for Rust
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
nya-macros
nya macros
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
kindest
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
vizia_reactive
Reactive primitives for VIZIA
-
raw_struct
procedural macro for easily declaring C-style structs that reference local or external memory, based on your memory implementation. It generates appropiate getter methods for easy access.
-
derive-merge-struct
A derive macro to partially update a named struct
-
txrc_macros
macros
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
googleapis-tonic-google-bigtable-v2
A Google APIs client library generated by tonic-build
-
derive_destructure2
Destructure structs that implement Drop
-
placid
Separated ownership and in-place construction in Rust
-
batched
rust macro util for batching expensive operations
-
const_str_slice_concat
const concatenation of string slices
-
comparator
A Java-like Comparator type
-
nanoservices-utils
A collection of utilities for nanoservices
-
hexga_generational
GenVec, ideal for MAS (Multi-Agent System), where each agent can be removed at any time and has references to other agents
-
aas-types
AAS Types - Agent Accountability Service
-
genius-invokation
Abstractions and structures for Genius Invokation TCG
-
qubit-io
Small I/O trait utilities for Rust
-
quark
Types for manipulating numeric primitives at the bit level
-
almost-enough
Batteries-included ergonomic extensions for the
enoughcooperative cancellation crate -
amble_data
Shared data model used by amble_engine and amble_script for the Amble game engine
-
zngur-generator
Generates Rust and C++ glue codes from the zng file
-
regex-macro
A macro to generate a lazy regex expression
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
crier
but flexible observer library
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
gostd_builtin
Package builtin binds the basic type in go through the type alias, and implements the basic type cast macro function.builtin 包通过类型别名绑定Go中的基础类型，并实现了基础类型强制转换宏函数…
-
fallible-option
Fallible is an Option with inverted Try-semantics
-
mownstr
Maybe Owned String
-
or-panic
unwrap or panic
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
abyss-interpreter
Runtime engine for the AbySS scripting language: evaluator, runtime environment, value representation, and the built-in standard library
-
solace-rs
Unofficial Solace PubSub+ Rust Client Library. It can be used to access the services of a Solace PubSub+ Event Broker. This is a wrapper around the Solace C library. Use under your own risk…
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
edsm-dumps-model
Data models for EDSM dump data
-
implementation
The implementation crate
-
rst-common
A shortcut to common Rust crates
-
org-rust-parser
parser for org mode documents
-
ezcfg
configuration
-
semisafe
Semi-safe utilities for performance-critical Rust
-
rioc
Zero cost dependency injection macros
-
sod
Service Oriented Design
-
struct-metadata
Macros for attaching metadata to structs
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
once_cell_no_std
Sync single assignment cells for
no_std -
facet-miette
Derive miette::Diagnostic for facet types - rich error reporting with source spans
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
progress-streams
Progress callbacks for types which implement Read/Write
-
safe-rust
A safety-oriented Rust crate that ensures your code is safe
-
pinkie
(Almost) compile-time scoped CSS-in-Rust
-
enum-typer
Type-indexed enums and GADTs for Rust via procedural macros
-
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)
-
dfo
Differentiable Floating-point Operations in Rust
-
sge_shapes
Shape types for SGE
-
macro_lisp
Lisp-like DSL for Rust language
-
v8_derive
Derive macros and helpers for Rusty v8
-
fused_error
working with composable errors
-
gur
A undo-redo framework
-
rostl-primitives
Oblivious primitives and utils
-
cjc-types
Type system and inference engine for CJC
-
bon-cli
Dev tool for working with the
boncrate -
unpaid-intern
A convenient little string interner
-
axum-typed-routing
Typed routing macros for axum
-
fundle
Compile-time safe dependency injection for Rust
-
occupied
A type-safe way to interact with removing from and inserting into options
-
lucidity
A distributed orchestrator platform for Rust
-
bounded-registers
A high-assurance memory-mapped register interaction library
-
shannon-nu-std
The standard library of Nushell
-
error-ext
Error utilities
-
surqx
Query macro for SurrealDB
-
tagged-vec
A Vec which can be indexed by one specific type
-
convi
Convenient (but safe) conversion (
From-like) traits -
onechatsocial-result
Revolt Backend: Result and Error types
-
mir-types
Type system primitives for the mir PHP static analyzer
-
swap-pool
Allow objects to be stored either in RAM or on disk
-
proc-easy
Macros to make writing proc-macro crates easy
-
hash_ord
lib contains OrdMap(avl tree) and HashMap(use avl to resolve collision);
-
mapcomp
Python-like list comprehensions for standard containers
-
shiplog-ports
Core port traits for shiplog adapters: Ingestor, WorkstreamClusterer, Renderer, Redactor
-
slip-10
SLIP10 implementation in Rust
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
hetero-cartesian
A procedural macro to flatten nested heterogeneous callback-based control flows into a clean cartesian product
-
parametric
providing the trait and a derive macro to bridge complex, hierarchical data structures with optimization algorithms that use flat parameter vectors
-
nyar_valkyrie
-
enumizer
macros for generating enums that are equivalent and convertible to standard library enums
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
hictor
declarative macro for __attribute__((constructor))/__attribute__((destructor))
-
any_cmp
Support dynamic type comparisons
-
enum_index
Trait and macros for extracting Enum variant index
-
elor
Base generic implementation of an Either type
-
doxidize
Fearlessly document function parameters with rustdoc
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
flatty-portable
Flatty portable trait and primitives
-
err-report
Clone of the unstable
std::error::Reporttype -
ocl-macros
Macros for easier/faster working with the ocl crate
-
zen-types
Zen Core Types
-
explicit-error-http
Explicit concrete Error type to manage and monitor errors that generate an HTTP response. It has dedicated feature flag to integrate well with most populars web frameworks.
-
anyanymap
Macro for building any Type Map with a standard interface
-
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
-
lcdm
High-performance ΛCDM Cosmology Engine (Facade)
-
scopes-rs
Strongly typed scoped authorization library
-
prange2
Parse numeric ranges for indexing
-
sw-errors
error parsing and pretty-printing, used across the swtools toolset
-
ref_iter
Dynamic borrowing iterator
-
slot-cell
SlotCell - an interior mutability container. It acts as a "Runtime-Checked Move Cell", providing owned access to data rather than references.
-
a1
A package for converting to and from A1 spreadsheet notation
-
mayber
A zero-cost enum for handling either references or owned values with a unified interface
-
igc_parser
A high-level parsing/deserializing crate for IGC flight recorder files
-
evident
Pub/Sub library using IDs to identify events
-
qanglang-core
Core library for QangLang
-
chalk-macros
Macros for Chalk
-
double-trait
A procedural macro to derive a mirror of a trait designed to make it easier to implement test doubles
-
accursed-unutterable-type-id
A worse version of std::any::TypeId
-
tramli-plugins
Plugin pack for tramli — audit, eventstore, observability, resume, idempotency, hierarchy, diagram, docs, lint, testing, subflow
-
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
thisctx
Easily create error with contexts
-
fray
A type-safe and ergonomic Rust library for working with bitfields
-
rokc_parser
parse a Kconfig file into a rowan CST
-
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
-
market
Infrastructure for producers and consumers
-
toobad
intuitive error handling library
-
named-block
Macro implementing early-exit-from-any-block
-
magic-params
Macro to call functions with typed arguments derived from a shared context
-
collect_failable
A trait for collecting values into a container which has an invariant to uphold and whose construction may fail
-
scall
Friendlier raw system calls for Rust
-
index-ext
Index slices with arbitrary ints and as arrays
-
openrunner-rs
running OpenScript
-
piggyl
Core library for the Pig trait — assign each struct its own pig of the day
-
roopert
object-oriented toolkit for Rust
-
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
plain_hasher
Hasher for 32-byte keys
-
teo-parser
Parser for Teo schema language
-
supertrait
enables default associated types and const fn trait items in stable Rust
-
update_cell
A Cell<Option<T>> that you can update
-
avx-error
AVL Platform error handling - replacement for anyhow/thiserror
-
wayle-core
Core reactive primitives and D-Bus utilities for Wayle services
-
leptos-floating
Floating UI primitives for Leptos
-
tpack
Std facade, registry integration, and optional serde support for TPACK
-
ranim-anims
The built-in animations of Ranim
-
measures
A unit-of-measure and electrical calculations library
-
nade
Adding named and default arguments to Rust functions
-
isotopes
Variants of common types for enforcing invariance
-
anon_enum
Enum types with fully-generic variants
-
bounds
interact with bounded and unbounded ranges
-
macro-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
scoped_static_storage
ScopedStatic which allows you to store and use a &mut T variable across threads and contexts safely very similar to scoped-tls-hkt but not in thread-local storage
-
miden-debug-dap
In-repo Debug Adapter Protocol support for miden-debug
-
result-transformer-flow
Traits, macros and utilities for transforming Result values
-
subsecond-types
Types crate for the Subsecond hotpatch engine
-
bon-sandbox
Not a real crate! It’s just a showcase of examples used by
bon’s documentation to demonstrate the rustdoc output for code generated by builder macros. Don’t use this crate, it… -
bronzite-types
🔮 Shared types for Bronzite compile-time reflection IPC protocol
-
runi-core
Runi core library — foundation types plus a feature-gated bundle that re-exports runi-log and runi-cli
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
naan
A fast, easy, and tasty functional programming prelude
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
dirty-fsm
A quick and dirty state machine library
-
type_enum
Create tagged unions consisting of different types
-
rust-extra
-
dyn-ptr
A box that stores types like pointers, forgetting everything besides
Self: Unsize<dyn Trait> -
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
key-path
Key path for Rust
-
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. -
vcell
Cellwith volatile read / write operations -
typewriter-plugin-ruby
Ruby (Sorbet) emitter plugin for typewriter
-
cortex-ai
An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling
-
yoshi-std
Core, std-only error type for the Yoshi framework
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
matrix-slice
Safe abstractions for two-dimensional slices
-
rc-borrow
Borrowed forms of Rc and Arc
-
from_form
From forms to your structs
-
stringleton
Extremely fast string interning library
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
ebml-iterable-specification
base
EbmlSpecificationused by theebml-iterableandebml-iterable-specification-derivecrates -
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
orceh
Easier plugin interfaces
-
contextro-core
Core domain types, traits, and errors for Contextro
-
kcr_inference_kubedl_io
Kubernetes Custom Resource Bindings
-
quick-error
A macro which makes error types pleasant to write
-
tryx-cancel
Cancellation outcome types for tryx
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
ratatui_router
Page-based router with auto-generated routing for ratatui
-
funcall
A lightweight Rust library that turns functions into JSON-callable tools
-
json-crawler
Wrapper for serde_json that provides nicer errors when crawling through large json files
-
brk_rolldown_plugin_vite_css_post
Rolldown plugin for Vite CSS post-processing
-
pleme-providers
Multi-provider integration library for Pleme platform - generic trait abstraction and registry
-
flaky_test
atttribute macro for running a flaky test multiple times
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
physical-quantity
dimension and unit system for general physical physical quantities
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
libobs-window-helper
list of windows that can be captured by OBS
-
gistyr-lib
small tools and helpers
-
sai
IoC/DI framework for Rust
-
sentry-conduit
Sentry middleware for conduit
-
portable-io
“ A subset of Rust
std::iofunctionality supported forno-std -
koicore_ffi
FFI bindings for koicore
-
autoproto
Replacement derive macros for
prost::Message, and supporting traits and types to make implementing this trait easier -
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
metrique-aggregation
aggregating metrique events
-
xuyingjie_hello_macro
test for publish xuyingjie_hello_macro
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
infinity-build-core
Core build abstractions for the infinity-msfs toolchain. Defines the Builder trait, common error/artifact types, and config primitives shared by Rust/WASM and JS/TS build paths.
-
tc-error
TinyChain's generic error struct
-
open-feature-env-var
Environment Variable provider for OpenFeature
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
inline_enum_handler
Match enum variants to #[handler] functions without boilerplate
-
nolife
open a scope and then freeze it in time for future access
-
order_theory
Traits which describe basic concepts from order theory
-
tiff-encoder
creating TIFF files
-
field33_rdftk_names_temporary_fork
set of modules that contain the
IRIs andQNamestrings for commonly used vocabularies. It also provides macro support for defining new namespaces in the same style as this library. -
const-units
that lets you check the dimensions of your quantities at compile time and run time
-
grass_chewer
A generalized COW (copy-on-write) type
-
defer-heavy
A versatile and easy to use defer statement for Rust. Similar to Go's or Zig's defer.
-
raw-transmute
A more permissive alternative to mem::transmute, because you know better
-
ropr
A blazing fast multithreaded ROP Gadget finder. ropper / ropgadget alternative
-
therror
derive(Error) with a twist (based on thiserror)
-
humthreads
Threads for humans
-
ffi_trait
FFI-safe trait vtables
-
mangle-interpreter
Pure Rust interpreter for Mangle IR
-
el-macro
a dumb macro collection for anti-idiomatic rust programming
-
objid
Generate a random object identifier
-
color-eyre-attach-report
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors. This fork adds the ability to attach new reports to existing reports.
-
supply
Provider API for arbitrary number of lifetimes
-
dterror
Dat Error
-
virtue
A sinless derive macro helper
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
structupdate_support
Type definitions used by the structupdate crate
-
lazy-init
Lazy initialization
-
append-only-bytes
Shareable append-only bytes
-
extended-primitives
providing primitive-like types for use
-
cobia
CAPE-OPEN COBIA binding interface library for rust
-
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
strux
Tabular declaration of similar structs
-
coercible_errors
Zero-cost error handling for generic traits
-
isit
compile time assertions and conditional checks
-
duat-txt-macro
A macro to create a Text struct from duat
-
lisette-emit
Little language inspired by Rust that compiles to Go
-
cronjob
scheduling your methods
-
delegate-match
Proc-macro for delegation of grouped match arms
-
stackstring
A fixed-size string
-
auto_ops_det
Macros for easy operator overloading
-
stable-type
OCaml inspired stable types
-
defer-rs
Deferred execution Rust utilities
-
sig
ffi library of signal(2) and kill(2)
-
abstract-impl
Create abstract implementations for traits
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
iterator-ext
An extension to Rust's Iterator
-
soapy
Structure-of-arrays derive macro
-
virtual_exec_extern
Sub-crate of virtual_exec - provide macro definition for building external function
-
fn_name
Macros that produce the name of the function they're invoked within
-
nuhound
Improve error handling capability
-
olis_string
Small-string optimization for Rust, aims to replace std::string::String
-
jcers
jce in rust
-
episode-renamer
Rename episode files from one naming pattern to another, using a TSV with mappings
-
simple-life
async lifecycle trait and convenient macros
-
facet-path
Path tracking for navigating Facet type structures
-
rusty-lines
Abstract reading lines from tty or File
-
lives
Lifetime-dynamic smart pointers
-
enum-unitary
Trait and macro for unitary enums
-
errata
Ergonomic pretty error handling for binaries
-
rust_twostack
Support for two-dimentional stacks for the Rust programming language
-
wisp-fuzzy
stable fuzzy matching abstraction for Wisp
-
aetheris-encoder-bitpack
High-performance binary contracts and communication traits for the Aetheris Engine
-
typestate
A proc macro DSL for typestates
-
unwrap_unreachable
Option::unreachable()andResult::unreachable()methods -
puniyu_plugin_basic
puniyu basic plugin
-
faultline
A typed error library for services and control planes that separates domain failures, transient faults, and invariant violations
-
culit
Custom literals
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
assert_hex
display assert panics in hexadecimal {:#x?} format
-
ordes
treating arrays and tuples a little bit more like vectors
-
iri-string
IRI as string types
-
commonware-utils
Leverage common functionality across multiple primitives
-
armature-app
Build complete Armature applications in Rhai scripts
-
trait-set
Support for trait alias feature on stable Rust
-
buffalo
Serialization library for Rust
-
macron-collections
Creates a new instance of std collections: HashMap, HashSet, BTreeMap, BTreeSet, VecDeque, LinkedList and BinaryHeap
-
common-stdx
extension for the std lib, for things i commonly reuse
-
letter-sequence
A method to create sequence displayed as uppercase or lower letters, or digits
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
interpolate
form of string interpolation
-
typemap-meta
compile-time macro to create type-to-value maps
-
tryvial
Small crate for ok-wrapping and try blocks
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
maud-extensions-runtime
Runtime slot helpers for maud-extensions
-
weirdboi_utils
A collection of utility macros
-
newtype-tools
Ergonomic utilities for the Rust newtype idiom
-
thread-object
Abstraction over thread-local storage allowing dynamic creation of TLS variables
-
dess
Differential Equation System Solver (DESS) is a Rust crate implementing fixed-step and adaptive-step solvers and designed especially for modeling physical systems. Seven explicit ordinary differential equation (ODE)…
-
string_capacity
Moved to capacity_builder
-
impl-opaque
Macro for declaring complex struct and initializer
-
arena-container
weak-typed arena (freelist) container without guards
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
yoshi
Entry for the Yoshi error framework
-
langlang_value
langlang is a parser generator based on Parsing Expression Grammars (library)
-
phenotype-internal
Defines
Phenotypetrait forPeapodcrate -
atomicell
Multi-threaded RefCell on atomics
-
warnalyzer
Show unused code from multi-crate Rust projects
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
bigerror-error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
luhlog
A horrible Rust logging library
-
moro-local
Experimental structured concurrency support for async Rust (similar to trio's nurseries). Works with non-Send futures on stable Rust.
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
dioxus-shareables
Hooks for sharing structures between components
-
swamp-script-derive-tests
tests for swamp macro
-
iterate-trait
Experiment with methods on IntoIterator
-
munarkma
Namumark parser
-
rust-automata
A framework and a DSL for building finite state machines in Rust
-
phlow
An engine for scripting reactive browsers in Rust by adding custom views to structures
-
drop-with-owned-fields
Safe and sound owned access to a
struct’s fields inDrop: no moreunsafeusage ofManuallyDrop! -
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
jaaptools
I really just wanted to try publishing a package, but this contains stuff I find useful in many circumstances
-
clap_reverse
Derive macro for building
std::process:Commandfrom a Rust struct -
rs_coroutine_core
Composable coroutine utilities and flow abstractions built on top of Rust's async ecosystem
-
takeable-option
A small wrapper around option
-
rustbill-core
RustBill plugin SDK — trait definitions, FFI macros, and shared types for building plugins
-
interns
Object interner
-
compose_core
The Compose Language implementation
-
maybe-single
A singleton. Maybe.
-
fre-rs
Safe, ergonomic Rust abstraction over the AIR Native Extension (ANE) C API (
fre-sys) for native-side development -
interrupt-read
interruptable reader
-
slotpoller
Bounded, lock-free futures collection. Faster than FuturesUnordered and other crates.
-
rx_core_subscriber_higher_order
higher_order subscriber provider for rx_core
-
const-util
Stable implementations for some missing const functions
-
ark-r1cs-std
A standard library for constraint system gadgets
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
cellumina
configure and run cellular automata
-
simple-color
color struct
-
bhc-intern
String interning for efficient symbol handling
-
rustfmt_lib
Rustfmt as a library
-
partial_application
partial function application via the partial! macro
-
zeph-context
Context budget, manager, compaction strategy, and assembler for the Zeph agent
-
api-guidelines
Rust API guidelines enums and utilities for code quality and best practices
-
koute/nes
emulator written in Rust
-
option-ext
Extends
Optionwith additional operations -
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
-
kmacros
Useful macros
-
rabbithole
JSON:API Data Structure & Query implementation
-
tayvo_okapi
Structs for OpenAPI (AKA Swagger) documents
-
async-err
Contextual asynchronous error handling
-
jsmoke_macros
JSmoke personal macros
-
test-with-tokio
attribute macro for tests using tokio with cases and async guards
-
coil-seo
SEO primitives for the Coil framework
-
projecture
Easy arbitrary type projections without proc macros
-
utoipa-helper
Helper Crate For Utoipa Axum Integration
-
coinduction
Attribute macros for defining circular type references and recursive trait implementations in Rust
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
const-exhaustive
Enumerate all values of a type at compile time
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
reax
A reactivity system for Rust that infers dependencies between functions
-
async-convert
Async TryFrom/TryInto traits
-
formatter-builder
The safe and stable builder for fmt::Formatter
-
ex_em_ell
Provide macros for serializing and deserializing XML
-
oxide-update-engine-types
Serializable types for the oxide-update-engine framework
-
unused
Allows for unused generic parameters that do not act like they are owned
-
skipcode
macro library enabling compile-time skipping of statements/blocks
-
ltk_meta
Metadata formats and utilities for League Toolkit
-
corsa_bind_core
Shared errors, process lifecycle helpers, and fast-path primitives for corsa-bind
-
secador
Stop repeating code
-
lazymut
Similar to LazyCell, but use &mut self to get or initialization
-
pin-init
Safe pinned-initialization in Rust
-
qubit-mixin
Trait mixins for domain objects, providing common properties and behaviors
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
sigma-enum
A macro to simulate sigma types with enums
-
bty
Streamlined definition and usage of branded types in Rust
-
macros_rule
Change the verbiage of
macro_rules!tomacros_rule! -
char-device
Character Device I/O
-
cmp
convenience macros and function for comparing
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
wartcl
A minimal embeddable Tcl-like language
-
rootcause-backtrace
Backtraces support for the rootcause error reporting library
-
closure
A macro for capturing variables on a per variable basis
-
optionally_const
Optional constness on stable Rust
-
swamp-types
types used in Swamp
-
rusty-bind-parser
Parses Rust module, generates Rust code with C ABI bindings and C/C++ header files and Swift gluecode
-
ellie_tokenizer
Tokenizer for ellie language
-
racros
Collection of rust macros
-
cgp-error-eyre
Context-generic programming error handlers implemented using eyre
-
float_plus
Additional features for float values
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
close-err
Add .close() to file-like types, for error handling
-
fast-rustc-ap-rustc_session
Automatically published version of the package
rustc_sessionin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
synapse-dsl
DSL parser for Synapse memory configuration language (.mnm)
-
derive-into
derive macro for easily creating conversions between structs and enums
-
hkalbasi-rustc-ap-rustc_abi
Automatically published version of the package
rustc_abiin the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
sql_tool_core
这个库是 sql_tool_macros 库的核心，存储 trait
-
fieldwork-borrow
Field-level borrow splitting for Rust
-
error-kit
A comprehensive error handling library for Rust applications
-
iced_af
The iced application framework project
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
pathbufd
PathBuf with Display + formatting macro
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
clap-handler
A command handler works with
clap-deriveto generating subcommand handlers -
stock-symbol
A data type for representing stock symbols
-
ffizz-passby
FFI helpers for implementing pass-by-value and pass-by-pointer
-
cdumay_base64
base64
-
noretry
retryable abstraction for your functions
-
primitive-from-enum
macros for get primitive enum from complex
-
wae-effect
WAE Effect - 代数效应依赖注入，声明式依赖获取
-
slugify-rs
generate slugs from strings
-
quickvariant
C++-style variant library
-
cppstreams
C++ streams in rust
-
beerec-variants
Procedural derive macro to generate boilerplate on unit variants enum types
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
aegir
Strongly-typed, reverse-mode autodiff library in Rust
-
kompost
easen functional programming in rust by facilitating the creating composition of Iterator methods and anonymous Iterators—all without writing any trait or struct, without macros or unsafe code
-
battler-wamprat-error
Procedural macro for custom WAMP errors
-
optionize
A procedural macro to generate optionized versions of structs for partial configurations, updates, and builders
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
is_empty
Easily check if the struct is empty
-
rustils
Utilities for rust
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
derive-name
Derive macro to get the name of a struct, enum or enum variant
-
plist_ffi
C FFI for the amazing plist crate, compatible with libplist
-
read_int
get user input in any primitive type
-
tao-of-rust
《Rust编程之道》随书源码
-
eventcore-postgres
PostgreSQL event store adapter for EventCore event sourcing library
-
enum_dict
Efficient enum-indexed dictionaries
-
cf-static-credstore-plugin
CredStore plugin with static secret mapping for development and testing
-
enum-group-macros
Define grouped enums with ergonomic pattern matching
-
fiberplane-pdk
Fiberplane Provider Development Kit
-
maybe-borrow
Macros for conditionally returning borrowed data
-
cryo
Extend the lifetime of a reference. Safely.
-
field33_rdftk_core_temporary_fork
core RDF data model; concrete implementations for Statements and Literals, along with a Resource type that provides a builder-like experience for models
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
transient
Reimplementation of
std::any::Anywith support for non-'statictypes -
scope-lock
Safely extend lifetimes
-
iceyee_error
Error Message
-
eager
macro expansion
-
drop_code
A macro that allows you to implement code that will be automatically executed after the function code has finished, be it the end of the function or even a panic state
-
spyparty
parsing SpyParty replays
-
jtd-infer
Generate JSON Typedef schemas from example data
-
light_clone
Compile-time enforcement for O(1) clone operations
-
implied-bounds
Make all the bounds of a trait definition be implied through a helper trait and macro attribute
-
interface
Typed, lossy-aware interface translation between API versions
-
dbus-strings
Rust native implementation of different D-Bus string types
-
sans
Composable coroutine-based programming library for sans-io
-
ostd-pod
A trait for plain old data (POD)
-
enum_handler
A macro to generate a handler trait for enums variants
-
string-literals
Rust macros to more easily create String types
-
dyn-context
mechanism for lifetimes erasing
-
fringe
safe, lightweight userland context switches
-
rooting-forms
Generates HTML (rooting) forms from structures
-
o2-primitives
Core trading primitives for the Fuel O2 exchange
-
tryx
Nightly outcome types for Rust's question mark operator
-
once
assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
borked
convienient error handling library for rust
-
ux2
Non-standard integer types like
u7,u9,u10,u63,i7,i9etc -
issues
An error reporting library for Rust
-
squote
A clone of the quote crate that uses a String as its backing store
-
chain_link
Micro library with a util for chaining operations on a single type
-
maw-git
Git abstraction layer for maw — trait-based interface backed by gix
-
borrowck_sacrifices
Necessary sacrifices to keep the Borrow Checker happy and developers sane
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
assemblist
Define your builder patterns as you use them
-
rust-2018
Macro to use Rust 2018 from all editions
-
ax-lazyinit
Initialize a static value lazily
-
better_unwrap
A trait providing clearer alternatives to unwrap() methods: or_panic(), panic_or(), panic_or_else(), panic_or_default(), and panic_with()
-
hello-world-in-rust
Hello World!
-
enum-derive-2018
macros for deriving additional functionality for enums
-
hexga_array
that impl trait / new functions for array
-
pulumi_gestalt_domain
Domain models and abstractions for Pulumi Gestalt
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
axioma
Compile-time declarative macros for static JSON-to-Matrix topology projection
-
aspect
Toolkit for Rust
-
parsevm
PEG-like parser tool, grammar matching implemented in virtual machine style, for handwritten lexers
-
gbench
tools to benchmark code for further analyzation using Chrome tracing
-
monadify
functional programming abstractions in Rust, focusing on Monads, Functors, Applicatives, and related concepts
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
code-path
A code path macro
-
enclose2
A convenient macro, for cloning values into a closure
-
nu-experimental
Nushell experimental options
-
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
enum-field
Declarative macros for enum-based heterogeneous field accessors
-
clockwork-tuples
Type-level tuple utilities for compile-time structural reasoning
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
culprit
error crate with the goal of identifying precisely where and in which context an error occurs
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
rten-base
Shared utilities for the rten family of crates
-
defew
A new() derive macro for structs
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
numeric_cast
Safely cast between numbers
-
defmac
A macro to define lambda-like macros inline
-
child-of
that allows you to make one struct a child of another
-
hexspec
A dsl for creating and verifying byte buffers
-
enumx
Ad-hoc enum extension
-
variant_counter
Rust's Enum variant counter
-
studiole-di
Dependency injection with sync and async constructors, resolve by type or trait, and singleton or transient scopes
-
tower-resilience-chaos
Chaos engineering layer for Tower services - inject failures and latency for testing resilience
-
monarch_core
Core functionality for the Monarch library
-
cew
Personal Rust utility library
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
tupa-parser
Parser for TupaLang source files
-
djin-protocol
protocol, for aoe-djin
-
iter-comprehensions
iterator comprehensions
-
dilib
A dependency injection library for Rust
-
varchain
Async-only chain-based variable lookup engine, support no_std with alloc
-
meta_tuple
A statically typed opaque tuple that can contain any type
-
llmcc-rust
llmcc brings multi-depth architecture graphs for code understanding and generation
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
namable_closures
types and macros to create namable closure types
-
machine-check-common
formal verification tool machine-check
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
radiation
Convert Rust type into raw bytes and vice versa
-
easy-int
macros for easy implementation of integer aliases
-
tosserror
derive(Toss)
-
typewit_gce
for coercing between equal types with generic const arguments
-
re_chunk
A chunk of Rerun data, encoded using Arrow. Used for logging, transport, storage and compute.
-
inline_dyn
A container type for storing dynamically-sized types inline
-
mstr
2-word, immutable Cow<str>
-
almost
comparing floating point numbers
-
floxide-longrunning
Long-running node abstractions for the floxide framework
-
bitstructs
Defining type-safe bitfield structures that can be used in both
stdandno_stdenvironments -
swamp-script-error-report
Swamp script error report
-
size
expressing, formatting, and interacting with file sizes
-
unit-ext
Fluent helpers for returning common wrapper values from the unit type
-
irox-types
Enums and structs to describe Rust's basic type system
-
strprintf
Provide a way to interpolate printf-style format strings using native Rust types. Part of libnewsboat lib dependencies
-
karpal-verify
External prover bridge and trust model for the Industrial Algebra ecosystem
-
cp-ast-core
Core AST types for competitive programming problem specification DSL
-
pair
Safe API for generic self-referential pairs of owner and dependent
-
shannon-nu-engine
Nushell's evaluation engine
-
tuplestructops
Structural manipulations for tuples
-
leptix-ui
Leptix UI — Radix-style accessible UI primitives for Leptos
-
univec
A vector that can hold elements of any single type
-
cronus_parser
The DSL parser for cronus API spec
-
flip-flop
implements the flip-flop operator from Perl and Ruby as a Rust macro
-
atri_plugin
AtriPlugin
-
ffizz-header
FFI helpers to generate a C header for your library
-
warp-types-builder
Build-time PTX compilation for warp-types GPU kernels
-
fb_cloned
Cloned macro
-
metadata_macro
Rust macros for a very elementary metadata-like system in structs and tuple structs
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
xmacro_lib
macro engine for producing multiple expansions
-
query_interface
Dynamically query a type-erased object for any trait implementation
-
composable
Easy composition of functional traits, functions or closures
-
text-block-macros
Create a multiline string literal
-
icebook
Generic component storybook framework for Iced applications - compiles to WASM
-
vector3d
3D vector type
-
log-error
A small crate to log the error result easily
-
enum-derived
Generate random instances of your enums and structs
-
tinter
ANSI Color output
-
typeslot
Statically assigned slot indices for types, grouped by a marker type
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
finny
Finite State Machines with a procedural builder-style API and compile time transition checks
-
zlink-core
The core crate of the zlink project
-
droppable-pin
The eponoymous
droppable_pin!macro around a givenlet var = pin!()declaration allows invokingpin_drop!andpin_set!on the givenvar, which have in turn been designed to avoid silly borrow-checking errors -
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
orzklv
consisting various implementation for std and libs by Orzklv
-
tagged-id
A zero-cost wrapper adding type-safety to resource identifiers
-
is_slice
Macro to answer the question: is it a slice?
-
enums
Enumerate trait for vector and slice in rust. It abstracts chain methods like .iter().enumerate().collect() into a clean, reusable method also called enums like python enumerate.
-
onlyerror
Obsessively tiny error derive macro
-
as-result
Traits for converting types which may be interpreted as or into a result
-
eventually
using Event Sourcing in Rust applications
-
extension-eyre
Re-export of color-eyre that introduces Extensions (type-map) to eyre::Report
-
urlquerystring
A high-performance, zero-allocation URL query string parser
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocaltype as an alternative tostd::thread_local!that allows per-object thread-local storage, while providing a similar API… -
speedy_refs
A collection of simple and fast and useful smart pointers
-
handybars
Minimal template parsing and expansion
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
unty-next
Explicitly types your generics
-
meerkat-schedule
Realm-scoped schedule domain for Meerkat
-
cuadra
layout types
-
chain-reader
Combining multiple [
Read] instances into a sequential read pipeline with configurable error handling -
hurry
Convenient macros for creating pointer types (Box, Rc, Arc, etc.)
-
diva
Opinionated convenience wrappers for
std::process::Commandand friends -
range_checker
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
photon-hook
Hook trait and broadcast primitives for reacting to Photon events
-
rustc-ap-rustc_lint_defs
Automatically published version of the package
rustc_lint_defsin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
jigs-map
HTML map generator for jigs pipelines
-
type-uuid
Safe, stable IDs for Rust types
-
dyn_compatible
Dyn compatible marker
-
memsizes
Type-safe memory size newtypes (Bytes, KiB, MiB, GiB, TiB, PiB, EiB, KB, MB, GB, TB, PB, EB) with checked conversions and arithmetic
-
ffd
Fast Function Dispatch: Improving the performance of Rust's dynamic function calls
-
cdumay_config
configuration manipulation and export
-
static_file_util
generating and managing static files in Rust applications
-
component-map
Generic component manager with sync/async and fallible/infallible initialisation
-
flexpiler
Deserialiser aiming at high customizability
-
clash-prism-smart
Smart proxy selector with EMA scoring and adaptive scheduling
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
secunit-core
Registry, evidence, hashing, and verification primitives for secunit
-
nyar-number
Numeric types with GC optimization
-
peresil
simplistic string parsing library
-
ohos-ime-sys
Bindings to the
inputmethodAPI of OpenHarmony -
hado
Monadic do notation using a macro
-
ipv6-ddn
convert between Standard IPv6 (Hex) and IPv6 Decimal Dot Notation (DDN)
-
assert-within
Macro for testing that (generic) floating point numbers are within some tolerance
-
casting
CastFrom and CastInto traits for generic numeric casting
-
shannon-nu-test-support
Support for writing Nushell tests
-
toast-cell
Zero-cost type-branded cell with no runtime checks
-
lessvec
A custom Vec implementation using the Rust standard library
-
forester-rs
Workflow framework based on the behavior trees
-
refined_type
imbuing rules into types and elevating them to more robust types
-
gazebo
A collection of well-tested utilities
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
dungeon-cell
Store (almost) any value as one type without dynamic memory
-
pathogen
Typed references and deep mutation into Rust types
-
shoogah
Add some syntactic 'shoogah' to Rust
-
hx-compiler
Compiler backend abstraction for hx
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
value-box
Allows developers to pass Rust-allocated structures over ffi
-
unocss-classes-utils
Utils for
unocss-classes -
destruct
structs and enums for simpler combinator implementation
-
nonicle
Tools for type-safe, canonical data representations
-
useful_macro
Collections of useful macros
-
a2a-types
A2A Protocol Types
-
async-ebpf
Async-friendly, fully preemptive userspace eBPF runtime
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
scoundrel
An engine for working with ASCII roguelikes
-
exhaustive
The trait for generating all values of a type, and a property-based test macro
-
envfmt
Expands environment variables in string
-
causal_inspector_utils
Describe DSL and shared utilities for the causal inspector UI
-
index_permute
permuting a slice which elements are not Clone or Copy in Rust
-
emboss_common
Common types and constants for emboss
-
hexga_tools
miscellaneous stuff, when somethings will be too big it will be on a separate crate
-
macro-utils
Some macros to make code writing more elegant and funny
-
standout-seeker
Generic query engine for filtering Rust struct collections
-
ioc
An Inversion-of-Control library in Rust
-
skedge
Ergonomic single-process job scheduling for Rust programs
-
functora-tagged
Lightweight, macro-free newtypes with refinement and derived traits
-
cjc-dispatch
Operator dispatch layer for CJC runtime
-
foxtive-ntex-multipart
Handling File Uploads Based on Ntex
-
rs_envflag
An easy way to define flags by environment variables
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
hash_str
Strings with a precomputed hash
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
pick-by-autoderef
Pick by autoderef: a compile-time dispatch by priority
-
structible
A macro for defining virtual structs backed by maps
-
auto-impl-ops
semi-automatic implementation proc-macro for binary operations
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
arcow
Atomically Reference-counted Copy-On-Write shared pointer
-
entrypoint
opinionated application framework/wrapper that eliminates main function boilerplate
-
aoko
extension library
-
cpp_utils
interoperability with C++
-
to-display
A trait that is Display or can be converted to Display
-
weechat
API bindings for Rust
-
derail
An alternative to
core::error::Error -
agent-diva-tooling
Tool traits and registry primitives for agent-diva
-
unslice-dst
Fancy slice-like DST support
-
rustato
A global state management library for Rust applications
-
flat-drop
Wrapper that drops recursive objects iteratively to avoid stack overflows
-
str_enum
declarative macro for an enum with associated strings for each variant
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
defvar
A macro that makes defining environment variables easy
-
hax-rust-engine
The engine of the hax toolchain
-
bt-dom
DOM primitives for browser_tester
-
csci
C Syntax, Completely Idiotic - a macro collection for writing not idiomatic, but idiotic Rust, with C-style variables and functions
-
ffi_time
FFI assistant for Rust time types
-
cognate-prompts
Type-safe prompt templating with compile-time validation for Cognate
-
osom_lib_reprc
Macros and traits for working with #[repr(C)] types
-
error_def
syntax extension for generating error-handling boilerplate code
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
const-macros
Various macros for const contexts
-
enumcapsulate
Safe casting for newtype enums and their variants
-
rtlola-frontend
A frontend for the RTLola runtime verification framework
-
TSPL
The Simplest Parser Library
-
readonly
Struct fields that are made read-only accessible to other modules
-
uuid-enum
UUID-based enums
-
fromenv
Derive-based, type-safe configuration from environment variables
-
alef-extract
Rust source extraction for alef
-
bulks
Amazing bulks! They are like iterators, but in bulk, and therefore support collection into arrays
-
filecaster
Procedural macro to derive configuration from files, with optional merging capabilities
-
rust-analyzer-modules
analyzing a Rust crate's module structure and dependencies (fork with rust-analyzer 0.0.289 support)
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
fnrs
some useful functions i like
-
context_manager
Python's like context_managers in Rust
-
ironcalc
The democratization of spreadsheets
-
serde-nixos
Generate NixOS type definitions from Rust structures
-
lootr
RPG-like looting system
-
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
-
refl
reflencoding 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 -
tuple_set
Ergonomic utilities for working with Rust tuples by unique types, not position
-
sqry-tree-sitter-support
Tree-sitter integration helpers for sqry
-
swamp-vm-isa
isa types for the Swamp VM
-
int_like
macro for defining integer-backed opaque types safely
-
sealedstruct
Generate boilerplate code to transition from raw (unchecked) structs to sealed (validated) structs
-
enum_downcast
Safe downcasting for enums
-
illicit
An implicit thread-local environment which is indexed by type
-
orchidlang
An embeddable pure functional scripting language
-
errore
error handling and tracing
-
constptr
NonNull without mutability
-
try-clone
Fallible cloning
-
erased-discriminant
Type-erased version of core::mem::Discriminant<T>
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
nanoneo
lisp-like dsl which "compiles" into html
-
take-until
A take_until extension for iterators
-
sod-crossbeam
Service Oriented Design - Crossbeam
-
rudi
out-of-the-box dependency injection framework for Rust
-
path-dsl
DSL and macro to help deal with Paths and PathBufs
-
multi-any
MultiAnyis just likeAnybut can downcast to trait objects -
provekit_nargo_expand
Macro expansion utilities for Nargo
-
tower-retry-plus
Enhanced retry middleware for Tower services with advanced backoff strategies
-
throw
Efficiently add statically-calculated stack traces to errors
-
cruxi-authz
Core relationship-based authorization traits and types for the Cruxi framework
-
clone-behavior
Bound the semantic behavior and time complexity of cloning a value
-
trait-bounds
Trait bounds primitives using generic_const_exprs
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
fixed-macro-types
Macro aliases used in the
fixed-macrocrate -
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
osom_lib_carc
ABI-stable atomic reference counted pointers for osom_lib
-
easy_complex
Complex numbers crate
-
facet-default
Derive Default for facet types with custom field defaults
-
tracked
A stringly-typed Error that includes
#[track_caller]information -
typewriter-plugin-php
PHP emitter plugin for typewriter
-
battler-wamp-values
WAMP value types
-
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
anyhow_ext
Extension of anynow
-
statum-graph
Static graph export for Statum machine introspection
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
textus
A derive macro that renders an entire folder of templates into typed, compile-time-validated output
-
num-conv
num_convis a crate to convert between integer types without usingascasts. This provides better certainty when refactoring, makes the exact behavior of code more explicit, and allows using turbofish syntax. -
type_cell
Attach values statically to a type using static get/set methods
-
typeswitch
A powerful, Go-inspired macro for clean and declarative runtime type switching on dyn Any trait objects
-
floxide-reactive
Reactive node abstractions for the floxide framework
-
aspect-runtime
Runtime utilities for aspect-oriented programming in Rust
-
stateset-ffi
C-ABI stable FFI surface for stateset-embedded — powers Python, Swift, Kotlin, Go, and C bindings
-
standback
New standard library, old compiler
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
data_models
used to lookup the sizes of various C-types of historical data models
-
variable-codegen
TypeScript code generation for the Variable feature flag DSL
-
shared-expiry-get
concurrent async get with expiration for Rust
-
qubit-error
Shared error handling helpers for Rust applications
-
dialasm
pest based dialogue DSL for Rust
-
treeerror
macros for generating trees of enums, as well as
Fromimplementations converting between them. Primarily intended for error handling. -
docpos
Compact-document items after defining them (fn, struct, enum) + document fn parameters with rustdoc (⑂roxygen)
-
bomboni_macros
Common macros for Bomboni library
-
pyprint
enable python-style printing in rust
-
fack
Declarative error handling library with no_std support and composable code generation
-
lyneate
beautiful code underlining and error reporting
-
even-odd-traits
traits for even and odd
-
http-derive
Derive macro for implementing
Into<http::StatusCode>for your enums using the standard http types -
ordered_iter
Ordered iterators
-
game_inventory
An inventory system independant of item data
-
is-odd
Returns true if the given number is odd
-
kcr_kpack_io
Kubernetes Custom Resource Bindings
-
nject
Zero cost dependency injection module
-
anyerr
Dynamic error library with rich error wrapping and context support
-
selfref
Semi-pain-free self-referential pinned types
-
valobj
defining value objects using procedural macros
-
linearity
providing various operations commonly found in branchless programming
-
zrx-scheduler
Scheduler for workflow execution
-
get-field-by-type
Get a value of field, based on the type of a field
-
coroflow
Composable coroutine utilities and flow abstractions built on top of Rust's async ecosystem
-
concat_const
const
&[u8]and&strconcatenation -
uncollate
array of structs into arrays of field
-
data-classes
Abbreviation of #[derive(xxx)]
-
not_enough_asserts
A collection of useful asserts
-
mutcy
Zero-cost safe mutable cyclic borrows using borrow relinquishing
-
inherent
Make trait methods callable without the trait in scope
-
backyard-nodes
Nodes representing PHP code AST
-
assure
macros for Rust runtime checks and error handling
-
ankiconnect-rs
A package for convenient interaction with AnkiConnect
-
recuerdame
Pre-calculate functions at compile-time rather than run-time
-
rmp-ipc
IPC using Rust MessagePack (rmp)
-
string_types
String newtypes
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
fallible_map
fallible mapping over
Optionand iterators using functions that can returnResults -
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
frut_std
Standard library for the Frut language
-
typed-builder-macro
Compile-time type-checked builder derive
-
bitflate-rs
Layout/bitfield helpers for previewing structs
-
mad-hatter-guardian
Compile-time literal guardian for Rust projects — detects implicit contracts in source code
-
messages
Runtime-agnostic actor library
-
verdure-ioc
An ecosystem framework for Rust
-
sevenmark_ast
AST types for SevenMark wiki markup
-
except
The only one
Error -
non-empty-str
Non-empty strings
-
vnum
Create enums with a constant value associated to every variant
-
redb_model_trait
Redb model trait
-
ty-tag
TypeId for lifetime containing types via type tags
-
twisterl
Reinforcement learning primitives and a Python extension for high performance training and inference
-
semval
Semantic validation
-
recursive_reference
way to walk on recursive structures easily and safely
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
panic-message
Get a panic message from a panic payload
-
android-logcat
Android logcat
-
monochange_linting
Authoring helpers and macros for monochange lint suites
-
newtype-ids
Type safe identifiers in Rust
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
roopert_macro_common
object-oriented toolkit for Rust (common data)
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
at
Helpers for indexing slices
-
grist_lens
Unsafe Nightly Ergonomic Lens API
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
suwrap
Contextual and explicit replacement for unwrap()
-
oneshot-fused-workaround
Fused wrapper for futures::channel::oneshot
-
argcall
Enables enums and structs to be callable by associating functions with their variants or fields
-
struct_to_array
Convert between homogeneous structs and fixed-size arrays
-
fast_assert
A faster assert!
-
make-send-sync
Unsafely make any type Send and Sync
-
common_macros
common macros like
hash_map!orhash_set!(WIP) -
newtype-ids-uuid
UuidIdentifier trait and derive macro
-
enum_variant_accessors
derive macros to generate is_*, as_* and as_*_mut accessors for enum variants
-
intid
Defines the IntegerId trait
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
byteorder_slice
Byteorder like crate for &[u8]
-
iterextd
This trait provides additional methods for working with iterators, enhancing their functionality
-
rombok
boilerplate generation macros like lombok
-
non-empty-iter
Non-empty iterators
-
webformd
trait for webformd_macro to deserialize actix_web::web::Form for structs with Option<Vec<String>> from a checkbox or similar
-
test_help-rs
Test helpers for Rust
-
assert4rs
Fluent assertions for Rust
-
hermit-sync
Synchronization primitives for kernels
-
num-notation
Offers multiple numeric choices, allowing you to work with various number representations including StandardForm, fractions, and f64 floating-point decimals. This versatile crate empowers…
-
containing
Newtypes for dealing with collections that are guaranteed to be non-empty
-
cdumay_error_base64
base64 error
-
head-tail-iter
An iterator that repeatedly splits head & tail
-
annotate-build
Build-script support for generating annotate environments
-
vanguard-plugin-sdk
SDK for developing Vanguard plugins
-
rx_core_subscriber_higher_order_map
higher_order_map subscriber for rx_core
-
qbice_stable_type_id
The Query-Based Incremental Computation Engine
-
ambient-authority
Ambient Authority
-
rual
A slim, embeddable language
-
abi_stable_shared
detail of abi_stable
-
cmdparsing
adds a macro to parse arguments
-
pulz-functional-utils
traits and macros to work with tuples and functions
-
ptrait
A small crate providing traits for pointer-like types, such as references and smart pointers
-
ever
Print the build information of your program with minimal boilerplate
-
capsec-std
Capability-gated wrappers around std::fs, std::net, std::env, and std::process
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
frunk_utils
working with frunk
-
tryphon
Type-safe configuration loading from environment variables using derive macros
-
pai_delegation
Delegation validator for PAI-Kernel · enforces capability scope and expiry per PAI-CD v2.2 Consent & Capability Model §P3 (Escalation Control)
-
opentalk-types-signaling-breakout
Signaling types for the OpenTalk breakout module
-
cgp-error-std
Context-generic programming error handlers implemented using
std::error::Error -
cel-core
High-level API for the Common Expression Language (CEL)
-
tauri-plugin-keygen-rs
Tauri plugin for Keygen.sh licensing, based on keygen-rs
-
layer-rs
Effect-TS like type level DI container in Rust, with O(log n) get and insert
-
hygiea
A comprehensive Rust toolkit with error handling, template rendering, application framework, and more
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
refinement-types
Refinement types
-
kube-core
Kube shared types, traits and client-less behavior
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
nshare
Conversion between n-dimensional types in different Rust crates
-
loomx-axum
Axum integration for loomx
-
koruma
The koruma crate
-
shared_singleton
trait provides singleton pattern state management with shared container
-
kvtree
Heterogenous in memory key value tree storage
-
bencode-minimal
A Bencode library depending only on the Rust standard library
-
prosia-extensions
Useful extensions for types, arrays and other helper functions for Prosia projects
-
upget
Super simple trait that patterns the value "updae" and "get"
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
n-functor
Faux-derive a
mapfunction for types with one or more type parameters -
fields-glob
Derived glob macro with the same name as the structure
-
pointdexter
unifies *const/*mut pointers using the trait system
-
archway
Rust traits for Rc and Arc interoperation
-
emscripten_rs_sys
Bindgen-generated bindings to all public emscripten functions
-
tectonic_errors
A boxed error type for Tectonic, with supporting utilities
-
friperms
framework for creating typed permission models for whatever system you could phatom
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
unwrapped
The unwrapped crate
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
type-factory
unique opaque types
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
sov-universal-wallet-macro-helpers
Helper crate for sov-universal-wallet derive macros
-
cell-project
Safe interface for cell projection
-
swamp-analyzer
analyzer for swamp
-
qed
Compile-time assertions
-
mikros
An optionated crate to help building multi-purpose applications
-
kabel
-
pisserror
A golden rip-off of thiserror
-
structural
Field accessor traits,and emulation of structural types
-
accompany
with-like macro for Rust -
crabchess
Chess API
-
num_string
perform conversion between string and number
-
const-zero
a const mem::zeroed
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
preprocessor
Compile-time computation macro library — analyzes computable sub-expressions in code and evaluates parts that can be executed at compile time
-
hexga_math
Math related crate that define number and casting, and support array programming
-
octofhir-cql-types
CQL type system
-
ownables
that defines the Ownable trait and facilitates mutation by moving or reading from the source
-
bumpref
Explicit .bump() method for Arc and Rc that signals cheap refcount cloning
-
veho
a iterable toolset
-
functype
Functional programming library for Rust
-
nekopas2rust
-
keetanetwork-utils
functions and build tools for Keetanetwork
-
tupleops
work with tuples
-
displaythis
derive(Display)
-
rformat
Runtime formatting library
-
display_container
implement Display
-
ffi-enum
Simply write and use
enums like rust native enums, freely passing through ffi -
abcgen
A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern
-
ranvier-test
Test utilities for Ranvier pipelines ??TestBus, TestAxon, assertion macros
-
array-bin-ops
Efficient array binary operations
-
ctreg
Compile-time regular expressions the way they were always meant to be
-
cause
A generic [std::error::Error] implementation
-
airbag
handling errors and panics using 3rd party services
-
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…
-
safe_unwrap
allows unwrapping and annotating that the unwrap will never fail. Does not require
std. -
result-transformer-dependencies
Traits, macros and utilities for transforming Result values
-
state-department
state management and dependency injection in Rust
-
utils-results
The easiest and most intuitive error handling solution
-
admixture
Core traits and macros for managing service lifecycles in integration tests
-
amonoid
A general-purpose monoid library
-
alloy-eventsource
Event sourcing contract primitives for the Alloy portfolio
-
syno_api
An incomplete set of DTOs and errors for Synology DSM APIs
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
xslice
Slice representation using relative extents instead of absolute pointers
-
option-like
Create your own Option-like enum
-
valkyrie-types
Shard types for valkyrie language
-
percentage
calculate percentages
-
is_default
A trait for checking whether a value is default, with derive support
-
plist-types
Common types for the bplist and xplist crates
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
copy_impl
Macro for effortlessly duplicating impl block code across various types in Rust
-
checked-float
making invariant-enforcing floating point wrappers
-
rustc-tools
Some internal rustc tools made accessible
-
late-struct
Late-bound structure definitions
-
influx3_lp
A serializer for Rust structs according to InfluxDB 3 line protocol
-
obzenflow_dsl
DSL and infrastructure layer for ObzenFlow - flow! macro and high-level orchestration
-
ra-ap-rustc_hashes
Automatically published version of the package
rustc_hashesin the rust-lang/rust repository from commit ba0949ab745985a442e274ba52e8fb348cb0c662 The publishing script for this crate lives at:… -
lisette-semantics
Little language inspired by Rust that compiles to Go
-
hexga_utils
miscellaneous stuff, when somethings will be too big it will be on a separate crate
-
broken-pipe-kills
Get rid of
failed printing to stdout: Broken pipe (os error 32)panics by settingSIGPIPEtoSIG_DFLbefore yourfn main()runs -
assert-impl
Macro for static assert types implement a trait or not
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
type_hash
Generate a hash for a Rust type. The primary use-case for this crate is for detecting differences in message types between versions of a crate. The
TypeHashtrait is implemented… -
blueprint-dupe
Marker for types which are cheap to clone
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
sector
A stateful vector implementation that provides different memory management behaviors through Rust traits and state machines
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
should
Postfix assertion library for Rust
-
xylem
Building context-sensitive type conversion
-
rexpr
Rust Json Object access Runtime
-
ortho_config_test_helpers
Shared test helpers for crates in the ortho-config workspace
-
thistermination
add the Termination trait to error enums inspired by thiserror
-
scoped_thread_local
Highly flexible Scoped thread local with HKT builtin
-
unipipe
pipe abstraction that extends to iterator and stream
-
lazybe
Handy CRUD boilerplate macros and utils for Rust backend
-
ltptr
Checked raw pointers
-
type_description
Machine-readable type descriptions
-
enumly
procedural macro that exposes a compile-time static list of all variants of an enum
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
runtime-fmt
Runtime-based string formatting
-
dynamic-provider
Dynamically request arbitrarily-typed values from providers with borrowed data
-
slice_trait
A generic trait for any slice, with item as a type parameter
-
windows-helpers
Helpers for the windows crate
-
simple_parse
A declarative converter for Rust type to and from binary
-
nvim-oxi-types
Rust bindings to types used by Neovim's C API
-
axum-error-object
Result<T>type and related utility types that can be used to holistically provide object response errors -
lockjaw
Compile time dependency injection framework inspired by dagger
-
objective-rust
Seamlessly bind Rust and Objective-C code
-
intertrait-nostd
The intertrait crate, with no_std support
-
tree-sitter-flutmax
Tree-sitter grammar for the flutmax DSL
-
ptr-utils
A lightweight library providing utilities for working with raw pointers
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
rust_kafka_like
A Kafka-like message broker in Rust
-
unsafe-fields
unsafe to access or modify fields with safety invariants
-
crfsuite-sys
Rust binding to crfsuite
-
known-types-luma
Well-known types for Luma APIs
-
rain_task
Distributed computational framework for large-scale task-based pipelines. A custom task library in Rust.
-
mvutils
made from commonly used functions in my projects
-
chassis
Compile-time dependency injection framework
-
jigs-trace
Per-jig execution tracing for the jigs framework
-
timed-locks
Smart pointers to
tokio::synclocks that either panic or error after a timeout -
batch_oper
some batch operation macro for some operations
-
husako-dts
TypeScript type definition generator for husako
-
decrust-promac-runtime
The ultimate all-in-one error handling framework for Rust
-
rvs
defining and evaluating random variables using a simple DSL
-
run-on-drop
Run code when an object is dropped
-
scoped-panic-hook
Adds scoped, nestable, thread-local hooks for panics and some utilities for capturing and analyzing panics more conveniently
-
detach
helper type for being able to detach/reatach a member item
-
syntaqlite-common
Internal shared primitives for syntaqlite — not intended for direct use
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
fieldx_aux
Various types and tools useful for fieldx crates and, potentially, to users of fieldx
-
nonnull-mut
NonNull<T>, but T is invariant like *mut T
-
newt-hype
A very easy-to-use crate for creating wrapper structs using the new-type pattern
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
microtype
simplify the creation of microtypes
-
exun
Handle unexpected errors
-
easy-config-def
defining and validating application configurations, inspired by Apache Kafka's ConfigDef
-
fastapi
Compile time generated OpenAPI documentation for Rust
-
tri_ton
A Macro for Handling Exceptions
-
oxur-lang
Oxur language processing: parser, expander, and Core Forms IR
-
concat-string
macros for concatenating string slices into owned strings
-
trait-morph
A lightweight procedural macro to transform
async fnin traits into-> impl Futurewith explicit bounds -
auto_array
A macro to automatically calculate the length of arrays
-
barexp
that automatically generates mod.rs files for your project
-
rs-utilities
Some utilities
-
enumorph
Derive macro to generate
TryFromandFromimplementations for converting between newtype enum variants and their wrapped values -
itemize
Traits for flattening heterogeneous, nested inputs into a single iterator
-
lens-rs
lens implemented in rust
-
benri
Convenient macros wrapping the standard library
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
yykv-types
Core type definitions for yykv storage engine
-
fat_type
A type which permits thin references to arrays and dynamic types
-
transpose-future
Transpose Option<impl Future>
-
dlib
Helper macros for handling manually loading optional system libraries
-
cmakelist_gen
A CMakeLists.txt generator for Rust projects
-
fb_stats
Stats library
-
karpal-arrow
Category and Arrow hierarchy for the Industrial Algebra ecosystem
-
static_interner
Similar to
internmentcrate, but with interface and performance tweaks -
kittycad-execution-plan
A DSL for composing KittyCAD API queries
-
forward_ref_generic
Generically forward references for operations on Copy types
-
CuPs
Dear Dev, this lib to make custom pointers to amend RowHammer-related issues [kiss principle been at the very heart]
-
retry_macro
A set of declarative macros which retries executing a function upon failure
-
snapshot-testing
Assert that strings equal easily updatable snapshot files. Show nice colored diffs if not.
-
ruby-types
📦 Ruby value and error types for Rusty Ruby
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
shoggoth
Generic and type-level programming for Rust
-
pyo3_special_method_derive
Automatically derive Python dunder methods for your Rust code
-
zip_clone
Zip an iterator to a repeatedly cloned object
-
recore
A re-implementation of various ::core features
-
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…
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
panicmsg
simplyifying common panic messages
-
cruxi-api
API response types and filter DSL for Cruxi
-
dicebag
Dice rolling!
-
newtype_derive
macros for deriving common traits for newtype structures
-
keepops
Extension traits for keeping the input of mapping functions
-
tuplify
Generic hlist/tuple library
-
kaguya_rs
Functional Programming tools and ADTs
-
xjbutil
A xjbly created utility library for my own use
-
functor_derive
A derive macro to derive a functor for a type
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
quick-error2
A macro which makes error types pleasant to write
-
typebitset
Type-level bitset implementation
-
copyvec
A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy
-
lib_utils
Misc utility functions
-
base64_type
type wrapper for Vec<u8> that uses base64 for serialization
-
numy
Trait boundaries for primitive Rust types
-
primitive_bounds
Traits representing primitive types (i32, usize, etc.) for use in generic bounds
-
lit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
cargo-manifest
Helper crate to parse and manipulate manifests -
Cargo.tomlfiles -
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
field_names_and_counts
Traits for accessing field names and counts at compile time
-
name-it
Give a name to async fn return types
-
solgpc
An elegantly fast GPC parser
-
excelx
Type-safe XLSX read/write helpers for Rust structs
-
syn-lite
limited but lite syntax parsing with only macro_rules
-
eqeval
An equation parser using the finum crate
-
synchro_macro
Synchro is a Rust framework for building fullstack applications that run seamlessly across platforms
-
rust-2021
Macro to use Rust 2021 from all editions
-
cli-panics
Make your panics easy to read
-
effing-mad
The hottest algebraic effects library in Rust
-
n-observer
An async/await observer pattern implementation
-
cxx-symbols
detail of the
cxxcrate -
try-drop
Batteries included error handling mechanisms for drops which can fail
-
unreachable
code optimization hint in stable rust
-
safevalue
A value based approach to uphold SAFETY requirements for unsafe Rust code
-
ownership
Obtaining ownership
-
non-zero
A macro for creating constant non-zero integers (with type inference)
-
notzero
macro for constructing
std::num::NonZero*from constants -
powerfmt
powerfmtis a library that provides utilities for formatting values. This crate makes it significantly easier to support filling to a minimum width with alignment, avoid heap… -
steckrs
A lightweight, trait-based plugin system for Rust applications and libraries
-
option_trait
Helper traits for more generalized options
-
similar-string
Find similar strings in Rust
-
liftor
Functors for Rust lifetimes
-
syrette
The convenient dependency injection framework
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
infinite-stream
Streams (asynchronous iterators) that always keep yielding items (or panic, or become pending forever)
-
jni-toolbox
tools to make writing JNI native functions less tiresome
-
faux-refine
that implements a pseudo-Refinement Type in Rust
-
relax
Derive Partial<T>
-
clamp_to
Clamp integer and float values to the values that fit within both the original number type and the receiving type
-
value-extra
A tri-state Patch<T> type for partial update semantics — distinguishing between 'has value', 'absent', and 'explicitly null'
-
ifmt
Inline expression interpolation for Rust
-
trackerr
Error tracker library with location capture and context
-
rvvm
idiomatic RVVM Rust bindings
-
chomp
A fast monadic-style parser combinator designed to work on stable Rust
-
stuff
Stuffing things into pointers
-
rustidy-ast
Rustidy formatter
-
rusty_v8_helper
Helper functions for rusty_v8_protryon
-
hitbox-fn
Function memoization for hitbox caching framework
-
check
Convenience assert!-like macros which return instead of panicking
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
ktest
A custom test framework for Rust-based operating system kernels
-
zrx-id
Identifier abstractions and utilities
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
demes-ffi
FFI for rust implementation of demes specification
-
multindex
Index slices with multiple const indices/ranges
-
prism3-core
Foundational utilities and language-level tools for Rust application development
-
closure_attr
An attribute macro to simplify closure captures
-
itertools-num
Numerical iterator tools. Extra iterators and iterator methods and functions.
-
reflect_to
Run-time type reflection and conversion
-
derive_macro_xiaochufuji
A custom derive macro collection by xiaochufuji
-
lgio
Lightweight, generic, no_std IO
-
env_parser
Env parser. Parse your env file and create a Rust file with mapped properties
-
validex
Input validating library
-
moduforge-macros
moduforge 宏定义
-
negative-impl
Negative trait implementations on stable Rust
-
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
dims_macro
Macros for Generating Systems of Units
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
sddl
parse and analyse SDDL Strings
-
lubeck
Functional programming framework written in cutting edge rust
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
commandspec
Rust macro to build std::process::Command objects with shell syntax. Uses macro_rules! and works on stable.
-
steepen
Create multiple iterators from a single iterator by separating elements
-
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
fileslice
Slices of files
-
escher
Self-referencial structs using the async/await transformation
-
show-option
displaying Options
-
generic-vec
a vector implementation that can be used in
no_stdenvioronments -
web-time-compat
Compatibility layer for web-time
-
tuple-fn
call functions and closures with tuple of arguments
-
solution_cli
CLI for convert crate use
solution::solution!()macro to a version for student (with solution stripped and hint intodo!()) -
xdi
Rust di containers system
-
timeout-macro-parse
A companion-crate for the tokio-timeout proc-macro-lib
-
inline_default
Macro for inline Default implementation
-
function_overloading
that adds function overloading
-
io-providers
Enables dependency injection for many I/O operations
-
floxide-transform
Transform node abstractions for the floxide framework
-
test_eq
assert_eq!-like macros that return a Result instead
-
simple_generators
making work with generators simpler
-
try-lazy-init
Fallible lazy initialization
-
clash-prism-core
Prism Engine core — Patch IR, compiler, executor, validator, cache, watcher
-
tlist
Type-level linked lists (of types) and type-level 'functions' to manipulate them. Because TList is implemented using GATs, usage is very ergonomic.
-
tor-async-utils
Async/futures helpers for use with Tor
-
nohash-hasher
std::hash::Hasherwhich does not hash at all -
opentalk-types-signaling-moderation
Signaling types for the OpenTalk moderation module
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
leekscript-analysis
LeekScript semantic analysis: scope, validation, type checking
-
copy_from_str
An extension trait to copy a string into another string
-
quasiquodo-ts
Compile-time TypeScript quasi-quoting
-
armature-rhai
Rhai scripting language integration for Armature - write handlers in Rhai
-
bitmask
generator for enum scoped bit flags
-
r-ex
Zero-bloat Rust core library extensions
-
nz
Collection of 100% safe macros for creating non-zero integers more easily
-
rust_c
Write C code inline in your rust code (hacky fork of rust-cpp / cpp crate)
-
scope-guard
RAII scope guard
-
integer_or_float
A data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
maybe_path
Zero overhead static initializer for Path
-
wcl_lsp
WCL Language Server Protocol implementation
-
com-scrape-types
Support code for bindings generated with com-scrape
-
enum-values
Exposes enum values via reflection
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
aether_primitives
Helpers for common SDR and signal generation operations
-
simple-dst
Traits for allocating and using custom DSTs
-
maybe-uninit-ext
Extended maybe-uninit types
-
tdx-rs
parsing TDX files
-
httpwg-macros
Macros to allow generating httpwg unit tests
-
assert_has_field
macro for checking if a struct has a specific field
-
fromsoftware-dlrf
Macro for generating singleton specifier for usage with the DLRF singleton finder
-
prim_int_kind
Enumeration whose variants represent kinds of primitive integers
-
oxi-types
Rust bindings to types used by Neovim's C API
-
never-say-never
The never type (the true one!) in stable Rust
-
diode
Core diode library
-
duplex
trait: interactive streams
-
type-exts
extension methods for std
-
once_cell_serde
Single assignment cells and lazy values
-
cmp_any
Comparison for &dyn types
-
maelstrom-test
Test macros for Maelstrom
-
always_equal
A wrapper for types that can't implement Eq
-
cute
A macro for Python-esque comprehensions
-
type-flow-macros
Macros to make pipelines that encode the order of operation execution in the type signature of the pipeline and allow for functions that mutate that order
-
debug_with_context
context-aware
Debugformatting via a custom derive macro -
rustrails-macros
Declarative macros for RustRails DSL
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
semester
High efficiency classnames macro
-
unwrap_none
Implements the
unwrap_noneandexpect_nonemethods removed by https://github.com/rust-lang/rust/pull/83349 -
rust2fun
functional programming in Rust
-
state-validation
Validation for states
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
service-builder
A lightweight, type-safe service construction library for Rust that provides compile-time dependency injection through builder pattern
-
omniswap
swap values between possibly-overlapping references
-
devela_base_alloc
base alloc shared functionality for devela
-
facet-spez
Auto-deref specialization helpers for the Facet reflection system
-
as_num
Checked conversions between Rust's numeric types
-
getfn
generating function pairs to refer to functions via custom expressions
-
gc_abi
Gridcore Plugin Safe ABI Bindings
-
torrust-tracker-located-error
provide error decorator with the location and the source of the original error
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
async_fn
Collection of helper annotations and macros for concise and yet explicit
async fnsignatures -
moving
Make elements of an array or a vector movable
-
flow-di
A dependency injection framework for Rust inspired by C# AutoFac and Microsoft.Extensions.DependencyInjection
-
cgp-component
Core CGP traits and types used for implementing the CGP component system
-
rustc-ap-syntax_pos
Automatically published version of the package
syntax_posin the rust-lang/rust repository from commit 625375400cdd172877e81c3ce44ce68f2011af2d The publishing script for this crate lives at: https://github… -
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
linspace
Turns a range into a linearly spaced sequence of values
-
microstring
Small, niche-able, stack allocated strings
-
predicates-core
An API for boolean-valued predicate functions
-
strid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
fsize
fsizeis aliased to the floating-point type of pointer size -
iterator-sorted
Stable functions for checking iterator sorting
-
better-conversions
Safe and explicit numeric conversions with range and precision checking
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
k-combinations
Efficient iterator over k-element combinations of a slice
-
simple_scan
Iterator extensions for simple scan operation
-
result-ext
Extends
Resultwith additional operations -
typify-impl
typify backend implementation
-
lifted
Higher-kinded types in Rust
-
ptrplus
Additional funtionality for pointer types
-
known-types-instagram
Well-known types for Instagram APIs
-
components-arena-traits
Does not intend for direct use
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
ferrite-session
Session Types DSL for Rust
-
all-the-errors
Collect all the errors from iterators over results
-
abstract-getters
Abstract how, what and from where to get a value using a trait
-
once-cell-regex
just gives you the
regexmacro from theonce_celldocs! -
set_slice
A macro for assigning values to slices
-
int-to-c-enum
TryFromInt - A convenient derive macro for converting an integer to an enum
-
replicante_util_failure
Helper functions to manage failures
-
cowstr
Copy-on-Write shared strings
-
konst_macro_rules
detail of the konst crate
-
veccell
variant of Vec with interior mutability
-
tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
pipa
Pipe Operator Library for Rust
-
chain_tools
A set of traits allowing for more a erganomic style of chain programming
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
hb_error
Useful macros and traits for creating and handling errors
-
cognate-tools
Type-safe tool calling and function execution for Cognate LLM applications
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
hgm
Reproduce the Haskell syntax sugar
-
rokc_core
Core library for rokc, a kconfig parser written in rust
-
pub_source
Make everything public
-
utilz-rs
A lightweight extension trait collection for Rust primitives and types
-
c2r
A C to Rust conversion program
-
global-mockable
creating global mockable objects
-
cib
proc-macros for crate cib
-
partial-borrow
Partially borrow a struct
-
swamp-std
Standard i/o functions for Swamp
-
chandeliers-err
Internal error message generators for the Chandeliers project
-
not-found-error
Convert Option to Result using convenient functions
-
assert_cfg
static assertions for crate features, with descriptive errors
-
tt-call
Token tree calling convention
-
return-ok
Macros for dealing with Options and Results where you shouldn't
-
flexcell
A flexible cell that allows safe circumvention of double borrow issues
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
rustidy-util
Rustidy formatter
-
scsys-traits
scsys is a collection of primitives and utilities for use throughout the ecosystem
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
enum_properties
A macro for declaring static properties on enum variants
-
rust-lcm-codegen
Generates Rust de/serialization code from LCM type specification
-
rust-2015
Macro to use Rust 2015 from all editions
-
into-result
convenience trait for converting something into a
ResultorOption -
reflect-nat
Type-level naturals, booleans, and HLists with Reflect implementations
-
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.
-
portable_intertrait
Allow for inter-trait casting
-
variant_access_traits
A set of traits and for defining a common api for Rust enums based on the std::variant api in the C++ standard library
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
newer-type
Support defining newtype wrapper with inheriting trait implementations
-
ddi
Dynamic dependency injection library for rust
-
static_assert_macro
so-called
static_assert -
osom_lib_arrays
ABI-stable array types and helpers for osom_lib
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
fsl
FakeHub State Language. DSL for managing state in fakehub
-
futures-copy
Copy data between AsyncRead and AsyncWrite, with bidirectional and flushing support
-
mediator-rs
CQRS-style mediator with type-safe command dispatch and a composable pipeline behavior system
-
karpal-recursion
Recursion schemes (cata, ana, hylo, para, apo, histo, futu, zygo, chrono) for the Industrial Algebra ecosystem
-
currying
anything implementing
FnOnce. Arguments can be passed one at a time, yielding a new something implementingFnOnce(and possiblyFnMutandFn) which can be called with one less argument. -
init_with
Helper trait to initilize an array with a function
-
rustato-macros
Macros for the Rustato library
-
aoc_driver
helper macros and functions for AoC
-
rust-kzg-bn254-primitives
offers a set of structs, traits and functions for generating Blobs and Polynomials which are used to interact with rust-kzg-bn254-prover and rust-kzg-bn254-verifier crates
-
future-local-storage
An init-once-per-future cell for thread-local values
-
floxide-event
Event-driven node abstractions for the floxide framework
-
struple
Convert structures from and to tuples
-
pyo3_special_method_derive_latest_pyo3
Automatically derive Python dunder methods for your Rust code
-
py-comp
A macro implementing a Python-like generator expression
-
pigeon-core
Generate recursive-descent & precedence climbing parsers. (traits)
-
kustos-shared
Shared types for kustos
-
multiconst
destructures an expression into multiple constants
-
without-ats
A one-function crate for removing '@...@' from a string
-
struct_baker
enable ergonomic creation of compile time parsers
-
unsafe-any
Traits and implementations for unchecked downcasting
-
cow2
Like Cow<B>, but B is covariant
-
prae
that aims to provide a better way to define types that require validation
-
kg-symbol
Atomic strings in Rust
-
necessist-core
-
simple-newtype
newtype macros for application development
-
enumi
Declare an enum for a range of integers
-
degeneric-macros
Hides struct generics into trait associated types
-
phantom_newtype
Lightweight newtypes without macros
-
dyn_struct
Construct dynamically sized types safely
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
inline-option
A memory-efficient alternative to Option that uses a pre-defined value to represent None
-
jigs-log
Renderers for jigs trace entries (tree view and structured JSON)
-
see-through
traits to provide access to internal fields of generic structs
-
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
blue_typemap
A TypeMap Dependency Injection method for dynamic function parameters
-
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
macro-bits
performing macro-based bit manipulation
-
random_variant
To be used with all variant, contains the derive macro
-
quiet_panics
Make your panics easy to read
-
testify_core
The core library for the testify framework, providing the core functionality and utilities
-
shellder
A lightweight, type-safe dependency injection and application framework for Rust inspired by Spring
-
unfold-iter
Create iterators with an initial value and a recurrence relation
-
nougat
(lifetime) GATs on stable Rust
-
copstr
COpy STRing module
-
iter_fixed
Iterator of fixed length
-
ensure_impl
Trait implementation assertion
-
boost-rs
boosting your develop productivity on Rust
-
effective
An effects library, an alternative to keyword generics
-
shannon-nu-protocol
Nushell's internal protocols, including its abstract syntax tree
-
llts_analysis
LLTS analysis — subset validation and type resolution
-
loso-inject
A compile-time dependency injection framework for Rust with zero runtime overhead
-
HOPA
A lightweight, higher-order parser
-
prealloc_ref_vec
Create temporary
Vecs of references without allocating/deallocating (useful for realtime code) -
static-cond
Macro for performing comparisons during macro expansion
-
rukt
dialect for token-based compile-time scripting
-
mathsys
The Natural Language of Math
-
no_std_strings
no_std version of crate fixedstr: strings of constant maximum size that can be copied and stack allocated
-
convergio-types
Core types, Extension trait, Manifest, DomainEvent — the contract everything builds on
-
autotrait
Reduces boilerplate by auto-generating trait definitions from impl blocks for dynamic dispatch
-
into-sorted
Collection of utility methods and functions that take an owned array and return a sorted owned array
-
packer
Pack static files into your binary at compile time
-
autosurgeon-cat
Derive-driven mapping between Rust types and automerge-cat documents
-
ketos
Lisp dialect scripting and extension language
-
ghosts
Type-check non-existing
Phantomcode for Fun And Profit™ -
warpin-types
Common types and primitives for the Warpin framework
-
default_new
A DefaultNew derive to generate a Default impl that just calls Self::new()
-
opentalk-types-signaling-polls
Signaling types for the OpenTalk polls module
-
gtin-validate
Validate GTIN barcodes including UPC-A and EAN-13. This module has built-in support for GTIN-8, GTIN-12 (UPC-A), GTIN-13 (EAN-13), and GTIN-14 codes
-
const_typed_builder
Compile-time type-checked builder derive using const generics
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
zrx-stream
Stream interface
-
influxdb2-structmap
Procedural macro library for converting between Rust structs and associative containers
-
semire_read
A safe, easy-to-use module for reading integers, floats, and strings from stdin in Rust
-
swimos_form
SwimOS Serialization and Deserialization
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
cereal
data serialisation library
-
teloc
compile-time DI framework for Rust
-
permission_check
A relatively flexible permission checking library written in rust which checks for permission is scope (like: org.1028.user.*.write), with macro for compile time type checking and code generation
-
var_num
Variable length number implementation that can be used as a drop in replacement for any number primitive
-
nclosure
composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
empty-fallback-chain
Iterator adaptor like chain, but conditional on empty first iterator
-
cgp-error-extra
Context-generic programming error components
-
std2
"minimal std is a feature" - a coping rust shill
-
error-iter
Error::sources on stable Rust
-
facet-opaque
Type-erased pointer helpers for Facet types
-
arc-interner
An interner that deallocates unused values
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
tcrts
Turing complete rust type system
-
phlow-build
Build-script support for generating phlow annotation metadata
-
just-string
Container for various kinds of strings
-
known-types-linkedin
Well-known types for LinkedIn APIs
-
slist
Algebraic lists with statically determined size that live on stack
-
frust
Functional Programming in Rust
-
stack_box
store unsize struct on stack with static check
-
zrx-store
Store abstractions and utilities
-
fluent-string
Fluent versions of String mutation methods
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
assert-order
Assert the order of Rust enum variants
-
appro-eq
Approximately equal traits and assertion
-
the-newtype
The Newtype trait
-
itern
enumtypes for choosing between N differentIteratortypes in a single type -
difficient
Efficient, type-safe, zero-allocation structural diffing
-
enum_reflect_extern
Traits for enum_reflect
-
aorist_primitives
Primitive macros for the aorist project
-
devela_base_std
base std shared functionality for devela
-
amass
Automatically generate
Fromimpls for nested enums, even across crates -
craken-container
Compile-time safe dependency injection container for the Craken framework
-
trait-gen
Trait implementation generator macro
-
pre
Compile-time assistance for working with unsafe code
-
rattish
Cast between trait objects
-
map_box_from
Adds
Box-ed versions ofFromandIntotraits - allowing implementations for unsized type parameters and following looser guidelines -
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
rs-schema
Types modeling rust code structures
-
cgp-monad
Monadic constructs for CGP computation
-
coi
Dependency Injection library
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
tor-basic-utils
General helpers used by Tor
-
multiple_choice
proc-macro library that verifies function results through multiple executions
-
nwnrs-io
Shared binary IO, endian, and invariant helpers for Neverwinter Nights crates
-
safebit
Safe and secure bit access into integer types
-
const-assert
Assert struct for const generics
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
bitbag
A useful struct for dealing with bit flags
-
torrust-index-located-error
provide error decorator with the location and the source of the original error
-
beaver
setting up Rust objects inspired by factory_bot
-
adjacent-pair-iterator
An iterator over adjacent pairs in another iterator
-
ffizz-string
FFI string implementation
-
eldenring-dlrf
Macro for generating singleton specifier for usage with the DLRF singleton finder
-
telocs
compile-time DI framework for Rust
-
tokio-timeout
A proc-macro which adds a timeout to an asynchronous function running under the tokio runtime
-
stringer
An easy way to turn an Unsafe *const c_char into a Rust String type and return a pointer
-
tacit
macro to make newtypes easier to create
-
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
seestr
pointer-wide nul-terminated strings with ownership semantics
-
convert-byte-size-string
Convert a byte size string to a u128 value
-
every_variant
EveryVariant trait that provides the every_variant method on types. Allows you to easily generate every combination of variants in structures that contains Enums, or in nested enum trees…
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
ident-util
macro to determine the string name of a binding, type, const, or function
-
respan
Macros to erase scope information from tokens
-
http-error
Error trait to help convert errors to http error responses
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
non_structural_derive
nonstructural derives for auto traits
-
easy-macros-helpers
Easy Macros support library
-
filters
Build filters/predicates with the builder pattern
-
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
-
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…
-
collect-with
enhanced collection operations with capacity control
-
astr
A const lenght stack str
-
cashly
一个简要投资记录法的 DSL 脚本解析器, 这个库包含 EBNF 设计和 rust 的实现
-
karpal-free
Free constructions (Coyoneda, Yoneda) for the Industrial Algebra ecosystem
-
phlow-extensions
Phlow views for Rust's core types
-
io-adapters
Adapters to convert between different writable APIs
-
safecast
Traits to define safe casting between types
-
multi_try
Safely combine results