-
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
-
generic-array
Generic types implementing functionality of arrays
-
http
A set of types for representing HTTP requests and responses
-
derive_more
Adds #[derive(x)] macros for more traits
-
once_cell
Single assignment cells and lazy values
-
ordered-float
Wrappers for total ordering on floats
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
itertools
Extra iterator adaptors, iterator methods, free functions, and macros
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
predicates
boolean-valued predicate functions
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
utoipa
Compile time generated OpenAPI documentation for Rust
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
signal-hook
Unix signal handling
-
bytes
Types and traits for working with bytes
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
snafu
An ergonomic error handling library
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
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
-
headers
typed HTTP headers
-
iri-string
IRI as string types
-
enumflags2
Enum-based bit flags
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
human-panic
Panic messages for humans
-
typed-builder
Compile-time type-checked builder derive
-
assert-json-diff
Easily compare two JSON values and get great output
-
thiserror
derive(Error)
-
similar-asserts
assert_eq! like macros with colorized diff output
-
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
-
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.
-
ouroboros
Easy, safe self-referential struct generation
-
pyo3-stub-gen
Stub file (*.pyi) generator for PyO3
-
string_cache
A string interning library for Rust, developed as part of the Servo project
-
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
pin-project
safe and ergonomic pin-projection
-
arrayref
Macros to take array references of slices
-
rustdoc-types
Types for rustdoc's json output
-
smol_str
small-string optimized string type with O(1) clone
-
az
Casts and checked casts
-
zerovec
Zero-copy vector backed by a byte array
-
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…
-
inventory
Typed distributed plugin registration
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
bitfield
macros to generate bitfield-like struct
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
dlopen2
opening and operating on dynamic link libraries (also known as shared objects or shared libraries)
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
const_panic
const panic with formatting
-
extendr-api
Safe and user friendly bindings to the R programming language
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
memoffset
offset_of functionality for Rust structs
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
nutype
The newtype with guarantees
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
rustc_apfloat
Rust port of C++ llvm::APFloat library
-
volatile
wrapper types for raw pointers
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
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… -
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
assert_matches
Asserts that a value matches a pattern
-
tap
Generic extensions for tapping values in Rust
-
konst
Const equivalents of std features: comparison, destructuring, iteration, and parsing
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
facet
Reflection for Rust: introspect types at compile time with metadata for serialization, pretty-printing, CLIs, and more
-
dyn-clone
Clone trait that is dyn-compatible
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
io-lifetimes
A low-level I/O ownership and borrowing library
-
derive-where
Deriving with custom trait bounds
-
testresult
type for concise and precise test failures
-
float-cmp
Floating point approximate comparison traits
-
bounded-collections
Bounded types and their supporting traits
-
writeable
A more efficient alternative to fmt::Display
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
by_address
Wrapper for comparing and hashing pointers by address
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
nonempty
Correct by construction non-empty vector
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
aide
A code-first API documentation library
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
codegen
generating Rust code
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
constcat
concat! with support for const variables and expressions
-
text-size
Newtypes for text offsets
-
const-gen
generating (relatively) complex compile-time constants in rust
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
rustlings
Small exercises to get you used to reading and writing Rust code!
-
bounded-integer
Bounded integers
-
oxc_index
Newtype-style helpers for
Vecandusize -
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
-
easy-cast
Type conversions which are expected to succeed
-
dynosaur
Dynamic dispatch for return position impl traits and async in Rust
-
faux
mock structs
-
jsonptr
Data structures and logic for resolving, assigning, and deleting by JSON Pointers (RFC 6901)
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
rootcause
A flexible, ergonomic, and inspectable error reporting library for Rust
-
orchestra
Generate an orchestra of subsystems from a single struct
-
bilge
Use bitsized types as if they were a feature of rust
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
tynm
Returns type names in shorter form
-
unwinding
in Rust and for Rust
-
pinned-init
facilitate safe pinned initialization
-
tlua
Zero-cost high-level wrapper for Tarantool-LuaJIT
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
rustc-literal-escaper
code to unescape string literals
-
as-any
provide the AsAny trait
-
enclose
A convenient macro, for cloning values into a closure
-
index_vec
Newtype-style helpers for
Vecandusize -
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 -
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
-
arrow-buffer
Buffer abstractions for Apache Arrow
-
async-once-cell
Async single assignment cells and lazy values
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
bevy_reflect
Dynamically interact with rust types
-
sugar_path
Sugar functions for manipulating paths
-
rustrict
profanity filter for Rust
-
merge
multiple values into one
-
tuples
many useful tools related to tuples
-
comparable
comparing data structures in Rust, oriented toward testing
-
erasable
Type-erased thin pointers
-
axum-valid
validation extractors for your Axum application, allowing you to validate data using validator, garde, validify or all of them
-
tiny-fn
Type erased closures on stack
-
async-trait
Type erasure for async trait methods
-
counter
package to count generic iterables
-
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… -
shape
A portable static type system for JSON-compatible data
-
deno_error
Error representation to JavaScript for deno
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
orion-error
Struct Error for Large Project
-
recursion
cache-aware stack safe recursion
-
n0-error
ergonomic errors with call-site location
-
docify
allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
fragile
wrapper types for sending non-send values to other threads
-
fallible-streaming-iterator
Fallible streaming iteration
-
safelog
Conditionally suppress confidential information from logs
-
error-code
Error code
-
oxc-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
error_set
Quick error declarations and automatic conversions between errors for precisely typed error handling. Inspired by Zig's error set type.
-
formatx
A macro for formatting non literal strings at runtime
-
kinded
Generate enums with same variants, but without data
-
async-fn-stream
Lightweight implementation of
async-streamwithout macros -
cap-std-ext
Extension APIs for cap-std
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
bitflagset
Enum and positional typed bitsets with Set API
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
stdext
Extensions for the Rust standard library structures
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
io-extras
File/socket handle/descriptor utilities
-
core_maths
Extension trait for full float functionality in
#[no_std]backed bylibm -
fallible-iterator
Fallible iterator traits
-
float-ord
A total ordering for floating-point numbers
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
nu-test-support
Support for writing Nushell tests
-
outref
Out reference
-
egui-probe
Trait and derive macro for exposing value editing in egui
-
safe-transmute
A safeguarded transmute() for Rust
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
documented
Derive and attribute macros for accessing your type's documentation at runtime
-
retry
retrying operations that can fail
-
as_variant
macro to convert enums with newtype variants to
Options -
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
better_any
Type id and Any for non static types
-
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
if_chain
Macro for writing nested
if letexpressions -
doc-comment
Macro to generate doc comments
-
try_match
Fallible pattern matching with a function-like syntax
-
iced_anim
creating animations in Iced
-
reflectapi
code-first web service API declaration and corresponding clients code generation tools
-
lazyinit
Initialize a static value lazily
-
optional_struct
defining a macro that will generate, from a structure, another structure with only Option<T> fields
-
rc-box
Known unique versions of Rc and Arc
-
stillwater
Pragmatic effect composition and validation for Rust - pure core, imperative shell
-
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
ptr_meta
A radioactive stabilization of the ptr_meta rfc
-
tryhard
Easily retry futures
-
qubit-function
Common functional programming type aliases for Rust, providing Java-style functional interfaces
-
joinery
A small crate for generically joining iterators with a separator
-
exn
A context-aware concrete Error type built on
core::error::Error -
thiserror-no-std
derive(Error)
-
float8
8-bit floating point types for Rust
-
strck
Checked owned and borrowed strings
-
rust-key-paths
Keypaths for Rust: Static dispatch implementation (rust-keypaths) and legacy dynamic dispatch (key-paths-core). Type-safe, composable access to nested data structures.
-
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
maybe-owned
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
pusherator
Push-based version of Rust iterators
-
rust_info
Extracts the current rust compiler information
-
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! -
uniplate
boilerplate-free operations on tree-shaped data types
-
wasmtime-internal-core
INTERNAL: Wasmtime's core utilities and helpers with minimal dependencies
-
anyerror
A type of any error for transport
-
field-offset
Safe pointer-to-member implementation
-
sealed
Macro for sealing traits and structures
-
failsafe
A circuit breaker implementation
-
thiserror-ext
Useful extension utilities for
thiserror -
whereat
Lightweight error location tracking with small sizeof and no_std support
-
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
-
creusot-contracts
contracts and logic helpers for Creusot
-
mago-reporting
Structured error and diagnostic reporting utilities
-
with_locals
Function attribute to return references to locals by using CPS
-
sqry-lang-elixir
Elixir language plugin for sqry
-
async-recursion
Recursion for async functions
-
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
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…
-
beef
More compact Cow
-
gofer
Gofer.rs makes it easy to fetch data from any URL
-
reborrow
Emulate reborrowing for user types
-
speculoos
Fluent test assertions
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
opentalk-types-signaling-automod
Signaling types for the OpenTalk automod module
-
oxrdf
Basic data structures related to RDF
-
buffered-reader
A super-powered Reader
-
sabi-rust
A small framework to separate logics and data accesses for Rust application
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
problem
Error handling for command line applications or prototypes
-
protest
An ergonomic, powerful, and feature-rich property testing library with minimal boilerplate
-
result-like
Option/Result-like monad interface for your own enum
-
speare
actor-like thin abstraction over tokio::task and flume channels
-
better_collect
composable, declarative way to consume an iterator
-
leo3
Rust bindings for the Lean4 theorem prover
-
n0-snafu
Utitilities for working with snafu
-
dprint-swc-ext
Functionality to make swc easier to work with
-
enum-display
A macro to derive Display for enums
-
fixnum
Fixed-point numbers with explicit rounding
-
istring
A replacement for String that allows storing short strings of length up to sizeof<String>() - 1 without a heap allocation
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
anymap3
A safe and convenient store for one value of each type
-
rustica
functional programming library for the Rust language
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
gix-error
gitoxide project to provide common errors and error-handling utilities
-
typed-arrow
Compile-time Arrow schemas for Rust
-
valitron
ergonomics, functional and configurable validator
-
more-di
support for dependency injection (DI)
-
rfluids
🦀 Rusty CoolProp wrapper
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
sdl3-main
Tools for using SDL's main and callback APIs
-
lazy_format
lazily formatting values for later
-
garnish_lang_traits
Shared traits for garnish core libraries
-
fatality
extension to
thiserror::Error -
modum
Workspace lint tool for Rust naming and API-shape policy
-
panic-halt
Set panicking behavior to halt
-
spire_enum
Procedural macros to facilitate enum usage, such as when delegating implementations, extracting variant types, or creating enum tables
-
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
hot_reload
Trait and service definition of periodic hot reloader and notifier for config-file, KVS, etc
-
sage-parser
Parser for the Sage language
-
shadow_counted
An iterator that counts every iteration in a hidden counter, nested iterators may commit the count to parents
-
pilgrimage
A Kafka-like message broker in Rust
-
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.
-
emergent-client
Client library for Emergent event-based workflow platform
-
indoc
Indented document literals
-
better_scoped_tls
scoped-tls, but with good error message
-
derive_generic_visitor
Boilerplate for building rust visitors
-
rancor
Scalable and efficient error handling without type composition
-
turul-mcp-json-rpc-server
Pure JSON-RPC 2.0 server implementation with type-safe domain/protocol separation
-
macro-asm-builder
macro-assemblers
-
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
hlua
Zero-cost high-level wrapper for Lua
-
variadics
Variadic generics on stable Rust using tuple lists
-
auto_enums
allow multiple return types by automatically generated enum
-
dtype_dispatch
Macro builder for working with data types
-
cljrs-eval
Tree-walking interpreter and macro expander for clojurust
-
overload
macro to simplify operator overloading
-
value-trait
Traits to deal with JSONesque values
-
bytes-str
A string type that is backed by bytes crate
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
utoipa-axum
Utoipa's axum bindings for seamless integration for the two
-
dync
An efficient alternative to
dyn Traitfor containerized types -
oni-comb-parser
Rebooted parser combinator library
-
hax-frontend-exporter-options
The options the
hax-frontend-exportercrate is sensible to -
deriving_via
DerivingVia
-
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. -
strong-type
Procedural macros for naming and strong-typing primitives and strings
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
bevy_gauge
A flexible attribute and stat system for Bevy
-
morok-schedule
Optimization passes and pattern engine for the Morok ML compiler
-
simple-zanzibar
A simplified Rust implementation of Google's Zanzibar authorization system with DSL support
-
ostd-pod
A trait for plain old data (POD)
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
condtype
Choose types at compile-time via boolean constants
-
dioxus-router
Cross-platform router for Dioxus apps
-
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
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
makepad-widgets
Makepad widgets
-
patchable
Automatically derive patch types for Rust structs to enable efficient partial updates with zero runtime overhead
-
marlin-verilog-macro-builder
🦀 No nonsense hardware testing in Rust 🛠️
-
awint_macro_internals
Internal macro utilities for the
awintsystem of crates -
karpal-core
HKT encoding, Functor, Semigroup, Monoid for the Industrial Algebra ecosystem
-
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…
-
eros
Error handling that is precise, no boilerplate, ergonomic, context aware, and performant
-
lazycell
providing a lazily filled Cell struct
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
sugars
An useful collection of macros to make tasks easier
-
runtara-dsl
DSL for agent metadata definitions in runtara workflows
-
steel-parser
Parser for use within steel
-
okapi
Structs for OpenAPI (AKA Swagger) documents
-
errs
handling errors with reasons
-
spark-signals
A standalone reactive signals library for Rust - fine-grained reactivity for any application
-
causal
A deterministic, event-driven coordination layer where machines decide, effects execute, and transactions define authority
-
corophage
Algebraic effects for stable Rust
-
autofolder
Single-element folding wrapper
-
racer
Code completion for Rust
-
environmental
Set scope-limited values can can be accessed statically
-
fixed-hash
Macros to define custom fixed-size hash types
-
random-number
Generate random numbers quickly
-
compactly
encode data types using adaptive arithmetic coding
-
processmanager
manage process lifecycles, graceful shutdown and process faults
-
shopify_function_wasm_api
High-level interface for interfacing with the Shopify Function Wasm API
-
cascade
Dart-like cascade macro for Rust
-
sigil-stitch
Type-safe, import-aware, width-aware code generation for multiple languages
-
base-traits
base traits (for Rust)
-
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.
-
facet_generate
Generate Swift, Kotlin and TypeScript from types annotated with
#[derive(Facet)] -
pin-utils
pinning
-
tools-rs
Core functionality for the tools-rs tool collection system
-
eventcore
Type-driven event sourcing library for Rust with atomic multi-stream commands
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
rama-error
error types and utilities for rama
-
enum-assoc
Procedural macro to associate constants with enum variants
-
async-injector
Reactive dependency injection for Rust
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
foras
First-Order Reasoner which uses the principles of predicate logic to derive new facts, verify statements, and prove theorems from an existing knowledge base
-
chaos_theory
Modern property-based testing and structure-aware fuzzing library
-
cynic-parser
A fast, correct and easy to use GraphQL parser
-
noos
Reliability layer for Rust LLM agents: scope drift, cost circuit breaks, and procedural correction memory as event-driven Decisions
-
creusot-std
Standard library of Creusot: provides specification macros, contracts for Rust standard library and logic helpers
-
netcdf3
A pure Rust library for reading and writing NetCDF-3 files
-
whitaker-common
Internal common utilities for Whitaker lints
-
shaku
Compile Time Dependency Injection for Rust
-
cadd
Painless checked arithmetics and conversions
-
std-next
Opinionated utilities and polyfills
-
retry-error
An error type for an operation that can fail more than once
-
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.
-
v-storage
Storage layer for the veda platform
-
qml_static_analyzer
A static analyzer for QML files
-
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
taurpc
A type-safe IPC layer for tauri commands
-
err_trail
Add context to errors through logging
-
pasta_dsl
Pasta DSL - Independent DSL parser and AST definitions
-
metastruct
Abstractions for iterating and mapping over struct fields
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
collection_literals
macros for initializing any collection
-
valico
JSON Schema validator and JSON coercer
-
expunge
redact and transform struct fields declaratively
-
const-field-offset
Derive macro providing const field offsets using core::mem::offset_of!
-
invoice-gen
SDK for generating invoices in schemas FA (2), FA (3), PEF (3), PEF_KOR (3) and FA_RR (1)
-
assert-eq-float
assert_eq_float!macros that support floats -
axerrno
Generic error code representation
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
valq
macros for querying semi-structured data with the JavaScript-like syntax
-
chasa
A parser combinator focused on rollback/commit, streaming inputs, and composable method chains
-
virtue-next
A sinless derive macro helper
-
rexlang-typesystem
Rex: A strongly-typed, pure, implicitly parallel functional programming language
-
fauxgen
write your own generators in stable rust
-
scah-query-ir
Internal query IR used by the scah selector and macro crates
-
euxis-commons
Shared Rust utilities and common patterns for the ecosystem. Provides reusable components for error handling, configuration, logging, validation, retry logic, and more
-
jemmy
This package provides a coherent set of manual accessor macros
-
loupe
Profiling tool for Rust
-
portage-atom-resolvo
Bridge between portage-atom and the resolvo dependency solver
-
figura
A flexible string template formatting crate
-
service-daemon
A declarative Rust framework for automatic service management, event-driven triggers, and compile-time dependency injection
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
fsmy
A finite state machine library
-
log_limit
A rate limiting logging crate
-
octseq
Abstractions for types representing octet sequences
-
resiter
Helper crate for handling iterators over result
-
salsa-macro-rules
Declarative macros for the salsa crate
-
uni_error
universal error type for Rust
-
impl-more
Concise, declarative trait implementation macros
-
cfg-elif
Formatter-friendly conditional compilation at item and expression positions
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
pixelscript
Multi language scripting runtime
-
assert_approx_eq
assert approximately equal
-
moku
creating hierarchical state machines (HSM)
-
alloc-checked
Collections that don't panic on alloc failures
-
oxur-smap
Source mapping for Oxur language - tracks code transformations for error reporting
-
cluFullTransmute
Extended, no-constraint type transmutation API, featuring safe checks and const-ready logic
-
spacetimedsl
The SpacetimeDB Rust Server Module meta-framework
-
resman
Runtime managed resource borrowing
-
mlua-extras
Extra helpers and functionality built on top of mlua for embedded lua development
-
tyrx
Typed, ergonomic regular expression library
-
borrow-or-share
Traits for either borrowing or sharing data
-
validated
The cumulative sibling of
ResultandEither -
openapi_type
OpenAPI type information for Rust structs and enums
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
belt
A fast, cross-platform Factorio benchmarking tool
-
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… -
const_soft_float
Const Soft Float Point
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
sptr
Strict Provenance Polyfill
-
inline-python
Inline Python code directly in your Rust code
-
compile_time_sort
Sort arrays and slices of primitives in const contexts
-
soa_derive
Automatic Struct of Array generation
-
components-arena
creating complex domain-specific self-referential data structures
-
gstuff
Small macro and trinkets that make my life easier
-
fn-ptr
introspecting and rewriting function pointer types at compile time
-
suitecase
The structured test toolkit. A sync Rust crate for named cases, optional suite and per-case hooks, and macros so each case appears in cargo test—without a custom harness or DSL.
-
ref-map
Helper trait for Option and Result to map references
-
frunk_proc_macro_helpers
Common internal functions for frunk's proc macros
-
crustal
generating C/C++ code
-
swamp
script language for embedding
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
yerevan
Small Rust crate that brings computation expressions idea from F# for help you to work easier with functors and monads
-
orx-meta
Meta structures such as statically typed queues of heterogeneous elements
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
cexpr
A C expression parser and evaluator
-
sumtype
Generate zerocost sumtype of iterators or closures
-
k8-client
Core Kubernetes metadata traits
-
ownedbytes
Expose data as static slice
-
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
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.
-
metered
Fast, ergonomic metrics for Rust!
-
lowdash
A Lodash inspired utility library to manipulate array and object for Rust
-
eio-okta-data
Data Types for Okta
-
tinyvec_macros
Some macros for tiny containers
-
dynify
Add dyn compatible variant to your async trait
-
leptos-mview
A concise view macro for Leptos
-
problemo
Problemo
-
plux-rs
A modular and performant plugin system for Rust applications, enabling secure and stable extension of functionality through external plugins
-
model-mapper
Derive macro to map between different types
-
sc
Raw system calls
-
meticulous
Result extension to add more meaning to unwrapping
-
handle-this
Ergonomic error handling with try/catch/throw/inspect/finally syntax and automatic stack traces
-
one_err
OneErr to rule them all
-
anyhow_serde
Flexible concrete Error type built on std::error::Error with serde support
-
loga
Combined logging and error handling
-
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
-
atoman
static data that can be accessed safely and concurrently from any part of your program
-
platform-num
Numbers for linksplatform
-
inplace_containers
In-place, fixed-capacity containers with optional features
-
case_insensitive_string
A case insensitive string struct
-
error2
error handle library for Rust
-
fastapi-openapi
OpenAPI 3.1 types and schema generation for fastapi_rust
-
aspect-core
Core traits and types for aspect-oriented programming in Rust
-
doku
A framework for documenting Rust data structures
-
adar
Collection of architectural tools including flags, state machine, enum and tuple operations
-
atlas-program-log
Lightweight log utility for Atlas programs
-
blanket
macro to derive blanket implementations for your traits
-
dioxus-config-macros
Macros used internally by codegen
-
error-rail
ErrorRail is a no_std compatible Error Handling library for the Rust language
-
pstd
parts of Rust std library ( different implementations, features not yet stabilised etc )
-
devela
A development layer of coherence
-
uy
A typesafe, flexible, simple, and user-friendly unit system library for Rust that has good error messages
-
pingora-error
Error types and error handling APIs for Pingora
-
culpa
error-handling syntax in Rust
-
impls
Determine if a type implements a logical trait expression
-
value-traits
By-value slices and iterators
-
wherror
The same derive(Error) macro thiserror provides + the features you want!
-
autofloat
Pure Rust library for efficient automatic differentiation
-
datafusion-comet-spark-expr
DataFusion expressions that emulate Apache Spark's behavior
-
directed
Evaluate programs based on Directed Acyclic Graphs
-
dill
Runtime depenency injection library
-
sitrep
Frontend-agnostic progress reporting
-
intern-arc
An interner that deallocates unused values
-
cryptify
A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
facet-solver
Constraint solver for facet - resolves type shapes from field names
-
linear_type
Unique linear types for rust
-
cynic-codegen
Procedural macro code generation for cynic - a code first GraphQL client for Rust
-
sparkles
Capture execution flow of your Rust application with CPU cycle precision!
-
typesafe_builder
A procedural macro to generate type-safe builder patterns for Rust structs
-
generic-container
Abstract over "containers" that hold a T, such as a T itself, Box<T>, or Arc<Mutex<T>>
-
gerber-types
Types and code generation for Gerber files (RS-274X)
-
prima_bridge
implement the bridge pattern
-
pretty-error-debug
If the process ends with an
Error, write out theErrormessage and chain -
describer
Struct describing helper
-
tlq-fhirpath
FHIRPath engine
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
direction
Representations of directions
-
anyhow2
（Fork of anyhow that adds the location where the error first occurred）Flexible concrete Error type built on std::error::Error
-
linked_list_r4l
Linked lists that supports arbitrary removal in constant time
-
smarterr
Smart error handling library
-
clash-prism-plugin
Plugin system with lifecycle hooks, multi-component architecture, and cron scheduling
-
assume
Macro for stating unsafe assumptions in Rust
-
signaled
A lightweight reactive programming library for Rust, providing a signal-slot mechanism
-
provekit_bn254_blackbox_solver
Solvers for black box functions which are specific for the bn254 curve
-
my-utils
Utilities
-
rspack_macros_test
rspack macros test
-
terni
Ternary error handling: Success, Partial with measured loss, Failure. Because computation is not binary.
-
hodgepodge
Lightweight dataset crate of enums for prototyping, teaching, and experimentation
-
ferment
Traits for FFI conversions and some helper methods
-
iter-comprehensions
iterator comprehensions
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
current
setting current values for stack scope, such as application structure
-
pi_null
define trait is named Null. u8,u32,u64,Option...is implements Null
-
hax-frontend-exporter
mirrors of the algebraic data types used in the Rust compilers, removing indirections and inlining various pieces of information
-
blinc_router
Cross-platform routing with deep linking for Blinc UI framework
-
err_tools
Helper traits and functions for building errors in rust
-
peel-off
Peel off a specific variant from a Rust enum, splitting it into the extracted variant and the residual
-
derive-io
derive macros for
std::io::{Read,Write},tokio::io::{AsyncRead,AsyncWrite}and more -
capacity_builder
Builders where the code to calculate the capacity is the same as the code to write what's being built
-
contained
works to provide several macros and interface for transparent wrapper types in Rust
-
annotate
Annotation framework for Rust functions and modules
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
renege
Tracking cache validity using fast concurrent invalidation propogation
-
preprocess
Preprocesses a struct with built-in preprocessors
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
flex-error
Flexible error definitions using macros and traits
-
for_build_rs
lexer for Rust's build.rs
-
reaktiv
A standalone, flexible fine-grained reactivity library
-
qubit-mixin
Trait mixins for domain objects, providing common properties and behaviors
-
join_me_maybe
an async
join!macro withselect!-like features -
ref_iter
Dynamic borrowing iterator
-
genies_dapr
整合DDD与Dapr 的 dapr 库
-
resext
lightweight error handling crate for Rust
-
mydi
MyDI. Dependency Injection library
-
tuple
Element-wise operations on tuples
-
nonbox
NaN boxing without boxing
-
emboss
Macros to embed metadata as an ELF/Mach-O section in your final binary
-
bcf_reader
a small, lightweight, pure-Rust library to allow efficient, cross-platform access to genotype data in BCF files
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
pretty-name
Get the human-friendly name of types, functions, methods, fields, and enum variants in a refactoring-safe way
-
eventql-parser
EventQL Lexer and Parser
-
neuer-error
Ergonomic error handling for machines and humans
-
cada
A monadic Chest<T> container and universal for-comprehension macro for Rust
-
aranya-capi-core
Aranya's C API tooling
-
scadman
Code generator for OpenSCAD
-
pulumi_gestalt_rust
UNOFFICIAL Rust Pulumi support based on Pulumi Gestalt
-
spacetimedb-primitives
Primitives such as TableId and ColumnIndexAttribute
-
thiserror-core
derive(Error)
-
cast_trait_object
Cast between trait objects using only safe Rust
-
socketpair
Cross-platform socketpair functionality
-
variant_count
Derive macro for enum which adds to it the count of variants
-
ensembler
running commands and reporting progress
-
srcmap-scopes
Scopes and variables decoder/encoder for source maps (ECMA-426)
-
str-macro
The str!() macro, similar to vec![] but for strings
-
approxim
Approximate floating point equality comparisons and assertions
-
superstruct
Versioned data types with minimal boilerplate
-
tpuf_zerovec_0115
Zero-copy vector backed by a byte array
-
defer
excecution of code, inspired by go's defer statement
-
shive
lightweight IOC service container writen for the Rust applications
-
sope
Simplified, and type-safe interface to MPI with error handling
-
redb_model
Redb model derive macro and DTO type conversion
-
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.
-
ungrammar
A DSL for describing concrete syntax trees
-
loop_lib
Core loop engine library for running commands across directories
-
derive_tools
A collection of derive macros designed to enhance STD
-
dupe
Marker for types which are cheap to clone
-
nu-engine
Nushell's evaluation engine
-
protocol
Easy protocol definitions
-
apt-pkg-native
Bindings for libapt-pkg
-
numdiff
Numerical differentiation via forward-mode automatic differentiation and finite difference approximations
-
index_type
Type-safe newtype indices for Rust
-
tola-caps
Capability system enabling type-level state tracking, trait detection, and stable specialization
-
relative-duration
Duration with negative capabilities
-
wfe-core
Core traits, models, builder, and executor for the WFE workflow engine
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
explicit-error
Explicit concrete Error type for binary crates
-
axum-openapi3
Facilitate the generation of OpenAPI 3.0 documentation for axum applications
-
spade-types
Helper crate for https://spade-lang.org/
-
off64
Read from and write to byte slices with u64 offsets
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
microcad-lang
µcad language
-
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
-
chapa
Bitfield structs, batteries included!
-
banish
A declarative framework for rule-based state machines
-
gerber_viewer
A cargo crate for rendering Gerber files
-
pud
Generate typed, composable, no-std-friendly modifications (“puds”) for Rust structs
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
http-request-derive
Use derive to create HTTP requests
-
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…
-
tldr-traits
Abstractions for TL;DR summarization using the five Ws: who? what? when? where? why?
-
goof
A reusable, composable, aggregate and
no_std-friendly error library -
eira
Ansi-colored error reporting output
-
nutype-enum
Helper macro to create a nutype that behaves like an enum
-
provekit-fp-rounding
Floating-point rounding utilities for BN254 arithmetic
-
leptix-core
Core utilities for Leptix UI components
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
overture-core
overture library
-
cocoon-tpm-utils-common
Cocoon TPM project - common utilities
-
wrapper-lite
Helper macro for building a wrapper type and implementing common traits for it
-
rust-memory-safety-examples
Comprehensive educational examples demonstrating memory-safe programming patterns with CVE case studies and benchmarks
-
metrique-writer
working with unit of work metrics - writer-side interface
-
rugen
generating random data based on a data description written in Rune
-
mago-docblock
Analyzes PHP docblocks to extract annotations, tags, and documentation comments, aiding tools that rely on inline documentation
-
sourceannot
render snippets of source code with annotations
-
void
The uninhabited void type for use in statically impossible cases
-
typeshaper
TypeScript utility-type idioms (Omit, Pick, Merge, Partial…) for Rust structs — one-line type algebra expressions
-
inline-c
Write and execute C code inside Rust
-
derive_aliases
#[derive]aliases for reducing code boilerplate -
corroded-rs
that bypasses Rust's safety features
-
mir-types
Type system primitives for the mir PHP static analyzer
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
codespan_preprocessed
Beautiful diagnostic reporting for M4 (or cpp) preprocessed text files
-
wry-bindgen
Native desktop implementation of wasm-bindgen APIs using wry
-
seal-the-deal
Attribute to use on the
traitmethods (or associated functions) that you wish to “seal”, a.k.a., render themfinal -
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
underscore_args
Macro for underscore named argument syntax, aka Dyon
-
multiple_errors
Propagate multiple errors instead of just the first one
-
suzunari-error
A highly traceable and noise-free error system that propagates error locations as error contexts and minimizes information output to the log
-
rutie
The tie between Ruby and 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…
-
variadics_please
Implement things as if rust had variadics
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
simple-error
error type backed by a string
-
hoicko_lib
Hoicko library
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
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.
-
bits-io
Bit-level IO operations
-
luhtwin
A beta horrible Rust error handling library with AnyError and context macros
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
tokenlock
cell types that decouple permissions from data
-
yule_log
A streaming parser for PX4 ULOG files
-
state-machines
Type-safe state machines with hierarchical states, guards, callbacks, and async support - Rust port of Ruby's state_machines gem
-
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…
-
nixl-sys
Low-level bindings to the nixl library
-
builder-pattern
A derivable macro for declaring a builder pattern
-
tighterror
A minimalistic error representation framework
-
rslint_errors
Pretty error reporting library based on codespan-reporting built for the RSLint project
-
stackerror
A pragmatic error handling library for Rust that provides helpful strings for debugging, and structured data for runtime error handling
-
rustfix
Automatically apply the suggestions made by rustc
-
pipeline-dsl
Pipeline DSL types and re-exports of #[pipeline]/#[stage]
-
arri_repr
Rust representations of Arri types
-
frunk_utils
working with frunk
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
qtbridge
Meta-package for Qt Bridge
-
origin-lang
Every value is origin, at a boundary, or contents. The compiler knows which.
-
either_of
working with enumerated types that contain one of 2..n other types
-
take-until
A take_until extension for iterators
-
orpc
Type-safe RPC framework for Rust, inspired by oRPC
-
file_rw
high-performance, memory-mapped file I/O utilities
-
quasiquodo
Compile-time quasi-quoting for typed languages
-
per-thread-object
Efficient per-object thread-local storage implementation
-
type_reflect
Extensible runtime reflection through a Derive macro
-
cast_checks
A procedural macro to check for invalid casts
-
app-error
Error type for applications
-
swift-rs-leap
Call Swift from Rust with ease!
-
evcxr_repl
A REPL for Rust
-
buildstructor
Macro to derive a builder from a constructor function
-
cjc-mir
Mid-level IR with CFG, SSA, dominators, and optimization passes
-
rig-cat
LLM agent framework built on comp-cat-rs: typed effects, no async, categorical foundations
-
powerletters
Concise spellings of common Rust operations
-
ra-ap-rustc_type_ir
Automatically published version of the package
rustc_type_irin the rust-lang/rust repository from commit ec2d669db8e5ca2cb1604c69a831ef244ebd9aa9 The publishing script for this crate lives at:… -
nnn
Generate your newtypes from a single macro
-
portrait
Fills an
implwith the associated items required by the trait -
dynamic-plugin
Write compile-time-checked, dynamically-loaded plugin libraries for your Rust software
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
plist-macro
Macros and utilities for manipulating plists
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
shannon-nu-engine
Nushell's evaluation engine
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
prudent
Help you make Rust code safer. For both authors and reviewers.
-
tstr
type-level strings on stable
-
bignumbe-rs
Large, medium-precision numbers
-
pareg
useful tools for command line argument parsing
-
hex_lit
Hex macro literals without use of hex macros
-
rudi-dev
Rudi - an out-of-the-box dependency injection framework for Rust
-
errgonomic
Macros for ergonomic error handling with thiserror
-
bint
Bounded Integer in Rust
-
once-list2
A single linked list which is backed by
OnceCell. You can append the value to the non-mutableOnceList. -
matched_enums
A macro that provides the option to bin enum attribute to match-statements. This makes it easier to convert values into enums.
-
sosecrets-rs
Secretwrapper type that reveals the secret at mostMEC: typenum::Unsignedtimes with compile time guarantees -
match_opt
A macro for turning a partial match into a full match returning an option
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
mightrix
treat continous memory as a matrix
-
makers
a POSIX-compatible make implemented in Rust
-
open-formula
A spreadsheet formula parser and evaluator that conforms to the Open Document Format for Office Applications Version 1.4 Format
-
absolute_unit
A unit system for Rust's type system to catch unit errors in your physical calculations
-
rust-texas
generate latex documents
-
cf-modkit-canonical-errors
ModKit canonical error types based on Google AIP-193 error model
-
witnesscalc-adapter
run witnesscalc in rust
-
ready-active-safe
Lifecycle engine for externally driven systems
-
fp_rust
Implement fp features for Rust
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
fx-callback
A subscription based callback to inform subscribers about relevant data events within structs
-
zip_clone
Zip an iterator to a repeatedly cloned object
-
capnp_conv2_codegen_req
Friendly Rust types for working with Cap'n Proto CodeGeneratorRequest schema data
-
edgee-sdk
The full-stack edge platform for your edge oriented applications
-
bizerror
standardized approach for defining and managing business-related errors
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
bauer
A derive macro for automatically generating builders
-
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
-
typed-measurements
handling physical measurements with units
-
tiff-forge
working with TIFF and BigTIFF files
-
mod_use
pub mod xxx; use xxx::*;
-
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
rustdoc_copy
Rustdoc comment copy helper
-
turso-mappers
Row mappers for turso
-
devnagari
Code in Devanagari (Hindi/Sanskrit) — type aliases, macros, and keyword translation for Rust
-
syn-locator
A source code locator for syn crate
-
potential-well
Atomic boxes
-
lighty-event
Event system for LightyLauncher
-
fluent_result
Fluent postfix helpers for Rust's Result and Option types
-
tauri-plugin-scoped-storage
Tauri 2 plugin for user-approved scoped folder access on Android and iOS
-
forgeconf
Declarative configuration loader for Rust structs powered by attribute macros
-
erdp
display an error and its nested errors
-
haskelujah-naming
Name resolution, interfaces, and symbol environments for the Haskelujah compiler
-
oxilangtag
fast implementation of language tag normalization and validation
-
anystack
Flexible and comprehensive error handling
-
fmu_from_struct
A derive macro for automatically setting up FMU models in Rust
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
el_roi
simplify reading user input
-
prism3-function
Common functional programming type aliases for Rust, providing Java-style functional interfaces
-
custom-display
A trait for implementing custom formatting logic for types
-
entrait
Loosely coupled Rust application design made easy
-
command-error
Detailed error messages and status checking for
std::process::Command -
typewriter-plugin-dart
Dart/Flutter emitter plugin for typewriter
-
statum
Represent workflow and protocol state correctly in Rust by making invalid states unrepresentable
-
errcode
simplified error handling
-
pipe-trait
possible to chain regular functions
-
radicle-std-ext
Monkey patches of std types
-
qenv
Define environment variables with macros and access them easily
-
cinderblock-core
Resource trait definitions, CRUD operations, runtime context, and in-memory data layer for cinderblock
-
doless
macro to simplify struct mapping , injects cache lookup logic directly into your functions ,and function utilities
-
bobcat-panic
Bobcat utilities with a panic handler on Arbitrum Stylus
-
rs95
implementing the ISA-95 domain models
-
enum_ext
procedural macro that enhances enums with additional methods and conversions
-
pgrx-pg-sys
Generated Rust bindings for Postgres internals, for use with 'pgrx'
-
directed-visit
Visitor pattern with interchangable implementations for both the visit algorithm and node object traversal
-
lerpable
a derive macro for combining ADTs
-
span-core
A span to span
-
tuplex
Rust tuple extension
-
cast
Ergonomic, checked cast functions for primitive types
-
crossfig
compile-time feature aliases and introspection
-
bhc-types
Type system, type inference, and type representations for BHC
-
eggplant
High-Level Rust API crate for Egglog
-
windmark-titanesque
An elegant and highly performant async Gemini server framework (fork with titan support)
-
display-error-chain
Formats a standard error and its sources
-
conflate
Merge multiple values into one
-
sod-actix-web
Service Oriented Design - Actix Web
-
tensorism
easy tensor manipulation on top of ndarray
-
marked-path
Type-safe path wrappers with compile-time absolute/relative guarantees
-
oni-comb-crond
Cron expression parser and scheduler built on oni-comb-parser
-
rustfmt-nightly
find and fix Rust formatting issues
-
burn_dragon_tokenizer
Tokenizer primitives for burn_dragon
-
errorstash
collecting multiple related errors, and reporting them together
-
rs-cor
A compile-time Chain of Responsibility pattern library for Rust
-
studiole-di
Dependency injection with sync and async constructors, resolve by type or trait, and singleton or transient scopes
-
alef-extract
Rust source extraction for alef
-
recallable
Traits (
Recallable,Recall,TryRecall) and macros for defining Memento pattern types and their state restoration behaviors -
seekwel
an experimental sqlite library
-
smox
Box that stores small objects inline and bigger objects on the heap using Box, Rc or Arc, with CoW semantic
-
head-tail-iter
An iterator that repeatedly splits head & tail
-
unescape_zero_copy
Unescape strings without allocating memory
-
semigroup
Useful semigroup trait
-
revolt-result
Revolt Backend: Result and Error types
-
hlist2
Compile-time heterogeneous list implementation
-
code-gen
aids in code generation
-
cli_utils_hoijui
A tiny CLI utilities library, providing functions and constants useful in many CLI tools
-
langkit
A builder library for creating programming languages in Rust
-
seasick
Tools for implementing and transcribing C APIs
-
unipipe
pipe abstraction that extends to iterator and stream
-
duration-extender
Adds fluent, highly readable methods (like .minutes(), .hours()) directly to integer types (u32, i64, etc.) to easily create std::time::Duration
-
okerr
Ergonomic result / error handling helpers built on anyhow and thiserror
-
tlns-google-oauth2
An enshitificated Google OAuth2 Server Side support for Rust with built in Scopes enum
-
no-break
Typesafe extraction of continuation values from unbreakable control flows
-
arr_macro
Initialize arrays with ease!
-
dragonfly-plugin
Dragonfly gRPC plugin SDK for Rust
-
iterextd
This trait provides additional methods for working with iterators, enhancing their functionality
-
newstr
macros for declaring String-base new types
-
orx-closure
An explicit closure with absolute separation of the captured data from the function
-
traitsequence
Traits to abstract over sequences
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
struct-to-enum
Derive macros to generate enums from struct fields - compile-time safe field selection and dispatch
-
error-envelope
Structured, consistent error responses for Rust APIs. Framework-agnostic with Axum support.
-
cdumay_core
standard code
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
lunka
Pretty thin bindings to Lua 5.4
-
TSPL
The Simplest Parser Library
-
data-rw
io buffer write reader
-
rs_ervice
service manager for vanilla or Tokio runtime
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
waker_tables
custom raw waker logic
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
midi-toolkit-rs
ultra high performance MIDI operations, designed for black MIDI. The library isn't perfect
-
rialo-aggregators-utils
Rialo Aggregators Utils
-
matchmaker-lib
A fuzzy finder for the terminal, powered by nucleo
-
clone_cell
A Cell that works with a restrictive form of Clone
-
enum-update
representing state changes as enums
-
arch-lint
AST-based architecture linter for Rust - catches what code review misses
-
SCLP
Command Line Parser Built with Rust
-
gpui_refineable
A macro for creating 'refinement' types that can be used to partially initialize or mutate a complex struct
-
conerror
macro that automatically adds context to errors
-
stdio-override
overriding Stdin/Stdout/Stderr with a different stream
-
branch_hints
that provides likely and unlikely branch hint functions in stable Rust
-
protoschema
📐 Programmatically define protobuf contracts using flexible, modular and reusable elements
-
deref
dereferencing types
-
skerry
Super Kool ERRors Yoh - A type-safe, zero-boilerplate error management framework
-
cfg_rust_features
Set cfg options according to probing for Rust compiler, language, and library features
-
pattern-wishcast
Pattern types emulation for conditional variants using conditional never types
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
sanitizers
Interfaces and FFI bindings for the sanitizers interfaces
-
rusttyc
writing type checkers with a lattice-like type system in rust
-
object-rainbow
distributed object model
-
condition-matcher
A flexible and type-safe condition matching library with automatic struct field access
-
unitforge
unit and quantity consistent computations in Rust
-
decycle
Solve circular trait obligation
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
named-generics-bundle
Convenience macros to help with the "bundle multiple generic params with a helper trait" pattern
-
no_drop
wrapper type that guards against a value being automatically dropped
-
structural-typing
Type-level field presence tracking for Rust structs, inspired by TypeScript
-
isclose
A collection of trait and macros for comparing approximate equality
-
dispose
wrapper for values that must be consumed on drop
-
dcc-lsystem
Lindenmayer system together with some rendering tools
-
mir-analyzer
Analysis engine for the mir PHP static analyzer
-
ax-linked-list-r4l
Linked lists that supports arbitrary removal in constant time
-
anyhow-http
Customizable HTTP errors built on anyhow
-
sfo-result
Result type for Rust
-
hexga_number
Provide basic trait and constant for number, and the macro map_on!
-
drop_bomb
A runtime guard for implementing linear types
-
convention-lint
File-naming convention linter configurable via Cargo.toml metadata — use as
cargo convention-lintor embed as a library -
symposium-crate-sources-proxy
ACP proxy component providing Rust crate source code research tools
-
srb-lens
Static analysis tool for Sorbet-typed Ruby projects — extracts method signatures, call graphs, and type information from Sorbet's CFG, symbol table, and parse tree
-
env_cfg
derive macro library for loading configuration structs from ENV variables
-
polymorph
A few utilities to better enable polymorphic behavior in Rust
-
traitreg
Create a registry of implementations of a trait
-
typeid
Const TypeId and non-'static TypeId
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
round
your floats with precision from 1 to 10
-
despatma
Design Pattern Macro like Loki
-
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) -
rsgenetic
providing genetic algorithm execution
-
c8str
String types that are both utf-8 and null terminated
-
alkahest
Fantastic serialization library with zero-overhead serialization and zero-copy deserialization
-
much
Handling Multi-Channel Audio Signals
-
reda-unit
physical units
-
anomalies
Structured, categorized error handling inspired by Cognitect's anomalies
-
macon
builder macro-based generator with its own idioms
-
unwrap_or_ai
providing AI-powered error handling using procedural macros
-
msft-typelib
Allocation-free parser for MSFT-format type library (.tlb) files
-
certain-map
A typed map which can make sure item exist
-
munge
Macro for custom destructuring
-
localtrace
A local tracing library for Rust
-
hexga
include all other console hexga crate in one !
-
functionality
Rust |> Functional programming = 💖. Useful traits, functions and macros for prettier code.
-
garray2d
Game development focused 2d array with signed index and offset support
-
tramli
Constrained flow engine — state machines that prevent invalid transitions at build time
-
llama-engine
Narrow-waist engine trait and core types for llama.rs
-
trait_mux
Proc macro library for generating enums that can multiplex different trait objects
-
early_returns
Macros to make early returns easier to work with in Rust
-
actuate
A reactive user-interface framework
-
rustapi-validate
Type-safe request validation for RustAPI. Wrapper around the
validatorcrate with deep framework integration. -
isnt
Inverted versions of boolean-valued stdlib functions
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values, their discriminant or their name; inspired by Java
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
smooai-smooth-plugin
Smooth Plugin — trait-based plugin system for extending Smooth with CLI commands, API routes, TUI views, and operator tools
-
sevenmark_ast
AST types for SevenMark wiki markup
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
stylish-html
stylishhelpers for writing styles as HTML elements -
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
enumerable
helping you to enumerate all possible values of a type
-
miniffi
but opinionated FFI system
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
inferni_bitstream
Bitstream implementation for Inferni
-
recovery
Trait and derive macros to declare how errors should be retried
-
throw_error
wrapping, throwing, and catching errors
-
notizia
Frictionless message passing for the Tokio runtime
-
execution-time
way to measure and display the execution time
-
dyson_boot
Dyson Quick Startup Crate
-
rustversion
Conditional compilation according to rustc compiler version
-
teloxide-plugins
Smart plugin system for Teloxide bots
-
specl-types
Type system and type checker for Specl
-
rangetools
Extending the Rust Range structs found in std::ops
-
utf8proj-parser
Parser for utf8proj native DSL (.proj files)
-
rootfinder
Root-finding methods for both univariate, scalar-valued functions and multivariate, vector-valued functions
-
broken-pipe-kills
Get rid of
failed printing to stdout: Broken pipe (os error 32)panics by settingSIGPIPEtoSIG_DFLbefore yourfn main()runs -
protobuf-core
A primitive utility library for Protocol Buffers in Rust
-
stream_assert
Macros to simplify testing of
Streambased APIs -
quither
A flexible enum-based utility for representing values that may be on the left, right, neither, or both sides
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
glam-traits
Traits for the vectors in glam
-
pyo3-error
Unified error causality chains across Rust and Python
-
vs-plugin-api
Shared plugin models and traits for the vs runtime manager
-
restructed
Quickly derive subsets of your structs
-
rust-asm
ObjectWeb ASM implementation in Rust
-
dioxus-stores
Server function macros for Dioxus
-
tan
language
-
mongo_indexed
derive macro to declaratively index mongo collections
-
hx-compiler
Compiler backend abstraction for hx
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
async-retry
Async Retry
-
nject
Zero cost dependency injection module
-
flaky_test
atttribute macro for running a flaky test multiple times
-
surreal_devl
Contains core logic of surreal derive
-
dioxus-use-js
A macro that generates Rust bindings to JavaScript or TypeScript functions, with compile time checks. For use with Dioxus.
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
dyn-hash
Hash trait that is dyn-compatible
-
rust-i18n-derive
derive macro for internationalization (i18n) support
-
haskelujah-typing
Kind inference, type inference, and exhaustiveness checking for the Haskelujah compiler
-
xccute
type safe declarative builders for shell commands in rust
-
accessorise
Add accessors to your struct and trait implementations
-
komadori
composable, declarative way to consume an iterator
-
spade-diagnostics
Helper crate for https://spade-lang.org/
-
optics
A no_std-compatible optics library providing composable lenses, prisms, isomorphisms, and fallible isomorphisms
-
convi
Convenient (but safe) conversion (
From-like) traits -
linux-errnos
A list of error numbers
-
persisted
Persist arbitrary program state quickly and easily
-
ruby-types
📦 Ruby value and error types for Rusty Ruby
-
delegation
Macro-based delegation for enums and structs
-
emixcollections
Collection utilities including generic range types with iteration, clamping, and overlap detection
-
u16cstr
A macro for creating c-style u16 wide strings at compile time
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
kti_cqrs_provider_rs
CQRS provider with ioc container
-
noprocess
A lightweight Rust library for managing long-running processes with graceful shutdown, restart capabilities, and error handling
-
ferrous-di
Type-safe, performant dependency injection for Rust, inspired by Microsoft.Extensions.DependencyInjection
-
binoc-sdk
Plugin SDK and ABI for Binoc dataset-diff plugins
-
derive_hash_fast
A faster replacement for
#[derive(Hash)]for types without padding -
universal-time
Cross-platform time primitives with compile-time guarantees — no runtime panics!
-
nvec
N-vectors and N-strings
-
errors
std::error::Error utilities
-
topo-core
Domain types, traits, and error types for Topo
-
indigauge-core
Core primitives for the Indigauge Rust SDK: event macros, tracing layer, and helpers
-
init_static
explicit static initialization
-
quad-url
Plugin for macro-, mini-quad (quads) to do anything with url
-
gen_ops
Macros for operator overloading for generic types
-
error-enum
Provide a easy way to define an enum that represents errors with error codes, document comments and several other functionalities
-
tracerr
Custom compile-time captured error tracing
-
luminos-container
Luminos Container
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
enumeration
An extension to rust enum
-
nlib
Nate's library. Various things or macro patterns I use to aid in more succint Rust programming.
-
ros_msgs_include
Build script macro for including ROS 2 message types generated by rosidl_generator_rs via the AMENT_PREFIX_PATH
-
lithium
Lightweight exceptions
-
philiprehberger-guard-clause
Early-return guard clause macros for cleaner control flow
-
facet-error
thiserror replacement powered by facet - derive Error trait from doc comments
-
roboticus-pipeline
Unified pipeline orchestrator — all business logic flows through here
-
mau
procedural macro library for memoization with MauQueue optimization
-
fastboop-core
Core profile matching and boot orchestration primitives for fastboop
-
generic-upper-bound
Stable workaround for internal uses of generic-const-exprs
-
binread
helping read structs from binary data using ✨macro magic✨
-
philiprehberger-result-ext
Extension traits for Result and Option with tap, map, and error accumulation
-
changeset-saga
Saga pattern for atomic multi-step operations
-
vsprintf
Rust bindings to the libc vsprintf function
-
arcbox-error
Common error types for ArcBox
-
chainerror
Make chaining errors easy
-
elain
Set a type's minimum alignment with const generics
-
traversable
Visitor Pattern over Traversable data structures
-
typed_tuple
Type-safe access, isolation and mutation of primitive tuple segments and elements
-
oofs
Error handling library that generates and injects context for you
-
type-state-builder
Type-state builder pattern derive macro with compile-time safety and enhanced ergonomics
-
optional-numeric-index
Traits and macros for creating compact optional numeric indices
-
never
A stable version of the unstable never type (!)
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
batched
rust macro util for batching expensive operations
-
static-conduit
A type-safe, zero-cost recursive pipeline engine for data transformation
-
ltk_primitives
Primitive types and helpers for League Toolkit
-
deltoid
calculate and apply deltas to structs and enums
-
beetle-nonzero
Combines the std
NonZerostructs into one struct -
dyngo
Type-safe dynamic (type-erased) generic outparams
-
haste-fhir-operation-error
Haste Health FHIR operation error handling
-
duplicate_macrotest
Fork of the macrotest crate specifically to test the duplicate crate
-
autonomic-core
Core types, traits, and errors for the Autonomic homeostasis controller
-
cell_wrappers
set of macros for ergonomically working with TCells and TLCells from the qcell crate
-
svi
A function to interpolate variables in a hashmap into a format string
-
rkyv_codec
Some adaptors to stream rkyv Archives over AsyncRead and AsyncWrite
-
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
-
medi-rs
mediator library for Rust
-
bitflag
A macro to generate bitflags structures from C-like enums
-
specmc-protocol
parsing Minecraft protocol specification
-
advanced-pid
An advanced PID control library implemented in Rust
-
easy_node
Smart pointer for graph nodes
-
zerust
Zero-cost Zinx for Rust
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
sync_select
A short-circuiting
std::thread::scope -
ijzer
Main crate for IJzer. Provides a macro for using IJzer in a rust project, and a prelude with dependencies..
-
nanokit
A collection of tiny, reusable utility methods that reduce code size and improve performance
-
ersa_lsp_core
LSP core for the GPC Scripting language. Intended to be used as a library.
-
syllogism
allow for some specialization using stable Rust
-
wiremock-grpc
Mock gRPC server to test your outgoing gRPC requests
-
to-query-params
A procedural macro and trait for easy use of arbitrary structs as query parameters in Hyper
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
card-stack
The Stack for card games
-
cloneable_errors
similar to anyhow, that allows the errors to be cloned, shared, cached and even sent over the network
-
biosyn
Mad Science Crate for working with
syn -
nonany
Integer types with customizable niche values
-
reborrow-generic
Generalized reborrowing traits and an optional derive macro
-
compare_variables
procedural macro for comparing the ordering of variables and creating useful error messages
-
corsa_bind_core
Shared errors, process lifecycle helpers, and fast-path primitives for corsa-bind
-
erio-workflow
DAG workflow engine for Erio
-
autowrap
Ergonomic smart pointer and interior mutability extensions
-
gostd_builtin
Package builtin binds the basic type in go through the type alias, and implements the basic type cast macro function.builtin 包通过类型别名绑定Go中的基础类型，并实现了基础类型强制转换宏函数…
-
flat_error
Error wrapper to ensure Clone, Debug, and PartialEq
-
context_error
create rich errors to help users understand what the error was and how to fix it
-
raws-error
RAWS common error type
-
beekeeper
A full-featured worker pool library for parallelizing tasks
-
avila-error
AVL Platform error handling - replacement for anyhow/thiserror
-
cranelift-assembler-x64
A Cranelift-specific x64 assembler
-
oors
Adding cross-crate inheritance features to Rust structs
-
ai-quick-error
A no_std fork of quick-error
-
defaulted
Trait and derive macro for testing whether a value equals its default state, with per-field customization and optional serde integration
-
structz
Anonymous struct implementation in rust
-
quickfig
Replace boilerplate in apps that read from user configuration files
-
mono-changeset
Mono repository changeset utilities
-
fromenv
Derive-based, type-safe configuration from environment variables
-
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
-
pleme-error
Unified error handling library for Pleme platform
-
fast-uuid-v7
A high-performance Rust library for generating UUID v7 compatible identifiers
-
arrays
Construct an array from an iterator
-
mode
A behavioral state machine library written in 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…
-
devela_base_core
base shared functionality for devela
-
bhc-arena
Arena allocators for efficient compiler data structure allocation
-
display-more
helper to display various types
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
embed_it_utils
The utils for [
embed_it] -
aerosol
dependency injection for Rust
-
unwrap-enum
generate methods to access enum variants
-
cee-scape
access to
setjmpandsigsetjmpfunctionality -
brk_traversable
Traits for Vecs structs throughout BRK
-
loose_enum
A macro for defining loose repr enums
-
utilities_rs
A small library of Rust utilities
-
spade-codespan-reporting
Beautiful diagnostic reporting for text-based programming languages
-
zerror
error interface for context-aware error-reporting
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
aprox_eq
determining aproximate equality between floating point types and deriving this capability to structs comprised of floating point numbers and other implementers of
AproxEq -
error-accumulator
easier for developers to write input validation
-
tray-controls
An enhanced menu management tool designed for the tray-icon library
-
dynamodel
derive macro to implement conversions between your object and
HashMap<String, AttributeValue> -
function-compose
function composition library for rust
-
errorstack
A derive-based typed error system with first-class error stack building
-
galaxy_save_core
Defining common types and traits used in the save data of Super Mario Galaxy and Super Mario Galaxy 2
-
rs-bean
A lightweight Rust library for bean management
-
codama-nodes
Node specifications and helpers for the Codama standard
-
error-combinator
Type-driven error composition with functional combinators
-
fyi_ansi
Compile-time ANSI formatting macros for FYI
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
parenv
Environment variable parser with a clap style derive macro and elm style error reporting
-
ps-uuid
An opinionated UUID implementation
-
cmporder
macros for prioritized Ord/PartialOrd
-
partial_derive2
makes all the properties of a struct type an optional property
-
enum_dict
Efficient enum-indexed dictionaries
-
inew
Macros for constructor generation
-
reda-lef
Lef file library
-
hamon
A zero-cost, type-level static decorator and pipeline builder
-
skg-effects-core
Core effect execution traits and errors
-
ffi_helpers
help make working with FFI easier
-
panicking
std::thread::panickinganalog available in theno_stdcontext -
sbe_gen
Binary Encoding (SBE) code generator for Rust using zerocopy
-
psl-types
Common types for the public suffix implementation crates
-
niloecl
axum handler pattern for twilight interactions
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
borrowme
The missing compound borrowing for Rust
-
arm64jit
Spec-driven AArch64 JIT assembler for Rust
-
erreur
A tiny crate that facilitates error handling, including tracing line numbers, customizing and propagating error messages
-
re_string_interner
string interning library
-
seekable-iterator
Traits for iterators and lending iterators with seeking capabilities
-
hcp
running and subprocess and pinging healthchecks.io with result
-
dkg
Distributed key generation over ff/group
-
kmod-tools
Reexported tools for working with kmod macros
-
crispii_errors
CrispiiError enum to be returned by any failing crispii functions
-
store_by_enum
Type-safe data stores addressed and accessed using enums (in any order)
-
axum-typed-routing
Typed routing macros for axum
-
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
-
as_repr
Rust trait for constant
#[repr(T)]conversions -
llm_xml_caster
An XML caster for LLM structured output in Rust
-
easy-ssh
A user-friendly SSH client wrapper for Rust, designed with a focus on ergonomics and safety
-
unchecked-std
Fast, unchecked variants of common std methods
-
derive-defs
generating derive preset macros from TOML configuration
-
easy-error
error utilities
-
globals
Painless global variables in Rust
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
einstellung
Configuration Parser
-
dizzy
Macros for safely interacting with DST newtypes
-
anony
Anonymous struct
-
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… -
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
lateinit
Unsafe late-initialization for statics
-
poise_error
An opinionated plug-and-play library for error handling in Discord bots made with poise
-
aspect-std
Standard aspects library for aspect-rs AOP framework
-
fray
A type-safe and ergonomic Rust library for working with bitfields
-
capsec-std
Capability-gated wrappers around std::fs, std::net, std::env, and std::process
-
cbsk_mut_data
ref mut tool
-
moxy
A set of helpful macros for day to day quality of life tasks
-
env-flags
A convenience macro for declaring environment variables
-
handle_trait
A trait for types that represent handles to shared resources
-
resultats
A result facility to handle multiple errors
-
karpal-verify
External prover bridge and trust model for the Industrial Algebra ecosystem
-
jkcenum
Rust enum library
-
masterror-template
Template utilities for masterror and its derive macros
-
xopsy
Structural pattern matching DSL for JSON. Perform declarative diagnostics and surgical in-place updates on dynamic data.
-
cudd-sys
Bindings for CU Decision Diagram library (CUDD)
-
bytestream
convenient way of writing binary data to a buffer
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
cdumay_error
define standard errors
-
iterator-sorted
Stable functions for checking iterator sorting
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
ouroboros_examples
Examples for the ouroboros crate
-
cgp-error
Context-generic programming error components
-
applying
Apply functions in method-position
-
as-is
An abstraction over ownership
-
elicit
SmartPointer-like structure for polymorphism
-
unwinder
Call stack spoofing for Rust
-
repr-discriminant
Trait to retrieve the discriminant of an enum variant with a repr(T) at runtime
-
typed_use_cases
Formalize use cases at the type level. Zero runtime overhead. Experimental proof-of-concept.
-
optfield
A macro that generates structs with optional fields
-
derive_destructure2
Destructure structs that implement Drop
-
shufti-matcher
shufti table based string matcher
-
funty
Trait generalization over the primitive types
-
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
-
dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
bulks
Amazing bulks! They are like iterators, but in bulk, and therefore support collection into arrays
-
ristretto_intrinsics
Intrinsic methods for the Ristretto JVM
-
thread_local_scope
Scoped access to thread local storage
-
backtrace-error
wrap errors with automatic backtrace capture and print-on-result-unwrap
-
steepen
Create multiple iterators from a single iterator by separating elements
-
plain_hasher
Hasher for 32-byte keys
-
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…
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
failed-result
A small crate for converting various failed value to result with corresponding error type
-
bubble
Enterprise-level development framework
-
sqlx-error
A wrapper around
sqlx::Errorto provide error path and additional context -
wordnet-types
Shared types and part-of-speech enums for WordNet data
-
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
-
bhc-span
Source location tracking and span management for BHC
-
retry-policy
Retry Policy
-
cjc-hir
High-level intermediate representation for CJC
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
structx
Simulating anonymous struct and named arguments in Rust
-
traitclaw-rag
RAG pipeline for TraitClaw — Retriever trait, grounding strategies, and BM25 keyword search
-
lox-test-utils
Testing utilities for the Lox ecosystem
-
rayon-join
macro to call join from rayon with more than 2 arguments
-
ubits
Bit fields and masks
-
wd_log
A practical log crate for rust
-
parlov-analysis
Analysis engine trait and signal detection for parlov
-
concat-with
Extend the function of the
concat!macro instd -
kozan-primitives
Foundational types for the Kozan UI platform: geometry, color, units
-
deaf
parsing and modifying ELF binaries
-
collect-with
enhanced collection operations with capacity control
-
s3-bucket
wrapper around aws-sdk-s3
-
mownstr
Maybe Owned String
-
merge2
Merge structs into single by values
-
result-transformer
Traits, macros and utilities for transforming Result values
-
isotopes
Variants of common types for enforcing invariance
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
swamp-script-derive-tests
tests for swamp macro
-
typeables
type aliases. By SixArm.com.
-
ottavino-gc-arena
safe, incrementally garbage collected arenas (updated fork of gc-arena)
-
witnessed
Type-level witness wrapper for carrying validated invariants
-
ra-ap-rustc_lexer
Automatically published version of the package
rustc_lexerin the rust-lang/rust repository from commit ec2d669db8e5ca2cb1604c69a831ef244ebd9aa9 The publishing script for this crate lives at:… -
non-empty-slice
Non-empty slices
-
small_type_id
generation constant 32 bit nonzero unique identifiers for types
-
more-convert
adds macros for various conversions
-
chillpill
A more powerful (and more restrictive)
std::panic::catch_unwind -
conv2
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
menv
Pulling in arguments from environment variables
-
alloy-storage
Shared async BlobStore trait and wire types for the portfolio storage contract
-
mers_lib
mers language in other projects
-
deep_causality_haft
HKT traits for for the deep_causality crate
-
axum-error-handler
error handler for axum
-
deterministic_default_hasher
A deterministic initialisation of the stdlib default hasher
-
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
-
shards
rust bindings and utility in order to use shards
-
hexkit
Lightweight boundary traits for hexagonal architecture in Rust
-
blf_lib-derivable
Shared traits used by blf_lib and blf_lib-derive
-
chemrust-core
The core modules defining the flow and structs of data in computational chemistry routines
-
yzy-prom
A macro crate for defining prometheus metrics
-
arr_ty
Macros for smart array initialization
-
downcast
Trait for downcasting trait objects back to their original types
-
stackaroo
Swap out of the OS-provided stack
-
pack1
Byte array newtypes for different primitive types
-
mayber
A zero-cost enum for handling either references or owned values with a unified interface
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
action_dispatch
通用的基于属性宏的 Action 注册与分发系统，支持正则匹配、优先级、全局同步执行模式
-
nu-std
The standard library of Nushell
-
bon-cli
Dev tool for working with the
boncrate -
reinhardt-di
Dependency injection system for Reinhardt, inspired by FastAPI
-
fabryk-auth
Generic auth primitives for Fabryk — AuthenticatedUser, TokenValidator trait, Tower middleware
-
update-available
check for updates of a crate on crates.io, GitHub or Gitea
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
subplotlib
functions and types for
subplot codegengenerated Rust based test suites. Relies onsubplotlib-derivefor associated macros. -
undoredo
Undo-redo for Rust using deltas, snapshots, or commands
-
xwt-erased
Type-erased wrappers for the
xwt-dyntraits -
enum_discriminant
Procedural macro to add functions on enum types to get discrimnant value from variant or create unit variant from discriminant value
-
gc_plugin_abi
Gridcore Plugin API
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
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
-
asm_block
Translate tokens to string for Rust inline assembly
-
candied
that provides macros to reduce code size and adds syntactic sugar
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
rust-box
odd set of tools for Rust programming
-
refineable-gpui-unofficial
A macro for creating 'refinement' types that can be used to partially initialize or mutate a complex struct
-
macron-collections
Creates a new instance of std collections: HashMap, HashSet, BTreeMap, BTreeSet, VecDeque, LinkedList and BinaryHeap
-
satellite-base
Core types and utilities for Satellite SAT solver
-
tauri-plugin-keygen-rs2
Tauri plugin for Keygen.sh licensing, based on keygen-rs
-
scheduled-task
对tokio-cron-scheduler库的增强
-
flowrs-core
Core components of the flowrs framework for directed graph workflows
-
from_variants
Rust macro to automatically generate conversions for newtype enums
-
pared
Projected reference counted pointers
-
try-specialize
Zero-cost specialization in generic context on stable Rust
-
lisette-emit
Little language inspired by Rust that compiles to Go
-
empty-fallback-chain
Iterator adaptor like chain, but conditional on empty first iterator
-
separator
Formats numbers into strings with thousands separators for readability
-
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
-
shannon-nu-std
The standard library of Nushell
-
const-destructure
Destructuring in const contexts on stable Rust
-
ezinit
Initialize structs with a generated new() function based on modifiable rules
-
collate
Traits and a data structure to support collation and bisection
-
optifier
Rust macros for deriving optional types
-
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)
-
anymore
AnyDebug: Dynamically typed values which can be inspected
-
deploy-temp-fringe
safe, lightweight userland context switches
-
ruru
Native Ruby extensions in Rust
-
qubit-common
Foundational utilities and language-level tools for Rust application development
-
with_drop
Nostd wrapper for using a closure as a custom drop function
-
open-feature-env-var
Environment Variable provider for OpenFeature
-
bias-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
pleme-providers
Multi-provider integration library for Pleme platform - generic trait abstraction and registry
-
field_path
Type-safe, no-std field access and reflection utilities
-
tee_output
'tee' functionality for the current process
-
msica
Windows Installer Custom Actions
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
fieldwork-borrow
Field-level borrow splitting for Rust
-
sge_math
Macro functionality for SGE
-
mdnt-groups-support
Support traits for the
picus::groupmacro -
panproto-theory-dsl
Declarative theory DSL for panproto with Nickel, JSON, and YAML support
-
nameof
macro to determine the string name of a binding, type, const, or function
-
or-panic
unwrap or panic
-
leptos-floating
Floating UI primitives for Leptos
-
v8_derive
Derive macros and helpers for Rusty v8
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
ltk_meta
Metadata formats and utilities for League Toolkit
-
rebounded
Bounded types
-
poly_it
A no-std library for manipulating polynomials with slice support and minimal allocation
-
onechatsocial-result
Revolt Backend: Result and Error types
-
json-crawler
Wrapper for serde_json that provides nicer errors when crawling through large json files
-
instability-example
Example crate demonstrating instablity usage
-
unpaid-intern
A convenient little string interner
-
itemize
Traits for flattening heterogeneous, nested inputs into a single iterator
-
eventcore-types
Shared vocabulary types and traits for EventCore event sourcing library
-
thiserrorctx
A wrapper around thiserror, giving you the ability to add context
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
egui_struct
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
eoe
exiting processes on errors gracefully
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
sqlxgentools_misc
Various data types and traits to use in a sqlxgentools-enabled codebase
-
thiserror-nostd-notrait
derive(Error)
-
bitrange
plugin to map bits in integer values to fields
-
drasi-ffi-primitives
Core FFI-safe types and vtable generation macros for the Drasi plugin boundary
-
itern
enumtypes for choosing between N differentIteratortypes in a single type -
typed-arrow-dyn
Dynamic Arrow facade for typed-arrow (runtime schema/builders)
-
custom-format
Custom formatting for Rust
-
abstract-impl
Create abstract implementations for traits
-
field-kinds
Derive macro for compile-time struct field type introspection
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
cronus_parser
The DSL parser for cronus API spec
-
oco_ref
A smart pointer for storing immutable values with relatively-cheap cloning. (Like a
Cowmeets anRc!) -
graphql-starter
GraphQL starter kit
-
c2pa-c-ffi
C language FFI base for c2pa crate to create bindings
-
try_create
A small library providing generic traits for fallible and infallible object creation
-
translatable
A robust internationalization solution for Rust featuring compile-time validation, ISO 639-1 compliance, and TOML-based translation management
-
const-tools
help write safe const fns such as destructuring and array operations
-
lwxm
lightweight extensible macros (universal macros for every language)
-
helper
provided some useful proc macros for Rust
-
isr-macros
Macros for ISR
-
ptr-arrow
A macro to emulate C-style arrow syntax
-
rumbok
Lombok-like derive macros (Getter, Setter, Data) for Rust
-
graphile_worker_ctx
Worker Context package for graphile_worker, a high performance Rust/PostgreSQL job queue
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
opentalk-types-signaling-timer
Signaling types the OpenTalk timer module
-
enum_default_generator
Codegen tool to generate Default trait impls for Gateway API enums
-
luau-parser
A blazingly fast Luau parser with robust error recovery
-
depends
Ergonomic, performant, incremental computation between arbitrary types
-
rust-code-analysis-web
Run a web service to compute and export code metrics
-
pinkie
(Almost) compile-time scoped CSS-in-Rust
-
fieldx_plus
Design patterns built on top of fieldx crate
-
tentacli-traits
Traits and types for tentacli and related projects
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
luhproc
A lightweight background process manager
-
zerortt-api
Primitive types and traits for zerortt
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
simple_impl
macros to make impls ergonomic, dense, and manageable
-
orceh
Easier plugin interfaces
-
enum_cycling
Small macro for working with enums
-
txrc_macros
macros
-
truc_runtime
Rust code generator for safe, fixed size, evolving records - runtime
-
gull
type generation
-
hierr
RUST Error
-
deverr
Opinionated error handling for developers
-
error-stack-macros2
Community-made procedural macros for error-stack
-
zeph-context
Context budget, manager, compaction strategy, and assembler for the Zeph agent
-
cooked-waker
A safe interface for creating async Wakers
-
calc_lib
calculating things with correct order of operations
-
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…
-
alef-backend-rustler
Elixir (Rustler) backend for alef
-
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
precept
A testing utility for fuzzing and fault injection to discover erroneous and interesting states
-
swift-rs-hatter-fork
Call Swift from Rust with ease!
-
fundle
Compile-time safe dependency injection for Rust
-
enum-typer
Type-indexed enums and GADTs for Rust via procedural macros
-
include-first
Proc macro to evaluate include_str! macros early
-
tc-error
TinyChain's generic error struct
-
rose-nockchain-types
Nockchain types for Rose wallet
-
rs_coroutine_core
Composable coroutine utilities and flow abstractions built on top of Rust's async ecosystem
-
nanocl_error
Nanocl error types
-
fcommon
Common library for the fiddlesticks agent harness framework
-
fluxo-typestate
Zero-cost type-state pattern via procedural macros
-
linspace
Turns a range into a linearly spaced sequence of values
-
rooting-forms
Generates HTML (rooting) forms from structures
-
signo
A human-readable, compile-time access descriptor that encodes ownership, shared borrowing, and exclusive borrowing as types
-
crashlog
Panic handling for humans
-
kindest
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
pavex_miette
A custom Miette theme for Pavex CLI errors
-
enum-derived
Generate random instances of your enums and structs
-
rtlola-reporting
An error reporting crate for RTLola-related crates
-
cppstreams
C++ streams in rust
-
lcdm
High-performance ΛCDM Cosmology Engine (Facade)
-
autoerr
Very opinionated helper to declare error types
-
rx_core_operator_error_boundary
error boundary operator for rx_core. ensures at the type level that no errors are coming from upstream.
-
raz-common
Common utilities and shared types for the raz project
-
kv-derive
Derive struct conversions from and to key-value vectors
-
state-shift
Macros for implementing Type-State-Pattern on your structs and methods
-
str_array
Fixed-size
strandCStrtypes backed by an array -
thisctx
Easily create error with contexts
-
extend_mut
extending exclusive references
-
or-die
deterrent methods for unwrapping a value from Options and Results with better parametrization
-
error-graph
Allows non-fatal errors in a tree of subfunctions to easily be collected by a caller
-
binmarshal
Pack and unpack structs and enums into and out of binary data streams
-
oneline-eyre
A fork of
simple-eyrewhich outputs errors on a single line -
unarray
working with uninitialized arrays
-
cock-lib
Measure the power level of a peen
-
basic-oop
OOP for Rust
-
illumos-nvpair
Idiomatic Rust bindings for illumos libnvpair
-
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
structupdate
defining complex updatable datastructures
-
unwrap_unreachable
Option::unreachable()andResult::unreachable()methods -
dioxus-keys
An unified DataKey interface coupled with a few helper macros to help you make global keys
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
merge-hashmap
Merge multiple values into one
-
filecaster
Procedural macro to derive configuration from files, with optional merging capabilities
-
langlang_value
langlang is a parser generator based on Parsing Expression Grammars (library)
-
cdumay_error_json
JSON error
-
nounwind
A attribute macro to prevent panics from unwinding, similar to C++ noexcept
-
iterstats
Statistics for rust iterators
-
bhc-diagnostics
Error reporting and diagnostics for BHC
-
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. -
fastn-resolved
fastn: Full-stack Web Development Made Easy
-
backtrace-ext
minor conveniences on top of the backtrace crate
-
try-partialord
Safe failable sort, min, max, binary_search functions for PartialOrd. No need to wrap f32, f64 to sort any more.
-
auto_ops_det
Macros for easy operator overloading
-
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
ser_mapper
Mapped DTO serialzation wrapper for DBO/Model
-
yoshi
Entry for the Yoshi error framework
-
toobad
intuitive error handling library
-
update_cell
A Cell<Option<T>> that you can update
-
tuple_list
macro-free variadic tuple metaprogramming
-
re_tuid
128-bit Time-based Unique Identifier
-
stilltypes
Domain-specific refined types for the Rust and Stillwater ecosystem
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
guard-clause
Syntactic sugar for writing simple guard clauses
-
rediff
Diff and compare Facet values with detailed structural difference reporting
-
typederror
A wrapper around anyhow that allows for a primary error type
-
io-streams
Unbuffered and unlocked I/O streams
-
macro-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
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…
-
unit-ext
Fluent helpers for returning common wrapper values from the unit type
-
nous-core
Core types, traits, and errors for the Nous metacognitive evaluation module
-
hax-rust-engine
The engine of the hax toolchain
-
identity-diff
Difftrait to compute and merge data structure differences -
crier
but flexible observer library
-
evident
Pub/Sub library using IDs to identify events
-
singlemap
rust single map a macro
-
macro-attr
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
ux2
Non-standard integer types like
u7,u9,u10,u63,i7,i9etc -
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
once_cell_no_std
Sync single assignment cells for
no_std -
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
wayle-core
Core reactive primitives and D-Bus utilities for Wayle services
-
u160
Unsigned Integer 160 bits
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
snapshot-testing
Assert that strings equal easily updatable snapshot files. Show nice colored diffs if not.
-
mig-types
Generated MIG-tree types for EDIFACT messages — shared segments, composites, enums, and PID-specific compositions
-
mac
A collection of great and ubiqutitous macros
-
bytify
macro that can write given const-expr values into a continuous byte array
-
ferrunix
A lightweight run-time dependency injection framework for Rust
-
fastpeek
A different way to peek iterators
-
parametric
providing the trait and a derive macro to bridge complex, hierarchical data structures with optimization algorithms that use flat parameter vectors
-
rst-common
A shortcut to common Rust crates
-
capture-it
Modern c++-ish capture syntax for rust
-
mall-portrait-common
Common utilities and types for mall portrait projects
-
regex-macro
A macro to generate a lazy regex expression
-
arid
An ergonomic object-model for Rust
-
prange2
Parse numeric ranges for indexing
-
elixirgen
Elixir generator
-
error-iter
Error::sources on stable Rust
-
hetero-cartesian
A procedural macro to flatten nested heterogeneous callback-based control flows into a clean cartesian product
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
moro-local
Experimental structured concurrency support for async Rust (similar to trio's nurseries). Works with non-Send futures on stable Rust.
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
synapse-dsl
DSL parser for Synapse memory configuration language (.mnm)
-
crony
cron runner that spawns another thread to run your cron jobs
-
poison-guard
maintaining sane state in the presence of panics and failures
-
parsable
A trait to easily parse data structures
-
tagged-vec
A Vec which can be indexed by one specific type
-
named-tup
Create named tuples using the tup!() macro
-
swap-pool
Allow objects to be stored either in RAM or on disk
-
xtk-macros
xtk macros
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
injection
A lightweight dependency injection container for Rust applications
-
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.
-
filters
Build filters/predicates with the builder pattern
-
frut_std
Standard library for the Frut language
-
tagset
Easily create trait-dispatching sum types
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
amble_data
Shared data model used by amble_engine and amble_script for the Amble game engine
-
singleton-manager
A programatical singleton manager
-
puniyu_library
puniyu 的共享动态库模块
-
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)
-
fourcc-rs
Types and macros for working with Four-Chracter Codes (fourcc)
-
typewriter-plugin-ruby
Ruby (Sorbet) emitter plugin for typewriter
-
occupied
A type-safe way to interact with removing from and inserting into options
-
order_theory
Traits which describe basic concepts from order theory
-
prefix-stmts
Macro to prefix several statements with the given tokens
-
tokmd-analysis-archetype
Project archetype inference for analysis receipts
-
nzliteral
Macro simplifying use of NonZero literals
-
prost-dto
Data transfer object conversion macros for prost
-
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)
-
exempi2
Safe Rust bindings to Exempi 2.4
-
ploidy-pointer
JSON Pointers for strongly-typed data structures
-
placid
Separated ownership and in-place construction in Rust
-
xiaoyong-value
Collection of sharing state primitives for async contexts (both Sync and !Sync)
-
nuhound
Improve error handling capability
-
macro-toolset
Some useful macros
-
progress-streams
Progress callbacks for types which implement Read/Write
-
sod
Service Oriented Design
-
get_set_macro
Procedural macro to generate customizable getters and setters in Rust
-
infinite-stream
Streams (asynchronous iterators) that always keep yielding items (or panic, or become pending forever)
-
pbni-rs
PBNI for Rust
-
lstring
Key String: optimized for map keys
-
radicle-git-ref-format
Radicle re-exports and macros for
git-ref-format-core -
kurtbuilds_std_ext
Standard library extensions
-
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. -
itertools-num
Numerical iterator tools. Extra iterators and iterator methods and functions.
-
faultline
A typed error library for services and control planes that separates domain failures, transient faults, and invariant violations
-
ps-util
aims to provide generally helpful utility functions and traits
-
histo
histograms with configurable buckets
-
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
-
pathbuf
A macro to conveniently build PathBufs
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
cortex-ai
An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling
-
maybe-uninit
MaybeUninit for friends of backwards compatibility
-
const_str_slice_concat
const concatenation of string slices
-
hexga_generational
GenVec, ideal for MAS (Multi-Agent System), where each agent can be removed at any time and has references to other agents
-
control-flow
A hack to control control-flow outside closures
-
qm-utils
functions and macros
-
sigma-enum
A macro to simulate sigma types with enums
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
quickvariant
C++-style variant library
-
mapcomp
Python-like list comprehensions for standard containers
-
simple_generators
making work with generators simpler
-
genius-invokation
Abstractions and structures for Genius Invokation TCG
-
regexpr
Regular expresions
-
swamp-vm-isa
isa types for the Swamp VM
-
untrusted_value
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
elor
Base generic implementation of an Either type
-
gistyr-lib
small tools and helpers
-
linreg
Calculates linear regresssions of two-dimensional data. Does not use stdlib, only depends on numeric traits.
-
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
-
ptxr
unifies *const/*mut pointers using the trait system
-
re_error
Helpers for handling errors
-
known-types-github
Well-known types for GitHub APIs
-
capsec
Compile-time capability-based security for Rust
-
metrique-aggregation
working with unit of work metrics - aggregation
-
rc-borrow
Borrowed forms of Rc and Arc
-
typeslot
Statically assigned slot indices for types, grouped by a marker type
-
fallible-option
Fallible is an Option with inverted Try-semantics
-
matrix-slice
Safe abstractions for two-dimensional slices
-
generativity
Generation of unique invariant lifetimes
-
cron-job
A cronjob implementation using the cron scheduler
-
malphas
Model orchestration and routing layer - The Builder constructs order from chaos
-
any_cmp
Support dynamic type comparisons
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
libobs-window-helper
list of windows that can be captured by OBS
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
finum
A numeric type of variable length (20 decimal digits)
-
edsm-dumps-model
Data models for EDSM dump data
-
implementation
The implementation crate
-
coil-seo
SEO primitives for the Coil framework
-
append-only-bytes
Shareable append-only bytes
-
openrunner-rs
running OpenScript
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
tryphon
Type-safe configuration loading from environment variables using derive macros
-
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… -
olis_string
Small-string optimization for Rust, aims to replace std::string::String
-
stateset-ffi
C-ABI stable FFI surface for stateset-embedded — powers Python, Swift, Kotlin, Go, and C bindings
-
rustc_errors
Reuse rustc_errors for compiler_base
-
dfo
Differentiable Floating-point Operations in Rust
-
macro_lisp
Lisp-like DSL for Rust language
-
fused_error
working with composable errors
-
gur
A undo-redo framework
-
gel-errors
Error types for Gel database client. Formerly published as gel-errors
-
warp-types-builder
Build-time PTX compilation for warp-types GPU kernels
-
teo-parser
Parser for Teo schema language
-
wartcl
A minimal embeddable Tcl-like language
-
stringleton
Extremely fast string interning library
-
wayle-traits
Shared traits for Wayle service monitoring and lifecycle
-
borrowck_sacrifices
Necessary sacrifices to keep the Borrow Checker happy and developers sane
-
quark
Types for manipulating numeric primitives at the bit level
-
release_tina
demo
-
ndrange
N-dimensional range iterator
-
option-ext
Extends
Optionwith additional operations -
ratatui_router
Page-based router with auto-generated routing for ratatui
-
cmp
convenience macros and function for comparing
-
wcl_lsp
WCL Language Server Protocol implementation
-
bounded-registers
A high-assurance memory-mapped register interaction library
-
lucidity
A distributed orchestrator platform for Rust
-
from_form
From forms to your structs
-
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
-
scopes-rs
Strongly typed scoped authorization library
-
runestr
User-perceived characters related types and data structures
-
std-traits
Traits for types in the standard library
-
supertrait
enables default associated types and const fn trait items in stable Rust
-
slip-10
SLIP10 implementation in Rust
-
cmake-parser
parse cmake language
-
defew
A new() derive macro for structs
-
deptypes
Dependent types
-
soapy
Structure-of-arrays derive macro
-
char-device
Character Device I/O
-
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.
-
anima-core
Soul, Identity, Belief, and Self primitives for the Life Agent OS
-
optionally_const
Optional constness on stable Rust
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
brk_rolldown_plugin_vite_css_post
Rolldown plugin for Vite CSS post-processing
-
ocl-macros
Macros for easier/faster working with the ocl crate
-
cfgenius
Conditional compilation with macro support in Rust
-
struct-metadata
Macros for attaching metadata to structs
-
enum-ptr
Ergonomic tagged pointer
-
arri_common
Common types and utilities shared across Arri crates
-
intertrait
Allow for inter-trait casting
-
sw-errors
error parsing and pretty-printing, used across the swtools toolset
-
dirty-fsm
A quick and dirty state machine library
-
mangle-interpreter
Pure Rust interpreter for Mangle IR
-
rokc_parser
parse a Kconfig file into a rowan CST
-
rialo-sol-lang-idl
Sol framework IDL
-
bigerror-error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
ffi_trait
FFI-safe trait vtables
-
rootcause-backtrace
Backtraces support for the rootcause error reporting library
-
compose_core
The Compose Language implementation
-
api-guidelines
Rust API guidelines enums and utilities for code quality and best practices
-
erio-core
Core types, traits, and error handling for the Erio agent runtime
-
rsutil
rsutilis a Rust library providing common utilities -
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
xuyingjie_hello_macro
test for publish xuyingjie_hello_macro
-
market
Infrastructure for producers and consumers
-
stock-symbol
A data type for representing stock symbols
-
annotate-build
Build-script support for generating annotate environments
-
extended-primitives
providing primitive-like types for use
-
indexed-struct
A derive macro for creating indexed data structure with efficient query capabilities
-
kubetsu
distinguish value type of other struct
-
accio_rs
macros for sync and async runtime
-
gramex
common language for advance parsers
-
roopert
object-oriented toolkit for Rust
-
alef-backend-php
PHP (ext-php-rs) backend for alef
-
moveit2
safe, in-place construction of Rust (and C++!) objects
-
named-block
Macro implementing early-exit-from-any-block
-
episode-renamer
Rename episode files from one naming pattern to another, using a TSV with mappings
-
k-combinations
Efficient iterator over k-element combinations of a slice
-
hash_ord
lib contains OrdMap(avl tree) and HashMap(use avl to resolve collision);
-
monarch_core
Core functionality for the Monarch library
-
enclose2
A convenient macro, for cloning values into a closure
-
physical-quantity
dimension and unit system for general physical physical quantities
-
dyn-eq
Test equality between trait objects
-
nuts-storable
Traits for serializing and deserializing NUTS models and states in nuts-rs
-
vcell
Cellwith volatile read / write operations -
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
quick-error
A macro which makes error types pleasant to write
-
measures
A unit-of-measure and electrical calculations library
-
anon_enum
Enum types with fully-generic variants
-
subsecond-types
Types crate for the Subsecond hotpatch engine
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
jcers
jce in rust
-
enumizer
macros for generating enums that are equivalent and convertible to standard library enums
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
valobj
defining value objects using procedural macros
-
result-transformer-flow
Traits, macros and utilities for transforming Result values
-
ffd
Fast Function Dispatch: Improving the performance of Rust's dynamic function calls
-
naan
A fast, easy, and tasty functional programming prelude
-
delegate-match
Proc-macro for delegation of grouped match arms
-
swap_crate
swap function crate
-
enum_index
Trait and macros for extracting Enum variant index
-
cobia
CAPE-OPEN COBIA binding interface library for rust
-
rust-extra
-
proc-easy
Macros to make writing proc-macro crates easy
-
dyn-ptr
A box that stores types like pointers, forgetting everything besides
Self: Unsize<dyn Trait> -
ranim-anims
The built-in animations of Ranim
-
rustidy-util
Rustidy formatter
-
parsy
efficient parser combinators library
-
data-classes
Abbreviation of #[derive(xxx)]
-
issues
An error reporting library for Rust
-
racros
Collection of rust macros
-
rs-utilities
Some utilities
-
yoshi-std
Core, std-only error type for the Yoshi framework
-
aas-types
AAS Types - Agent Accountability Service
-
el-macro
a dumb macro collection for anti-idiomatic rust programming
-
baxe
that simplifies error handling in Axum
-
double-trait
A procedural macro to derive a mirror of a trait designed to make it easier to implement test doubles
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
anyhow-auto-context
Automatic context for anyhow errors based on scope and location
-
funcall
A lightweight Rust library that turns functions into JSON-callable tools
-
wae-effect
WAE Effect - 代数效应依赖注入，声明式依赖获取
-
kcr_inference_kubedl_io
Kubernetes Custom Resource Bindings
-
iter_accumulate
An iterator adaptor that accumulates the elements and yields the current accumulated value for each iteration
-
interface
Typed, lossy-aware interface translation between API versions
-
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
magic-params
Macro to call functions with typed arguments derived from a shared context
-
ffi_time
FFI assistant for Rust time types
-
strid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
rst_lex
lexer for Rust
-
atomicell
Multi-threaded RefCell on atomics
-
ezcfg
configuration
-
bronzite-types
🔮 Shared types for Bronzite compile-time reflection IPC protocol
-
peeking-iter
An iterator adapter that allows infinitely-deep peeking
-
sai
IoC/DI framework for Rust
-
ordes
treating arrays and tuples a little bit more like vectors
-
structible
A macro for defining virtual structs backed by maps
-
dterror
Dat Error
-
xmlparser-derive
A proc macro to generate functions for writing to and parsing from xml string, based on xmlparser
-
sentry-conduit
Sentry middleware for conduit
-
luhlog
A horrible Rust logging library
-
autoproto
Replacement derive macros for
prost::Message, and supporting traits and types to make implementing this trait easier -
scall
Friendlier raw system calls for Rust
-
armature-app
Build complete Armature applications in Rhai scripts
-
implied-bounds
Make all the bounds of a trait definition be implied through a helper trait and macro attribute
-
index_permute
permuting a slice which elements are not Clone or Copy in Rust
-
clap_reverse
Derive macro for building
std::process:Commandfrom a Rust struct -
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
safe-rust
A safety-oriented Rust crate that ensures your code is safe
-
enum-unitary
Trait and macro for unitary enums
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
child-of
that allows you to make one struct a child of another
-
derive-merge-struct
A derive macro to partially update a named struct
-
raw-transmute
A more permissive alternative to mem::transmute, because you know better
-
iceyee_error
Error Message
-
macros_rule
Change the verbiage of
macro_rules!tomacros_rule! -
ropr
A blazing fast multithreaded ROP Gadget finder. ropper / ropgadget alternative
-
const-units
that lets you check the dimensions of your quantities at compile time and run time
-
async-convert
Async TryFrom/TryInto traits
-
tiff-encoder
creating TIFF files
-
re_span
An integer range that always has a non-negative length
-
doxidize
Fearlessly document function parameters with rustdoc
-
projecture
Easy arbitrary type projections without proc macros
-
defer-heavy
A versatile and easy to use defer statement for Rust. Similar to Go's or Zig's defer.
-
index-ext
Index slices with arbitrary ints and as arrays
-
therror
derive(Error) with a twist (based on thiserror)
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
typearrays
Array of types
-
platify
Streamline cross-platform Rust development with declarative attribute macros
-
jaaptools
I really just wanted to try publishing a package, but this contains stuff I find useful in many circumstances
-
humthreads
Threads for humans
-
type_enum
Create tagged unions consisting of different types
-
objid
Generate a random object identifier
-
rs_envflag
An easy way to define flags by environment variables
-
jtd-infer
Generate JSON Typedef schemas from example data
-
redb_model_trait
Redb model trait
-
interns
Object interner
-
cronjob
scheduling your methods
-
lsdata
LSD (Less Syntax Data) configuration/data transfer format
-
iter-index
More flexible alternative to Iterator's enumerate() method
-
virtue
A sinless derive macro helper
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
bounds
interact with bounded and unbounded ranges
-
ipv6-ddn
convert between Standard IPv6 (Hex) and IPv6 Decimal Dot Notation (DDN)
-
grass_chewer
A generalized COW (copy-on-write) type
-
interrupt-read
interruptable reader
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
next-web-mqtt
Next Web Mqtt
-
imgref-iter
A small crate for iterating over the rows or columns of
imgrefbuffers -
defer-rs
Deferred execution Rust utilities
-
warnalyzer
Show unused code from multi-crate Rust projects
-
strux
Tabular declaration of similar structs
-
tramli-plugins
Plugin pack for tramli — audit, eventstore, observability, resume, idempotency, hierarchy, diagram, docs, lint, testing, subflow
-
coercible_errors
Zero-cost error handling for generic traits
-
a1
A package for converting to and from A1 spreadsheet notation
-
chalk-macros
Macros for Chalk
-
functora
Missing pieces of the Rust standard library
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
simple-logging
logger for the log facade
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
bty
Streamlined definition and usage of branded types in Rust
-
tayvo_okapi
Structs for OpenAPI (AKA Swagger) documents
-
nvim-oxi-luajit
Rust bindings to LuaJIT for nvim-oxi
-
pathbufd
PathBuf with Display + formatting macro
-
typemap-meta
compile-time macro to create type-to-value maps
-
lightyear_deterministic_replication
Primitives for deterministic replication (as opposed to state replication) in the lightyear networking library
-
typewit_gce
for coercing between equal types with generic const arguments
-
tryvial
Small crate for ok-wrapping and try blocks
-
cspcl
Rust bindings for the cspcl library
-
typestate
A proc macro DSL for typestates
-
facet-miette
Derive miette::Diagnostic for facet types - rich error reporting with source spans
-
winit-main
Abstract away winit's event-loop inversion of control
-
fiberplane-pdk
Fiberplane Provider Development Kit
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
ctrlgen
Generate enums for message-passing services
-
http-derive
Derive macro for implementing
Into<http::StatusCode>for your enums using the standard http 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…
-
iterpipes
Compositional, pipes-style stream processing
-
onlyerror
Obsessively tiny error derive macro
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
error-ext
Error utilities
-
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.
-
safe-manually-drop
ManuallyDrop“owned field” pattern with nounsafe, no.unwrap()s, no macros -
errata
Ergonomic pretty error handling for binaries
-
arena-container
weak-typed arena (freelist) container without guards
-
include-utils
mdBook-like include macro as the powerful replacement for the standard
include_strmacro -
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
radiation
Convert Rust type into raw bytes and vice versa
-
type-flow-traits
Traits to implment for the type-flow abstractions
-
closure
A macro for capturing variables on a per variable basis
-
letter-sequence
A method to create sequence displayed as uppercase or lower letters, or digits
-
oxide-update-engine-types
Serializable types for the oxide-update-engine framework
-
structupdate_support
Type definitions used by the structupdate crate
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
ebml-iterable-specification
base
EbmlSpecificationused by theebml-iterableandebml-iterable-specification-derivecrates -
const_struct
macro that allows const structures to be passed as const generics
-
surqx
Query macro for SurrealDB
-
str_enum
declarative macro for an enum with associated strings for each variant
-
fast-rustc-ap-rustc_parse
Automatically published version of the package
rustc_parsein the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
hurry
Convenient macros for creating pointer types (Box, Rc, Arc, etc.)
-
limnus-local-resource
local resource storage
-
mathsys
The Natural Language of Math
-
daft-dsl
Domain-specific language for the Daft project
-
duh
macro utilities
-
weirdboi_utils
A collection of utility macros
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
const-exhaustive
Enumerate all values of a type at compile time
-
trait-cast
Get your own Any with support for casting to trait objects
-
chain-reader
Combining multiple [
Read] instances into a sequential read pipeline with configurable error handling -
unslice-dst
Fancy slice-like DST support
-
beerec-variants
Procedural derive macro to generate boilerplate on unit variants enum types
-
univec
A vector that can hold elements of any single type
-
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)…
-
photon-hook
Hook trait and broadcast primitives for reacting to Photon events
-
thread-object
Abstraction over thread-local storage allowing dynamic creation of TLS variables
-
unwrapped
The unwrapped crate
-
reax
A reactivity system for Rust that infers dependencies between functions
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
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
-
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.
-
leptix-ui
Leptix UI — Radix-style accessible UI primitives for Leptos
-
metadata_macro
Rust macros for a very elementary metadata-like system in structs and tuple structs
-
rust-2018
Macro to use Rust 2018 from all editions
-
secador
Stop repeating code
-
erg_linter
the Erg linter
-
borked
convienient error handling library for rust
-
fn_name
Macros that produce the name of the function they're invoked within
-
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. -
light_clone
Compile-time enforcement for O(1) clone operations
-
eventcore-postgres
PostgreSQL event store adapter for EventCore event sourcing library
-
nolife
open a scope and then freeze it in time for future access
-
igc_parser
A high-level parsing/deserializing crate for IGC flight recorder files
-
ownership
Obtaining ownership
-
argus-lib
Trait debugger analysis for IDE interactions
-
solution
Some macro for automatically generate student and teacher version of rust exercise
-
lazy-init
Lazy initialization
-
provekit_nargo_expand
Macro expansion utilities for Nargo
-
async-err
Contextual asynchronous error handling
-
nesting
structs, enums, and impls, in Rust!
-
takeable-option
A small wrapper around option
-
enum-group-macros
Define grouped enums with ergonomic pattern matching
-
jsmoke_macros
JSmoke personal macros
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
patchwork-eval
Patchwork language interpreter with suspend/resume for LLM integration
-
noretry
retryable abstraction for your functions
-
mstr
2-word, immutable Cow<str>
-
close-err
Add .close() to file-like types, for error handling
-
ark-r1cs-std
A standard library for constraint system gadgets
-
rust-automata
A framework and a DSL for building finite state machines in Rust
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
assemblist
Define your builder patterns as you use them
-
defmac
A macro to define lambda-like macros inline
-
compiler_builtins
Compiler intrinsics used by the Rust compiler
-
slugify-rs
generate slugs from strings
-
atri_plugin
AtriPlugin
-
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
-
slotpoller
Bounded, lock-free futures collection. Faster than FuturesUnordered and other crates.
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
kmacros
Useful macros
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
rx_core_subscriber_higher_order
higher_order subscriber provider for rx_core
-
newtype-tools
A lightweight library designed to make the newtype idiom more ergonomic to use
-
overengineered_hkts
Expiremental crate of higher-kinded types integrated with lifetimes and matching function types and optional cloning and supporting no_std
-
rustils
Utilities for rust
-
binvec
binary vector type developed in Rust to use memory efficiently. It is characterized by using the minimum memory space to store an array of bool values.
-
supply
Provider API for arbitrary number of lifetimes
-
ex_em_ell
Provide macros for serializing and deserializing XML
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
cgp-error-eyre
Context-generic programming error handlers implemented using eyre
-
ellie_tokenizer
Tokenizer for ellie language
-
anyanymap
Macro for building any Type Map with a standard interface
-
affix-macro
Macros for affixing tokens to groups of other tokens
-
cjc-types
Type system and inference engine for CJC
-
battler-wamp-values
WAMP value types
-
coroflow
Composable coroutine utilities and flow abstractions built on top of Rust's async ecosystem
-
hex-display
Display impl for byte slices which provides a hexdump
-
min-max
max! and min! macros
-
qa
Requirements traceability for safety-critical Rust software
-
numy
Trait boundaries for primitive Rust types
-
culprit
error crate with the goal of identifying precisely where and in which context an error occurs
-
hash_str
Strings with a precomputed hash
-
cdumay_base64
base64
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
interpolate
form of string interpolation
-
cew
Personal Rust utility library
-
enumcapsulate
Safe casting for newtype enums and their variants
-
bo4e-extensions
BO4E extension types for EDIFACT mapping — companion structs, WithValidity, LinkRegistry
-
lives
Lifetime-dynamic smart pointers
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
sql_tool_core
这个库是 sql_tool_macros 库的核心，存储 trait
-
diva
Opinionated convenience wrappers for
std::process::Commandand friends -
string-literals
Rust macros to more easily create String types
-
float_plus
Additional features for float values
-
error-kit
A comprehensive error handling library for Rust applications
-
android-logcat
Android logcat
-
rustfmt_lib
Rustfmt as a library
-
iced_af
The iced application framework project
-
sstr
A stack allocated String type that maximally emulates dynamic behaviors. Relies on generic const expressions for concatenating stack allocated strings.
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
koicore_ffi
FFI bindings for koicore
-
ffizz-passby
FFI helpers for implementing pass-by-value and pass-by-pointer
-
postmortem
A validation library that accumulates all errors for comprehensive feedback
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
primitive-from-enum
macros for get primitive enum from complex
-
flatty-portable
Flatty portable trait and primitives
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
drop-with-owned-fields
Safe and sound owned access to a
struct’s fields inDrop: no moreunsafeusage ofManuallyDrop! -
derive_agent_tools
Derive macros for defining AI tools from structs
-
size_hinter
Iterator adaptors allowing overriding or specifying size_hint
-
stringlit
A macro to convert from str to String
-
urlquerystring
A high-performance, zero-allocation URL query string parser
-
floxide-transform
Transform node abstractions for the floxide framework
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
hooking_macros
hooking libs in rust
-
enumtrait
macros for polymorphism using enums
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
summum-types
A sum-type macro crate with all the conversions, accessors, and support for abstract methods across variants, and interoperability between sum-types
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
monadify
functional programming abstractions in Rust, focusing on Monads, Functors, Applicatives, and related concepts
-
accursed-unutterable-type-id
A worse version of std::any::TypeId
-
anthill-di
Rust di containers system
-
text-block-macros
Create a multiline string literal
-
culit
Custom literals
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
float-bits
Floats stored as raw bits, making them hashable and totally ordered
-
hello-world-in-rust
Hello World!
-
maybe-borrow
Macros for conditionally returning borrowed data
-
easy-int
macros for easy implementation of integer aliases
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
iter_fixed
Iterator of fixed length
-
rusty-bind-parser
Parses Rust module, generates Rust code with C ABI bindings and C/C++ header files and Swift gluecode
-
nu-experimental
Nushell experimental options
-
abs-file-macro
A macro that returns the absolute file path of the Rust source file in which it is invoked
-
vector3d
3D vector type
-
icebook
Generic component storybook framework for Iced applications - compiles to WASM
-
llmcc-rust
llmcc brings multi-depth architecture graphs for code understanding and generation
-
silx-types
aSynchronous Interactive calcuLation eXecutor: an easy to use executor for asynchronous and interacting processes
-
variant_counter
Rust's Enum variant counter
-
erio-embedding
Embedding engine for Erio
-
influx3_lp
A serializer for Rust structs according to InfluxDB 3 line protocol
-
dbus-strings
Rust native implementation of different D-Bus string types
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
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… -
non-empty-str
Non-empty strings
-
error_status
Model common error context with HTTP 4xx and 5xx code
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
djin-protocol
protocol, for aoe-djin
-
unocss-classes-utils
Utils for
unocss-classes -
ruroonga_command
A tiny Groonga query builder and generator
-
aspect
Toolkit for Rust
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
cljrs-types
Core types, source spans, and diagnostics for clojurust
-
casting
CastFrom and CastInto traits for generic numeric casting
-
smooth-operator
Procedural macro that transforms regular infix arithmetic expressions into checked arithmetic expressions
-
valued-enums
Macros collection and specify trait for creating valued or python-like enums
-
impl-opaque
Macro for declaring complex struct and initializer
-
axioma
Compile-time declarative macros for static JSON-to-Matrix topology projection
-
delfi
Conveniently writing data to csv-files
-
koute/nes
emulator written in Rust
-
karpal-optics
Profunctor optics (Lens, Prism) for the Industrial Algebra ecosystem
-
plist_ffi
C FFI for the amazing plist crate, compatible with libplist
-
enum-derive-2018
macros for deriving additional functionality for enums
-
round_pipers
A way to pipe ndarrays using circular buffers
-
dyn_compatible
Dyn compatible marker
-
almost
comparing floating point numbers
-
xmacro_lib
macro engine for producing multiple expansions
-
bhc-intern
String interning for efficient symbol handling
-
squote
A clone of the quote crate that uses a String as its backing store
-
tao-of-rust
《Rust编程之道》随书源码
-
trait-set
Support for trait alias feature on stable Rust
-
varchain
Async-only chain-based variable lookup engine, support no_std with alloc
-
fack
Declarative error handling library with no_std support and composable code generation
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
better_unwrap
A trait providing clearer alternatives to unwrap() methods: or_panic(), panic_or(), panic_or_else(), panic_or_default(), and panic_with()
-
partial_application
partial function application via the partial! macro
-
erased-discriminant
Type-erased version of core::mem::Discriminant<T>
-
nil
Noxmore's Ixperimental Lutilities
-
context_manager
Python's like context_managers in Rust
-
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
key-paths-core
Keypaths, ReadableKeyPath, WritableKeyPath and EnumKeypath for struct and enums in Rust
-
fast_assert
A faster assert!
-
type-factory
unique opaque types
-
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
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
-
auto_ops
Macros for easy operator overloading
-
common-stdx
extension for the std lib, for things i commonly reuse
-
swamp-script-error-report
Swamp script error report
-
forester-rs
Workflow framework based on the behavior trees
-
textus
A derive macro that renders an entire folder of templates into typed, compile-time-validated output
-
smartcow
a cow for smartstrings
-
unfold-iter
Create iterators with an initial value and a recurrence relation
-
enumx
Ad-hoc enum extension
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
typeswitch
A powerful, Go-inspired macro for clean and declarative runtime type switching on dyn Any trait objects
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
trait-bounds
Trait bounds primitives using generic_const_exprs
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
chain_link
Micro library with a util for chaining operations on a single type
-
namable_closures
types and macros to create namable closure types
-
ohos-ime-sys
Bindings to the
inputmethodAPI of OpenHarmony -
jaarg
It can parse your arguments you should use it it's called jaarg
-
enum_handler
A macro to generate a handler trait for enums variants
-
statum-graph
Static graph export for Statum machine introspection
-
lazymut
Similar to LazyCell, but use &mut self to get or initialization
-
facet-path
Path tracking for navigating Facet type structures
-
tosserror
derive(Toss)
-
dioxus-shareables
Hooks for sharing structures between components
-
dialasm
pest based dialogue DSL for Rust
-
rten-base
Shared utilities for the rten family of crates
-
inline_dyn
A container type for storing dynamically-sized types inline
-
moro
Experimental structured concurrency support for async Rust (similar to trio's nurseries)
-
tagged-id
A zero-cost wrapper adding type-safety to resource identifiers
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
pin-init
Safe pinned-initialization in Rust
-
code-path
A code path macro
-
strprintf
Provide a way to interpolate printf-style format strings using native Rust types. Part of libnewsboat lib dependencies
-
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
tree-sitter-flutmax
Tree-sitter grammar for the flutmax DSL
-
prev-iter
Iterator which allows you to view the previous element
-
libabort
A abort function that doesn't require the standard library
-
flip-flop
implements the flip-flop operator from Perl and Ruby as a Rust macro
-
log_err
Log error messages from Unwrap and Expect with log crate
-
query_interface
Dynamically query a type-erased object for any trait implementation
-
wiwi
Stuff™
-
upget
Super simple trait that patterns the value "updae" and "get"
-
hexga_array
that impl trait / new functions for array
-
path-dsl
DSL and macro to help deal with Paths and PathBufs
-
kittycad-execution-plan
A DSL for composing KittyCAD API queries
-
size
expressing, formatting, and interacting with file sizes
-
simple_scan
Iterator extensions for simple scan operation
-
numeric_cast
Safely cast between numbers
-
preprocessor
Compile-time computation macro library — analyzes computable sub-expressions in code and evaluates parts that can be executed at compile time
-
derive-into
derive macro for easily creating conversions between structs and enums
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
tuplestructops
Structural manipulations for tuples
-
comparator
A Java-like Comparator type
-
async-ebpf
Async-friendly, fully preemptive userspace eBPF runtime
-
derive-name
Derive macro to get the name of a struct, enum or enum variant
-
yield-return
Implement a coroutine like C#‘s
yield returnusing Rust’sasync,await -
slice_trait
A generic trait for any slice, with item as a type parameter
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
simplerror
A zero-dep macro to declaratively define error enum types and their common trait implementations
-
loomx-axum
Axum integration for loomx
-
cmakelist_gen
A CMakeLists.txt generator for Rust projects
-
eager
macro expansion
-
maybe-single
A singleton. Maybe.
-
clockwork-tuples
Type-level tuple utilities for compile-time structural reasoning
-
scoundrel
An engine for working with ASCII roguelikes
-
as-result
Traits for converting types which may be interpreted as or into a result
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
nanoneo
lisp-like dsl which "compiles" into html
-
flexpiler
Deserialiser aiming at high customizability
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
hexga_map_on
Define the map_on! macro that can be used to impl a lot of trait quickly using macros
-
dilib
A dependency injection library for Rust
-
tower-resilience-chaos
Chaos engineering layer for Tower services - inject failures and latency for testing resilience
-
reformy
Derive ratatui form widgets from structs or enums
-
derail-report
Tools for reporting
derail::Errors -
mad-hatter-guardian
Compile-time literal guardian for Rust projects — detects implicit contracts in source code
-
assert-within
Macro for testing that (generic) floating point numbers are within some tolerance
-
variable-codegen
TypeScript code generation for the Variable feature flag DSL
-
gazebo
A collection of well-tested utilities
-
stable-type
OCaml inspired stable types
-
unty-next
Explicitly types your generics
-
int_like
macro for defining integer-backed opaque types safely
-
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… -
cuadra
layout types
-
enum-field
Declarative macros for enum-based heterogeneous field accessors
-
partial-borrow
Partially borrow a struct
-
toast-cell
Zero-cost type-branded cell with no runtime checks
-
dyn-context
mechanism for lifetimes erasing
-
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… -
floats
f16 and f128 floating point types for compatibility with future Rust versions
-
slice-of-bytes-reader
Turns an iterator of
AsRef<[u8]>into a reader implementsstd::io::Read -
newtypes
Macros that ease the implementation of the Newtype pattern
-
type-uuid
Safe, stable IDs for Rust types
-
cryo
Extend the lifetime of a reference. Safely.
-
rust-analyzer-modules
analyzing a Rust crate's module structure and dependencies (fork with rust-analyzer 0.0.289 support)
-
pathogen
Typed references and deep mutation into Rust types
-
undo_stack
A minimal undo stack for user defined types
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
test-with-tokio
attribute macro for tests using tokio with cases and async guards
-
estimate_size
Replaces an iterator’s
size_hintwith a custom value -
csci
C Syntax, Completely Idiotic - a macro collection for writing not idiomatic, but idiotic Rust, with C-style variables and functions
-
speedy_refs
A collection of simple and fast and useful smart pointers
-
fb_cloned
Cloned macro
-
ra2-mix
Red Alert 2 MIX file format library for reading and writing MIX archives
-
constptr
NonNull without mutability
-
uuid-enum
UUID-based enums
-
try-clone
Fallible cloning
-
envfmt
Expands environment variables in string
-
make-send-sync
Unsafely make any type Send and Sync
-
shannon-nu-protocol
Nushell's internal protocols, including its abstract syntax tree
-
nyar-number
Numeric types with GC optimization
-
useful_macro
Collections of useful macros
-
emboss_common
Common types and constants for emboss
-
hado
Monadic do notation using a macro
-
range_checker
derive-macro crate aimed to provide declarative bounds checking and filtering for structure
-
skipcode
macro library enabling compile-time skipping of statements/blocks
-
moire-types
Core graph types for moire: entities, events, edges, scopes, and snapshots
-
simple-life
async lifecycle trait and convenient macros
-
skedge
Ergonomic single-process job scheduling for Rust programs
-
auto-impl-ops
semi-automatic implementation proc-macro for binary operations
-
functora-tagged
Lightweight, macro-free newtypes with refinement and derived traits
-
core-nightly
Nightly build of libcore from the rust repo
-
derive_destructure2_examples
Examples for crate derive_destructure2
-
memsizes
Type-safe memory size newtypes (Bytes, KiB, MiB, GiB, TiB, PiB, EiB, KB, MB, GB, TB, PB, EB) with checked conversions and arithmetic
-
eventually
using Event Sourcing in Rust applications
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
from_nested_tuple
Create structs from left-nested tuples (meant to complement chumsky)
-
tryumph
A flexible retry library for operations that may fail, with customizable delay strategies for both synchronous and asynchronous code
-
even-odd-traits
traits for even and odd
-
unzip_iter
Unzip an iterator to iterators
-
pyo3_special_method_derive
Automatically derive Python dunder methods for your Rust code
-
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 -
axum-error-object
Result<T>type and related utility types that can be used to holistically provide object response errors -
macro-utils
Some macros to make code writing more elegant and funny
-
bitread
in Rust is designed to efficiently convert small binary data into Rust structs
-
is_empty
Easily check if the struct is empty
-
sqry-tree-sitter-support
Tree-sitter integration helpers for sqry
-
ioc
An Inversion-of-Control library in Rust
-
loomx-macros
Macros for loomx
-
typewriter-plugin-php
PHP emitter plugin for typewriter
-
destruct
structs and enums for simpler combinator implementation
-
log-error
A small crate to log the error result easily
-
yyds-types
Common type system for the yyds ecosystem, providing DsValue and zero-copy data layout
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
fromsoftware-dlrf
Macro for generating singleton specifier for usage with the DLRF singleton finder
-
o2-primitives
Core trading primitives for the Fuel O2 exchange
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
shuriken-api-types
Public API payload types for the Shuriken platform
-
static_file_util
generating and managing static files in Rust applications
-
effective
An effects library, an alternative to keyword generics
-
hexga_tools
miscellaneous stuff, when somethings will be too big it will be on a separate crate
-
ranvier-test
Test utilities for Ranvier pipelines ??TestBus, TestAxon, assertion macros
-
errore
error handling and tracing
-
component-map
Generic component manager with sync/async and fallible/infallible initialisation
-
anyhow-std
Wrap std APIs with anyhow error context
-
nonicle
Tools for type-safe, canonical data representations
-
const-macros
Various macros for const contexts
-
illicit
An implicit thread-local environment which is indexed by type
-
ax-lazyinit
Initialize a static value lazily
-
shoogah
Add some syntactic 'shoogah' to Rust
-
lib_utils
Misc utility functions
-
derive_fn
Macro to implement all three Fn traits
-
nz
Collection of 100% safe macros for creating non-zero integers more easily
-
bitflate-rs
Layout/bitfield helpers for previewing structs
-
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 -
sge_shapes
Shape types for SGE
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
likely_polyfill
cold_path, likely, and unlikely for non-nightly Rust
-
portable-io
“ A subset of Rust
std::iofunctionality supported forno-std -
coil-observability
Observability primitives for the Coil framework
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
extension-eyre
Re-export of color-eyre that introduces Extensions (type-map) to eyre::Report
-
facet-core
Core reflection traits and types for the facet ecosystem - provides the Facet trait, Shape metadata, and type-erased pointers
-
lootr
RPG-like looting system
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
munarkma
Namumark parser
-
id-wrapper
A small generic wrapper to add a unique identifier to a struct without modifying it
-
data_models
used to lookup the sizes of various C-types of historical data models
-
string_types
String newtypes
-
webformd
trait for webformd_macro to deserialize actix_web::web::Form for structs with Option<Vec<String>> from a checkbox or similar
-
relax
Derive Partial<T>
-
shannon-nu-test-support
Support for writing Nushell tests
-
hexspec
A dsl for creating and verifying byte buffers
-
transient
Reimplementation of
std::any::Anywith support for non-'statictypes -
nekopas2rust
-
zlink-core
The core crate of the zlink project
-
grist_lens
Unsafe Nightly Ergonomic Lens API
-
phlow
An engine for scripting reactive browsers in Rust by adding custom views to structures
-
exhaustive
The trait for generating all values of a type, and a property-based test macro
-
cpp_utils
interoperability with C++
-
rombok
boilerplate generation macros like lombok
-
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
CuPs
Dear Dev, this lib to make custom pointers to amend RowHammer-related issues [kiss principle been at the very heart]
-
selfref
Semi-pain-free self-referential pinned types
-
admixture
Core traits and macros for managing service lifecycles in integration tests
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
refined_type
imbuing rules into types and elevating them to more robust types
-
comprehensive_dns
A DNS resolver for https://crates.io/crates/comprehensive
-
iter-scan
Iterator scan methods that don't suck
-
fnrs
some useful functions i like
-
tower-retry-plus
Enhanced retry middleware for Tower services with advanced backoff strategies
-
rmp-ipc
IPC using Rust MessagePack (rmp)
-
sod-crossbeam
Service Oriented Design - Crossbeam
-
to-display
A trait that is Display or can be converted to Display
-
docpos
Compact-document items after defining them (fn, struct, enum) + document fn parameters with rustdoc (⑂roxygen)
-
rustato
A global state management library for Rust applications
-
flat-drop
Wrapper that drops recursive objects iteratively to avoid stack overflows
-
clone-behavior
Bound the semantic behavior and time complexity of cloning a value
-
ffi-enum
Simply write and use
enums like rust native enums, freely passing through ffi -
dungeon-cell
Store (almost) any value as one type without dynamic memory
-
enum_downcast
Safe downcasting for enums
-
functor_derive
A derive macro to derive a functor for a type
-
faux-refine
that implements a pseudo-Refinement Type in Rust
-
aspect-runtime
Runtime utilities for aspect-oriented programming in Rust
-
obzenflow_dsl
DSL and infrastructure layer for ObzenFlow - flow! macro and high-level orchestration
-
diesel_derives_traits
Traits for diesel_derives_extra
-
uncollate
array of structs into arrays of field
-
concat_const
const
&[u8]and&strconcatenation -
ownables
that defines the Ownable trait and facilitates mutation by moving or reading from the source
-
copyvec
A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
get-field-by-type
Get a value of field, based on the type of a field
-
fallible_map
fallible mapping over
Optionand iterators using functions that can returnResults -
linearity
providing various operations commonly found in branchless programming
-
lessvec
A custom Vec implementation using the Rust standard library
-
approx-eq-trait
A trait for floating-point equality
-
pick-by-autoderef
Pick by autoderef: a compile-time dispatch by priority
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
xchecker-error-reporter
Human-friendly error reporting for xchecker
-
multi-any
MultiAnyis just likeAnybut can downcast to trait objects -
bumpref
Explicit .bump() method for Arc and Rc that signals cheap refcount cloning
-
rbx-rsml
A lexer and parser for the RSML language
-
game_inventory
An inventory system independant of item data
-
newtype-ids
Type safe identifiers in Rust
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
fields-glob
Derived glob macro with the same name as the structure
-
rtlola-frontend
A frontend for the RTLola runtime verification framework
-
read_int
get user input in any primitive type
-
rudi
out-of-the-box dependency injection framework for Rust
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
assert_hex
display assert panics in hexadecimal {:#x?} format
-
emscripten_rs_sys
Bindgen-generated bindings to all public emscripten functions
-
keetanetwork-utils
functions and build tools for Keetanetwork
-
verdure-ioc
An ecosystem framework for Rust
-
filedescriptor
More ergonomic wrappers around RawFd and RawHandle
-
cdumay_config
configuration manipulation and export
-
myutil
Rust Util Collections
-
kcr_kpack_io
Kubernetes Custom Resource Bindings
-
anyhow_ext
Extension of anynow
-
argcall
Enables enums and structs to be callable by associating functions with their variants or fields
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
commonware-utils
Leverage common functionality across multiple primitives
-
swamp-types
types used in Swamp
-
mutcy
Zero-cost safe mutable cyclic borrows using borrow relinquishing
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
standback
New standard library, old compiler
-
windows-helpers
Helpers for the windows crate
-
valkyrie-types
Shard types for valkyrie language
-
shared-expiry-get
concurrent async get with expiration for Rust
-
rioc
Zero cost dependency injection macros
-
stecs
Experimental static compiler-checked ECS library
-
cdumay_error_base64
base64 error
-
n-functor
Faux-derive a
mapfunction for types with one or more type parameters -
error_def
syntax extension for generating error-handling boilerplate code
-
kyomu
Allows recursive reflection of types, mapping runtime values to that recursive struct and constructing objects generically
-
serde-nixos
Generate NixOS type definitions from Rust structures
-
assert4rs
Fluent assertions for Rust
-
common_macros
common macros like
hash_map!orhash_set!(WIP) -
entrypoint
opinionated application framework/wrapper that eliminates main function boilerplate
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
pulz-functional-utils
traits and macros to work with tuples and functions
-
lyneate
beautiful code underlining and error reporting
-
ts-error-stack
error stacks for better reporting
-
layer-rs
Effect-TS like type level DI container in Rust, with O(log n) get and insert
-
intid
Defines the IntegerId trait
-
ptr-utils
A lightweight library providing utilities for working with raw pointers
-
cel-core
High-level API for the Common Expression Language (CEL)
-
from-string
that provides a FromString trait with a String to String noop
-
cruxi-authz
Core relationship-based authorization traits and types for the Cruxi framework
-
pyprint
enable python-style printing in rust
-
not_enough_asserts
A collection of useful asserts
-
weechat
API bindings for Rust
-
hermit-sync
Synchronization primitives for kernels
-
nshare
Conversion between n-dimensional types in different Rust crates
-
amonoid
A general-purpose monoid library
-
vanguard-plugin-sdk
SDK for developing Vanguard plugins
-
blueprint-dupe
Marker for types which are cheap to clone
-
tuple_set
Ergonomic utilities for working with Rust tuples by unique types, not position
-
handybars
Minimal template parsing and expansion
-
byteorder_slice
Byteorder like crate for &[u8]
-
oneshot-fused-workaround
Fused wrapper for futures::channel::oneshot
-
rstgen
Even simpler code generation for Rust
-
panic-message
Get a panic message from a panic payload
-
typeshaper-macros
Proc-macro internals for the typeshaper crate — do not use directly
-
struct_to_array
Convert between homogeneous structs and fixed-size arrays
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
tauri-plugin-keygen-rs
Tauri plugin for Keygen.sh licensing, based on keygen-rs
-
standout-seeker
Generic query engine for filtering Rust struct collections
-
orchidlang
An embeddable pure functional scripting language
-
unsafe-fields
unsafe to access or modify fields with safety invariants
-
cli-panics
Make your panics easy to read
-
vnum
Create enums with a constant value associated to every variant
-
ty-tag
TypeId for lifetime containing types via type tags
-
inherent
Make trait methods callable without the trait in scope
-
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…
-
prosia-extensions
Useful extensions for types, arrays and other helper functions for Prosia projects
-
aoko
extension library
-
a2a-types
A2A Protocol Types
-
semval
Semantic validation
-
anyerr
Dynamic error library with rich error wrapping and context support
-
ptrait
A small crate providing traits for pointer-like types, such as references and smart pointers
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
ambient-authority
Ambient Authority
-
prealloc_ref_vec
Create temporary
Vecs of references without allocating/deallocating (useful for realtime code) -
containing
Newtypes for dealing with collections that are guaranteed to be non-empty
-
state-department
state management and dependency injection in Rust
-
xslice
Slice representation using relative extents instead of absolute pointers
-
ankiconnect-rs
A package for convenient interaction with AnkiConnect
-
stable-eyre
A custom context for eyre that supports capturing Backtraces on stable
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
roopert_macro_common
object-oriented toolkit for Rust (common data)
-
proc_micro
Small conveniences for high-quality macros
-
iter-n
functions returning impl Iterator to return one of several distinct types
-
enumly
procedural macro that exposes a compile-time static list of all variants of an enum
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
quasiquodo-ts
Compile-time TypeScript quasi-quoting
-
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… -
assure
macros for Rust runtime checks and error handling
-
non-empty-iter
Non-empty iterators
-
const-zero
a const mem::zeroed
-
nyar-error
Error types for valkyrie language
-
write-into
A trait to write things into io::Write
-
enum_reflect_extern
Traits for enum_reflect
-
typed-builder-macro
Compile-time type-checked builder derive
-
aorist_primitives
Primitive macros for the aorist project
-
arc-cell
Helper for a simple Cell-like object containing Arc/Weak
-
pisserror
A golden rip-off of thiserror
-
floxide-reactive
Reactive node abstractions for the floxide framework
-
const-util
Stable implementations for some missing const functions
-
readonly
Struct fields that are made read-only accessible to other modules
-
diatom-std-core
Diatom core standard library
-
throw
Efficiently add statically-calculated stack traces to errors
-
explicit-error-exit
Explicit concrete Error type to manage errors that end a process/program
-
recuerdame
Pre-calculate functions at compile-time rather than run-time
-
messages
Runtime-agnostic actor library
-
sage-checker
Name resolution and type checker for the Sage language
-
kube-core
Kube shared types, traits and client-less behavior
-
runi-core
Core types for the Runi library collection
-
shared_singleton
trait provides singleton pattern state management with shared container
-
newtype-ids-uuid
UuidIdentifier trait and derive macro
-
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… -
enum_variant_accessors
derive macros to generate is_*, as_* and as_*_mut accessors for enum variants
-
ever
Print the build information of your program with minimal boilerplate
-
rx_core_subscriber_higher_order_map
higher_order_map subscriber for rx_core
-
maybe-trait
Allows writing functions which are polymorphic over taking an option
-
ctreg
Compile-time regular expressions the way they were always meant to be
-
archway
Rust traits for Rc and Arc interoperation
-
is-odd
Returns true if the given number is odd
-
simple_parse
A declarative converter for Rust type to and from binary
-
solgpc
An elegantly fast GPC parser
-
rformat
Runtime formatting library
-
decrust-promac-runtime
The ultimate all-in-one error handling framework for Rust
-
slice-utils
A collection of slice utils, like itertools
-
stupid_utils
that provides some simple and maybe stupid or useful tools
-
detach
helper type for being able to detach/reatach a member item
-
jimmy-rs
A type-safe JSON builder using the typestate pattern that ensures syntactically correct JSON at compile time
-
tracked
A stringly-typed Error that includes
#[track_caller]information -
rvs
defining and evaluating random variables using a simple DSL
-
meta_tuple
A statically typed opaque tuple that can contain any type
-
backyard-nodes
Nodes representing PHP code AST
-
thistermination
add the Termination trait to error enums inspired by thiserror
-
concat-string
macros for concatenating string slices into owned strings
-
coinduction
Attribute macros for defining circular type references and recursive trait implementations in Rust
-
toml_config_trait
Rust trait to turn a Rust struct into a TOML config
-
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…
-
suwrap
Contextual and explicit replacement for unwrap()
-
defvar
A macro that makes defining environment variables easy
-
accompany
with-like macro for Rust -
benri
Convenient macros wrapping the standard library
-
cjc-dispatch
Operator dispatch layer for CJC runtime
-
ortho_config_test_helpers
Shared test helpers for crates in the ortho-config workspace
-
rustc-tools
Some internal rustc tools made accessible
-
prism3-core
Foundational utilities and language-level tools for Rust application development
-
type_cell
Attach values statically to a type using static get/set methods
-
peresil
simplistic string parsing library
-
safe_unwrap
allows unwrapping and annotating that the unwrap will never fail. Does not require
std. -
cell-project
Safe interface for cell projection
-
rexpr
Rust Json Object access Runtime
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
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
-
steckrs
A lightweight, trait-based plugin system for Rust applications and libraries
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
blueprint-display-container
implement Display
-
qed
Compile-time assertions
-
kvtree
Heterogenous in memory key value tree storage
-
easy_complex
Complex numbers crate
-
value-extra
A tri-state Patch<T> type for partial update semantics — distinguishing between 'has value', 'absent', and 'explicitly null'
-
sector
A stateful vector implementation that provides different memory management behaviors through Rust traits and state machines
-
syscall_encode_traits
Traits and macros to help define a syscall interface for a kernel
-
friperms
framework for creating typed permission models for whatever system you could phatom
-
cstl-sys
Low level CSTL Rust bindings generated with bindgen
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
utils-results
The easiest and most intuitive error handling solution
-
plist-types
Common types for the bplist and xplist crates
-
bencode-minimal
A Bencode library depending only on the Rust standard library
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
ltptr
Checked raw pointers
-
visit-rs
A generic visitor pattern library for Rust
-
veho
a iterable toolset
-
twisterl
Reinforcement learning primitives and a Python extension for high performance training and inference
-
objective-rust
Seamlessly bind Rust and Objective-C code
-
blueprint-cmp-any
Comparison for &dyn types
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
sized-dst
Owned container for dynamically-sized types backed by inline memory
-
late-struct
Late-bound structure definitions
-
assert-type-eq
Macro to assert types across potentially different crate versions are compatible
-
alloy-eventsource
Event sourcing contract primitives for the Alloy portfolio
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
trackerr
Error tracker library with location capture and context
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
cause
A generic [std::error::Error] implementation
-
hexga_math
Math related crate that define number and casting, and support array programming
-
panicmsg
simplyifying common panic messages
-
typify-impl
typify backend implementation
-
except
The only one
Error -
timeout-macro-parse
A companion-crate for the tokio-timeout proc-macro-lib
-
octofhir-cql-types
CQL type system
-
assert-impl
Macro for static assert types implement a trait or not
-
moduforge-macros
moduforge 宏定义
-
ordered_iter
Ordered iterators
-
karpal-arrow
Category and Arrow hierarchy for the Industrial Algebra ecosystem
-
yykv-types
Core type definitions for yykv storage engine
-
devirt
Transparent devirtualization for Rust trait objects via witness-method dispatch
-
result-transformer-dependencies
Traits, macros and utilities for transforming Result values
-
non-zero
A macro for creating constant non-zero integers (with type inference)
-
displaythis
derive(Display)
-
copy_impl
Macro for effortlessly duplicating impl block code across various types in Rust
-
test_help-rs
Test helpers for Rust
-
functype
Functional programming library for Rust
-
abi_stable_shared
detail of abi_stable
-
checked-float
making invariant-enforcing floating point wrappers
-
rain_task
Distributed computational framework for large-scale task-based pipelines. A custom task library in Rust.
-
synchro_macro
Synchro is a Rust framework for building fullstack applications that run seamlessly across platforms
-
hexga_utils
miscellaneous stuff, when somethings will be too big it will be on a separate crate
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
array-bin-ops
Efficient array binary operations
-
almost-enough
Batteries-included ergonomic extensions for the
enoughcooperative cancellation crate -
num_string
perform conversion between string and number
-
sketchddd-parser
DSL parser for SketchDDD domain models
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
tupleops
work with tuples
-
unstacked
Lock-free, no-std concurrent stack for Rust
-
pf-types
Lightweight naming and validation primitives for the PromptFleet agent ecosystem (AgentSlug, normalize_name)
-
enum-values
Exposes enum values via reflection
-
newt-hype
A very easy-to-use crate for creating wrapper structs using the new-type pattern
-
run-on-drop
Run code when an object is dropped
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
concrete-type-rules
Rules and validation for concrete types
-
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. -
chassis
Compile-time dependency injection framework
-
rustrails-macros
Declarative macros for RustRails DSL
-
lazybe
Handy CRUD boilerplate macros and utils for Rust backend
-
microtype
simplify the creation of microtypes
-
dlib
Helper macros for handling manually loading optional system libraries
-
percentage
calculate percentages
-
combined_str
Zero-copy, const-generic string combinator for no_std environments
-
impl-macro
Macro reducing boilerplate of similar impl declarations
-
mvutils
made from commonly used functions in my projects
-
inline-option
A memory-efficient alternative to Option that uses a pre-defined value to represent None
-
cmdparsing
adds a macro to parse arguments
-
coil-assets
Asset publishing and delivery primitives for the Coil framework
-
fat_type
A type which permits thin references to arrays and dynamic types
-
demes-ffi
FFI for rust implementation of demes specification
-
scoped-panic-hook
Adds scoped, nestable, thread-local hooks for panics and some utilities for capturing and analyzing panics more conveniently
-
once-cell-regex
just gives you the
regexmacro from theonce_celldocs! -
mapper
Mapping macro to help to reduce mapping boilerplate
-
base64_type
type wrapper for Vec<u8> that uses base64 for serialization
-
hashtree-merge
Deterministic path-based merge primitives for hashtree
-
xylem
Building context-sensitive type conversion
-
microstring
Small, niche-able, stack allocated strings
-
rust_kafka_like
A Kafka-like message broker in Rust
-
eqeval
An equation parser using the finum crate
-
enumorph
Derive macro to generate
TryFromandFromimplementations for converting between newtype enum variants and their wrapped values -
koruma
The koruma crate
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
lens-rs
lens implemented in rust
-
solution_cli
CLI for convert crate use
solution::solution!()macro to a version for student (with solution stripped and hint intodo!()) -
cid-base
Shared base utilities for cid
-
simple-newtype
newtype macros for application development
-
enum_like
trait to treat any type as an enum. If a type has a reasonably small number of variants, for example a
struct A(bool, bool)which has 4 variants, this trait provides a 1-to-1 mapping from type value to a… -
cgp-component
Core CGP traits and types used for implementing the CGP component system
-
shoggoth
Generic and type-level programming for Rust
-
magic-args
"Magic" declarative-style function arguments
-
mini_macro
helper mini macros
-
makeit
Compile-time checked Builder pattern
derivemacro with zero-memory overhead -
derive_macro_xiaochufuji
A custom derive macro collection by xiaochufuji
-
default_new
A DefaultNew derive to generate a Default impl that just calls Self::new()
-
hitbox-fn
Function memoization for hitbox caching framework
-
micro_errors
deal with errors without taking the derive macro approach
-
nexcore-error
Zero-dependency error handling for NexVigilant Core ecosystem
-
debug_with_context
context-aware
Debugformatting via a custom derive macro -
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
generic-vec
a vector implementation that can be used in
no_stdenvioronments -
diode
Core diode library
-
transpose-future
Transpose Option<impl Future>
-
fn_meta
Returns metadata about a function at runtime
-
n-observer
An async/await observer pattern implementation
-
check
Convenience assert!-like macros which return instead of panicking
-
suika_utils
A small utility library for the suika web stack
-
ifmt
Inline expression interpolation for Rust
-
airbag
handling errors and panics using 3rd party services
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
int-to-c-enum
TryFromInt - A convenient derive macro for converting an integer to an enum
-
devela_base_alloc
base alloc shared functionality for devela
-
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…
-
exun
Handle unexpected errors
-
featureflag
Runtime feature flagging for Rust
-
bagel
Compile-time evaluation and other tools
-
causal_inspector_utils
Describe DSL and shared utilities for the causal inspector UI
-
fastapi
Compile time generated OpenAPI documentation for Rust
-
enum-struct
Add shared fields to each variant of the enum
-
notzero
macro for constructing
std::num::NonZero*from constants -
batch_oper
some batch operation macro for some operations
-
tri_ton
A Macro for Handling Exceptions
-
ktest
A custom test framework for Rust-based operating system kernels
-
effs
Effects based minimal std lib alternative
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
rustidy-ast
Rustidy formatter
-
flatty-base
Flatty traits and primitives
-
type_description
Machine-readable type descriptions
-
runtime-fmt
Runtime-based string formatting
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
field_names_and_counts
Traits for accessing field names and counts at compile time
-
facet-default
Derive Default for facet types with custom field defaults
-
tuplify
Generic hlist/tuple library
-
aether_primitives
Helpers for common SDR and signal generation operations
-
dynamic-provider
Dynamically request arbitrarily-typed values from providers with borrowed data
-
refinement-types
Refinement types
-
using-param
Add parameters, generics and return types to all functions in the impl block
-
noema
IOC and DI framework for Rust
-
fb_stats
Stats library
-
function_overloading
that adds function overloading
-
map_box_from
Adds
Box-ed versions ofFromandIntotraits - allowing implementations for unsized type parameters and following looser guidelines -
alef-backend-csharp
C# (P/Invoke) backend for alef
-
should
Postfix assertion library for Rust
-
barexp
that automatically generates mod.rs files for your project
-
ffizz-header
FFI helpers to generate a C header for your library
-
cowstr
Copy-on-Write shared strings
-
linq
Language Integrated Query in Rust
-
torrust-tracker-located-error
provide error decorator with the location and the source of the original error
-
rusty_v8_helper
Helper functions for rusty_v8_protryon
-
recursive_reference
way to walk on recursive structures easily and safely
-
recore
A re-implementation of various ::core features
-
intercom
writing COM visible Rust components
-
reflect_to
Run-time type reflection and conversion
-
flex
Flexible borrowing and ownership for Rust
-
jni-toolbox
tools to make writing JNI native functions less tiresome
-
quiet_panics
Make your panics easy to read
-
trait-morph
A lightweight procedural macro to transform
async fnin traits into-> impl Futurewith explicit bounds -
keepops
Extension traits for keeping the input of mapping functions
-
xjbutil
A xjbly created utility library for my own use
-
newtype_derive
macros for deriving common traits for newtype structures
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
stuff
Stuffing things into pointers
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
proptest-recurse
Helper for defining mutually recursive strategies with proptest
-
autosurgeon-cat
Derive-driven mapping between Rust types and automerge-cat documents
-
dims_macro
Macros for Generating Systems of Units
-
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… -
map
map!macro andmap_insert!macro, to create a HashMap collection and insert key-value pairs. Inspired by thevec!macro. -
timed-locks
Smart pointers to
tokio::synclocks that either panic or error after a timeout -
rust-2021
Macro to use Rust 2021 from all editions
-
objio
traits for reading and writing objects
-
lazy_bastard
A helpfull macro because writeing a seperate Default function is too much effort
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
assert_has_field
macro for checking if a struct has a specific field
-
abcgen
A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern
-
quick-error2
A macro which makes error types pleasant to write
-
ferrite-session
Session Types DSL for Rust
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
derive-ctor
Adds
#[derive(ctor)]which allows for the auto-generation of struct, enum, and union constructors -
type-exts
extension methods for std
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
liftor
Functors for Rust lifetimes
-
better-refcell
A drop-in replacement for RefCell with safe unborrow and reborrow capabilities
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
hooks
Compile-time, async hooks
-
maybe-uninit-ext
Extended maybe-uninit types
-
dicebag
Dice rolling!
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
inline_default
Macro for inline Default implementation
-
is_slice
Macro to answer the question: is it a slice?
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
tectonic_errors
A boxed error type for Tectonic, with supporting utilities
-
effing-mad
The hottest algebraic effects library in Rust
-
assert-order
Assert the order of Rust enum variants
-
not-found-error
Convert Option to Result using convenient functions
-
soupa
macro allowing expressions to be eagerly evaluated before a scope
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
anyhow-source-location
Two simple macros that make it easy to add the source location to the anyhow context errors
-
thinnable
Thin references to unsized types
-
tcrts
Turing complete rust type system
-
validex
Input validating library
-
option_trait
Helper traits for more generalized options
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
retry_macro
A set of declarative macros which retries executing a function upon failure
-
fieldx_aux
Various types and tools useful for fieldx crates and, potentially, to users of fieldx
-
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… -
maelstrom-test
Test macros for Maelstrom
-
nvm_rs
that provides the
nvm!macro to run safe code within unsafe blocks -
cib
proc-macros for crate cib
-
stackbox_2
&owning references in stable Rust - no_std-friendly Box -
splitmut
Safely retrieves multiple mutable values from the same collection
-
global-mockable
creating global mockable objects
-
maybe_path
Zero overhead static initializer for Path
-
rust_c
Write C code inline in your rust code (hacky fork of rust-cpp / cpp crate)
-
bhc-prelude
Core types and functions for BHC standard library
-
validator-async
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
arbintrary
Proof of concept for arbitrary integer sizes using generic const
-
ref_wrapper
Wrapper of dynamically borrowed data
-
closure_attr
An attribute macro to simplify closure captures
-
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
state-validation
Validation for states
-
syntaqlite-common
Internal shared primitives for syntaqlite — not intended for direct use
-
floxide-longrunning
Long-running node abstractions for the floxide framework
-
mediator-rs
CQRS-style mediator with type-safe command dispatch and a composable pipeline behavior system
-
dyn_struct
Construct dynamically sized types safely
-
c2r
A C to Rust conversion program
-
only_one
OnlyOne trait, which allows less nesting when chaining results
-
nohash-hasher
std::hash::Hasherwhich does not hash at all -
konst_macro_rules
detail of the konst crate
-
enum_properties
A macro for declaring static properties on enum variants
-
aoc_driver
helper macros and functions for AoC
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
syrette
The convenient dependency injection framework
-
typebitset
Type-level bitset implementation
-
crusty_traits
that creates a macro and supporting code to allow for traits to be FFI-safe using C ABI
-
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
sipha-fmt
Formatter options and helpers for sipha syntax trees
-
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
-
clamp_to
Clamp integer and float values to the values that fit within both the original number type and the receiving type
-
boost_assert
Boost C++ library boost_assert packaged using Zanbil
-
name-it
Give a name to async fn return types
-
brk-aide
A code-first API documentation library
-
unreachable
code optimization hint in stable rust
-
kaguya_rs
Functional Programming tools and ADTs
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
checked-rs
encoding validation semantics into the type system
-
bronzite-query
🔮 Rustc plugin for Bronzite compile-time reflection - extracts type information from Rust code
-
zrx-id
Identifier abstractions and utilities
-
set_slice
A macro for assigning values to slices
-
negative-impl
Negative trait implementations on stable Rust
-
option-chain
A macro for using
?operator in functions that don’t returnOption -
better-conversions
Safe and explicit numeric conversions with range and precision checking
-
opentalk-types
Types and traits for the OpenTalk API and signaling protocols
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
user_input_macros
input macros for reading single and multiple values
-
result-ext
Extends
Resultwith additional operations -
bitmask
generator for enum scoped bit flags
-
service-builder
A lightweight, type-safe service construction library for Rust that provides compile-time dependency injection through builder pattern
-
cgp-error-extra
Context-generic programming error components
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
rvvm
idiomatic RVVM Rust bindings
-
oxur-lang
Oxur language processing: parser, expander, and Core Forms IR
-
copy_from_str
An extension trait to copy a string into another string
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
cute
A macro for Python-esque comprehensions
-
structural
Field accessor traits,and emulation of structural types
-
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
-
nvim-oxi-types
Rust bindings to types used by Neovim's C API
-
enumi
Declare an enum for a range of integers
-
cmp_any
Comparison for &dyn types
-
duplex
trait: interactive streams
-
metrique-writer-core
working with unit of work metrics - writer-side interface core traits
-
rsz
parser for data files from the RE Engine
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
crfsuite-sys
Rust binding to crfsuite
-
try-lazy-init
Fallible lazy initialization
-
test_eq
assert_eq!-like macros that return a Result instead
-
lubeck
Functional programming framework written in cutting edge rust
-
escher
Self-referencial structs using the async/await transformation
-
veccell
variant of Vec with interior mutability
-
leekscript-analysis
LeekScript semantic analysis: scope, validation, type checking
-
web-time-compat
Compatibility layer for web-time
-
with-cell
More convenient Cell for non-Copy types
-
moving
Make elements of an array or a vector movable
-
coil-jobs
Background job and scheduler primitives for the Coil framework
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
rust2fun
functional programming in Rust
-
all-the-errors
Collect all the errors from iterators over results
-
slot-cell
SlotCell - an interior mutability container. It acts as a "Runtime-Checked Move Cell", providing owned access to data rather than references.
-
io-providers
Enables dependency injection for many I/O operations
-
tuple-fn
call functions and closures with tuple of arguments
-
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
-
pyo3_special_method_derive_latest_pyo3
Automatically derive Python dunder methods for your Rust code
-
tor-async-utils
Async/futures helpers for use with Tor
-
lucidstream
Event Sourcing Traits and Types
-
never-say-never
The never type (the true one!) in stable Rust
-
supercow
A generic way to accept general reference-like values without proliferating generics
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
autotrait
Reduces boilerplate by auto-generating trait definitions from impl blocks for dynamic dispatch
-
is_default
A trait for checking whether a value is default, with derive support
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
scope-guard
RAII scope guard
-
r-ex
Zero-bloat Rust core library extensions
-
llts_analysis
LLTS analysis — subset validation and type resolution
-
tdx-rs
parsing TDX files
-
difficient
Efficient, type-safe, zero-allocation structural diffing
-
kg-symbol
Atomic strings in Rust
-
cell-core-macros
Core macro types for the Cell framework
-
familiar
reserve
-
iter_seq_ext
Iterator extension for sequential items
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
semester
High efficiency classnames macro
-
omniswap
swap values between possibly-overlapping references
-
newer-type
Support defining newtype wrapper with inheriting trait implementations
-
known-types-instagram
Well-known types for Instagram APIs
-
hgm
Reproduce the Haskell syntax sugar
-
pointdexter
unifies *const/*mut pointers using the trait system
-
flexcell
A flexible cell that allows safe circumvention of double borrow issues
-
treesap
A #[derive(Parser)] interface for sap
-
com-scrape-types
Support code for bindings generated with com-scrape
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
always_equal
A wrapper for types that can't implement Eq
-
show-option
displaying Options
-
pipa
Pipe Operator Library for Rust
-
fallback-if
Fall back to an alternative given some predicate
-
karpal-recursion
Recursion schemes (cata, ana, hylo, para, apo, histo, futu, zygo, chrono) for the Industrial Algebra ecosystem
-
tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples
-
unwrap_none
Implements the
unwrap_noneandexpect_nonemethods removed by https://github.com/rust-lang/rust/pull/83349 -
error_mancer
Quickly define custom error enums for a function
-
fsl
FakeHub State Language. DSL for managing state in fakehub
-
archery
Abstract over the atomicity of reference-counting pointers
-
cismute
Safely transmute type to itself in generic contexts
-
multiconst
destructures an expression into multiple constants
-
phlow-build
Build-script support for generating phlow annotation metadata
-
cxx-symbols
detail of the
cxxcrate -
map-self
Map a value itself instead of its contained value in usual closure style
-
cow2
Like Cow<B>, but B is covariant
-
components-arena-traits
Does not intend for direct use
-
indicator
Abstractions for stream aggregation, we call them
Indicators -
split-spare
A trait to allow referencing the already initialized part of a collection while pushing into it's reserved capacity
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
fluent-string
Fluent versions of String mutation methods
-
gesha-macros
Macors for Gesha proejct
-
replicante_util_failure
Helper functions to manage failures
-
vtid
generating volatile type IDs
-
shellder
A lightweight, type-safe dependency injection and application framework for Rust inspired by Spring
-
ezexec
API to execute binaries or shell commands via
std::process::Command -
facet-spez
Auto-deref specialization helpers for the Facet reflection system
-
lifted
Higher-kinded types in Rust
-
tt-call
Token tree calling convention
-
trustmebro-macro
A macro that wraps arbitrary tokens in an unsafe block
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
chandeliers-err
Internal error message generators for the Chandeliers project
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
rukt
dialect for token-based compile-time scripting
-
httpwg-macros
Macros to allow generating httpwg unit tests
-
prae
that aims to provide a better way to define types that require validation
-
static_assert_macro
so-called
static_assert -
cashly
一个简要投资记录法的 DSL 脚本解析器, 这个库包含 EBNF 设计和 rust 的实现
-
utilz-rs
A lightweight extension trait collection for Rust primitives and types
-
abstract-getters
Abstract how, what and from where to get a value using a trait
-
swamp-std
Standard i/o functions for Swamp
-
generic-to
method-generic conversion traits
-
loso-inject
A compile-time dependency injection framework for Rust with zero runtime overhead
-
as_num
Checked conversions between Rust's numeric types
-
async_fn
Collection of helper annotations and macros for concise and yet explicit
async fnsignatures -
chomp
A fast monadic-style parser combinator designed to work on stable Rust
-
atomic_refcell
Threadsafe RefCell
-
static-dispatch
Implement a trait for an enum, where all variants implement the trait
-
without-ats
A one-function crate for removing '@...@' from a string
-
rust-2015
Macro to use Rust 2015 from all editions
-
once_cell_serde
Single assignment cells and lazy values
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
bitbag
A useful struct for dealing with bit flags
-
omitty
On-demand TypeScript-like Omit<> for Rust - generate type variants with omitted fields using #[omitty] and Omit! macro
-
dynstack
A stack for trait objects that minimizes allocations
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
bytelike
Common types and functions for byte size handling
-
rs-schema
Types modeling rust code structures
-
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.
-
hb_error
Useful macros and traits for creating and handling errors
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
wraps
create marker types that wrap other, inner, types - with trait impls matching PhantomData
-
stenm-inter-core-interface
Inter-core data types and signal primitives for STENM
-
predicates-core
An API for boolean-valued predicate functions
-
nutype_test_util
Ergonomically create newtypes in tests
-
just-string
Container for various kinds of strings
-
cdumay_error_standard
define standard errors
-
safebit
Safe and secure bit access into integer types
-
init_with
Helper trait to initilize an array with a function
-
pochoir-lang
Custom parser and interpreter for the pochoir template engine
-
dyn_safe
Take control of the Semver hazard of the
dynsafety of your traits! -
rokc_core
Core library for rokc, a kconfig parser written in rust
-
no_std_strings
no_std version of crate fixedstr: strings of constant maximum size that can be copied and stack allocated
-
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
formatter-builder
The safe and stable builder for fmt::Formatter
-
py-comp
A macro implementing a Python-like generator expression
-
specx
Minimal Specification pattern utilities for Rust with composable predicate specs, boolean combinators, and a micro-DSL
-
copstr
COpy STRing module
-
scsys-traits
scsys is a collection of primitives and utilities for use throughout the ecosystem
-
env_parser
Env parser. Parse your env file and create a Rust file with mapped properties
-
necessist-core
-
into-result
convenience trait for converting something into a
ResultorOption -
exit_safely
Enables exiting safely with custom exit codes while still calling
Dropas needed. Aims for minimal magic and maximum flexibilty. -
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. -
tor-basic-utils
General helpers used by Tor
-
unsafe-any
Traits and implementations for unchecked downcasting
-
struct_baker
enable ergonomic creation of compile time parsers
-
oxi-types
Rust bindings to types used by Neovim's C API
-
wrapping_macros
A macro for wrapping arithmetic
-
into-sorted
Collection of utility methods and functions that take an owned array and return a sorted owned array
-
swimos_form
SwimOS Serialization and Deserialization
-
random_variant
To be used with all variant, contains the derive macro
-
convert-byte-size-string
Convert a byte size string to a u128 value
-
ddi
Dynamic dependency injection library for rust
-
semire_read
A safe, easy-to-use module for reading integers, floats, and strings from stdin in Rust
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
warpin-types
Common types and primitives for the Warpin framework
-
easy-macros-helpers
Easy Macros support library
-
flow-di
A dependency injection framework for Rust inspired by C# AutoFac and Microsoft.Extensions.DependencyInjection
-
amass
Automatically generate
Fromimpls for nested enums, even across crates -
return-ok
Macros for dealing with Options and Results where you shouldn't
-
eldenring-dlrf
Macro for generating singleton specifier for usage with the DLRF singleton finder
-
strongly
A proc macro to create strongly-typed primitives
-
with_capacity_safe
A safer alternative to Vec::with_capacity with into_raw_parts which can be used from stable
-
struple
Convert structures from and to tuples
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
boost-rs
boosting your develop productivity on Rust
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
into_inner
IntoInner trait for Rust newtypes
-
rust-lcm-codegen
Generates Rust de/serialization code from LCM type specification
-
non_structural_derive
nonstructural derives for auto traits
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
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
-
phantom_newtype
Lightweight newtypes without macros
-
packer
Pack static files into your binary at compile time
-
builderx
A concise builder-pattern UI DSL for Rust
-
nougat
(lifetime) GATs on stable Rust
-
xdi
Rust di containers system
-
slist
Algebraic lists with statically determined size that live on stack
-
err-rs
Error level management
-
testify_core
The core library for the testify framework, providing the core functionality and utilities
-
portable_intertrait
Allow for inter-trait casting
-
future-local-storage
An init-once-per-future cell for thread-local values
-
degeneric-macros
Hides struct generics into trait associated types
-
torrust-index-located-error
provide error decorator with the location and the source of the original error
-
zrx-stream
Stream interface
-
static-cond
Macro for performing comparisons during macro expansion
-
zrx-store
Store abstractions and utilities
-
multiple_choice
proc-macro library that verifies function results through multiple executions
-
non-zero-size
Non-zero sizes
-
floxide-event
Event-driven node abstractions for the floxide framework
-
assert-size-derive
Compile time type size assertion attribute macro
-
variadiz
Variadic function support for rust
-
catalyser
A comprehensive collection of extensions to simplify and enhane rust development
-
dzn-rs
dealing with DZN files used in the MiniZinc language
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
blue_typemap
A TypeMap Dependency Injection method for dynamic function parameters
-
bool-enum
A macro for generating boolean-like enums that support bitwise and boolean operations
-
je-di
Hierarchical dependency injection
-
sddl
parse and analyse SDDL Strings
-
ensure_impl
Trait implementation assertion
-
known-types-gravatar
Well-known types for Gravatar APIs
-
const_typed_builder
Compile-time type-checked builder derive using const generics
-
ghosts
Type-check non-existing
Phantomcode for Fun And Profit™ -
appro-eq
Approximately equal traits and assertion
-
stringer
An easy way to turn an Unsafe *const c_char into a Rust String type and return a pointer
-
cgp-type
Context-generic programming core component traits
-
gc_abi
Gridcore Plugin Safe ABI Bindings
-
irox-types
Enums and structs to describe Rust's basic type system
-
advancer
Helper for advancing over mutable slices
-
see-through
traits to provide access to internal fields of generic structs
-
winnow-regex
A set of winnow parsers backed by the regex crate
-
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
cruxi-api
API response types and filter DSL for Cruxi
-
frust
Functional Programming in Rust
-
validus
A string validation library
-
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
fastcode
Fast to writing your code with extension function and popular crates
-
coi
Dependency Injection library
-
transmute_guard
Transmute between types that have been marked as safe by the marker type
-
rust-tailcall
TailCall, The crate is a rust implementation of The Art of Simplicity_Venkat Subramaniam
-
ketos
Lisp dialect scripting and extension language
-
fsize
fsizeis aliased to the floating-point type of pointer size -
rattish
Cast between trait objects
-
beaver
setting up Rust objects inspired by factory_bot
-
teloc
compile-time DI framework for Rust
-
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…
-
astr
A const lenght stack str
-
unzip3
Same as Iterator::unzip, but for 3 items. Based on Rust 1.6 implementation.
-
samtest
Vitest-inspired testing for Rust
-
macro-bits
performing macro-based bit manipulation
-
treeerror
macros for generating trees of enums, as well as
Fromimplementations converting between them. Primarily intended for error handling. -
safecast
Traits to define safe casting between types
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
stack_box
store unsize struct on stack with static check
-
assert_eq
location-aware equality assertions
-
respan
Macros to erase scope information from tokens
-
digitize
Traits for accessing digits of primitive integers & floats
-
atomflag
Atomics for your bitflags!
-
assert_cfg
static assertions for crate features, with descriptive errors
-
emplacable
Return unsized values from functions
-
karpal-free
Free constructions (Coyoneda, Yoneda) for the Industrial Algebra ecosystem
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
nightly-quirks
A basic set of utilities that mimic nightly behaviour in stable Rust, with the possibility of using nightly implementation with the nightly feature
-
io-adapters
Adapters to convert between different writable APIs
-
ambit
Attribute macro for ranged number newtypes
-
take-static
Static items that provide mutable access only once
-
entrance
A command line argument parser library which provides type assisted tools
-
cereal
data serialisation library
-
derive_convert
Derives 'impl (Try)From for Self' and 'impl (Try)From<Self>'
-
tokio-timeout
A proc-macro which adds a timeout to an asynchronous function running under the tokio runtime
-
http-error
Error trait to help convert errors to http error responses
-
std2
"minimal std is a feature" - a coping rust shill
-
tacit
macro to make newtypes easier to create
-
atomint
Trait for mapping integer types to their corresponding atomic types
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
ident-util
macro to determine the string name of a binding, type, const, or function
-
string_macro
macro to create string
-
ranvier-std
Standard Module Library for Ranvier
-
rustidy-parse
Rustidy formatter
-
stringreader
wrapper for strings so that they can be consumed via the std::io::Read trait
-
the-newtype
The Newtype trait
-
shared_error
SharedError wrapper for cloneable Error
-
craken-container
Compile-time safe dependency injection container for the Craken framework
-
phlow-extensions
Phlow views for Rust's core types
-
var_num
Variable length number implementation that can be used as a drop in replacement for any number primitive
-
conveyor-etl-dsl
YAML DSL parser for Conveyor ETL pipeline definitions
-
no-std-thiserror
thiserror but no_std compatible
-
choices
HTTP configuration service by defining a struct
-
docify_clone
Docify allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
telocs
compile-time DI framework for Rust
-
arc-interner
An interner that deallocates unused values
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
ffizz-string
FFI string implementation
-
iter-python
Python generator expressions and 'list' comprehensions
-
cursor
A more free Rust-Iterator
-
cflp
A context-free-language parser generated by procedural macros
-
eso
Type machinery to build Cow-like containers
-
devela_base_std
base std shared functionality for devela
-
type-const
Type-level associated consts
-
type-toppings
Opinionated extensions to standard types
-
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
io-arrays
Random-access I/O
-
gostd_strings
part of gostd, gostd_strings 是go标准库strings的rust实现
-
litenum
minimal convertion utilities between literal and enum
-
fromage
A cheesy Rust hack for converting between non-local types
-
result_option
An enum combining Result and Option into a single type
-
facet-opaque
Type-erased pointer helpers for Facet types