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