-
bitflags
A macro to generate structures which behave like bitflags
-
anyhow
Flexible concrete Error type built on std::error::Error
-
zerocopy
makes zero-cost memory manipulation effortless. We write "unsafe" so you don't have to.
-
once_cell
Single assignment cells and lazy values
-
derive_more
Adds #[derive(x)] macros for more traits
-
arrow
Apache Arrow
-
pretty_assertions
Overwrite
assert_eq!andassert_ne!with drop-in replacements, adding colorful diffs -
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
-
ordered-float
Wrappers for total ordering on floats
-
eyre
Flexible concrete Error Reporting type built on std::error::Error with customizable Reports
-
derive_builder
Rust macro to automatically implement the builder pattern for arbitrary structs
-
predicates
boolean-valued predicate functions
-
thiserror
derive(Error)
-
pin-project-lite
A lightweight version of pin-project written with declarative macros
-
num_enum
Procedural macros to make inter-operation between primitives and enums easier
-
validator
Common validation functions (email, url, length, …) and trait - to be used with
validator_derive -
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…
-
bytes
Types and traits for working with bytes
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
snafu
An ergonomic error handling library
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
enumflags2
Enum-based bit flags
-
inventory
Typed distributed plugin registration
-
zerovec
Zero-copy vector backed by a byte array
-
assert-json-diff
Easily compare two JSON values and get great output
-
self_cell
Safe-to-use proc-macro-free self-referential structs in stable Rust
-
approx
Approximate floating point equality comparisons and assertions
-
similar-asserts
assert_eq! like macros with colorized diff output
-
enum-map
A map with C-like enum keys represented internally as an array
-
utoipa
Compile time generated OpenAPI documentation for Rust
-
miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
generic-array
Generic types implementing functionality of arrays
-
pin-project
safe and ergonomic pin-projection
-
ouroboros
Easy, safe self-referential struct generation
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
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.
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
frunk
developers with a number of functional programming tools like HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid, Semigroup and friends
-
macro_rules_attribute
Use declarative macros in attribute or derive position
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
enum-iterator
Tools to iterate over all values of a type (e.g. all variants of an enumeration)
-
downcast-rs
Trait object downcasting support using only safe Rust. It supports type parameters, associated types, and type constraints.
-
float-cmp
Floating point approximate comparison traits
-
dlopen2
opening and operating on dynamic link libraries (also known as shared objects or shared libraries)
-
dyn-clone
Clone trait that is dyn-compatible
-
tap
Generic extensions for tapping values in Rust
-
nonempty
Correct by construction non-empty vector
-
az
Casts and checked casts
-
smol_str
small-string optimized string type with O(1) clone
-
bitfield
macros to generate bitfield-like struct
-
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… -
typed-builder
Compile-time type-checked builder derive
-
memoffset
offset_of functionality for Rust structs
-
human-panic
Panic messages for humans
-
streaming-iterator
Streaming iterators
-
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
-
error-stack
A context-aware error-handling library that supports arbitrary attached user data
-
extendr-api
Safe and user friendly bindings to the R programming language
-
cmd_lib
Common rust commandline macros and utils, to write shell script like tasks easily
-
cargo-manifest
Helper crate to parse and manipulate manifests -
Cargo.tomlfiles -
rustlings
Small exercises to get you used to reading and writing Rust code!
-
new_debug_unreachable
panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)
-
decorum
Total ordering, equivalence, hashing, and constraints for floating-point types
-
replace_with
Temporarily take ownership of a value at a mutable location, and replace it with a new value based on the old one
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
polonius-the-crab
Tools to feature more lenient Polonius-based borrow-checker patterns in stable Rust
-
deku
bit level serialization/deserialization proc-macro for structs
-
cfg_aliases
A tiny utility to help save you a lot of effort with long winded
#[cfg()]checks -
rustc_apfloat
Rust port of C++ llvm::APFloat library
-
writeable
A more efficient alternative to fmt::Display
-
process-wrap
Wrap a Command, to spawn processes in a group or session or job etc
-
nutype
The newtype with guarantees
-
volatile
wrapper types for raw pointers
-
bit_field
bit field trait providing get_bit, get_bits, set_bit, and set_bits methods for Rust's integral types
-
safer-ffi
Write safer FFI code in Rust without polluting it with unsafe code
-
arrayref
Macros to take array references of slices
-
rustdoc-types
Types for rustdoc's json output
-
nonmax
Numeric types that cannot hold maximum values
-
beef
More compact Cow
-
assertables
assert macros for better testing, debugging, quality assurance, and runtime reliability
-
derive-where
Deriving with custom trait bounds
-
counter
package to count generic iterables
-
constcat
concat! with support for const variables and expressions
-
educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
iri-string
IRI as string types
-
easy-cast
Type conversions which are expected to succeed
-
trie-db
Merkle-Patricia Trie generic over key hasher and node encoding
-
konst
Const equivalents of std functions, compile-time comparison, and parsing
-
stdext
Extensions for the Rust standard library structures
-
if_chain
Macro for writing nested
if letexpressions -
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
index_vec
Newtype-style helpers for
Vecandusize -
async-once-cell
Async single assignment cells and lazy values
-
flagset
Data types and a macro for generating enumeration-based bit flags
-
multimap
A multimap implementation
-
io-extras
File/socket handle/descriptor utilities
-
j4rs
j4rs stands for 'Java for Rust' and allows effortless calls to Java code, from Rust
-
assert_matches
Asserts that a value matches a pattern
-
bounded-integer
Bounded integers
-
orchestra
Generate an orchestra of subsystems from a single struct
-
float-ord
A total ordering for floating-point numbers
-
jsonptr
Data structures and logic for resolving, assigning, and deleting by JSON Pointers (RFC 6901)
-
auto_impl
Automatically implement traits for common smart pointers and closures
-
by_address
Wrapper for comparing and hashing pointers by address
-
typify
JSON schema to rust type code generator
-
unwinding
in Rust and for Rust
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
la-arena
index-based arena without deletion
-
tynm
Returns type names in shorter form
-
speculoos
Fluent test assertions
-
testresult
type for concise and precise test failures
-
axum-valid
validation extractors for your Axum application, allowing you to validate data using validator, garde, validify or all of them
-
recursion
cache-aware stack safe recursion
-
const-gen
generating (relatively) complex compile-time constants in rust
-
color-eyre
An error report handler for panics and eyre::Reports for colorful, consistent, and well formatted error reports for all kinds of errors
-
maplit
Collection “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
event-manager
Abstractions for implementing event based systems
-
byte-slice-cast
Safely cast bytes slices from/to slices of built-in fundamental numeric types
-
arrow-buffer
Buffer abstractions for Apache Arrow
-
extism-pdk
Extism Plug-in Development Kit (PDK) for Rust
-
swift-rs
Call Swift from Rust with ease!
-
lazy_format
lazily formatting values for later
-
fallible_collections
adds fallible allocation api to std collections
-
virtue
A sinless derive macro helper
-
terrors
ergonomic and precise error handling built atop type-level set arithmetic
-
rustrict
profanity filter for Rust
-
indenter
A formatter wrapper that indents the text, designed for error display impls
-
comparable
comparing data structures in Rust, oriented toward testing
-
ref-cast
Safely cast &T to &U where the struct U contains a single field of type T
-
doc-comment
Macro to generate doc comments
-
erasable
Type-erased thin pointers
-
anymap3
A safe and convenient store for one value of each type
-
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 -
cool_asserts
A collection of useful testing assertions and utilities
-
lender
A lending-iterator trait based on higher-rank trait bounds, with full std::iter::Iterator functionality
-
field-offset
Safe pointer-to-member implementation
-
typewit
type-witness-based abstractions, mostly for emulating polymorphism in const fns
-
tlua
Zero-cost high-level wrapper for Tarantool-LuaJIT
-
ra_ap_stdx
Missing batteries for standard libraries for rust-analyzer
-
tuples
many useful tools related to tuples
-
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… -
async-trait
Type erasure for async trait methods
-
rustc-literal-escaper
code to unescape string literals
-
enclose
A convenient macro, for cloning values into a closure
-
tiny-fn
Type erased closures on stack
-
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
-
tryhard
Easily retry futures
-
ptr_meta
A radioactive stabilization of the ptr_meta rfc
-
buffered-reader
A super-powered Reader
-
dynosaur
Dynamic dispatch for return position impl traits and async in Rust
-
google-youtubereporting1
A complete library to interact with YouTube Reporting (protocol v1)
-
pinned-init
facilitate safe pinned initialization
-
indoc
Indented document literals
-
fatality
extension to
thiserror::Error -
fallible-iterator
Fallible iterator traits
-
safe-transmute
A safeguarded transmute() for Rust
-
soa_derive
Automatic Struct of Array generation
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
egui-probe
Trait and derive macro for exposing value editing in egui
-
st-map
Runtime for a stack-alocated map
-
resman
Runtime managed resource borrowing
-
as-any
provide the AsAny trait
-
drop_bomb
A runtime guard for implementing linear types
-
auto_enums
allow multiple return types by automatically generated enum
-
oxc-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
more-asserts
Small library providing additional assert_* and debug_assert_* macros
-
pusherator
Push-based version of Rust iterators
-
try_match
Fallible pattern matching with a function-like syntax
-
rustversion
Conditional compilation according to rustc compiler version
-
psm
Portable Stack Manipulation: stack manipulation and introspection routines
-
bounded-collections
Bounded types and their supporting traits
-
castaway
Safe, zero-cost downcasting for limited compile-time specialization
-
value-trait
Traits to deal with JSONesque values
-
atomic_refcell
Threadsafe RefCell
-
fallible-streaming-iterator
Fallible streaming iteration
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
outref
Out reference
-
myutil
Rust Util Collections
-
implicit-clone
Immutable types and ImplicitClone trait similar to Copy
-
deno_error
Error representation to JavaScript for deno
-
merge
multiple values into one
-
munge
Macro for custom destructuring
-
impl-more
Concise, declarative trait implementation macros
-
strck
Checked owned and borrowed strings
-
deriving_via
DerivingVia
-
mirai-annotations
Macros that provide source code annotations for MIRAI
-
typed-generational-arena
A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices. Now with typed indices and custom integer types for generations!
-
overload
macro to simplify operator overloading
-
shaku
Compile Time Dependency Injection for Rust
-
orx-fixed-vec
An efficient fixed capacity vector with pinned element guarantees
-
reval
expression evaluator
-
socketpair
Cross-platform socketpair functionality
-
reborrow
Emulate reborrowing for user types
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
okapi
Structs for OpenAPI (AKA Swagger) documents
-
oxc_index
Newtype-style helpers for
Vecandusize -
lending-iterator
Fully general lending iterators in stable rust: windows_mut!
-
async-condvar-fair
Condition variables for async Rust
-
cap-std-ext
Extension APIs for cap-std
-
vtable
Helper crate to generate ffi-friendly virtual tables
-
o2o
Object to Object mapper for Rust. Derive '(Try)From' and '(Try)Into' traits.
-
tstr
Type-level strings
-
version-sync
ensuring that version numbers in README files and other files are kept in sync with the crate version
-
retry-error
An error type for an operation that can fail more than once
-
halo2-base
Embedded domain specific language (eDSL) for writing circuits with the
halo2API. It simplifies circuit programming to declaring constraints… -
formatx
A macro for formatting non literal strings at runtime
-
joinery
A small crate for generically joining iterators with a separator
-
ltpp-output
An atomic output library based on Rust that supports output functionalities through functions, builders, and other methods. It allows customization of text and background colors.
-
sealed
Macro for sealing traits and structures
-
const_soft_float
Const Soft Float Point
-
shape
A decidable static shape system for JSON-like data
-
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. -
as_variant
macro to convert enums with newtype variants to
Options -
macon
builder macro-based generator with its own idioms
-
cast_trait_object
Cast between trait objects using only safe Rust
-
cascade
Dart-like cascade macro for Rust
-
string_cache
A string interning library for Rust, developed as part of the Servo project
-
dprint-swc-ext
Functionality to make swc easier to work with
-
makers
a POSIX-compatible make implemented in Rust
-
fluent-comparisons
Boost readability by writing multicomparison expressions like
if any_of!({a,b,c}>=5) {...}while keeping the benefits of hand-written code -
dupe
Marker for types which are cheap to clone
-
autosurgeon
working with data in automerge documents
-
loupe
Profiling tool for Rust
-
k8-client
Core Kubernetes metadata traits
-
lazy_errors
Effortlessly create, group, and nest arbitrary errors, and defer error handling ergonomically
-
graphql-tools
Tools for working with GraphQL in Rust, based on graphql-parser Document
-
argp
Derive-based argument parser optimized for code size
-
inline-python
Inline Python code directly in your Rust code
-
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…
-
environmental
Set scope-limited values can can be accessed statically
-
flex-error
Flexible error definitions using macros and traits
-
valico
JSON Schema validator and JSON coercer
-
pyinrs
type library that is as easy to use as Python built-in types
-
cluFullTransmute
A more complete and extended version of data type conversion without constraint checks
-
pin-utils
pinning
-
okapi-operation
Procedural macro for generating OpenAPI operation specification (using okapi)
-
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.
-
assert-eq-float
assert_eq_float!macros that support floats -
core_extensions
Extensions for core/std library types, and other miscelaneous features
-
components-arena
creating complex domain-specific self-referential data structures
-
thiserror-context
A wrapper around thiserror, giving you the ability to add context
-
elain
Set a type's minimum alignment with const generics
-
rc-box
Known unique versions of Rc and Arc
-
thiserror-ext
Useful extension utilities for
thiserror -
rustica
functional programming library for the Rust language
-
transformers
intuitive interface for Rust developers who want to work with Large Language Models locally, powered by the Candle crate. It offers an API inspired by Python's Transformers, tailored for Rust developers.
-
error_set
An error set macro that simplifies error management by providing a streamlined method for defining errors and easily converting between them. Inspired by Zig's error set type.
-
better_scoped_tls
scoped-tls, but with good error message
-
base-traits
base traits (for Rust)
-
gofer
Gofer.rs makes it easy to fetch data from any URL
-
r3bl_redux
Redux library built using Tokio, concurrent & parallel
-
type_reflect
Extensible runtime reflection through a Derive macro
-
capacity_builder
Builders where the code to calculate the capacity is the same as the code to write what's being built
-
jemmy
This package provides a coherent set of manual accessor macros
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
retry
retrying operations that can fail
-
andex
Safe, strongly typed array indexes and wrappers for rust with zero dependencies
-
stdio-override
overriding Stdin/Stdout/Stderr with a different stream
-
ra-ap-rustc_lexer
Automatically published version of the package
rustc_lexerin the rust-lang/rust repository from commit febb10d0a2d29278135676783f6a22eb83295981 The publishing script for this crate lives at:… -
buildstructor
Macro to derive a builder from a constructor function
-
miden-miette
Fancy diagnostic reporting library and protocol for us mere mortals who aren't compiler hackers
-
fixnum
Fixed-point numbers with explicit rounding
-
condtype
Choose types at compile-time via boolean constants
-
fix-hidden-lifetime-bug
Proc-macro to write an automatic fix for the "hidden lifetime in impl Trait" issue
-
documented
Derive and attribute macros for accessing your type's documentation at runtime
-
dync
An efficient alternative to
dyn Traitfor containerized types -
aws-smithy-types-convert
Conversion of types from aws-smithy-types to other libraries
-
rust_info
Extracts the current rust compiler information
-
alfrusco
building Alfred workflows with Rust
-
extend
Create extensions for types you don't own with extension traits but without the boilerplate
-
lambda_calculus
zero-dependency implementation of pure lambda calculus in Safe Rust
-
option_trait
Helper traits for more generalized options
-
anystack
Flexible and comprehensive error handling
-
parse-display
Procedural macro to implement Display and FromStr using common settings
-
uniplate
boilerplate-free operations on tree-shaped data types
-
statum
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
biscuit-parser
Datalog parser used in the biscuit-auth and biscuit-quote crates
-
sugars
An useful collection of macros to make tasks easier
-
moveit
safe, in-place construction of Rust (and C++!) objects
-
typeid
Const TypeId and non-'static TypeId
-
tor-units
macros for types which are constrained within a range, ensuring invalid values are unrepresentable
-
dispose
wrapper for values that must be consumed on drop
-
maybe-owned
MaybeOwned(andMaybeOwnedMut) type similar to std’sCowbut it implementsFrom<T>andFrom<&'a T>and does not requireToOwned -
tskit
rust interface to tskit
-
rst_lex
lexer for Rust
-
data-rw
io buffer write reader
-
autofolder
Single-element folding wrapper
-
core_maths
Extension trait for full float functionality in
#[no_std]backed bylibm -
exhaust
Trait and derive macro for working with all possible values of a type (exhaustive enumeration)
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
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… -
cynic-codegen
Procedural macro code generation for cynic - a code first GraphQL client for Rust
-
orion-error
Struct Error for Large Project
-
garnish_lang_traits
Shared traits for garnish core libraries
-
io-streams
Unbuffered and unlocked I/O streams
-
qualifier_attr
Procedural macro attributes for adding "qualifiers" (pub, async, unsafe, const, extern "C", ...) to various items
-
dioxus-router
Cross-platform router for Dioxus apps
-
racer
Code completion for Rust
-
panic-halt
Set panicking behavior to halt
-
proc-bitfield
expressively declare bitfield-like structs
-
sparkles
Capture execution flow of your Rust application with CPU cycle precision!
-
metered
Fast, ergonomic metrics for Rust!
-
lazyinit
Initialize a static value lazily
-
erg_linter
the Erg linter
-
phantom-type
A
PhantomDataanalog which prevents “parameter is never used” error, but does not produce any restrictions in contrast withPhantomData -
ownedbytes
Expose data as static slice
-
wallee
Flexible concrete Error type built on std::error::Error with caller location tracking
-
sptr
Strict Provenance Polyfill
-
secretary
Transform natural language into structured data using large language models (LLMs) with powerful derive macros
-
valitron
ergonomics, functional and configurable validator
-
codegen
generating Rust code
-
mintyml
A minialist alternative syntax to HTML
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
crevice
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
entrait
Loosely coupled Rust application design made easy
-
freecs
A high-performance, archetype-based Entity Component System (ECS) written in Rust
-
processmanager
manage process lifecycles, graceful shutdown and process faults
-
random-number
Generate random numbers quickly
-
sbnf
A BNF-style language for writing sublime-syntax files
-
derive-io
derive macros for
std::io::{Read,Write},tokio::io::{AsyncRead,AsyncWrite}and more -
open-enum
An attribute for generating "open" fieldless enums, those that accept any integer value, by using a newtype struct and associated constants
-
smarterr
Smart error handling library
-
crevice_notan
Create GLSL-compatible versions of structs with explicitly-initialized padding
-
strong-type
Procedural macros for naming and strong-typing pritimives and strings
-
cirru_parser
Parser for Cirru text syntax
-
iced_anim
creating animations in Iced
-
gerber-types
Types and code generation for Gerber files (RS-274X)
-
try-specialize
Zero-cost specialization in generic context on stable Rust
-
srdf
RDF data shapes implementation in Rust
-
portrait
Fills an
implwith the associated items required by the trait -
thiserror-core
derive(Error)
-
lazycell
providing a lazily filled Cell struct
-
variadics
Variadic generics on stable Rust using tuple lists
-
include-utils
mdBook-like include macro as the powerful replacement for the standard
include_strmacro -
display-error-chain
Formats a standard error and its sources
-
aerosol
dependency injection for Rust
-
tan
language
-
rust-loguru
A flexible and extensible logging library for Rust. Similar functionality as python's loguru package.
-
sabi-rust
A small framework to separate logics and data accesses for Rust application
-
with_locals
Function attribute to return references to locals by using CPS
-
TSPL
The Simplest Parser Library
-
delegation
Macro-based delegation for enums and structs
-
beekeeper
A full-featured worker pool library for parallelizing tasks
-
tighterror
A minimalistic error representation framework
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
macro-attr-2018
macro_attr!macro that enables the use of custom, macro-based attributes and derivations -
xx
A collection of useful Rust macros and small functions
-
void
The uninhabited void type for use in statically impossible cases
-
reactive_stores
Stores for holding deeply-nested reactive state while maintaining fine-grained reactive tracking
-
tuple
Element-wise operations on tuples
-
ra_ap_ide_assists
Code assists for rust-analyzer
-
istring
A replacement for String that allows storing short strings of length up to sizeof<String>() - 1 without a heap allocation
-
emboss
Macros to embed metadata as an ELF/Mach-O section in your final binary
-
current
setting current values for stack scope, such as application structure
-
collection_literals
macros for initializing any collection
-
loga
Combined logging and error handling
-
pared
Projected reference counted pointers
-
float8
8-bit floating point types for Rust
-
one_err
OneErr to rule them all
-
redb_model
Redb model derive macro and DTO type conversion
-
inline-c
Write and execute C code inside Rust
-
k8s-openapi-codegen-common
Common code for the k8s-openapi code generator and k8s-openapi-derive
-
tracerr
Custom compile-time captured error tracing
-
aranya-capi-core
Aranya's C API tooling
-
optics
A no_std-compatible optics library providing composable lenses, prisms, isomorphisms, and fallible isomorphisms
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
tinyvec_macros
Some macros for tiny containers
-
v-storage
Storage layer for the veda platform
-
arrow-data
Array data abstractions for Apache Arrow
-
pretty-error-debug
If the process ends with an
Error, write out theErrormessage and chain -
endian-writer
[no_std] Methods for efficient reading and writing of structures to raw pointers in a stream-like fashion
-
termprogress
A terminal progress bar renderer with status and spinners
-
hyper_byte
An unsafe, near-zero cost (1-2 instructions) byte transmuter to numeric types with fast byte reader
-
sdl3-main
Tools for using SDL's main and callback APIs
-
soa-rs
A Vec-like structure-of-arrays container
-
small_type_id
generation constant 32 bit nonzero unique identifiers for types
-
ungrammar
A DSL for describing concrete syntax trees
-
monadify
functional programming abstractions in Rust, focusing on Monads, Functors, Applicatives, and related concepts
-
funcmap
Derivable functorial mappings for Rust
-
unty
Explicitly types your generics
-
tokio-util-codec-compose
Building blocks for composing tokio-util codecs
-
taurpc
A type-safe IPC layer for tauri commands
-
cbsk_mut_data
ref mut tool
-
fav_core
Fav's core crate; A collection of traits
-
acts
a fast, lightweight, extensiable workflow engine
-
certain-map
A typed map which can make sure item exist
-
bitflag
A macro to generate bitflags structures from C-like enums
-
axum_responses
way to use Axum responses
-
async-fn-stream
Lightweight implementation of
async-streamwithout macros -
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
-
bounded-static
Defines the ToBoundedStatic and IntoBoundedStatic traits
-
cbor-data
using CBOR as in-memory representation for working with dynamically shaped data
-
sod-actix-web
Service Oriented Design - Actix Web
-
gstuff
Small macro and trinkets that make my life easier
-
async-recursion
Recursion for async functions
-
zoet
Adds
#[zoet]macro to reduce boilerplate when implementing common traits -
conflate
Merge multiple values into one
-
concat-with
Extend the function of the
concat!macro instd -
ufotofu
Abstractions for lazily consuming and producing sequences
-
pilgrimage
A Kafka-like message broker in Rust
-
human-errors
An error library focused on providing your users with relevant advice for any problem
-
rbx_types
Types used to represent Roblox values
-
marauders
A work-in-progress code mutation tool
-
compiler_builtins
Compiler intrinsics used by the Rust compiler
-
cell_wrappers
set of macros for ergonomically working with TCells and TLCells from the qcell crate
-
caret
Macros for declaring non-exhaustive C-style enumerations, with named members
-
direction
Representations of directions
-
simple-zanzibar
A simplified Rust implementation of Google's Zanzibar authorization system with DSL support
-
tw_merge
merging Tailwind CSS classes or creating variants
-
ext-trait
Annotation to easily define ad-hoc / one-shot extension traits
-
wasm-bindgen-wasm-conventions
working with Wasm codegen conventions (usually established by LLVM/lld)
-
figura
A flexible string template formatting crate
-
mydi
MyDI. Dependency Injection library
-
codama-nodes
Node specifications and helpers for the Codama standard
-
enum-derived
Generate random instances of your enums and structs
-
tea-core
Core data structures and traits for tevec
-
sosecrets-rs
Secretwrapper type that reveals the secret at mostMEC: typenum::Unsignedtimes with compile time guarantees -
refined_type
imbuing rules into types and elevating them to more robust types
-
dtype_dispatch
Macro builder for working with data types
-
arrow-array
Array abstractions for Apache Arrow
-
bilge
Use bitsized types as if they were a feature of rust
-
dyf
Dynamic string formatting library for Rust supporting all standard format specifiers
-
arr_macro
Initialize arrays with ease!
-
spacetimedsl
Ergonomic DSL for SpacetimeDB
-
typesafe_builder
A procedural macro to generate type-safe builder patterns for Rust structs
-
fmt2io
A bridge between std::io::Write and std::fmt::Write
-
sas-lexer
Ultra fast "correct" static context-aware parsing SAS code lexer
-
auto_ops
Macros for easy operator overloading
-
explicit-error
Explicit concrete Error type for binary crates
-
relative-duration
Duration with negative capabilities
-
scoped-stream-sink
Easy way to make streams and sinks
-
culpa
error-handling syntax in Rust
-
anyinput
A macro for easier writing of functions that accept any string-, path-, iterator-, array-, or ndarray-like input
-
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) -
defer
excecution of code, inspired by go's defer statement
-
tycho-asm
TVM Assembler
-
hax-frontend-exporter
mirrors of the algebraic data types used in the Rust compilers, removing indirections and inlining various pieces of information
-
derive_destructure2
Destructure structs that implement Drop
-
fauxgen
write your own generators in stable rust
-
wot-td
Web of Things (WoT) Thing Description manipulation
-
crustal
generating C/C++ code
-
fixed-hash
Macros to define custom fixed-size hash types
-
rust-box
odd set of tools for Rust programming
-
bizerror
standardized approach for defining and managing business-related errors
-
enum-assoc
Procedural macro to associate constants with enum variants
-
foreign-types
A framework for Rust wrappers over C APIs
-
peggen
Generate recursive-descent & precedence climbing parsers
-
pipe-trait
possible to chain regular functions
-
bio-types
A collection of common biomedical types for use in rust-bio and rust-htslib
-
bears_health
Testing suite for the bears library
-
synonym
Customizable derive macro to create newtypes. It peeks into the underlying type to choose which traits should be implemented.
-
case_insensitive_string
A case insensitive string struct
-
timely_bytes
Disjoint mutable byte slices from a common allocation
-
quither
A flexible enum-based utility for representing values that may be on the left, right, neither, or both sides
-
eio-okta-data
Data Types for Okta
-
doku
A framework for documenting Rust data structures
-
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
-
elicit
SmartPointer-like structure for polymorphism
-
cexpr
A C expression parser and evaluator
-
num-t
Num<T>: Associate arbitrary types with numeric types
-
reflectapi
code-first web service API declaration and corresponding clients code generation tools
-
sal-process
SAL Process - Cross-platform process management and command execution
-
fastn-type
fastn: Full-stack Web Development Made Easy
-
pawc
🐾 PawScript interpreter
-
rc-borrow
Borrowed forms of Rc and Arc
-
struct-metadata
Macros for attaching metadata to structs
-
structz
Anonymous struct implementation in rust
-
wiwi
Stuff™
-
slice-diff-patch
providing utility functions for diff and patch of slices
-
codespan_preprocessed
Beautiful diagnostic reporting for M4 (or cpp) preprocessed text files
-
wartcl
A minimal embeddable Tcl-like language
-
spacetimedb-primitives
Primitives such as TableId and ColumnIndexAttribute
-
easy-ext
A lightweight attribute macro for easily writing extension trait pattern
-
lowdash
A Lodash inspired utility library to manipulate array and object for Rust
-
file_rw
high-performance, memory-mapped file I/O utilities
-
witnesscalc-adapter
run witnesscalc in rust
-
quad-url
Plugin for macro-, mini-quad (quads) to do anything with url
-
steel-parser
Parser for use within steel
-
slip-10
SLIP10 implementation in Rust
-
copyless
Ways to eliminate memcpy calls when using the standard library
-
datasize
A simplified heap memory size estimator
-
thiserror-no-std
derive(Error)
-
ijzer
Main crate for IJzer. Provides a macro for using IJzer in a rust project, and a prelude with dependencies..
-
fn_meta
Returns metadata about a function at runtime
-
std_io_iterators
An iterator for
STDINand a wrapper forSTDOUT. Allows easy piping, and graceful closing of application if pipe breaks -
yoshi-std
Core, std-only error type for the Yoshi framework
-
compactly
encode data types using adaptive arithmetic coding
-
aad
Automatic adjoint differentiation library
-
fp_rust
Implement fp features for Rust
-
relrc
Reference counted pointers, with relationships to other pointers
-
swamp
script language for embedding
-
salsa-macro-rules
Declarative macros for the salsa crate
-
culprit
error crate with the goal of identifying precisely where and in which context an error occurs
-
eira
Ansi-colored error reporting output
-
slice_map
A generic container to store a single type of data into unevenly sized slices
-
oxrdf
providing basic data structures related to RDF
-
cfg-iif
A macro for defining
#[cfg]if-elsefunctions -
mime2
MIME types that are up to date
-
lazybe
Handy CRUD boilerplate macros and utils for Rust backend
-
tokenlock
cell types that decouple permissions from data
-
state-department
state management and dependency injection in Rust
-
rancor
Scalable and efficient error handling without type composition
-
moduforge-macros
moduforge 宏定义
-
cast
Ergonomic, checked cast functions for primitive types
-
termite-dmg
Termite Data Model Generator is a crate meant to generate boiler plate code for data models
-
custom_error
Define custom errors without boilerplate using the custom_error! macro
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
model-mapper
Derive macro to map between different types
-
char-device
Character Device I/O
-
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. -
hlist2
Compile-time heterogeneous list implementation
-
generic-upper-bound
Stable workaround for internal uses of generic-const-exprs
-
enum2egui
derive macro that creates a set of egui ui databindings from arbitrary data structures. Supports egui v0.31.0
-
subplotlib
functions and types for
subplot codegengenerated Rust based test suites. Relies onsubplotlib-derivefor associated macros. -
gerber_viewer
A cargo crate for rendering Gerber files
-
conv2
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
collate
Traits and a data structure to support collation and bisection
-
anybytes
A small library abstracting over bytes owning types in an extensible way
-
directed-visit
Visitor pattern with interchangable implementations for both the visit algorithm and node object traversal
-
exhaustive
The trait for generating all values of a type, and a property-based test macro
-
resiter
Helper crate for handling iterators over result
-
ankiconnect-rs
A package for convenient interaction with AnkiConnect
-
luau-parser
A blazingly fast Luau parser with robust error recovery
-
bencher
port of the libtest (unstable Rust) benchmark runner to Rust stable releases. Supports running benchmarks and filtering based on the name. Benchmark execution works exactly the same…
-
openapiv3-extended
data structures that represent the OpenAPI v3.0.x specification easily deserializable with serde
-
debug3
Space Efficient Pretty Printer
-
openrunner-rs
running OpenScript
-
drying_paint
observer pattern for Rust
-
jni-toolbox
tools to make writing JNI native functions less tiresome
-
pingora-error
Error types and error handling APIs for Pingora
-
autofloat
Pure Rust library for efficient automatic differentiation
-
translatable
A robust internationalization solution for Rust featuring compile-time validation, ISO 639-1 compliance, and TOML-based translation management
-
stringleton
Extremely fast string interning library
-
raw-parts
Ergonomic wrapper around
Vec::from_raw_partsandVec::into_raw_parts -
frunk_proc_macro_helpers
Common internal functions for frunk's proc macros
-
double-trait
A procedural macro to derive a mirror of a trait designed to make it easier to implement test doubles
-
simple-error
error type backed by a string
-
stackerror
A pragmatic error handling library for Rust that provides helpful strings for debugging, and structured data for runtime error handling
-
http-request-derive-client-reqwest
Use derive to create HTTP requests - reqwest client
-
machine-check
Formal verification tool for digital systems
-
pavex_miette
A custom Miette theme for Pavex CLI errors
-
sector
A stateful vector implementation that provides different memory management behaviors through Rust traits and state machines
-
dynamic-plugin
Write compile-time-checked, dynamically-loaded plugin libraries for your Rust software
-
errs
handling errors with reasons
-
multiple_errors
Propagate multiple errors instead of just the first one
-
as-is
An abstraction over ownership
-
route_match
A context-agnostic http routing utility
-
derive-merge-struct
A derive macro to partially update a named struct
-
downcast
Trait for downcasting trait objects back to their original types
-
scsys-traits
scsys is a collection of primitives and utilities for use throughout the ecosystem
-
bigerror
handle big errors ¯\_(ツ)_/¯
-
google-pagespeedonline2
A complete library to interact with pagespeedonline (protocol v2)
-
metastruct
Abstractions for iterating and mapping over struct fields
-
evcxr_repl
A REPL for Rust
-
devela
A development layer
-
kcr_mutations_gatekeeper_sh
Kubernetes Custom Resource Bindings
-
ffi_helpers
help make working with FFI easier
-
re_arrow2
Unofficial implementation of Apache Arrow spec in safe Rust
-
structx
Simulating anonymous struct and named arguments in Rust
-
ruut-functions
parse math functions from string (1D,2D,3D,ND) and perform symbolic derivation, gradient, hessian
-
orx-pinned-vec
PinnedVectrait defines the interface for vectors which guarantee that elements added to the vector are pinned to their memory locations unless explicitly changed -
ordr
Executes and keeps track of a set of interdependent functions
-
prima_bridge
implement the bridge pattern
-
traitsequence
Traits to abstract over sequences
-
nonbox
NaN boxing without boxing
-
conerror
macro that automatically adds context to errors
-
persisted
Persist arbitrary program state quickly and easily
-
untrusted_value
aim to provide a type-safe way to handle and sanitize potentially untrusted values like user input
-
quoth
scannerless (no-lexing), developer-friendly parsing library for implementing DSLs and syntax parsers in Rust
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
allow
Alias/label lints (to disable) with your intentions. Reexported from allow_prefixed, grouped under rustc::, clippy:: and rustdoc:: modules.
-
hash-db
Trait for hash-keyed databases
-
default-constructor
Macros for creating pseudo-dsls that constructs structs through default construction and field conversion
-
mlua-extras
Extra helpers and functionality built on top of mlua for embedded lua development
-
unwinder
Call stack spoofing for Rust
-
conf
A derive-based config parser for CLI args and env parameters
-
deno_io
IO primitives for Deno extensions
-
expect-exit
Result.expected(): display an error message and exit without a panic
-
separator
Formats numbers into strings with thousands separators for readability
-
rust-automata
A framework and a DSL for building finite state machines in Rust
-
clone_cell
A Cell that works with a restrictive form of Clone
-
handybars
Minimal template parsing and expansion
-
hash_str
Strings with a precomputed hash
-
rs_envflag
An easy way to define flags by environment variables
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
dto_mapper
create dynamic DTOs (Data Transfer Object) from a structure
-
opentalk-kustos-prefix
Derive macro for defining kustos prefix
-
stack_dst
A wrapper that allows storage of unsized values of up to a fixed size inline (without boxing)
-
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.
-
guard-clause
Syntactic sugar for writing simple guard clauses
-
implementation
The implementation crate
-
superstruct
Versioned data types with minimal boilerplate
-
genotype_json_schema
Genotype language JSON Schema crate
-
cfg-elif
Formatter-friendly conditional compilation at item and expression positions
-
rusttyc
writing type checkers with a lattice-like type system in rust
-
kindest
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
code-gen
aids in code generation
-
dyn-context
mechanism for lifetimes erasing
-
macro-asm-builder
macro-assemblers
-
hierr
RUST Error
-
deki
A base for most of my rust projects (tailored to myself)!
-
hax-frontend-exporter-options
The options the
hax-frontend-exportercrate is sensible to -
fluent-asserter
write tests assertions with a fluent interface
-
update-available
check for updates of a crate on crates.io, GitHub or Gitea
-
stupid_utils
that provides some simple and maybe stupid or useful tools
-
reductor
Generic abstractions for combining and nesting reduction patterns for iterables
-
encdec
binary object encoding / decoding helpers
-
traitgate
A zero-dependency authorization mini-library powered by stateless traits and an ergonomic
AuthorizationDecisionenum -
axum-error-handler
error handler for axum
-
kinded
Generate enums with same variants, but without data
-
unit-ext
Fluent helpers for returning common wrapper values from the unit type
-
stylo_traits
Types used by the Stylo CSS engine
-
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
-
specmc-protocol
parsing Minecraft protocol specification
-
regex-macro
A macro to generate a lazy regex expression
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
glam-traits
Traits for the vectors in glam
-
horizon-plugin-api
API utils and shared types for Horizon plugins
-
fyi_ansi
Compile-time ANSI formatting macros for FYI
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
medi-rs
mediator library for Rust
-
trait-cast
Get your own Any with support for casting to trait objects
-
hex_lit
Hex macro literals without use of hex macros
-
conv
number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'
-
mod_use
pub mod xxx; use xxx::*;
-
variadics_please
Implement things as if rust had variadics
-
enum_discriminant
Procedural macro to add functions on enum types to get discrimnant value from variant or create unit variant from discriminant value
-
impl-opaque
Macro for declaring complex struct and initializer
-
pareg
useful tools for command line argument parsing
-
borked
convienient error handling library for rust
-
seal-the-deal
Attribute to use on the
traitmethods (or associated functions) that you wish to “seal”, a.k.a., render themfinal -
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)
-
either_of
working with enumerated types that contain one of 2..n other types
-
bits-io
Bit-level IO operations
-
bignumbe-rs
Large, medium-precision numbers
-
heterob
conversion between bytes/bits and heterogeneous lists (tuples)
-
merge2
Merge structs into single by values
-
result-like
Option/Result-like monad interface for your own enum
-
nonzero_ext
Extensions and additional traits for non-zero integer types
-
easy-err
An easy Error wrapper
-
nanokit
A collection of tiny, reusable utility methods that reduce code size and improve performance
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
cew
Personal Rust utility library
-
hlua
Zero-cost high-level wrapper for Lua
-
smallmap
Small byte-sized generic key-value map type
-
proc-easy
Macros to make writing proc-macro crates easy
-
async_async_io
AsyncRead,AsyncWritetraits but withasync fnmethods -
pair
Safe API for generic self-referential pairs of owner and dependent
-
show-option
displaying Options
-
fnrs
some useful functions i like
-
spade-types
Helper crate for https://spade-lang.org/
-
hypershell-components
Modular DSL for shellscripting in Rust
-
agb_fixnum
abstracting over fixed precision numbers. Designed for use with the agb library for the Game Boy Advance
-
cwtch-imp
small demon, a familiar of a witch. imp is a set of bot creating utilities built on top of libcwtch-rs
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
enum-lexer
A proc_macro lexer generator. using
enum-like syntax. -
jkcenum
Rust enum library
-
egui_struct
EguiStruct is a rust derive macro that creates egui UI's from arbitrary structs and enums
-
msica
Windows Installer Custom Actions
-
rsgenetic
providing genetic algorithm execution
-
chain_link
Micro library with a util for chaining operations on a single type
-
concat-idents
Allows concatenating multiple identifiers and using them everywhere
-
wizify
A macro library for generating a creation wizard from a struct
-
assume
Macro for stating unsafe assumptions in Rust
-
deterministic_default_hasher
A deterministic initialisation of the stdlib default hasher
-
jist
Welcome to Jist a lightweight and efficient programming language built in Rust, designed for simplicity, flexibility, and fast performance with a clean and readable syntax. Github: https://github.com/jon429r/JistR
-
prometheus-macros
Macros for declaring prometheus metrics
-
lstring
Key String: optimized for map keys
-
rou3
🌳 Lightweight and fast rou(ter) for Rust
-
lazy-static-include
lazy_static_include_bytesandlazy_static_include_strmacros to replaceinclude_bytesandinclude_strmacros -
rst-common
A shortcut to common Rust crates
-
cubix
Standardized building block components born for Rust craft
-
mutcy
Zero-cost safe mutable cyclic borrows using borrow relinquishing
-
hot_reload
Trait and service definition of periodic hot reloader and notifier for config-file, KVS, etc
-
context_manager
Python's like context_managers in Rust
-
easy-error
error utilities
-
netmap-rs
Safe, zero-cost abstractions for Netmap kernel-bypass networking
-
linear_type
Linear types for rust
-
globals
Painless global variables in Rust
-
urlquerystring
A high-performance, zero-allocation URL query string parser
-
econf
Load environment variables into your struct members in one shot
-
rudi
out-of-the-box dependency injection framework for Rust
-
raz-common
Common utilities and shared types for the raz project
-
nshare
Conversion between n-dimensional types in different Rust crates
-
crashlog
Panic handling for humans
-
ferment
Traits for FFI conversions and some helper methods
-
radicle-std-ext
Monkey patches of std types
-
gametime
Time handling library for games
-
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
-
typed-num
Typed number in Rust with serde and bincode support
-
rogue-runtime
Async RPC Runtime
-
nuhound
Improve error handling capability
-
raws-error
RAWS common error type
-
rangetools
Extending the Rust Range structs found in std::ops
-
service-builder
A lightweight, type-safe service construction library for Rust that provides compile-time dependency injection through builder pattern
-
relib_host
relib is a framework for reloadable dynamic libraries
-
pyprint
enable python-style printing in rust
-
fallthrough
Pattern match with fallthrough, in the style of C switch
-
nu-std
The standard library of Nushell
-
blanket
macro to derive blanket implementations for your traits
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
precomputed-hash
intending to be a base dependency to expose a precomputed hash
-
async-injector
Reactive dependency injection for Rust
-
error-graph
Allows non-fatal errors in a tree of subfunctions to easily be collected by a caller
-
rawcode
Implements a simple as-is encoding format
-
should_match
Pass a test if the output matches a pattern
-
mstr
2-word, immutable Cow<str>
-
clap-handler
A command handler works with
clap-deriveto generating subcommand handlers -
from_form
From forms to your structs
-
semval
Semantic validation
-
funcall
A lightweight Rust library that turns functions into JSON-callable tools
-
mago-type-syntax
core utilities useful for building lexers and parsers within Mago
-
hermit-sync
Synchronization primitives for kernels
-
orfail
Error handling library for portable unrecoverable errors
-
enumerable
helping you to enumerate all possible values of a type
-
ghost
Define your own PhantomData
-
at
Helpers for indexing slices
-
pathbufd
PathBuf with Display + formatting macro
-
open-editor
Open files or Strings in user's default editor
-
optionally_const
Optional constness on stable Rust
-
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
-
atom
A safe abstraction around AtomicPtr
-
exp-rs
no_std expression parser, compiler, and evaluation engine for math expressions designed for embedded, with qemu examples
-
mapper
Mapping macro to help to reduce mapping boilerplate
-
conditional-mod
macro for conditional module visibility
-
non_structural_derive
nonstructural derives for auto traits
-
internal-iterator
Internal iteration equivalent of
std::iter::Iterator -
despatma
Design Pattern Macro like Loki
-
woah
A Result type that differentiates between local errors (which can be handled) and fatal errors (which cannot)
-
sfo-result
Result type for Rust
-
spire_enum
Procedural macros to facilitate enum usage, such as when delegating implementations, extracting variant types, or creating enum tables
-
hexga_map_on
Define the map_on! macro that can be used to impl a lot of trait quickly using macros
-
hibachi
Asynchronous Batched Inference Platform
-
enumcapsulate
Safe casting for newtype enums and their variants
-
assert_matches2
A version of the assert_matches! macro that brings variables from the pattern into scope
-
branch_hints
that provides likely and unlikely branch hint functions in stable Rust
-
nnn
Generate your newtypes from a single macro
-
safecast
Traits to define safe casting between types
-
lerpable
a derive macro for combining ADTs
-
rvstruct
A helper macros implementation for Value Classes in Rust
-
bytelike
Common types and functions for byte size handling
-
mylibrary_
my personal library
-
pkgcraft-c
C library for pkgcraft
-
time-test
Measure how long your test cases take with one simple macro
-
supertrait
enables default associated types and const fn trait items in stable Rust
-
stream_assert
Macros to simplify testing of
Streambased APIs -
pike
A macro collection to pipe |> your functions calls, like in functional languages such as F#, Elixir and OCamel
-
nutype-enum
Helper macro to create a nutype that behaves like an enum
-
self-rust-tokenize
Turns instances of Rust structures into a token stream that creates the instance
-
radiation
Convert Rust type into raw bytes and vice versa
-
transient
Reimplementation of
std::any::Anywith support for non-'statictypes -
dyn-hash
Hash trait that is dyn-compatible
-
system-pause
system-pauseis a Rust library for stopping program execution temporarily. It offers simple macros for pausing the console, either waiting for user input or pausing with a countdown timer… -
easy_node
Smart pointer for graph nodes
-
problem
Error handling for command line applications or prototypes
-
moduforge-runtime
插件加载、热更新、依赖管理
-
clawless
A framework for building command-line applications
-
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.
-
relax
Derive Partial<T>
-
tlns-google-oauth2
An enshitificated Google OAuth2 Server Side support for Rust with built in Scopes enum
-
surreal_devl
Contains core logic of surreal derive
-
v8_derive
Derive macros and helpers for Rusty v8
-
indicator
Abstractions for stream aggregation, we call them
Indicators -
parsel
Zero-code parser generation by using AST node types as the grammar
-
static-keys
Reimplement Linux kernel static keys for Rust userland applications
-
command-error
Detailed error messages and status checking for
std::process::Command -
terror
Uniform REST error response body, tailored for JSON
-
edgee-sdk
The full-stack edge platform for your edge oriented applications
-
mopa
My Own Personal Any: get your own Any with additional functionality
-
get-field-by-type
Get a value of field, based on the type of a field
-
ra_ap_la-arena
index-based arena without deletion
-
mdbx-derive-traits
poorman MDBX orm
-
cooked-waker
A safe interface for creating async Wakers
-
ffi_trait
FFI-safe trait vtables
-
kago
custom-width signed and unsigned integers
-
paracord
A fast, simple, multi-threaded string interning library
-
abstract-impl
Create abstract implementations for traits
-
wrap-match
A procedural macro to wrap a function in match statement to make error logging super easy
-
deptypes
Dependent types
-
delegate-attr
Attribute proc-macro to delegate method to a field
-
dynamic-provider
Dynamically request arbitrarily-typed values from providers with borrowed data
-
typeables
type aliases. By SixArm.com.
-
error_mancer
Quickly define custom error enums for a function
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
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
-
anony
Anonymous struct
-
is-odd
Returns true if the given number is odd
-
no_std_strings
no_std version of crate fixedstr: strings of constant maximum size that can be copied and stack allocated
-
maelstrom-test
Test macros for Maelstrom
-
cartesian
QOL macro that creates the cartesian product of multiple iterators
-
pattern-wishcast
Pattern types emulation for conditional variants using conditional never types
-
game_inventory
An inventory system independant of item data
-
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. -
serde-implicit
the serde(untagged) you wish you had
-
stellar-axelar-operators
AxelarOperators contract, responsible for managing operators and enabling invoking functions with access control and upgradeability
-
ff-arcium-fork
building and interfacing with finite fields (Arcium fork)
-
rsspice
Pure Rust port of the SPICE Toolkit for space geometry
-
log_limit
A rate limiting logging crate
-
syllogism
allow for some specialization using stable Rust
-
defaultdict
A hashmap implementation that mirrors the python defaultdict
-
cargo_pup_lint_impl
Core lint implementations and rustc integration for cargo-pup architectural linting
-
confi
confidence intervals and significance levels for statistical computation
-
rudi-dev
Rudi - an out-of-the-box dependency injection framework for Rust
-
tamago
generating C code
-
familiar
reserve
-
retry-backoff
Retry Backoff
-
bellframe
Fast and idiomatic primitives for Change Ringing
-
sod
Service Oriented Design
-
better_any
Type id and Any for non static types
-
duplicate_macrotest
Fork of the macrotest crate specifically to test the duplicate crate
-
fx-callback
A subscription based callback to inform subscribers about relevant data events within structs
-
rustfmt-nightly
find and fix Rust formatting issues
-
dynify
Add dyn compatible variant to you async trait
-
copy_from_str
An extension trait to copy a string into another string
-
rs_ervice
service manager for vanilla or Tokio runtime
-
safelog
Conditionally suppress confidential information from logs
-
eldenring-dlrf
Macro for generating singleton specifier for usage with the DLRF singleton finder
-
pisserror
A golden rip-off of thiserror
-
structre
Static-checked parsing of regexes into structs
-
scoped-panic-hook
Adds scoped, nestable, thread-local hooks for panics and some utilities for capturing and analyzing panics more conveniently
-
forester-rs
Workflow framework based on the behavior trees
-
stylish-html
stylishhelpers for writing styles as HTML elements -
text-block-macros
Create a multiline string literal
-
eoe
exiting processes on errors gracefully
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
std-next
Opinionated utilities and polyfills
-
lithium
Lightweight exceptions
-
string_capacity
Moved to capacity_builder
-
constptr
NonNull without mutability
-
cortex-ai
An asynchronous flow-based processing framework for building flexible data pipelines with conditional branching and error handling
-
tuplex
Rust tuple extension
-
rtlola-frontend
A frontend for the RTLola runtime verification framework
-
pyo3-error
Unified error causality chains across Rust and Python
-
pic8259
Abstractions for the 8259 and 8259A interrupt controllers
-
function_name
macro that expands to the name of the annotated function
-
cryptify
A procedural macro library to obfuscate Rust code. Provides compile-time string encryption and random flow obfuscation.
-
vsprintf
Rust bindings to the libc vsprintf function
-
guard
Macro implementation of RFC 1303: a guard-let-else statement a la Swift
-
unpaid-intern
A convenient little string interner
-
cubob
Structured output helpers for display mode
-
enum_cycling
Small macro for working with enums
-
mode
A behavioral state machine library written in Rust
-
inline-option
A memory-efficient alternative to Option that uses a pre-defined value to represent None
-
sitrep
Frontend-agnostic progress reporting
-
iterate-trait
Experiment with methods on IntoIterator
-
fibre_ioc
A flexible, thread-safe and dynamic Inversion of Control (IoC) container for Rust
-
qualified_do_proptest
Proptest integration for qualified_do, enabling alternative sytnax for prop_compose!
-
gan
Just do it! A small tool provides ergonomic value handling with ignore/ ok/ some semantics
-
simple-logging
logger for the log facade
-
unsafe_cell_slice
A microlibrary for creating multiple mutable references to a slice
-
batched
rust macro util for batching expensive operations
-
abs-file-macro
A macro that returns the absolute file path of the Rust source file in which it is invoked
-
portable-io
“ A subset of Rust
std::iofunctionality supported forno-std -
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
-
kismesis
A static site generator with plugins and a custom markup language
-
re_tuid
128-bit Time-based Unique Identifier
-
torrust-index-located-error
provide error decorator with the location and the source of the original error
-
const_fn
A lightweight attribute for easy generation of const functions with conditional compilations
-
swamp-script-derive-tests
tests for swamp macro
-
nameof
macro to determine the string name of a binding, type, const, or function
-
nvim-oxi-luajit
Rust bindings to LuaJIT for nvim-oxi
-
foxtive-ntex-multipart
Handling File Uploads Based on Ntex
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
localsavefile
Save and load structs from a local file. A convenience wrapper around the savefile crate.
-
code-path
A code path macro
-
stable-eyre
A custom context for eyre that supports capturing Backtraces on stable
-
lockjaw
Compile time dependency injection framework inspired by dagger
-
thiserror_string_context
Adds context string to error enums generated with thiserror
-
ref_iter
Dynamic borrowing iterator
-
no-break
Typesafe extraction of continuation values from unbreakable control flows
-
derive_generic_visitor
Boilerplate for building rust visitors
-
polyhal-trap
interface for multiple platforms
-
clone-stream
Lazily clone streams
-
neo4j_cypher
A flexible and intuitive query builder for Neo4j and Cypher
-
enum_ext
procedural macro that enhances enums with additional methods and conversions
-
case_clause
case clause macro for rust
-
assert_approx_eq
assert approximately equal
-
poem-stackvec
stack-allocated vector types for poem_openapi route parameters
-
const_struct
macro that allows const structures to be passed as const generics
-
timeout-macro-parse
A companion-crate for the tokio-timeout proc-macro-lib
-
cranelift-assembler-x64
A Cranelift-specific x64 assembler
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
typeshare-model
core definition of the typeshare Language trait for implementations
-
utilz-rs
A lightweight extension trait collection for Rust primitives and types
-
rutie
The tie between Ruby and Rust
-
steckrs
A lightweight, trait-based plugin system for Rust applications and libraries
-
hexga_math
Math related crate that support multi dimensionnal vector, matrix, rectangle
-
stream-find
Add a
findandfind_mapmethods to any stream -
unzip_iter
Unzip an iterator to iterators
-
fast-concat
Fastest macro for concatenating strings
-
rusty_vikings
full of my shared implementations
-
c8str
String types that are both utf-8 and null terminated
-
next-web-mqtt
Next Web Mqtt
-
og-enum-to-string
EnumToStringderive macro which implements the methodsas_str()andas_dbg()to enums with no associated values -
droppy
Friendlier dropwatch
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
command-macros
Macros for creating std::process::Command with shell-like syntax
-
freenet-scaffold
Support library for building Freenet apps
-
enum-ptr
Ergonomic tagged pointer
-
tfhe-versionable
Add versioning informations/backward compatibility on rust types used for serialization
-
quick-error
A macro which makes error types pleasant to write
-
const-field-offset
Wrapper around field-offset crate and const-field-offset-macro
-
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
-
toml_config_trait
Rust trait to turn a Rust struct into a TOML config
-
ra-ap-rustc_next_trait_solver
Automatically published version of the package
rustc_next_trait_solverin the rust-lang/rust repository from commit febb10d0a2d29278135676783f6a22eb83295981 The publishing script for this crate lives at:… -
optfield
A macro that generates structs with optional fields
-
partial_derive2
makes all the properties of a struct type an optional property
-
append-only-bytes
Shareable append-only bytes
-
graphql-starter
GraphQL starter kit
-
capnp_conv
capnp write/read traits to convert from structs to readers/builders
-
type_cell
Attach values statically to a type using static get/set methods
-
native_messaging
Async implementation of MDN native messaging. Provides the ability to install host manifest.
-
iderive
Drop-in replacement for derive that doesn't directly depend on generic bounds
-
round
your floats with precision from 1 to 10
-
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
-
nom-supreme
A collection of excellent utilities for nom
-
univec
A vector that can hold elements of any single type
-
cenum-utils
A minimal library for querying enum properties in const contexts
-
restructed
Quickly derive subsets of your structs
-
impl-rlp
RLP serialization support for uint and fixed hash
-
arri_repr
Rust representations of Arri types
-
rusty-cmd
creating custom line-oriented command interpreters in Rust
-
cast_checks
A procedural macro to check for invalid casts
-
stratagem
A trait library that enables state management and command execution with built-in undo support, inspired by the Command design pattern
-
should
Postfix assertion library for Rust
-
linked_list_r4l
Linked lists that supports arbitrary removal in constant time
-
clamp_to
Clamp integer and float values to the values that fit within both the original number type and the receiving type
-
gen_ops
Macros for operator overloading for generic types
-
nullnet-liberror
Error handling library for NullNet
-
maybe_path
Zero overhead static initializer for Path
-
tartan-bitfield
Define structures with accessors for particular bits or bit ranges
-
readonly
Struct fields that are made read-only accessible to other modules
-
kuberator
simplify writing an k8s operator
-
generic-bytes
A derivable trait for conversion to and from an array of bytes with a type-level size
-
unsafe-fields
unsafe to access or modify fields with safety invariants
-
tools-rs
Core functionality for the tools-rs tool collection system
-
onlyerror
Obsessively tiny error derive macro
-
anyhow-http
Customizable HTTP errors built on anyhow
-
forward_ref
Rust's forward_ref_* macros for easier implementation of operator overloading
-
dioxus-keys
An unified DataKey interface coupled with a few helper macros to help you make global keys
-
messages
Runtime-agnostic actor library
-
error_status
Model common error context with HTTP 4xx and 5xx code
-
opdater
Small trait based approch to struct updates
-
autotrait
Reduces boilerplate by auto-generating trait definitions from impl blocks for dynamic dispatch
-
macron-collections
Creates a new instance of std collections: HashMap, HashSet, BTreeMap, BTreeSet, VecDeque, LinkedList and BinaryHeap
-
round_pipers
A way to pipe ndarrays using circular buffers
-
runestr
User-perceived characters related types and data structures
-
chemrust-core
The core modules defining the flow and structs of data in computational chemistry routines
-
named-tup
Create named tuples using the tup!() macro
-
cee-scape
access to
setjmpandsigsetjmpfunctionality -
impl_ops_cmp
Macros for easy operator overloading without Copy derive
-
thisctx
Easily create error with contexts
-
tungstenite-get-stream
Convenience trait method to get underlying stream
-
partially
Partial trait, and an optional macro to mirror a struct, wrapping each field in an Option
-
netcdf3
A pure Rust library for reading and writing NetCDF-3 files
-
skedge
Ergonomic single-process job scheduling for Rust programs
-
smacros
Minimalistic macro for easy String creation
-
indexed_valued_enums
Create enums resolving into values, and get their variants back through their values or their discriminant, inspired by Java
-
gettid
Helper to get an integer ID for the current thread
-
facet-types
Core types and traits for the facet reflection library
-
ouroboros_examples
Examples for the ouroboros crate
-
generativity
Generation of unique invariant lifetimes
-
gravitron_macro_utils
Gravitron's Macro Utils
-
type-const
Type-level associated consts
-
crete
Ergonomic, thread-safe & flexible state management
-
eros
Context aware, ergonomic and precise error handling
-
zip_clone
Zip an iterator to a repeatedly cloned object
-
dyn_compatible
Dyn compatible marker
-
sly_static
Seamless Rust Static Initialization: Effortless and Efficient
-
custom_error_core
Define custom errors without boilerplate using the custom_error! macro
-
collect-with
enhanced collection operations with capacity control
-
nil
Noxmore's Ixperimental Lutilities
-
outcome-46f94afc-026f-5511-9d7e-7d1fd495fb5c
Augmentations for error propagation
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
ez_jni
Macros and functions that make using Java in rust feel natural
-
maybe-borrow
Macros for conditionally returning borrowed data
-
dynarg
mechanism for dynamic robust argument handling
-
ocl-macros
Macros for easier/faster working with the ocl crate
-
enum_reflect_extern
Dependency for enum_reflect
-
concat_const
const
&[u8]and&strconcatenation -
ccgen
generate manually maintained C (and C++) headers
-
rtk-lua
The Lua engine for Rust Type Kit - query Rust types and produce FFI types
-
spade-diagnostics
Helper crate for https://spade-lang.org/
-
float_plus
Additional features for float values
-
relayr
Cron scheduler with a delegated-flavour syntax
-
std-ext
Extend the standard library functionality
-
itemizer
Containing an itemizer to itemize structs
-
cmake-parser
parse cmake language
-
portal-solutions-id-arena
id-based arena
-
diff-struct
A trait for diffing and applying diffs to types
-
niloecl
axum handler pattern for twilight interactions
-
ice_code
A macro to mark code paths as cold, allowing the common case to be inlined
-
fast-math
Fast, approximate versions of mathematical functions
-
rustc-ap-rustc_expand
Automatically published version of the package
rustc_expandin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
docify_clone
Docify allows you to live-embed at compile time pieces of code from throughout your project as rust doc examples
-
vexity
Tiny scripting language for hacking on abstractions of financial markets
-
stack_box
store unsize struct on stack with static check
-
dynamodel
derive macro to implement conversions between your object and
HashMap<String, AttributeValue> -
tear
Typed early returns and loop control + Syntax sugar for try!-like error handling
-
newer-type
Support defining newtype wrapper with inheriting trait implementations
-
gramatika
A minimal toolkit for writing parsers with Rust
-
gumdrop
Option parser with custom derive support
-
fastsend
快速生成适用于分布式环境的 ID 和序列号
-
ubits
Bit fields and masks
-
opentalk-types-signaling-moderation
Signaling types for the OpenTalk moderation module
-
ferrunix
A lightweight run-time dependency injection framework for Rust
-
spargebra
A SPARQL parser
-
ffi-enum
Simply write and use
enums like rust native enums, freely passing through ffi -
baxe
that simplifies error handling in Axum
-
const-type-layout
Derivable const trait to view and compare the layout of a struct, union, or enum
-
checked-rs
encoding validation semantics into the type system
-
edition
Macros to switch between Rust editions
-
iter_num_tools
Create simple iterators over non integer ranges. itertools + num = iter_num_tools
-
wherr
Enhance Rust errors with file and line details using the
#[wherr]macro for clearer debugging -
haskell_bits
Rust implementations of various Haskell typeclasses and functions
-
try_create
A small library providing generic traits for fallible and infallible object creation
-
lang_extension
Rust Lang Extension
-
lebe
Tiny, dead simple, high performance endianness conversions with a generic API
-
ffi_time
FFI assistant for Rust time types
-
env_home
Get the user home directory in a cross-platform way
-
spider_firewall
Firewall to use for Spider Web Crawler
-
in
Python's input() for Rust
-
variant_count
Derive macro for enum which adds to it the count of variants
-
ambient-authority
Ambient Authority
-
ordes
treating arrays and tuples a little bit more like vectors
-
dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
alkahest
Fantastic serialization library with zero-overhead serialization and zero-copy deserialization
-
rtml
(r)ust macros for h(tml) expansion => rtml. (r)ust type safe (css) => rcss
-
binary-util
A panic-free binary utility crate to read/write binary streams over the wire
-
debug-ignore
A newtype wrapper that causes a field to be skipped while printing out Debug output
-
split_channel
stream-of-messages abstraction with split send/recv channels
-
binread
helping read structs from binary data using ✨macro magic✨
-
tinycolors
a tiny color management library focused on erganomics
-
mac
A collection of great and ubiqutitous macros
-
next-gen
Safe generators on stable Rust
-
padder
Highly efficient data and string formatting library for Rust
-
dioxus-class
Dioxus class
-
sigmut
a state management framework designed to be used as a foundation for UI frameworks
-
function_overloading
that adds function overloading
-
dialogue-macro
An extension to dialoguer that simplifies command-line interaction interfaces
-
lucene_query_builder
A procmacro derive crate to generate lucene query builder for Rust structs :
-
hydroflow_lang
Hydroflow's Surface Syntax implementation
-
nix-compat-derive-tests
Nix protocols and data formats
-
bash-builtins
implement loadable builtins for bash
-
dowhile_rs
Do while macro for rust with labels and nesting support
-
nzliteral
Macro simplifying use of NonZero literals
-
forangex
Range maker for foreward/backward and step may be larger than 1 (or less than -1), plus index support
-
bherror
TBTL's library for error handling in Rust
-
pgde
A macro library for consuming PostgreSQL row data into structs
-
derive-regex
Easily parse a regex into a struct or enum variant
-
sudo_plugin
Macros to easily write custom sudo plugins
-
retry_macro
A set of declarative macros which retries executing a function upon failure
-
flaky_test
atttribute macro for running a flaky test multiple times
-
static_file_util
generating and managing static files in Rust applications
-
timed
Macros to time function execution
-
binmarshal
Pack and unpack structs and enums into and out of binary data streams
-
functor_derive
A derive macro to derive a functor for a type
-
nohashmap
Use HashMap syntax in Rust for non-hashable types
-
intern-arc
An interner that deallocates unused values
-
copstr
COpy STRing module
-
cobweb_asset_format
COB definition with parsing and ser/de
-
pipa
Pipe Operator Library for Rust
-
selfie
Experimental, macro-free and allocation-free self-referential structs
-
oi-pkg-checker
For finding problems/errors in packages/components in OpenIndiana
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
per-thread-object
Efficient per-object thread-local storage implementation
-
pinkie
(Almost) compile-time scoped CSS-in-Rust
-
pyderive
Derive macro of Python special methods and a class attributes for PyO3
-
pbni-rs
PBNI for Rust
-
str-chunks
implements char-wise chunked iteration of str
-
rusty-bind-parser
Parses Rust module, generates Rust code with C ABI bindings and C/C++ header files and Swift gluecode
-
cfgenius
Conditional compilation with macro support in Rust
-
crony
cron runner that spawns another thread to run your cron jobs
-
tailcall-valid
validating multiple inputs, collecting all possible errors instead of failing at the first error. Useful for scenarios where comprehensive feedback is required for user inputs or configuration settings.
-
enum-derive-2018
macros for deriving additional functionality for enums
-
rust-code-analysis-web
Run a web service to compute and export code metrics
-
hs-bindgen
Handy macro to generate C-FFI bindings to Rust for Haskell
-
cock-lib
Measure the power level of a peen
-
swap-pool
Allow objects to be stored either in RAM or on disk
-
env_var_helpers
Macros and functions that help provide access to environment variable values
-
base64_type
type wrapper for Vec<u8> that uses base64 for serialization
-
derive-alias
Alias multiple derives as one
-
defer-lite
A lightweight high-performance implementation of Go's defer statement
-
nu-engine
Nushell's evaluation engine
-
type-fn
Allows for simpler coding of type-level logic, e.g. for type-number systems.
-
beetle-nonzero
Combines the std
NonZerostructs into one struct -
tuple_list
macro-free variadic tuple metaprogramming
-
more-di
support for dependency injection (DI)
-
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.
-
ra2-mix
Red Alert 2 MIX file format library for reading and writing MIX archives
-
enumtrait
macros for polymorphism using enums
-
unwrap_or_else_error_handle
Function to handle errors in a way that prints a message and exits the program
-
unwrap_or
Four easy unwrap Result and Option macros that allow for any inline-scoped code for things like return, continue, and break
-
yerevan
Small Rust crate that brings computation expressions idea from F# for help you to work easier with functors and monads
-
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
-
bittersweet
Add more intentional predicates to bitwise calcs
-
readfile-custom
read file content by cli
-
ltptr
Checked raw pointers
-
early_returns
Macros to make early returns easier to work with in Rust
-
re_error
Helpers for handling errors
-
more-convert
adds macros for various conversions
-
typed_builder_rules
Opinionated and very limited macro_rules reimplementation of the typed_builder macro
-
fsl
FakeHub State Language. DSL for managing state in fakehub
-
swamp-vm-types
Low-level types for memory layout, addresses, and instructions used by the Swamp Virtual Machine (VM)
-
cdylib-shim
A macro for creating dynamic library shims that can intercept and modify function calls
-
toast-cell
Zero-cost type-branded cell with no runtime checks
-
docsplay
A derive macro for implementing the display Trait via a doc comment and string interpolation. Fork of displaydoc
-
hexga
include all other console hexga crate in one !
-
big-int
arbitrary-precision, arbitrary-base arithmetic, supporting arbitrarily large integers of any base from 2 to u64::MAX
-
dddk_core
Tactical DDD framework based on command_bus, event_bus and query_bus. It offers annex feature such as authorization, logging ...
-
noco
no code, no problem
-
jtd-infer
Generate JSON Typedef schemas from example data
-
skip-if
Attribute macro to skip running a function that produces files
-
ougi
インタラクティブエンターテインメントを作成する個人プロジェクト
-
oasert
verifying in-flight requests against a provided OpenAPI 3.1.x or 3.0.x specification
-
simpletime
timer macro
-
parenv
Environment variable parser with a clap style derive macro and elm style error reporting
-
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
-
htmf
hypertext markup functions: functions for generating HTML
-
shadow_counted
An iterator that counts every iteration in a hidden counter, nested iterators may commit the count to parents
-
j4rs-171h
j4rs stands for 'Java for Rust' and allows effortless calls to Java code, from Rust
-
ux2
Non-standard integer types like
u7,u9,u10,u63,i7,i9etc -
panicmsg
simplyifying common panic messages
-
murrelet_draw
drawing functions for murrelet, a livecode framework
-
borrow-or-share
Traits for either borrowing or sharing data
-
poem-typed-multipart
Typesafe multipart extractor for poem
-
trycatch
Throw and catch exceptions in rust
-
atri_plugin
AtriPlugin
-
ctreg
Compile-time regular expressions the way they were always meant to be
-
cassandra_macro
Create Cassandra tables and CRUD CQL prepared statements from Rust structs. (custom derive: cassandra_macro_derive)
-
aws-resource-id
Copyable AWS resource IDs
-
copyvec
A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy
-
k8s-controller
lightweight framework for writing kubernetes controllers
-
axum-typed-routing
Typed routing macros for axum
-
hictor
declarative macro for __attribute__((constructor))/__attribute__((destructor))
-
tryumph
A flexible retry library for operations that may fail, with customizable delay strategies for both synchronous and asynchronous code
-
tracked
A stringly-typed Error that includes
#[track_caller]information -
kind
Costless typed identifiers backed by UUID, with kind readable in serialized versions
-
trig
Complete set of trigonometric and hyperbolic functions in Rust
-
opensearch-dsl
Strongly typed OpenSearch DSL
-
guarded-tls
Guarded thread-local variables
-
better-refcell
A drop-in replacement for RefCell with safe unborrow and reborrow capabilities
-
cdumay_error
define standard errors
-
option-chain
A macro for using
?operator in functions that don’t returnOption -
single-utilities
provdes types, traits and utility functions to the single-rust ecosystem that can be universally used. You can also use it within your own ecosystem 👀
-
enum-unitary
Trait and macro for unitary enums
-
fiberplane-pdk
Fiberplane Provider Development Kit
-
derive-ctor
Adds
#[derive(ctor)]which allows for the auto-generation of struct, enum, and union constructors -
doless
macro to simplify struct mapping and function utilities
-
exun
Handle unexpected errors
-
extended-primitives
providing primitive-like types for use
-
orx-closure
An explicit closure with absolute seperation of the captured data from the function
-
olis_string
Small-string optimization for Rust, aims to replace std::string::String
-
json-query
Run jq programs to extract data from json strings
-
argcall
Enables enums and structs to be callable by associating functions with their variants or fields
-
terra-items
enum contatining terraria items and prefixes
-
jdt_maybe_multiple
MaybeMultiple is a utility crate that establishes an enum to use in place of
Optionwhere the content may be singular, multiple, or None -
lazy-init
Lazy initialization
-
utils-results
The easiest and most intuitive error handling solution
-
resplus
attaching messages to results
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
with_drop
Nostd wrapper for using a closure as a custom drop function
-
implied-bounds
Make all the bounds of a trait definition be implied through a helper trait and macro attribute
-
chasa
A parser combinator with
manytaking iterator, conditional branching, and method chain -
thesis
controlling & monitoring experimental code paths
-
cve-rs
Blazingly fast memory vulnerabilities, written in 100% safe Rust
-
supply
Provider API for arbitrary number of lifetimes
-
enum_discriminant_traits
Internal implementation of traits for enum_discriminant crate
-
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
-
anyerr
Dynamic error library with rich error wrapping and context support
-
luminos-container
Luminos Container
-
mapcomp
Python-like list comprehensions for standard containers
-
reltester
Automatically verify the correctness of [Partial]Eq/Ord implementations
-
airbag
handling errors and panics using 3rd party services
-
genius-invokation
Abstractions and structures for Genius Invokation TCG
-
scout-json
JSON representation of ScoutLang AST
-
cplex-rs
Binding of IBM Cplex library
-
kurtbuilds_regex
Wraps the regex library to also provide macros
-
stak-primitive
Stak Scheme primitives
-
bevy_crevice
Create GLSL-compatible versions of structs with explicitly-initialized padding (Bevy version)
-
asm_block
Translate tokens to string for Rust inline assembly
-
bestbefore
A procedural macro for marking code with expiration dates
-
rust-2018
Macro to use Rust 2018 from all editions
-
plain_hasher
Hasher for 32-byte keys
-
delegate-match
Procedural macro for delegation of grouped match arms
-
error2
error handle library for Rust
-
derive_screaming_snake_case
A lightweight Rust proc-macro crate that implements the Display trait for enums with unit variants by converting each variant's name into SCREAMING_SNAKE_CASE
-
ab-code-gen
Functions to generate boilerplate code for objects implementing the 'Actor' pattern. Used by the abcgen crate.
-
fmt-cmp
Traits and utilities for lexicographically comparing values in their
Displayrepresentations -
axum-resp-result
Help Struct For Axum Response
-
derive_tools
A collection of derive macros designed to enhance STD
-
pin-init
Safe pinned-initialization in Rust
-
lerp
Generic linear interpolation and extrapolation, automatically implemented for a variety of numeric types
-
tor-async-utils
Async/futures helpers for use with Tor
-
hightorrent
High-level torrent library which supports Bittorrent v1, v2 and hybrid torrents
-
blue_typemap
A TypeMap Dependency Injection method for dynamic function parameters
-
funty
Trait generalization over the primitive types
-
notedown-error
Notedown Error Handlers
-
path-dsl
DSL and macro to help deal with Paths and PathBufs
-
numeric_cast
Safely cast between numbers
-
sal-rhai
SAL Rhai - Rhai scripting integration for the System Abstraction Layer
-
tisel
Effective type-based pseudodynamic dispatch to impls, enums and typeid
-
truc_runtime
Rust code generator for safe, fixed size, evolving records - runtime
-
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
-
fused_error
working with composable errors
-
coded
concrete error type with an
ErrorKindenum matching Google’s “canonical error codes” -
variant_counter
Rust's Enum variant counter
-
facet-spez
Auto-deref specialization helpers for the Facet reflection system
-
macro-bits
performing macro-based bit manipulation
-
poem-openapi-problemdetails
Integration layer between problemdetails and poem_openapi
-
spipe
Smart pipe macro for chaining function/method calls, with unwrap, map, and and_then support
-
codes-iso-639
This package contains an implementation of the ISO 639 (Parts 1, 3, and 5) Language Code specifications
-
effing-mad
The hottest algebraic effects library in Rust
-
rustato
A global state management library for Rust applications
-
data_models
used to lookup the sizes of various C-types of historical data models
-
gostd_builtin
Package builtin binds the basic type in go through the type alias, and implements the basic type cast macro function.builtin 包通过类型别名绑定Go中的基础类型，并实现了基础类型强制转换宏函数…
-
cdumay_json
JSON
-
backtrace-ext
minor conveniences on top of the backtrace crate
-
bounded-registers
A high-assurance memory-mapped register interaction library
-
builder-pattern
A derivable macro for declaring a builder pattern
-
var_num
Variable length number implementation that can be used as a drop in replacement for any number primitive
-
url_encoded_data
Ergonomic, Versatile Url-Encoded-Data Manipulator
-
aegir
Strongly-typed, reverse-mode autodiff library in Rust
-
nyar-number
Numeric types with GC optimization
-
evident
Pub/Sub library using IDs to identify events
-
genrc
refcounted pointer type that allows subobject pointers
-
refinement-types
Refinement types
-
n-functor
Faux-derive a
mapfunction for types with one or more type parameters -
bty
Streamlined definition and usage of branded types in Rust
-
bossy
Opinionated convenience wrappers for
std::process::Commandand friends -
hypotaxis
Uninterrupted method chaining
-
jcers
jce in rust
-
bytestream
convenient way of writing binary data to a buffer
-
ser_mapper
Mapped DTO serialzation wrapper for DBO/Model
-
algoroutine
Light-weight algebraic effect(algebraic goroutine) in Rust
-
strum-lite
Lightweight declarative macro for sets of strings
-
map-self
Map a value itself instead of its contained value in usual closure style
-
com-impl
Automatically implement Win32 COM interfaces from Rust, along with some useful helper types for getting it done
-
meticulous
Result extension to add more meaning to unwrapping
-
tri_ton
A Macro for Handling Exceptions
-
enum-repr
Derive enum repr conversions compatible with type aliases
-
known-types
Well-known types
-
goof
A reusable, composable, aggregate and
no_std-friendly error library -
merg
Merge multiple values into one
-
newstr
macros for declaring String-base new types
-
sealed_trait
making sealed traits more accessible
-
lichen
Scripting DSL (for Dialogue Graphs, et al)
-
standalone-syn
Fork of syn that turns of the proc-macro feature in proc-macro2 and standalone-quote so as to remove the rustc dylib dependency
-
alternating-iter
Provide an iterator adaptor which alternate between two iterators
-
market
Infrastructure for producers and consumers
-
guarded
Guard macros
-
lambda-types
Puts the lambda calculus in Rust...'s type system
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
orbiter-rs
Rust bindings for the Orbiter spaceflight simulator SDK
-
stylo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
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. -
interruptible_polling
General purpose polling tasks with RAII-driven fast clean exits
-
rain_task
Distributed computational framework for large-scale task-based pipelines. A custom task library in Rust.
-
instability-example
Example crate demonstrating instablity usage
-
prange2
Parse numeric ranges for indexing
-
pathogen
Typed references and deep mutation into Rust types
-
phlow
An engine for scripting reactive browsers in Rust by adding custom views to structures
-
width_counters
Atomic counters with variable bit widths and customizable atomic ordering
-
seasick
Tools for implementing and transcribing C APIs
-
pad-adapter
that provides pad adapter
-
irox-types
Enums and structs to describe Rust's basic type system
-
tdx-rs
parsing TDX files
-
deltoid
calculate and apply deltas to structs and enums
-
pipelining-macro
A convenience macro for the pipeline syntax pattern
-
soapy
Structure-of-arrays derive macro
-
physical-quantity
dimension and unit system for general physical physical quantities
-
progress-streams
Progress callbacks for types which implement Read/Write
-
ellie_tokenizer
Tokenizer for ellie language
-
anon_enum
Enum types with fully-generic variants
-
staticrypt
Static encryption for string literals and binary data
-
measures
A unit-of-measure and electrical calculations library
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
match-commutative
Match on patterns commutatively, reducing the use of duplicated patterns. ↔️
-
iced_af
The iced application framework project
-
erased-discriminant
Type-erased version of core::mem::Discriminant<T>
-
manifest-dir-macros
function-like macros to check or operate paths relative to CARGO_MANIFEST_DIR at compile time
-
oneline-eyre
A fork of
simple-eyrewhich outputs errors on a single line -
barexp
that automatically generates mod.rs files for your project
-
amonoid
A general-purpose monoid library
-
degeneric-macros
Hides struct generics into trait associated types
-
type_enum
Create tagged unions consisting of different types
-
typemap-meta
compile-time macro to create type-to-value maps
-
hs-bindgen-traits
traits behind hs-bindgen ergonomics
-
modbus-mapping
Modbus register mapping traits and derive macros
-
dyn-ptr
A box that stores types like pointers, forgetting everything besides
Self: Unsize<dyn Trait> -
shoogah
Add some syntactic 'shoogah' to Rust
-
bluejay-typegen
A GraphQL type generator
-
pipeline
A macro collection to pipe |> your functions calls, like in F# or Elixir
-
unwrap-ord
Wrapper type to easily convert Ord to PartialOrd. inspired by std::cmp::Reverse
-
chalk-macros
Macros for Chalk
-
horloge
Clock and timer traits
-
dyn_std
Dynamic (object-safe) version of std traits
-
nakago
A lightweight Rust toolkit for sharp dependency injection 😎
-
ownable
Derive macro for structs/enums with Cow, which can convert Type<'a> to Type<'static> and more
-
get_set_macro
Procedural macro to generate customizable getters and setters in Rust
-
hel-colored
ANSI string colorizer and styler
-
env_parser
Env parser. Parse your env file and create a Rust file with mapped properties
-
type_description
Machine-readable type descriptions
-
mockdown
single file and macro/dependency free mock library for Rust
-
shadow-clone
A macro to clone variables into the current scope shadowing old ones
-
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.
-
enum_delegate
Easily replace dynamic dispatch with an enum, for speed and serialization
-
ezcmd
An opinionated wrapper around
std::process::Commandoptimized for brevity and clear errors -
bitrange
plugin to map bits in integer values to fields
-
yikes-intenum
Augment integer-based enums with an unknown variant; a macro that makes you say "yikes!"
-
accursed-unutterable-type-id
A worse version of std::any::TypeId
-
bon-cli
Dev tool for working with the
boncrate -
variadiz
Variadic function support for rust
-
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…
-
linreg
Calculates linear regresssions of two-dimensional data. Does not use stdlib, only depends on numeric traits.
-
hypershell-tokio-components
Modular DSL for shellscripting in Rust
-
roopert
object-oriented toolkit for Rust
-
kti_cqrs_provider_rs
CQRS provider with ioc container
-
visibility
Attribute to override the visibility of items (useful in conjunction with cfg_attr)
-
io-enum
#[derive(Read, Write, Seek, BufRead)] for enums
-
zrx-id
Internal package, use zrx::id
-
inherent
Make trait methods callable without the trait in scope
-
undo_stack
A minimal undo stack for user defined types
-
hcstatic-str
compact storage for short static strings
-
chillpill
A more powerful (and more restrictive)
std::panic::catch_unwind -
rioc
Zero cost dependency injection macros
-
warnalyzer
Show unused code from multi-crate Rust projects
-
entrance
A command line argument parser library which provides type assisted tools
-
assert_unordered
A direct replacement for
assert_eqfor unordered collections -
windows-helpers
Helpers for the windows crate
-
f2rust_std
Standard library for FORTRAN-to-Rust translated programs
-
gur
A undo-redo framework
-
ioc
An Inversion-of-Control library in Rust
-
const_str_slice_concat
const concatenation of string slices
-
iceyee_error
Error Message
-
future-local-storage
An init-once-per-future cell for thread-local values
-
summum-types
A sum-type macro crate with all the conversions, accessors, and support for abstract methods across variants, and interoperability between sum-types
-
clap-dispatch
Ergonomically dispatch CLI subcommands
-
isr-macros
Macros for ISR
-
functo_rs
Control/Data/Unrestricted monad hierarchies for Rust to be used with qualified_do
-
meta_tuple
A statically typed opaque tuple that can contain any type
-
accio_rs
macros for sync and async runtime
-
cow2
Like Cow<B>, but B is covariant
-
fieldx_plus
Design patterns built on top of fieldx crate
-
adhesion
A set of macros for design by contact in Rust. The design of this library was inspired by D's contract programming facilities.
-
amass
Automatically generate
Fromimpls for nested enums, even across crates -
implicit-fn
A macro that adds support for implicit closures to Rust
-
high_mem_utils
bunch of mem safe abstractions,some involving transmute
-
approxim
Approximate floating point equality comparisons and assertions
-
wutil
A lightweight library that contains useful functions, wrappers, and macros
-
flexible-io
Wraps values such that dyn-safe IO traits need not appear as static bounds
-
ointers
What do you call a pointer we stole the high bits off? An ointer
-
tagged-id
A zero-cost wrapper adding type-safety to resource identifiers
-
vector3d
3D vector type
-
yoshi
Entry for the Yoshi error framework
-
rust-quiz
Medium to hard Rust questions with complete explanations
-
convi
Convenient (but safe) conversion (
From-like) traits -
dioxus-shareables
Hooks for sharing structures between components
-
rdcl_aoc_helpers
Helpers for Advent of Code
-
nade
Adding named and default arguments to Rust functions
-
const-macros
Various macros for const contexts
-
revolt_okapi
Structs for OpenAPI (AKA Swagger) documents
-
flexcell
A flexible cell that allows safe circumvention of double borrow issues
-
veclite
A lightweight, ergonomic wrapper around Vec<T> that implements Display and provides extra list-like utilities
-
typestate
A proc macro DSL for typestates
-
sw-errors
error parsing and pretty-printing, used across the swtools toolset
-
once_cell_serde
Single assignment cells and lazy values
-
piston-float
Traits for generic floats in game development
-
hrbf
Hermite Radial Basis Functions with higher order derivatives
-
catnip
No-std, panic-never, heapless UDP/IP ethernet stack for data acquisition and real-time controls
-
maybe-single
A singleton. Maybe.
-
tytro
类型上的尾递归优化
-
dirty-fsm
A quick and dirty state machine library
-
shorten
A collection of convenience functions, macros and traits to shorten repetitive code
-
flat-drop
Wrapper that drops recursive objects iteratively to avoid stack overflows
-
libimagerror
imag core distribution
-
concrete-type-rules
Rules and validation for concrete types
-
astro-notation
transcoding between Astro Notation Format and Native Rust data types
-
hash_ord
lib contains OrdMap(avl tree) and HashMap(use avl to resolve collision);
-
interpolate
form of string interpolation
-
never
A stable version of the unstable never type (!)
-
ferris-gc
Flexible implementation of garbage collector for Rust
-
imstr
Cheaply clonable and slicable immutable strings
-
bytify
macro that can write given const-expr values into a continuous byte array
-
b-x
The stupidest boxed error ever
-
min-max
max! and min! macros
-
advent-of-rust
Advent of Code utility macro for Rust
-
as_http_status_code
A derive macro for defining HTTP status code representation for struct and enum variants
-
stenotyme
Basic / experimental stenotype translation library, made to support the stenottyper practice UI, aiming at compatibility with (and embedding dictionary data from) Plover
-
temporary_enum_delegate_0_3_0
trait delegation functionality for enums and structs
-
struple
Convert structures from and to tuples
-
phenotype-internal
Defines
Phenotypetrait forPeapodcrate -
defer-heavy
A versatile and easy to use defer statement for Rust. Similar to Go's or Zig's defer.
-
expand-env-vars
Cross-platform environment variable expander for Rust (supports $VAR, ${VAR}, and %VAR%)
-
unsafe-send-sync
Unsafe wrappers for making structs Send and/or Sync
-
compile_time_sort
Sort arrays and slices of primitives in const contexts
-
easy_errors
simplify and enhance error handling in Rust
-
derive-name
Derive macro to get the name of a struct, enum or enum variant
-
yoylib
simpler
-
multer-derive
derive for constructign type from multer Multipart
-
stringreader
wrapper for strings so that they can be consumed via the std::io::Read trait
-
ffd
Fast Function Dispatch: Improving the performance of Rust's dynamic function calls
-
humthreads
Threads for humans
-
iter-enum
#[derive(Iterator, DoubleEndedIterator, ExactSizeIterator, Extend)] for enums
-
rust-extra
-
tupl
Perform generic operations on tuples
-
qaq-macro
qaq
-
naan
A fast, easy, and tasty functional programming prelude
-
hzrd
Shared mutability containers based on hazard pointers
-
tiny-input
Tiny input macros
-
takeable-option
A small wrapper around option
-
ad-hoc-result
that extends the standard Result type with an AdHoc variant for returning fallback values alongside errors
-
kube-core
Kube shared types, traits and client-less behavior
-
destruct
structs and enums for simpler combinator implementation
-
unocss-classes-utils
Utils for
unocss-classes -
gen_value
indexes and values with generations for vectors
-
size
expressing, formatting, and interacting with file sizes
-
selfref
Semi-pain-free self-referential pinned types
-
fixed-type-id
Make your types have a fixed type id&stable type name with version support between different builds
-
wasm_macro
Collections of useful macros for wasm
-
rustbench
A lightweight Rust procedural macro for benchmarking function execution time
-
transpose-future
Transpose Option<impl Future>
-
calc_lib
calculating things with correct order of operations
-
tardar
Extensions for diagnostic error handling with
miette -
sod-crossbeam
Service Oriented Design - Crossbeam
-
unipipe
pipe abstraction that extends to iterator and stream
-
zellij-tile
A small client-side library for writing Zellij plugins
-
enumeration
An extension to rust enum
-
enumx
Ad-hoc enum extension
-
panic-message
Get a panic message from a panic payload
-
flip-flop
implements the flip-flop operator from Perl and Ruby as a Rust macro
-
write_mode
API for handling file write modes using either std lib or fs-err
-
featureflag
Runtime feature flagging for Rust
-
friperms
framework for creating typed permission models for whatever system you could phatom
-
cprint
Cargo-like print
-
koute/nes
emulator written in Rust
-
axum-error-object
Result<T>type and related utility types that can be used to holistically provide object response errors -
langlang_syntax
langlang is a parser generator based on Parsing Expression Grammars (library)
-
impls
Determine if a type implements a logical trait expression
-
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)
-
taskchampion-lib
Personal task-tracking
-
parameterized_test
A macro to support providing arguments to test functions
-
copilot-rs
SDK for interacting with chat models, providing easy-to-use functions and tools
-
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
-
marker_trait
Implement a blanket implementation for a marker trait
-
winit-main
Abstract away winit's event-loop inversion of control
-
ra-ap-rustc_type_ir
Automatically published version of the package
rustc_type_irin the rust-lang/rust repository from commit febb10d0a2d29278135676783f6a22eb83295981 The publishing script for this crate lives at:… -
dbus-strings
Rust native implementation of different D-Bus string types
-
test-try
An alternative to Rust’s
#[test]macro for writing unit tests -
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
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 -
thistermination
add the Termination trait to error enums inspired by thiserror
-
peak-result
trait that extends the standard Result enum to allow you to run some code in case of error or success
-
hb_error
Useful macros and traits for creating and handling errors
-
tlkit
Tool Kit integration
-
rombok
boilerplate generation macros like lombok
-
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… -
mownstr
Maybe Owned String
-
golangify
published at 01.04.2024 this crate brings familiar flavor for newcomers from golang
-
generics
macros for parsing generics (with optional where clause) in
macro_rules! -
nyar-error
Error types for valkyrie language
-
vcell
Cellwith volatile read / write operations -
ps-util
aims to provide generally helpful utility functions and traits
-
syno_api
An incomplete set of DTOs and errors for Synology DSM APIs
-
event-listener-primitives
Low-level primitive for building Node.js-like event listeners
-
throw
Efficiently add statically-calculated stack traces to errors
-
flatty-portable
Flatty portable trait and primitives
-
thread-scoped-ref
that is similar to a thread local storage but allows to store references / dyn Trait within a scope
-
wdl-macros
Macros used within the
wdlcrate ecosystem -
throw_error
wrapping, throwing, and catching errors
-
chain-reader
Combining multiple [
Read] instances into a sequential read pipeline with configurable error handling 将多个 [Read] 实例组合为具有可配置错误处理的顺序读取管道 -
flatty-base
Flatty traits and primitives
-
branded
types for Rust
-
cryo
Extend the lifetime of a reference. Safely.
-
fgoxide
Utility/QoL code for writing command-line / file processing tools
-
actix-web-error
Derive ResponseError for your errors
-
extension-traits
Annotation to easily define ad-hoc / one-shot extension traits
-
dyn_struct
Construct dynamically sized types safely
-
ctrlgen
Generate enums for message-passing services
-
hado
Monadic do notation using a macro
-
hexga_bitflags
Bitflags utilities
-
opentalk-types-signaling-recording-service
Signaling types for the OpenTalk recording_service module
-
rngstr
A cli tool for generating random strings of characters with customization options and a small domain specific language
-
mantra-rust-trace
Collects requirement traces from rust code for the
mantraframework -
explicit-error-exit
Explicit concrete Error type to manage errors that end a process/program
-
thiserror-nostd-notrait
derive(Error)
-
generic_graph
implementing general purpose graphs. Including some default implementation (the latter are still WIP)
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
projecture
Easy arbitrary type projections without proc macros
-
structify
A procedural macro to transform functions into structs with state and execution dependencies
-
pattern_code
Given a path patterm matched source code
-
string-builder
string builder type
-
my_tuple
A pretty implementation of tuple
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
nz
Collection of 100% safe macros for creating non-zero integers more easily
-
eventually
using Event Sourcing in Rust applications
-
squote
A clone of the quote crate that uses a String as its backing store
-
cmdstruct
A lightweight macro for implementing commands with a struct
-
access-json
Use serde to query large nested structures in Rust. For low-effort, read-only FFI.
-
lootr
RPG-like looting system
-
trait_mux
Proc macro library for generating enums that can multiplex different trait objects
-
isclose
A collection of trait and macros for comparing approximate equality
-
arc-cow
ArcCow is a Rust smart pointer that combines the best features of Cow (clone-on-write) and Arc (atomic reference counting) to provide efficient, flexible data handling
-
retry-policy
Retry Policy
-
cli_input
Various functions for gathering user input in the terminal
-
functionality
Rust |> Functional programming = 💖
-
defer-rs
Deferred execution Rust utilities
-
ffizz-string
FFI string implementation
-
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
failchain
Ergonomic companion library for failure
-
byte-array-struct
Macro to create a byte-array backed struct
-
quark
Types for manipulating numeric primitives at the bit level
-
delfi
Conveniently writing data to csv-files
-
kust
Kotlin-like APIs for Rust
-
rama-error
error types and utilities for rama
-
scoped_thread_local
Highly flexible Scoped thread local with HKT builtin
-
rustils
Utilities for rust
-
parsely-impl
Macro-based struct serialization/deserialization
-
pass_by_catastrophe
Please do not use this
-
plain_enum
Mimicing Java's enum::values() and EnumMap
-
parsey
parser-generator framework
-
rustler
Safe Rust wrappers for creating Erlang NIF functions
-
alemat
type-safe building of MathML
-
enum-display
A macro to derive Display for enums
-
vnum
Create enums with a constant value associated to every variant
-
hexga_generational
GenVec, ideal for MAS (Multi-Agent System), where each agent can be removed at any time and has references to other agents
-
therror
derive(Error) with a twist (based on thiserror)
-
mayda_codec
Separate compilation unit for functions generated by mayda_macros
-
scientisto
A light-weight Rust implementation of the github/scientist library used for careful refactoring of critical code paths
-
bimm-contracts
Runtime contracts for the bimm framework
-
fixedstr-ext
A fork of fixedstr, which add more const functions to it
-
axum-accept-shared
Shared code for the axum-accept crate
-
extent
replacement for std::ops::{Range,RangeInclusive}
-
sharded-offset-map
A map from u64 to T that can be written from multiple threads
-
dddk_security
Security module of dddk_core. Impl features regarding command_bus pattern and security
-
retrying
General-purpose retrying library for Rust with macros and functions
-
animatron
Animation state management
-
kast-try-hash
Failable Hash trait
-
accessorise
Add accessors to your objects
-
printc
Print-clean macro. Like
println!but cleaner input. -
io-adapters
Adapters to convert between different writable APIs
-
simple_parse
A declarative converter for Rust type to and from binary
-
thiserror_core2
derive(Error) (no_std-enabled using core2)
-
list_tools
一个自己研发的Vec<T>
-
pyspark-arrow-rs
Derive macros to be used to add some helper functions to Rust structs to make them useable in Pyspark's mapInArrow
-
posix-errors
Posix error codes and handy functions for using them
-
oxineat-nn
A neural-network implementation of the OxiNEAT crate's Genome trait
-
concat-string
macros for concatenating string slices into owned strings
-
hash256-std-hasher
Standard library hasher for 256-bit prehashed keys
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
restd
A re-implementation of various std features
-
cantor
A general toolkit for working with types that have a small number of values
-
stackbox
&owning references in stable Rust - no_std-friendly Box -
cifg
A macro for defining #[cfg] if/else blocks; alternate to cfg-if
-
enum-variants-strings
Derive macro for converting instances of enums to and from strs using variant names
-
algar
Algebraic structures, higher-kinded types and other category theory bad ideas
-
is_empty
Easily check if the struct is empty
-
docpos
Compact-document items after defining them (fn, struct, enum) + document fn parameters with rustdoc (⑂roxygen)
-
capture-it
Modern c++-ish capture syntax for rust
-
align_ext
An extension trait for Rust integer types to make integers aligned to a power of two
-
scoped-writer
Scoped writer utility
-
internal_iterator_rec
Recursive extension for the
internal_iteratorcrate -
nanopre
A a zero-dependency, no-unsafe implementation of a minimal C-style text preprocessor
-
wx-core
微信数据解析工具
-
err-rs
Error level management
-
audiotags-dev-macro
macros used during the development of audiotags
-
merfolk_frontend_derive
A
Frontendfor merfolk using derive macros -
sumtype
Generate zerocost sumtype of iterators or closures
-
generational_vector
A vector type using generational indices
-
cowstr
Copy-on-Write shared strings
-
home-prelude
Prelude library to support home applications
-
dec-number
Decimal Floating Point Arithmetic for Rust
-
bitbag
A useful struct for dealing with bit flags
-
relend
A generalized reborrowing mechanism that extends beyond simple references. It also allows for implementing traits that work with reborrowing for custom types.
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
dev-csr
Macro for developing code to manage control status registers
-
async-convert
Async TryFrom/TryInto traits
-
cargo_toml
Cargo.tomlstruct definitions for parsing with Serde -
sayaka
some simple colorful debugging functions
-
pinned-aliasable
Pin-based stopgap for unboxed aliasable values in self-referential data structures
-
brain_flak_macro
Brain-Flak macro
-
rbx-rsml
A lexer and parser for the RSML language
-
basic-oop
OOP for Rust
-
dlib
Helper macros for handling manually loading optional system libraries
-
intertrait
Allow for inter-trait casting
-
smartcow
a cow for smartstrings
-
macro-utils
Some macros to make code writing more elegant and funny
-
ebml-iterable-specification
base
EbmlSpecificationused by theebml-iterableandebml-iterable-specification-derivecrates -
uwuizer
Rust Macro to UwUize your text. UwU.
-
hello-world-in-rust
Hello World!
-
bitio-rs
🚀A lightweight Rust library for bit-level I/O: read, peek, write, with both big-endian and little-endian support
-
ex_em_ell
Provide macros for serializing and deserializing XML
-
higher-kinded-types
"Generic generics" / higher-kinded APIs in stable Rust
-
rust-2015
Macro to use Rust 2015 from all editions
-
standback
New standard library, old compiler
-
dilib
A dependency injection library for Rust
-
plectrum
An easy way to represent lookup tables in a db as rust enums
-
dungeon-cell
Store (almost) any value as one type without dynamic memory
-
enum_primitive
Macro to generate num::FromPrimitive instances for enum that works in Rust 1.0
-
assert_has_field
macro for checking if a struct has a specific field
-
lurk-ipld-macro
lurk-ipld macro
-
prometheus-metric-storage
Derive macro to instantiate and register prometheus metrics without having to write tons of boilerplate code
-
typed_tuple
Type based operations on primitive tuple elements
-
rw-exact-ext
Extension of std::io to read and write data types with exact amounts of bytes
-
seventy
Newtype sanitization and validation
-
assemblist
Define your builder patterns as you use them
-
borrowme
The missing compound borrowing for Rust
-
deep_safe_drop
Safe dropping of deep trees that otherwise could cause stack overflow
-
aliri_macros
Macros used by the
alirifamily of crates -
stringer
An easy way to turn an Unsafe *const c_char into a Rust String type and return a pointer
-
comparator
A Java-like Comparator type
-
ref_thread_local
A macro for declaring thread-local
statics like using both oflazy_static!andRefCell -
chainerror
Make chaining errors easy
-
enum_macro
Useful macro for enum
-
input-rust
prompting user input, similar to Python's input(), with error handling
-
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
-
test_eq
assert_eq!-like macros that return a Result instead
-
collapse
Trim and collapse consecutive whitespace to a single space
-
metatype
Helper methods to determine whether a type is
TraitObject,SliceorConcrete, and work with them respectively -
nofmt
nofmt::pls, a macro that does its best at preventing a code block from being mangled -
proto-mapper
A Macro library for easier mapping between custom models and proto generated code
-
re_unwrap
An unwrap macroset for types Result<T, E> and Option<T> with several options for using alternativly to matches
-
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… -
parametrizer
safe crate for parsing properly-formatted math strings representing parametric functions into Rust functions
-
elina
Safe, high-level Rust wrapper for ELINA
-
kmacros
Useful macros
-
esync
This package contains some useful synchronization primitives
-
metacrate
Metadata for crates
-
permeable
A permission-demand trait. Decouples the permission-demander from the permission / auth provider.
-
lset
Data types describing linear sets
-
behavior-tree-lite
A minimal behavior tree implementation
-
unwrap-macros
Convenience macro for unwrapping result and option
-
enum_handler
A macro to generate a handler trait for enums variants
-
string-literals
Rust macros to more easily create String types
-
thin_cstr
An experimental crate which provides a truly thin std::ffi::CStr
-
typed_macros
Adds typing to your macro's arguments, making it a lot less of a pain to deal with them
-
aoc_driver
helper macros and functions for AoC
-
ghost-lite
custom PhantomData types
-
ignore-result
Adds a
Result<_, _>.ignore()method to ignore the return value of a function call without panicking in case of error -
traitreg
Create a registry of implementations of a trait
-
atomicell
Multi-threaded RefCell on atomics
-
precept
A testing utility for fuzzing and fault injection to discover erroneous and interesting states
-
ed
Encode and Decode traits
-
efmt_core
Core library for efmt crate
-
flag-bearer
Generic async semaphores
-
index-ext
Index slices with arbitrary ints and as arrays
-
ara_reporting
A Reporting library for for Ara Programming Language 📃
-
trybox
stable,
no_std-compatible, fallible heap allocation -
upget
Super simple trait that patterns the value "updae" and "get"
-
parameterx
flexible and type-safe parameter management system for Rust applications. This library provides multiple ways to store and retrieve typed values using a key-value structure, with support…
-
derive_constructors
Deriving From, TryFrom and create new_with_*args* functions
-
version
A very simple library who's job is to return the version of your crate if you're building with Cargo
-
precisej-printable-errno
Printable system call errors for nix
-
digitize
Traits for accessing digits of primitive integers & floats
-
clone-macro
Super simple utility macro for cloning before moving into a move closure/block
-
isolator
A lightweight library for isolating Rust functions
-
ffizz-passby
FFI helpers for implementing pass-by-value and pass-by-pointer
-
bit-flags
Flags trait that makes custom bitflag enums easier to implement in Rust
-
sapper_std
Wrappers for rapid coding for sapper web framework
-
tram
event bus that can be cloned and shared across threads
-
write-to-file
Write to a file, simple helper fn and traits lib crate
-
yansongda-utils
rust 中一些关于我自己的常用工具
-
pyo3_special_method_derive
Automatically derive Python dunder methods for your Rust code
-
cpr_bf
A brainfuck interpreter
-
typederror
A wrapper around anyhow that allows for a primary error type
-
facet-opaque
Type-erased pointer helpers for Facet types
-
fast-rustc-ap-rustc_session
Automatically published version of the package
rustc_sessionin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
googleapis-tonic-google-ads-googleads-v15-errors
A Google APIs client library generated by tonic-build
-
rabbithole
JSON:API Data Structure & Query implementation
-
magic_static
Global singletons initialized at program start, an alternative to lazy initialization
-
poly_enum
Hierarchical polymorphism with enums
-
phantasm
Small lib that helps with variance
-
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…
-
oop
Object-Oriented Inheritence in Rust
-
tiff-encoder
creating TIFF files
-
derive-sql-common
Common functions supporting
derive-sqland associated crates -
str_id
Interns str slices, giving you back an ID value
-
fold-license
Folding licenses from multiple dirs with
cargo/Cargo.toml andyarn/package.json -
failed-result
A small crate for converting various failed value to result with corresponding error type
-
castle_types
all Castle types for Castle_Api
-
lup
A custom indexed loop macro library for Rust
-
into-static
Upgrading to static lifetimes
-
butcher
An easy way to interact with structs and enums wrapped in Cows
-
enum_traits
Traits for builtin enum items that are primarily used by
enum_traits_macroswhen automatically deriving types -
num-sign
enum Sign { Positive = 1, Negative = -1 }
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
sodium
FRP (Functional Reactive Programming)
-
dev_bestia_url_utf8
url utf8 encode/decode
-
lazy_bastard
A helpfull macro because writeing a seperate Default function is too much effort
-
easyerr
easier creation and transformation of error types
-
rbuwu
rust macros but in uwu
-
primitive-from-enum
macros for get primitive enum from complex
-
igc_parser
A high-level parsing/deserializing crate for IGC flight recorder files
-
easy-shortcuts
easy helper utilities for short command-line programs
-
laby_common
Shared code required by laby
-
error-ex
designed for those who desire clear, explicit, and easy-to-use error creation and handling
-
xmacro_lib
macro engine for producing multiple expansions
-
async-retry
Async Retry
-
cirru_edn
Parser/Writer for Cirru EDN
-
reax
A reactivity system for Rust that infers dependencies between functions
-
lens-rs
lens implemented in rust
-
must_destroy
forced explcit destructors
-
poison-guard
maintaining sane state in the presence of panics and failures
-
swamp-types
types used in Swamp
-
ruroonga_command
A tiny Groonga query builder and generator
-
ruru
Native Ruby extensions in Rust
-
diesel_derives_traits
Traits for diesel_derives_extra
-
is_slice
Macro to answer the question: is it a slice?
-
iter-identify_first_last
A helper iterator, flagging first and last elements
-
cstl-sys
Low level CSTL Rust bindings generated with bindgen
-
tor-basic-utils
General helpers used by Tor
-
libtree
general or game tree
-
shellder
A lightweight, type-safe dependency injection and application framework for Rust inspired by Spring
-
hatch_result
A result-like struct that returns on Ok, instead of on Err when ? operator is used
-
cetkaik_traits
traits for cetkaik
-
openapi_type
OpenAPI type information for Rust structs and enums
-
gazebo
A collection of well-tested utilities
-
rust_kafka_like
A Kafka-like message broker in Rust
-
twurst-error
Twirp error struct
-
downgrade
mutable reference to an immutable one
-
idioma
Print Rust'y error messages
-
ask_nicely
A rest client helper library
-
inline_default
Macro for inline Default implementation
-
rvs
defining and evaluating random variables using a simple DSL
-
debugless-unwrap
Unwrap Result<!Debug, !Debug> and Option<!Debug>
-
unused
Allows for unused generic parameters that do not act like they are owned
-
decrust-promac-runtime
The ultimate all-in-one error handling framework for Rust
-
tao-of-rust
《Rust编程之道》随书源码
-
err-per-field
A more fine-grained control over field-level error handling
-
regexm
macro for writing regex pattern matching
-
applying
Apply functions in method-position
-
rust2fun
functional programming in Rust
-
matches2
A macro to evaluate, as a boolean, whether an expression matches a pattern
-
from_variant
Automatically derive From impls for enums
-
reportify
error handling and reporting
-
subslice-to-array
Extract fixed-range subslices as arrays, with compile-time checks
-
extract-variant
Destructure expressions into, and return assignments from, a single pattern
-
winnow-regex
A set of winnow parsers backed by the regex crate
-
samsvar
trait for matching on custom types
-
html_tag
An Enigmatic Way to use HTML in Rust
-
tryvial
Small crate for ok-wrapping and try blocks
-
tuple_utils
A set of utilities to enable higher level operations over tuples
-
kutil-std
std utilities from Kutil
-
darkly
scanf-style scanner
-
assert-cmp
Convenient assertion macros that print the failed expressions and their evaluated values
-
inline_dyn
A container type for storing dynamically-sized types inline
-
indiscriminant
A proc-macro for mapping between values and enum discriminants
-
io-read-line-prototype
Prototype for io::read_line
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
identity-diff
Difftrait to compute and merge data structure differences -
tca-rs
The Composable Architecture (TCA, for short) is a library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind
-
wopt
A procedural macro that automatically generates an Option-wrapped version of a struct, reducing boilerplate for optional updates
-
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. -
oofs
Error handling library that generates and injects context for you
-
captur
Macro to capture whole structs from disjoint fields in a closure
-
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… -
macro_error
A macro to display error message
-
unwrap_let
macro for quickly unwrapping a refutable pattern
-
awaitdrop
WaitGroup
-
rual
A slim, embeddable language
-
stub-macro
stub!() is a better version of todo!() that can be assigned to a variable
-
conniecs
ECS system based off of the
ecscrate, but with some minor API adjustments and derive macros for implementing most of the boilerplate. Make sure to include theconniecs-derivecrate as well -
drop-bin
Defer running expensive destructors until later
-
macro_clap
Command-line argument parsing to its simplest
-
simplerror
A zero-dep macro to declaratively define error enum types and their common trait implementations
-
symbol-ty
generating symbols as type-level strings
-
standalone-proc-macro2
Fork of proc-macro2 that uses rustc-ap-proc_macro so as to remove the rustc dylib dependency
-
xdc
eXperimental Dynamic Casting - support library
-
partial_application
partial function application via the partial! macro
-
tlist
Type-level linked lists (of types) and type-level 'functions' to manipulate them. Because TList is implemented using GATs, usage is very ergonomic.
-
rbx_types_ops
Adds operation methods to rbx_types
-
smol_buf
small-string optimized string / buffer type with O(1) clone
-
non-non-full
Vec and String wrappers that assert the containers are always non-empty (or, ahem, non-non-full)
-
interning
Thread-Lcoal and Global Interning Library
-
abi_stable_shared
detail of abi_stable
-
up_set
Set values, or update them using a closure
-
partial-borrow
Partially borrow a struct
-
valq
macros for querying and extracting value from structured data by JavaScript-like syntax
-
to-display
A trait that is Display or can be converted to Display
-
macon_api
builder macro-based generator with its own idioms
-
valued-enums
Macros collection and specify trait for creating valued or python-like enums
-
arr_ty
Macros for smart array initialization (best for trait object element types)
-
fringe
safe, lightweight userland context switches
-
mikros
An optionated crate to help building multi-purpose applications
-
abcgen
A procedural macro to generate boilerplate code for objects implementing the 'Actor' pattern
-
const-zero
a const mem::zeroed
-
pigeon-core
Generate recursive-descent & precedence climbing parsers. (traits)
-
mini-macro-magic
Export tokens to other modules and crates. Now with 100% less proc macros!
-
bit_roles
Granular role management based on bit flags
-
lyneate
beautiful code underlining and error reporting
-
match_opt
A macro for turning a partial match into a full match returning an option
-
derive_destructure2_examples
Examples for crate derive_destructure2
-
itertools-num
Numerical iterator tools. Extra iterators and iterator methods and functions.
-
private-gemm-x86
x86 matmul impl
-
flaggy
parsing command-line flags
-
named-block
Macro implementing early-exit-from-any-block
-
ratelimit_rs
The ratelimit package provides an efficient token bucket implementation
-
macro_lisp
Lisp-like DSL for Rust language
-
methods-enum
Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait
-
anthill-di
Rust di containers system
-
twitter/rustcommon-metrics
Common Twitter Rust lib
-
boost-rs
boosting your develop productivity on Rust
-
testify_core
The core library for the testify framework, providing the core functionality and utilities
-
partial-default
PartialDefault, a trait similar to Default but with fewer guarantees
-
thin_delegate
Auto implementation of trivial delegation to inner types
-
clap-doc
Create markdown descriptions for
clap::Commands -
litho-diagnostics
Definitions for all diagnostics that Litho (a GraphQL framework) can emit
-
graphic-walker-parser
Graphic-walker DSL parser
-
deserr
Deserialization library with focus on error handling
-
rxml_validation
Plumbing crate for rxml and rxml_proc crates
-
apply
A tiny library for chaining free functions into method call chains
-
structural
Field accessor traits,and emulation of structural types
-
numeric_literals
Easily cope with numeric literals in generic Rust code
-
benri
Convenient macros wrapping the standard library
-
decurse
Macro to make recursive function run on the heap (i.e. no stack overflow).
-
topdown-rs
A top-down parsing library
-
recs
flexible, macro-free entity-component system in pure (stable!) Rust
-
nougat
(lifetime) GATs on stable Rust
-
delta-struct
Delta struct provides a rust-lang Deriveable trait, Delta, that can be used to compute the difference (aka delta) between two instances of a type
-
to_boxed
defines ToBoxed Trait and its derive
-
bilk
Miscellaneous convenience functions and traits
-
casual
parsing user input
-
these
A three-way enum capturing This, That, or Both. Inspired by the Haskell package https://hackage.haskell.org/package/these
-
linked_lists
Different types of linked lists
-
panda-re
The official library for interfacing with PANDA (Platform for Architecture-Neutral Dynamic Analysis)
-
xavier-internal
Internal module of Xavier. Xavier is a lightweight and versatile XML parsing library designed to streamline the process of handling XML data with ease and efficiency.
-
queue-model
Abstraction of the concept of a queue
-
tamanegi-error
detail of
tamanegi-errorcrate -
from_variants
Rust macro to automatically generate conversions for newtype enums
-
letter-sequence
A method to create sequence displayed as uppercase or lower letters, or digits
-
elvish
Overengineered Advent of Code framework - not quite Santa's elves
-
enum_index
Trait and macros for extracting Enum variant index
-
option-ext
Extends
Optionwith additional operations -
input_macro_fold_func
A small crate for handling user input more easilly
-
sod-mpsc
Service Oriented Design - Multi Producer Single Consumer
-
nonany
Integer types with customizable niche values
-
defmac
A macro to define lambda-like macros inline
-
slice-utils
A collection of slice utils, like itertools
-
ref-ops
An escape hatch for implementing
opstraits for references to newtypes -
fr
A programming language with an unusual compiler backend
-
konst_macro_rules
detail of the konst crate
-
utility-macros
emulate Utility Types and Unions from TypeScript
-
bint
Bounded Integer in Rust
-
wiwi-macro-decl
declarative macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
microtype
simplify the creation of microtypes
-
enum-update
representing state changes as enums
-
rsps_vergen_emboss
macro to emboss vergen-based environment variables into your binary, primarily for rsps support
-
togglog
A compile-time toggle wrapper for the log crate
-
perthread
ThreadMap structure for accessing PerThread thread local variables form a static context
-
exms
Get statistics and compare exams results
-
rust_io
Macro implementation for [rust_io] defining several operators to be used emulating Haskel [do notation]
-
non-empty-str
Non-empty strings
-
rerast_macros
Macros for use in Rerast rules
-
sting
Smaller alternatives to Cow<'static, {str,[u8]}>
-
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
-
control-flow
A hack to control control-flow outside closures
-
hereditary
Procedural macros for emulating OOP Inheritance in Rust
-
fmu_from_struct
A derive macro for automatically setting up FMU models in Rust
-
irox-structs
Traits for Struct Types - linearly serialized big/little endian bytes
-
vtid
generating volatile type IDs
-
spore-vm
Virtual machine for the Spore interpretted language
-
json-crawler
Wrapper for serde_json that provides nicer errors when crawling through large json files
-
int-to-c-enum
TryFromInt - A convenient derive macro for converting an integer to an enum
-
entwine
Generic slice-like interface for operating on multiple slices at the same time
-
simple_scan
Iterator extensions for simple scan operation
-
lifted
Higher-kinded types in Rust
-
serde-textual
derive Display/FromStr by using serde
-
drop-with-owned-fields
Safe and sound owned access to a
struct’s fields inDrop: no moreunsafeusage ofManuallyDrop! -
mers_lib
mers language in other projects
-
coercible_errors
Zero-cost error handling for generic traits
-
syn-test-suite
Test suite of the syn crate
-
linux-errnos
A list of error numbers
-
element-ptr
A macro to make accessing elements through raw pointers easier
-
ty-tag
TypeId for lifetime containing types via type tags
-
zoomer
Making Rust a true modern language™️ with revolutionary macros
-
const-util
Stable implementations for some missing const functions
-
tiptoe
An easy-to-support intrusively reference-counting smart pointer
-
strprintf
Provide a way to interpolate printf-style format strings using native Rust types. Part of libnewsboat lib dependencies
-
uy
A typesafe, flexible, simple, and user-friendly unit system library for Rust that has good error messages
-
aspect
Toolkit for Rust
-
dynamic-cast
The fifth pillar of OOP: dynamic casting
-
atruct
macros for anonymous structs in Rust
-
ark-r1cs-std
A standard library for constraint system gadgets
-
hexspec
A dsl for creating and verifying byte buffers
-
abstractions
Abstraction traits
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
totally-ordered
No dependency, no-std totally ordered f32/f64
-
gemini-mainloop
An engine-agnostic mainloop abstraction library
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
cove
Casts Of Varying Elegance (COVE): extension traits for casting numerical types
-
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…
-
try-guard
A guard! macro inspired by the guard Alternative function from Haskell
-
phantom-enum
macro library for creating phantom enums
-
common_macros
common macros like
hash_map!orhash_set!(WIP) -
intfloat
Fast and simple hashable float alternative using ints
-
not-found-error
Convert Option to Result using convenient functions
-
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…
-
stated-scope-guard
A more flexible RAII pattern for stated resouce management
-
almost
comparing floating point numbers
-
fallback-if
Fall back to an alternative given some predicate
-
gtk_widget_macro
A derive macro helps you handle Gtk widgets
-
cdumay_error_base64
base64 error
-
assert_hex
display assert panics in hexadecimal {:#x?} format
-
jsonerr
macro and builder
-
bool_vec
A crates that exposes a vector called BoolVec which allows you to store a boolean in a single bit
-
overloaded_literals
Overloaded Literals to construct your datatypes without boilerplate and with compile-time validation
-
the-string-macro
The missing
string!macro to constructStringvalue from string literal -
fancy-default
A better
derive(Default)implementation -
shorter-bounds
Write shorter bounds with a trait alias macro
-
racer-interner
thread-local string interner for racer-rust
-
flow-control
Declarative macros for common flow-control use cases such as break, continue, and return
-
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…
-
jealousy
A wrapper arount the envy crate, providing an easily implementable trait
-
internship
Interned string and more
-
then
bool::then functions but named properly
-
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.
-
ez-err
error handling library with support for ergonomic and fast error handling
-
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
trait-set
Support for trait alias feature on stable Rust
-
take-until
A take_until extension for iterators
-
extfn
Call any freestanding function as
a.foo(b)instead offoo(a, b)just by adding#[extfn]and renaming the first parameter toself -
wtflip
A language in a Rust macro... or something.
-
advent_of_code_traits
Minimal, flexible framework for implementing solutions to Advent of Code in Rusts
-
rquickjs-extension
An extension system for rquickjs
-
conspiracy
Safe, efficient configuration abstractions
-
tailwag_utils
A collection of assorted utility functions / traits. Part of the tailwag stack.
-
singleton-manager
A programatical singleton manager
-
tokio-bin-process
run your application under a separate process with tokio tracing assertions when integration testing
-
diatom-std-core
Diatom core standard library
-
strck_ident
Checked owned and borrowed Unicode-based identifiers
-
simplicio
Gets rid of the boilerplate in rust
-
nvim-oxi-types
Rust bindings to types used by Neovim's C API
-
maybe-uninit-ext
Extended maybe-uninit types
-
consume_on_drop
A zero-cost abstraction that allows Drop::drop to consume self by value
-
simple_detailed_error
Stack and specify errors explainations saying what happened, why, how, where, how to solve it and its causes
-
thread-object
Abstraction over thread-local storage allowing dynamic creation of TLS variables
-
error-ext
Error utilities
-
once-option
OnceOptiontype, similar toOption, with the constraint that once emptied it cannot be re-set to contain a value. Useful for members that need to be consumed on drop or cannot be re-set otherwise (e… -
tch-tensor-like
Derive convenient methods for struct or enum of tch tensors
-
permitit
Cute little library to permit a specific error
-
onechatsocial-result
Revolt Backend: Result and Error types
-
test_help-rs
Test helpers for Rust
-
prae
that aims to provide a better way to define types that require validation
-
heron-rebuild-traverse
Workflow graph traversal utilities for heron-rebuild
-
fuck-backslash
replace the backslash with slash in-place in your PathBuf
-
nonzero_lit
Easy, safe, and fully zero-cost NonZero constants and literals
-
macron-path
Creates a new instance of PathBuf
-
io-ensure
Prototype of the
std::io::ensurefamily of macros -
rdc
generating Java code from rust structs
-
portaldi-core
Core functionalities for portaldi
-
safe-discriminant
A minimalistic,
no_stdcompatible trait and procedural macro for extracting discriminants from enums at zero cost -
macro-attr
macro_attr!macro that enables the use of custom, macro-based attributes and derivations. Supercedes thecustom_derivecrate. -
bijective-enum-map
Convert an enum to and from another type, with From (or TryFrom)
-
tailsome
Blanket traits providing
.into_ok(),.into_err(), and.into_some()for happier method chaining -
rs-luau
Minimal overhead Luau bindings for Rust!
-
throwing
Create explicit errors easily with a handy macro
-
ddi
Dynamic dependency injection library for rust
-
std-traits
Traits for types in the standard library
-
shive
lightweight IOC service container writen for the Rust applications
-
intuple
Convert structs and enums into tuples (of refs) and back - recursive, ignore fields
-
cond
Rust macro to use a match-like syntax as an elegant alternative to nesting if-else statements
-
serde_newtype
Macro for generating newtypes with validity checks for use with serde
-
env-var
Macros providing easier access to environment variables in rust
-
tl_interface
Type-level interface for type-level programming in Rust
-
diffuser-edit
Edit diffuser models without GPU and Python
-
failsafe
A circuit breaker implementation
-
shoggoth
Generic and type-level programming for Rust
-
libabort
A abort function that doesn't require the standard library
-
oxiderr
Streamlining Error Handling in Rust
-
pubserve
generic observer trait
-
strpatmatch
string pattern matching
-
descriptive_toml_derive
Procedural derive macro for serializing a struct into a TOML template with field descriptions that is easily edited and deserialized
-
tuple_split
An extension for the tupleops crate which adds a trait for splitting tuples
-
lifterr
A small set of adapters extending Rust's error-handling capabilities
-
nolife
open a scope and then freeze it in time for future access
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
menu_genie
Multi-level terminal menu library
-
type-toppings
Opinionated extensions to standard types
-
advancedresearch-higher_order_core
Core structs and traits for programming with higher order structures in Rust
-
unwrap-infallible
Unwrapping Result values with compile-time guarantee of infallibility
-
read-restrict
Restrict the number of bytes read from a reader
-
io-arrays
Random-access I/O
-
my-little-eval
A little library for evaluating mathematical expressions
-
interior_mutability_pointer
A wrapper around
Rc<RefCell<T>>allowing immediate access to inner methods -
init_array
Initialize arrays itemwise
-
orion-exchange
exchange data struct
-
iterstats
Statistics for rust iterators
-
recore
A re-implementation of various ::core features
-
shallowclone
Traits for working with copy-on-write types more efficiently
-
tacit
macro to make newtypes easier to create
-
count-tts-inner
macro for counting any position tokens
-
facet-poke
Build and alter arbitrary Facet types
-
xselfref
Fork of the selfref library, with some additions
-
kti_cqrs_rs
CQRS pattern in Rust
-
next_tuple
A trait to build and extend tuples
-
shared-type
Shared type alias and several traits to simplify working with Arc<Mutex<T>>
-
laxcow
Clone-on-write smart pointer with relaxed trait constraints
-
namable_closures
types and macros to create namable closure types
-
uninit-tools
that allows working with uninitialized memory entirely in safe code
-
nonicle
Tools for type-safe, canonical data representations
-
kcr_wgpolicyk8s_io
Kubernetes Custom Resource Bindings
-
arrays
Construct an array from an iterator
-
rich-result
Rich result type differentiating between recoverable & fatal errors
-
interns
Object interner
-
dyn_struct2
Construct dynamically sized types safely. Supports arbitrary unsized types, not just slices
-
match_any
declarative macro, that matches an expression to any of the patterns and executes the same expression arm for any match
-
command-ext
Extension traits for std::process::Command
-
torrust-tracker-located-error
provide error decorator with the location and the source of the original error
-
trustmebro
macro that magically turns unsafe code into ‘totally safe, bro’ with no consequences. Ideal for those who want to assert dominance over the compiler and live on the edge of catastrophe.
-
derive_builder_fork_arti
Rust macro to automatically implement the builder pattern for arbitrary structs
-
async_fn
Collection of helper annotations and macros for concise and yet explicit
async fnsignatures -
fluent-string
Fluent versions of String mutation methods
-
tiny-ordered-float
Tiny version of OrderedFloat
-
langlang_value
langlang is a parser generator based on Parsing Expression Grammars (library)
-
macron-regex
Creates a new instance of Regex
-
wrapping-macro
wrapping macro
-
anywrap
error handling mechanism with pseudo-stack traces implemented through SNAFU, the proc macro trace_error, and the DebugTrace trait, inspired by GreptimeDB
-
simple-color
color struct
-
tlv-rs
A parser for SIMPLE TLVs
-
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
-
html5ever_macros
High-performance browser-grade HTML5 parser − compiler plugins
-
fluent_state_machine
A domain-specific language (DSL) for creating state machines in Rust
-
inew
Macroses for constructor generation
-
random_variant
To be used with all variant, contains the derive macro
-
random-trait
random trait meant to produce random generic types
-
enum-to-string-traits
EnumToStringderive macro which implements the methodsas_str()andas_dbg()to enums with no associated values -
easy-int
macros for easy implementation of integer aliases
-
apply_attr
A syntax extension providing higher-order attributes to Rust
-
iter_accumulate
An iterator adaptor that accumulates the elements and yields the current accumulated value for each iteration
-
finite-state-machine
A type and trait based finite state machine macro
-
rustato-macros
Macros for the Rustato library
-
kvtree
Heterogenous in memory key value tree storage
-
tex-rs
create latex documents in Rust
-
external_mixin_umbrella
Backing library for
rust_mixinandexternal_mixinto keep them DRY -
derive-into
derive macro for easily creating conversions between structs and enums
-
bset
Fast and compact sets of bytes or ASCII characters
-
shoulda
derive macro for test assertions
-
pathsep
a small macro to enable easy path construction in other macro calls
-
bounds
interact with bounded and unbounded ranges
-
hypershell-reqwest-components
Modular DSL for shellscripting in Rust
-
tupleops
work with tuples
-
tor-error
unified type-erased error type returned by many (esp. high-level) Tor APIs.
-
arc-cell
Helper for a simple Cell-like object containing Arc/Weak
-
replace_err
Adds a
replace_errmethod toResultwhich throws away the current error and replaces it -
async_fn_traits
Trait synonyms for “Fn[…]”-trait bounds returning futures
-
illicit
An implicit thread-local environment which is indexed by type
-
autotrait2
generate trait definitions from impl blocks
-
env-type
define environment variables as types
-
rsb_derive
An opinionated macro implementation for Rust struct builder pattern with compile-time validation
-
catch_panic
A helper macro for safe Java-Rust interop that "catches" Rust panics and rethrows them as Java exceptions
-
yukon
trait for the ability to cheaply duplicate an object
-
cfg-or-panic
Replace function bodies with
unimplemented!()when condition is not met -
static-cond
Macro for performing comparisons during macro expansion
-
cell-map
Many-layered 2D cellular generic map
-
erreur
A tiny crate that facilitates error handling, including tracing line numbers, customizing and propagating error messages
-
mightrix
treat continous memory as a matrix
-
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… -
kg-symbol
Atomic strings in Rust
-
tokio-timeout
A proc-macro which adds a timeout to an asynchronous function running under the tokio runtime
-
composable
Easy composition of functional traits, functions or closures
-
liftor
Functors for Rust lifetimes
-
cudd-sys
Bindings for CU Decision Diagram library (CUDD)
-
dims_macro
Macros for Generating Systems of Units
-
opentalk-types-signaling-breakout
Signaling types for the OpenTalk breakout module
-
anyhow-std
Wrap std APIs with anyhow error context
-
boolean-enums
Generate enums with Yes and No variants. Supports no_std and serde.
-
cell
A replacement of std::cell::RefCell adding advanced support for mapping borrows
-
envfig
A flexible and type-safe system for defining, documenting, and validating environment variables
-
atomflag
Atomics for your bitflags!
-
r-ex
Zero-bloat Rust core library extensions
-
value-traits
By-value slices and iterators
-
swamp-analyzer
analyzer for swamp
-
mathelogos
as a functional programming language
-
fb_stats
Stats library
-
prost-validate-types
validation types with prost and prost-reflect support
-
default-test
A default trait that can be used in tests
-
enum-primitive-derive
enum_primitive implementation using procedural macros to have a custom derive
-
fmt-derive
A more robust and versatile derive macro for Debug and Display
-
iter-index
More flexible alternative to Iterator's enumerate() method
-
trait-enumizer
Proc macro to automatically generate enum based on method signatures (with appropriate helpers)
-
type-factory
unique opaque types
-
veho
a iterable toolset
-
battler-wamp-values
WAMP value types
-
tuplify
Generic hlist/tuple library
-
vec-of-enum
Helper macros for a Vec of enum values
-
typestate-builder
Derive-macro-based generator that combines
TypestateandBuilderpatterns -
macroland
macro shorthands of various types in Rust
-
irgo
macro to use go-defer-like in Rust
-
kaguya_rs
Functional Programming tools and ADTs
-
rassert-rs
macro for expressing Result-returning assertions
-
big_s
Rust’s missing
Stringliteral -
racros
Collection of rust macros
-
crossdylib
Cross-platform shared state across shared libraries/modules
-
fmap
Functors in Rust
-
fluid-macro
Write long method chains as a series of steps instead, and more!
-
try-drop
Batteries included error handling mechanisms for drops which can fail
-
partial-functional
A small collection of Semigroups and Monoids for rust
-
fat_type
A type which permits thin references to arrays and dynamic types
-
macroific_core
Shared functionality for macroific & macroific_macro
-
enum_properties
A macro for declaring static properties on enum variants
-
squeak
providing types allowing execution of callbacks in response to values being broadcast or mutated
-
rustring_builder
string builder
-
overflower
A compiler plugin to easily select overflow behavior for all integer operations of an item
-
copy_impl
Macro for effortlessly duplicating impl block code across various types in Rust
-
impl-converter-helper
declarative macro library to help you implement the
FromorTryFromtrait for your type -
matched_enums_types
Types and helpers used for the matched enum macro
-
should_error
The test should fail with Err
-
recursive_reference
way to walk on recursive structures easily and safely
-
slice-copy
Go style copying for slices
-
scalar_map
mapfor scalar types -
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
enum_downcast
Safe downcasting for enums
-
quick-error2
A macro which makes error types pleasant to write
-
oneshot-fused-workaround
Fused wrapper for futures::channel::oneshot
-
useful_macro
Collections of useful macros
-
seestr
pointer-wide nul-terminated strings with ownership semantics
-
roopert_macro_common
object-oriented toolkit for Rust (common data)
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
hexga_tools
miscellaneous stuff, when somethings will be too big it will be on a separate crate
-
add_macro
more additional macros to help you write code faster!
-
ezing
Easing functions
-
softfloat-sys
Rust bindings for Berkeley SoftFloat 3
-
yadir
Dependency Injection Registry for Rust
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
extension-eyre
Re-export of color-eyre that introduces Extensions (type-map) to eyre::Report
-
chainer
A cursed crate that allows for global call chaining with access to chained function results
-
duplex
trait: interactive streams
-
curerr
easy error handling
-
read_buffer
ReadBuffer, a wrapper to safely read into a buffer from a Read
-
cluConstData
Create and merge any persistent data at compile time
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
try_hard
Malleable error handling for rust
-
moro-local
Experimental structured concurrency support for async Rust (similar to trio's nurseries). Works with non-Send futures on stable Rust.
-
stuff
Stuffing things into pointers
-
safevalue
A value based approach to uphold SAFETY requirements for unsafe Rust code
-
peck-lib
A set of library and type functions
-
cell-project
Safe interface for cell projection
-
cdumay_error_json
JSON error
-
ruva-core
Event Driven TEvent Handling
-
wrapper-lite
Helper macro for creating a wrapper over any type (new-type idiom)
-
defew
A new() derive macro for structs
-
encdec-base
encdec simple encoder/decoder base types and traits
-
tokio-inherit-task-local
Task local variables for tokio that can be inherited across a spawn
-
simple-eyre
One of the simplest error reporters one can build ontop of eyre, defining only an error report
-
detach
helper type for being able to detach/reatach a member item
-
cmp
convenience macros and function for comparing
-
shared_singleton
trait provides singleton pattern state management with shared container
-
fluent_builder
builder API
-
nonneg-float
A generic NonNegative float wrapper with compile-time checked macro
-
cvt
Expose the cvt function from Rust libstd
-
into_inner
IntoInner trait for Rust newtypes
-
copper
A constraint programming solver
-
declarative_type_state
A collection of declarative macros to reduce boilerplate code when implementing type-state patterns
-
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… -
async_labjack
A pure rust, async interface to the LabJack T-series via Modbus TCP
-
singleton-cell
A more powerful Ghost Cell allowing the use of any singleton as the key
-
derive_environment
modifying structs via environment variables
-
displaythis
derive(Display)
-
mint
Math interoperability standard types
-
fromage
A cheesy Rust hack for converting between non-local types
-
type-uuid
Safe, stable IDs for Rust types
-
always_equal
A wrapper for types that can't implement Eq
-
schemafy_lib
Generates serializeable Rust types from a json schema
-
crispii_errors
Errors intended for use in Crispii
-
bongonet-error
Error types and error handling APIs for Bongonet
-
qcomms
small library that offers a simple, zero-cost message passing trait. no async-trait
-
xylem
Building context-sensitive type conversion
-
supply-chain-trust-crate-000022
Single assignment cells and lazy values
-
carykh-macro-rust
macro for finding strings that contain self-referential numbers. Inspired by carykh. This description contains twenty-seven words, fifty-four vowels, and ninety-nine consonants.
-
cgp-error
Context-generic programming error components
-
tupletools
functions for tuples
-
no-std-thiserror
thiserror but no_std compatible
-
try_utils
The try! macro descends into an enum variant. It's more flexible than ? and unwrap(), and it works with your enum, too!
-
mogrify
macro for autogenerating a “Parse, Don’t Validate”
TryFromimplementation for structs -
infinite-stream
Streams (asynchronous iterators) that always keep yielding items (or panic, or become pending forever)
-
splitmut
Safely retrieves multiple mutable values from the same collection
-
egg_recursive
A recursive interface for egg: e-graphs good without S-expresion!
-
rexpr
Rust Json Object access Runtime
-
custom-string
aids in generating string types with custom validation
-
mods
Simpler module declaration
-
closure
A macro for capturing variables on a per variable basis
-
stable-pattern
Stable port of std::str::Pattern and friends
-
grass-runtime
Runtime library for GRASS
-
dyn-dyn
Flexible trait object downcasting using ptr_metadata
-
stackstack
A singly linked list intended to be chained along stack frames
-
sycamore-state-core
sycamore-state core types and trait definitions
-
strunemix
allows to build a struct with a form of its fields, by deriving enums of them
-
scope-guard
RAII scope guard
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
haz
A thin abstraction over polymorphic environments
-
swamp-script-error-report
Swamp script error report
-
valid8
no-nonsense validation library
-
wrapping_macros
A macro for wrapping arithmetic
-
murrelet_livecode_macros
livecode macros for murrelet, a livecode framework
-
static_assert_macro
so-called
static_assert -
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)…
-
dynrsaur
working with type-erasure/dynamic-types in Rust
-
dzn-rs
dealing with DZN files used in the MiniZinc language
-
valkyrie-docgen
-
aorist_primitives
Primitive macros for the aorist project
-
html5ever-atoms
Static strings for html5ever
-
tosserror
derive(Toss)
-
dir-assert
Assertion to compare directories recursively
-
with_builtin_macros
Helper for macro_rules authors to chain their macros with builtin ones (such as
env!,include!, orconcat_idents!) -
swift-rs-hatter-fork
Call Swift from Rust with ease!
-
incomplete
incomplete!(), a compile-time checked version of unimplemented!()
-
ffizz-header
FFI helpers to generate a C header for your library
-
moro
Experimental structured concurrency support for async Rust (similar to trio's nurseries)
-
usize_cast
Compile time checked cast from and to
usize/isize -
clap-file
types for clap's derive interface, enabling easy handling of input/output with automatically opened files or standard input/output based on command-line arguments
-
dyn-error
Error-related utilites for Rust
-
alone_ee
Small event emitter for rapid development of weak dependency in applications. simple. powerful. predicted
-
ident-util
macro to determine the string name of a binding, type, const, or function
-
escher
Self-referencial structs using the async/await transformation
-
tl_str_list
Type-level string (tl list of chars)
-
ord_subset
Tools for working with the Ord subset of certain PartialOrd types, like floats
-
ownref
Provide the smart pointer type that bundles the data with its owner
-
split-stream-by
Stream extension crate for splitting a Stream into two per a predicate
-
maflow
Flow macros: basically unwrap for return, continue and break
-
friendly_safety_buddy
A fun macro to write safe code with
-
standard_test
A set of tests checking the properties of your impls of std traits
-
inter-struct
Automatically generated traits for arbitrary structs
-
components-arena-traits
Does not intend for direct use
-
swahili-dsl
A Swahili-based DSL made for educational purposes
-
async-iter-ext
Async iterator methods and async methods for option and result
-
assert-within
Macro for testing that (generic) floating point numbers are within some tolerance
-
rust-2024
Macro to use Rust 2024 from all editions
-
derive_default_builder
derives a builder implementation relying on all fields implementing Default
-
di
Dependency injection container
-
transitive
derive macros for Rust
-
atomint
Trait for mapping integer types to their corresponding atomic types
-
respan
Macros to erase scope information from tokens
-
futility
Functional Utility types, macros, and functions for common tasks or needs in Rust
-
propertybindings
Experimental rust-based QML-like language
-
fallible_map
fallible mapping over
Optionand iterators using functions that can returnResults -
engineer
master builder!
-
typebitset
Type-level bitset implementation
-
codespan-derive
derive(IntoDiagnostic) for easy codespan integration
-
coc
A useful macro collections for struct
-
visita
Elegant implementation of the Visitor Pattern
-
sized-dst
Owned container for dynamically-sized types backed by inline memory
-
nanoval
A nan-tagged value for representing f64, i32, u32, booleans, null and arbitrary pointers
-
write-into
A trait to write things into io::Write
-
option-like
Create your own Option-like enum
-
hudi-core
The native Rust implementation for Apache Hudi
-
tree-rizzen-yazston
Tree Library using the Any trait for data
-
re_span
An integer range that always has a non-negative length
-
check
Convenience assert!-like macros which return instead of panicking
-
impl_ops
Macros for easy operator overloading
-
multi_try
Safely combine results
-
fake-enum
creating FFI safe "fake" enum types
-
romap
A trait for read-only-maps
-
stecs
Experimental static compiler-checked ECS library
-
chisel-common
Chisel common macros, types and functions
-
unchecked_wrap
Convenient UncheckedSync/Send wrapper types
-
byteorder_slice
Byteorder like crate for &[u8]
-
replicante_util_failure
Helper functions to manage failures
-
mod
project that provides two simple and useful utility functions for converting between Option and Result types
-
seesaw
generate traits from C header files
-
patched
Macro for patch like structure
-
finite_repr
Isomorphic encoding/decoding data to & from numbers
-
swiss-army-knife
Common utility code to support linux-support and other projects
-
tangu
language
-
type-operators
A macro system for creating type operators in Rust and writing type-level logic
-
bevy_cell
Attach Bevy's Handles/Entities statically to Types
-
easy_error_core
Core error type for easy_error
-
non-zero
A macro for creating constant non-zero integers (with type inference)
-
fuzzypath
Quick & dirty fuzzy path comparison
-
from_bytes_or_zeroed
Reads integers from an arbitrary slice of bytes
-
big_mac
A metamacro toolkit for writing complex macros
-
run-on-drop
Run code when an object is dropped
-
unwrap_none
Implements the
unwrap_noneandexpect_nonemethods removed by https://github.com/rust-lang/rust/pull/83349 -
mlua-gen
Generates code to easily use Rust's structs or enums in Lua with mlua
-
webidl-utils
working with the WebIDL AST, by extending weedle2
-
machinery
safe wrappers for working with The Machinery game engine
-
negative
impls in stable Rust
-
destruct-drop
Macro for dropping the fields of a struct or enum without dropping the container
-
humane_commands
Allows you to write more shell-like Commands
-
rustrix
Supports macro and basic operations for matrix
-
the-newtype
The Newtype trait
-
cronjob
scheduling your methods
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
pre
Compile-time assistance for working with unsafe code
-
struct-validation
trait and derive to validate structs and return a list of errors
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
thinnable
Thin references to unsized types
-
unwind_safe
Readable unwind-safe code thanks to a try-finally-looking builder pattern
-
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…
-
variadic_generics
A first attempt in using traits & tuples to work around Rusts lack of variadic generics
-
split-every
Split for every n occurrences of a pattern iteratively!
-
beaver
setting up Rust objects inspired by factory_bot
-
eso
Type machinery to build Cow-like containers
-
hex-slice
Extends the std::fmt::*Hex traits to slices
-
sod-bus
Service Oriented Design - Single Producer Multi Consumer
-
strongly
A proc macro to create strongly-typed primitives
-
aggregate
attributes of structs for runtime
-
prost-dto
Data transfer object conversion macros for prost
-
iter_fixed
Iterator of fixed length
-
assure
macros for Rust runtime checks and error handling
-
parkour
A fast, extensible command-line arguments parser
-
ucsi
SI-based unit typing system
-
eager
macro expansion
-
perhaps
Maybe monad implementation with a more intuitive name. Using Certain and Dubious instead of Just and Nothing
-
frunk_core
Frunk core provides developers with HList, Coproduct, LabelledGeneric and Generic
-
near-safe-cell
A more ergonomic 'UnsafeCell' wrapper/replacement
-
sw_my_crate
Just a test crate
-
lit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
as_num
Checked conversions between Rust's numeric types
-
tuplestructops
Structural manipulations for tuples
-
tectonic_errors
A boxed error type for Tectonic, with supporting utilities
-
en
The easiest numeric traits!
-
finite-fields
Traits and types for computations on finite fields
-
byte-strings
Rust byte strings manipulation, for a better and safer C FFI
-
teo-teon
Object notation for Teo
-
fn_zip
zip trait for functions, allowing two functions to be combined before being called
-
iterator-ext
An extension to Rust's Iterator
-
from-string
that provides a FromString trait with a String to String noop
-
oxi-types
Rust bindings to types used by Neovim's C API
-
qualifiers
Conditionally add qualifiers to item definitions
-
cpp_to_rust_generator
Automatic generator of C++ library wrappers
-
exprtk_rs
Rust bindings to the ExprTk C++ library (http://www.partow.net/programming/exprtk)
-
derive_variants
derives an additional enum from a nested enum that contains only variants and no nested fields
-
picostring
A stack allocated string that requires no extra space to store length
-
flagger
Enum flag generator
-
syscall_encode_traits
Traits and macros to help define a syscall interface for a kernel
-
type-census
Track the number of extant instances of your types
-
autoproto
Replacement derive macros for
prost::Message, and supporting traits and types to make implementing this trait easier -
nest-guard
working with nested guard-type APIs
-
unchecked-std
some methods from the Rust standard library without some checks
-
erreport
A Result helper to catch all the Err propagation path for Rust
-
xdi
Rust di containers system
-
funlib
Rust functional library
-
micro_errors
deal with errors without taking the derive macro approach
-
diva
Opinionated convenience wrappers for
std::process::Commandand friends -
repeated
Allows you to repeat a block of code a number of times
-
helper
provided some useful proc macros for Rust
-
columnation
Unsafe columnar containers for native Rust types
-
phantom_newtype
Lightweight newtypes without macros
-
validus
A string validation library
-
deref_owned
Generalization of std::borrow::Cow
-
libquickjs-sys
QuickJS Javascript Engine FFI bindings
-
serde_table
Write structs in an easy table format
-
bevy_state_plugin_generator
A build-dependency that generates a Bevy State Plugin from a simple state definition
-
panicking
std::thread::panickinganalog available in theno_stdcontext -
polymorph
A set of utilities to better enable polymorphic behavior in Rust
-
hacspec-lib
The hacspec library
-
nonzero
Statically checked non-zero integers
-
yield-return
Implement a coroutine like C#‘s
yield returnusing Rust’sasync,await -
try-blocks
macro to emulate the upcoming
tryblock feature on stable -
mazer-macros
A minimal, simple math markup language that compiles to HTML, written in Rust
-
dc-ock
reverse polish notation desk calculator library
-
retrieval
Allows the retrieval of trait implementations
-
lox_utils
General helpers used by Lox
-
catalyser
A comprehensive collection of extensions to simplify and enhane rust development
-
redb_model_trait
Redb model trait
-
schema2000
derive a JSON schema from given JSON objects
-
rusty-matrix
A generic matrix implementation
-
newtype-derive-2018
macros for deriving common traits for newtype structures
-
map
map!macro andmap_insert!macro, to create a HashMap collection and insert key-value pairs. Inspired by thevec!macro. -
rvs-repl
REPL for Rvs - A library for defining and evaluating random variables using a simple DSL
-
struct-builder
Derive a builder for your structs
-
iter-chunks
Extend Iterator with chunks
-
take-static
Static items that provide mutable access only once
-
tl_list_lib
Type-level kinded heterogeneous list for type-level programming in Rust
-
cdumay_error_standard
define standard errors
-
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… -
omniswap
swap values between possibly-overlapping references
-
ordered_iter
Ordered iterators
-
rs-utilities
Some utilities
-
tlbf
Type level bitflags
-
leetcode_prelude
Some useful macros and definition for exercising in leetcode
-
num-to
Number conversions without using as
-
smurf
SMall Useful Rust Functions
-
cismute
Safely transmute type to itself in generic contexts
-
batch_oper
some batch operation macro for some operations
-
fieldx_aux
Various types and tools useful for fieldx crates and, potentially, to users of fieldx
-
chomp
A fast monadic-style parser combinator designed to work on stable Rust
-
signrel
Trait expressing relationship between integers of different signedness
-
chassis
Compile-time dependency injection framework
-
statum-core
Compile-time state machine magic for Rust: Zero-boilerplate typestate patterns with automatic transition validation
-
recycle_vec
method for Vec to recycle it's backing allocation for use with another Vec of different type
-
ez_jni_general_utils
General utility functions and data that are common for the ez_jni crate, its macros, and its tests
-
thisisplural
#[derive(Plural)] for creating frictionless new types with any collection type like Vec or HashMap
-
aranya-buggy
A less panicky replacement for unreachable!() and unwrap
-
transmute_guard
Transmute between types that have been marked as safe by the marker type
-
io-close
An extension trait for safely dropping I/O writers such as File and BufWriter
-
cute
A macro for Python-esque comprehensions
-
hephae-utils
Hephae's generic utility module
-
hex-display
Display impl for byte slices which provides a hexdump
-
frankencell
An alternative to
qcellandghost-cellthat instead uses const generics -
peggen-core
Generate recursive-descent & precedence climbing parsers. (traits)
-
dynerr
Macros for dynamic error handling
-
nutype_test_util
Ergonomically create newtypes in tests
-
assert-impl
Macro for static assert types implement a trait or not
-
frust
Functional Programming in Rust
-
pi_print_any
print any value without trait bounds using specialization (Rust nightly channel)
-
ts_static
Wrapper macro for lazy static and a struct to aid in accessing a static in a thread safe way
-
str-macro
The str!() macro, similar to vec![] but for strings
-
approx_eq
A macro for comparing equality of two values up to an arbitrary error in the *relative* difference
-
nested-struct
Create nested structs using a macro
-
ld_preload_helpers
Macros to run code at load time and override C functions
-
dependent_view
Wrappers to produce weak trait objects from reference types
-
biodome
Reading and parsing env vars with defaults and structured types
-
error-doc
proc macro to generate #[doc] comments from #[error] messages
-
oco_ref
A smart pointer for storing immutable values with relatively-cheap cloning. (Like a
Cowmeets anRc!) -
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
-
newtype_derive
macros for deriving common traits for newtype structures
-
podio
Additional trait for Read and Write to read and write Plain Old Data
-
multi_stack_queue
Abstraction layer for a stack-allocated multi-queue with bounded length. WIP
-
log-once
Collection of helper macros for logging some events only once
-
common-testing
Common testing shortcuts and utilities reused across projects
-
inline-const
Inline consts implemented as a macro
-
mixed-num
A trait for generic implementations of numerical methods
-
newtype-ops
Mass-derive many operators for newtypes. Wartier than newtype_derive.
-
elor
Base generic implementation of an Either type
-
closure_attr
An attribute macro to simplify closure captures
-
axmac
Readable indexing macros for 1-4 dimensional data structures
-
custom-format
Custom formatting for Rust
-
typesafe-builders
Infallible compile-time checked builders for your structs
-
enum_variant_macros
Macros to generate From & TryFrom for enums
-
forgy
Derive macro for building dependency graphs
-
auto-variants
A macro that exposes a function that returns all enum variants
-
rust-fp-categories
A Functional Programming Library in Rust, Category
-
necessist-core
-
unchecked-index
Unchecked indexing wrapper using regular index syntax
-
okapi-response-mac
A macro for creating response code based on responses structs rather than typing and implementing OkapiRocketResponseInner manually
-
memory-size-type
A data type for dealing with memory sizes
-
mat-rs
no_std implementation of mathematical matrix types
-
int-range-ext
A trait that implements some convenience methods for integer ranges
-
unroll_range
Repeats a block of code for each number in a specified range
-
shared-expiry-get
concurrent async get with expiration for Rust
-
bagel
Compile-time evaluation and other tools
-
hexga_number
Provide basic trait and constant for number, and the macro map_on!
-
flexpiler
Deserialiser aiming at high customizability
-
indexing
Sound unchecked indexing using “generativity”; a type system approach to indices, pointers and ranges that are trusted to be in bounds
-
gobble
A Combinator based parser for strings that gets out of the way, and leaves your code looking like a grammer
-
inner
The inner! macro descends into an enum variant. It's more flexible than try!() and unwrap(), and it works with your enum, too!
-
tupperware
Storage traits for your types
-
HOPA
A lightweight, higher-order parser
-
oops
Lightweight error-handling. Provides
Option<T> -> std::io::Result<T>. -
guilt-by-association
Macro for declaring/implementing traits with fake associated consts (in stable Rust)
-
arrcomp
Python-style list comprehension syntax for contiguous memory Rust arrays
-
once-cell-regex
just gives you the
regexmacro from theonce_celldocs! -
name-it
Give a name to async fn return types
-
merge-hashmap
Merge multiple values into one
-
ferrite-session
Session Types DSL for Rust
-
bevis
Fiat-Shamir without the Hassle
-
scad
generating OpenSCAD models using rust
-
rusty-hkt
Higher-kinded types for Rust
-
platform-cast
Platform-specific safe cast
-
automap
pattern to implement key-value maps where the value type contains the key type
-
objid
Generate a random object identifier
-
errify
Function error context provider
-
rusty-typesh
A flexible type pattern matching system for Rust
-
vine
framework inspired by Spring Boot
-
tagged-vec
A Vec which can be indexed by one specific type
-
ref-map
Helper trait for Option and Result to map references
-
cgp-error-eyre
Context-generic programming error handlers implemented using eyre
-
optargs
Easily create macros for functions with optional arguments
-
clc-engine
Provide calculation api for calculator ui
-
wiwiwiwiwiwiwiwiwiwi
declarative macros for wiwi, a library, of, Stuff™ (implementation detail; do not depend on this crate directly)
-
byte-order
reading and writing numbers in big-endian and little-endian
-
tailwind-parse
Parses tailwind directives and yields user-friendly errors
-
destructure_traitobject
Unsafe helpers for working with raw trait objects. (Forked from traitobject)
-
yadi
Dependency Injection framework for writing applications with Rust programming language
-
generic_static
Generic static variables in generic functions
-
tagged_cell
Fast, initializable, and thread safe static variables
-
fb_cloned
Cloned macro
-
ref_kind
Different reference kinds
-
lazy-attribute
convenient attribute macro for lazy function execution
-
notzero
macro for constructing
std::num::NonZero*from constants -
emplacable
Return unsized values from functions
-
set_field
Set fields on structs by string
-
init-token
one-time safe initialization of static, without overhead
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
derive-insert
GetOrInserttrait for enums and its derive macro -
arc-interner
An interner that deallocates unused values
-
singleton-trait
Singleton trait for types with unique values and Erased type for zero-sized ownership proofs
-
test-with-tokio
attribute macro for tests using tokio with cases and async guards
-
maxlen
Length-bounded string and slice/vector
-
simplebyteunit
A thin encapsulate for integer primitives to facilitate a fast, simple, yet ergonomic byteunit implementation
-
qcontext
One-time initializable static state with statically-checked zero-cost interior mutability
-
error_def
syntax extension for generating error-handling boilerplate code
-
astr
A const lenght stack str
-
coi
Dependency Injection library
-
iter-scan
Iterator scan methods that don't suck
-
rattish
Cast between trait objects
-
tuplemagic
manipulating tuples through various operations like mapping, filtering, nesting, and reducing
-
loop_chain
Macro for writing nested Loop expressions
-
result-ext
Extends
Resultwith additional operations -
fast-floats
Fast-math wrappers for floats; experimental and unstable; for experiments
-
symbolism
Unique symbols made from human readable tags
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
pointer-identity
Wrapper type to treat the pointer address of types as identity rather than the value
-
dare
daring flexible data representation
-
recursion-visualize
visualized cache-aware stack safe recursion
-
aidanhs-tmp-parse-generics-shim
A stable shim for the proposed RFC #1583; provides macros for parsing generics and where clauses
-
re_types_core
The core traits and types that power Rerun's data model
-
display_container
implement Display
-
bos
Flexible Borrowed, Owned or Shared (B.O.S.) smart pointers. Like std's Cow but with Rc/Arc and without the ToOwned requirement
-
errore
error handling and tracing
-
multiconst
destructures an expression into multiple constants
-
conditional-assignment
very simple, small crate to help make conditional assignments more ergonomic
-
xcsp3-rust
that help constraint programming solvers implemented by Rust to read XCSP3 files
-
partialdebug
Derive Debug partially
-
unwrap_todo
Option::todo and Result::todo methods
-
archery
Abstract over the atomicity of reference-counting pointers
-
scanmut
Insert/remove multiple items from Vecs in O(n) time
-
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
-
extprim_literals
Plugin for creating extra primitive types literals (u128!(n), i128!(n))
-
jget
Rust tools
-
damock
Derivable data mocking for tests
-
open-ambient
Open files and directories with constant paths
-
bitmask
generator for enum scoped bit flags
-
predicate
Use enum to predicate something, support & and | operator
-
classes
Dependency-free macro that simplifies the process of building class strings for DOM elements
-
giacrs
Bindings to the giac/xcas library
-
silx-types
aSynchronous Interactive calcuLation eXecutor: an easy to use executor for asynchronous and interacting processes
-
generic-vec
a vector implementation that can be used in
no_stdenvioronments -
timed-locks
Smart pointers to
tokio::synclocks that either panic or error after a timeout -
slist
Algebraic lists with statically determined size that live on stack
-
rsor
Reusable slice of references
-
syrette
The convenient dependency injection framework
-
irox-enums
Traits for better Enumerated Types
-
err_mac
no dependency macro for creating error enums with automatic
Fromimplementations -
u-plus
Pretty Unicode code point literals: U+12345 instead of '\u{12345}'
-
cxx-symbols
detail of the
cxxcrate -
better-as-any
Automatically makes your trait objects downcasting-capable
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
lgio
Lightweight, generic, no_std IO
-
displaydoc-lite
Implement the Display trait using your standard doc comments
-
flow_impl
Definition of an Implementation trait for flow functions, and a derive macro
-
strand-cam-enum-iter
provide an EnumIter trait for iterating over enums in the Strand Camera ecosystem
-
cflp
A context-free-language parser generated by procedural macros
-
atomic_non_null
An atomic wrapper around NonNull
-
unwrap_helpers
Helper macros for unwrapping
-
retry-block
retry operations that may fail with configurable backoff behavior using macros over blocks of code
-
arbintrary
Proof of concept for arbitrary integer sizes using generic const
-
more_collection_macros
Adds new macros to rust for creating collections
-
try_as
Macros and traits to ease using enums whose sole purpose is to enumerate a set of types
-
derail
An alternative to
core::error::Error -
odesolver
solving ODE's
-
structmap
Procedural macro library for converting between Rust structs and associative containers
-
ward
ward! macro which returns the contents of an Option<T> and otherwise returns early, and a guard! macro, which does the same, but with a syntax more similar to Swift's guard syntax
-
const-units
that lets you check the dimensions of your quantities at compile time and run time
-
convert_traits
Define your own conversion traits to solve the problem of converting two external types without using new types
-
kudi
Compile Time Interface-Oriented Dependency Injection
-
avocado-schema
A schema DSL which can be interpreted to implement multiple purposes
-
epui
Equisized (primitive) unsigned ints for primitive ints: u8 for u8, u16 for i16, etc
-
unflatter
unflatteris a Rust library providing extension traits for flattening and unwrapping nested structures, including nestedOptionandResulttypes. It simplifies working with deeply… -
borrow-framework
More flexible borrowing
-
funkjon
One of the worst macros this world has ever been (dis)graced with
-
lazy_thread_local
Lazily initialised per-object thread-local storage
-
phantomdrop
Go-like deferring of function calls
-
predicates-core
An API for boolean-valued predicate functions
-
scanfmt
easy to use macro for parsing a string
-
whiteout
macros that erase the type of any value into an impl Trait for a given trait
-
cjson-rs
Rust bindings for the cJSON library
-
facet-core
Core types and traits for the facet ecosystem
-
tested-trait
Associate tests with traits
-
list_comprehension
A macro for Haskell-like list comprehensions in Rust
-
color-core
Color shared definition
-
iterextd
This trait provides additional methods for working with iterators, enhancing their functionality
-
dyn-eq
Test equality between trait objects
-
lambek
Type-Level Programming in Rust
-
iter_variants
A way to iterate over all variants of a rust struct/enum
-
builder_option
A macro to generate builder class for a struct
-
qed
Compile-time assertions
-
serde-struct-tuple-enum
Procedural macro for deserializing an enum of structs from tuples
-
pushgen
Push-style design pattern for processing of ranges and data-streams
-
default_is_triple_underscore
Shorter syntax for Default::default() : ___()
-
hazmat
A collection of helpers for working with hazardous materials in Rust crates
-
tagged-pointer-as-enum
A set of structs, traits and macros to implement tagged pointers
-
appro-eq
Approximately equal traits and assertion
-
multindex
Index slices with multiple const indices/ranges
-
pathext
A small path trait extension with some convenience methods
-
into_index
Helper traits allowing indexing into vectors and similar types by other types than
usize -
const-anonymous-functions
macro to create const anonymous functions
-
typeable
Exposes Typeable, for getting TypeIds at runtime
-
gitoxide-core
implementing all capabilities of the gitoxide CLI
-
serser
serialization crate
-
file_access
wrapper-lib to make performing certain file manipulations more convenient
-
ddd-rs
Domain-Driven Design (DDD) building blocks, for Rust applications
-
nohash-hasher
std::hash::Hasherwhich does not hash at all -
leptos_form
Derive forms from structs
-
unique
ptr::Unique for stable Rust
-
extensions-rs
File extension types in Rust
-
assert-type-eq
Macro to assert types across potentially different crate versions are compatible
-
set_slice
A macro for assigning values to slices
-
proptest-recurse
Helper for defining mutually recursive strategies with proptest
-
podstru
Bureaucratic structs to speed up rust development
-
except
The only one
Error -
os_str_bytes
Lossless functionality for platform-native strings
-
surrealize
A procedural macro for generating helper struct variants for use with SurrealDB
-
typify-impl
typify backend implementation
-
ghosts
Type-check non-existing
Phantomcode for Fun And Profit™ -
steepen
Create multiple iterators from a single iterator by separating elements
-
min-specialization
Experimental implementation of specialization
-
tc-error
TinyChain's generic error struct
-
description
like Display, but 'static
-
cause
A generic [std::error::Error] implementation
-
anodyne
An opinionated set of tools for building applications (mostly with
axum) -
handlevec
Small abstraction over index-style iteration over a vector, with deletion, insertion, and other operations on the vector while iterating
-
const-exhaustive
Enumerate all values of a type at compile time
-
std_utils
Standard utilities for Rust
-
callable
closures implementing PartialEq and argument operations
-
ambient_cb
Defines helper types for callbacks wrapped in
Arcthat implementDebug -
jnt
full of just neat things
-
thin-slice
An owned slice that packs the slice storage into a single word when possible
-
moore-circt
Rust wrappers around the CIRCT API
-
const_typed_builder
Compile-time type-checked builder derive using const generics
-
tt-call
Token tree calling convention
-
right-as
Chain call assigns tuple elements to outside
-
debug-fn
A function adapter that implements Display and Debug
-
sqnc
Traits and adaptors for sequences
-
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… -
my-desire
poc generic and injection-proof interpolation API for Rust
-
integer_or_float
A data type holding an ‘integer or float’ (a data type in the Unified Font Object specification, among others)
-
slab_typesafe
A wrapper for Slab that provides type-safe tokens instead of usize
-
fruit-salad
Compare apples and oranges (and more). Trait object reference casting and trait object comparisons.
-
swamp-ast
ast types for swamp
-
once
assert_has_not_been_called! macro that panics if the surrounding function is called twice. Useful for initialization functions.
-
type-sets
Sets implemented in the rust type-system
-
databend_educe
offers procedural macros designed to facilitate the swift implementation of Rust's built-in traits, temporarily used in databend
-
token-ref-cell
Interior mutability cell using an external token to synchronize accesses
-
option-cell
OptionCell: OnceCell but derivable from Option
-
iex
Idiomatic exceptions
-
fn_name
Macros that produce the name of the function they're invoked within
-
sod-tungstenite
Service Oriented Design - Tungstenite
-
sum_type
A convenience macro for creating a wrapper enum which may be one of several distinct types
-
injectiny
A tiny dependency injection utility for Rust
-
ebacktrace
error wrapper which captures a backtrace and can carry an optional textual description
-
squall_dot_io_resp
A RESP parser implementation, written with edge performance in mind
-
see-through
traits to provide access to internal fields of generic structs
-
shared_error
SharedError wrapper for cloneable Error
-
rs_state_machine
A business-oriented state machine library
-
devela_depend
Optional external dependencies for
devela -
externcfn
macro_rules for define correct extern 'C' functions with an normal syntax
-
transitive_from
Helper macros for creating hierarchies of transitive
Fromimplementations -
rudeboy
Rlua User Data Extension Boy - Derive/attr macros and traits for easily exporting user data to RLua
-
wrapp
Add additional functionality to Rust errors using a wrapper
-
spectral
Fluent test assertions
-
cas-error
Error type for generic errors in CalcScript
-
x-bow
Precise State Management Library
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
zc_io
zero-copy I/O
-
gpp
A generic C-like preprocessor for Rust
-
anyflux
Generic flux-like state management
-
fsize
fsizeis aliased to the floating-point type of pointer size -
byte-calc
Helper crate to work with bit, byte, and block sizes
-
any_ref
To capture and move things that are NOT 'static with memory safety
-
has-some
The opposite of is_empty (and is_empty for filters)
-
filters
Build filters/predicates with the builder pattern
-
similar-structs-macros
Quality-of-life macros for more concise struct/enum definitions
-
u16cstr
A macro for creating c-style u16 wide strings at compile time
-
const-assert
Assert struct for const generics
-
ref_wrapper
Wrapper of dynamically borrowed data
-
constany_blank
Convert any function to constant
-
nype
Newtype helper macros for Rust
-
harbourmaster
Convenient, high-level abstractions of running Docker containers
-
rust2fun_laws
Laws for rust2fun
-
wxrust-base
Binding for the (part of) wxBase library of the wxWidgets toolkit
-
unnest
Macros for an unnested control flow
-
derive_di
realized the dependency injection pattern
-
select_indices
Iterators for taking multiple shared/exclusive references from a slice
-
tany
Type-erased container with inline storage for small values
-
zero_v
implementing iterators over function outputs for collections of types implementing a common trait, without using vtables/ dynamic polymorphism
-
simple-life
async lifecycle trait and convenient macros
-
token-read
reading whitespace delimited files intended for competitive programming
-
rust-releases-core
Base traits and definitions for rust-releases
-
axerrno
Generic error code representation
-
cpp_core
interoperability with C++
-
polymorphic-constant
A macro to define a numerical constant in multiple types at once
-
lua53-ext
Extension to jcmoyer's Lua 5.3 bindings
-
buffed
Traits & implementation of parsing buffered IO
-
app-frame
Compile-time dependency-injected application framework with a service orchestrator
-
zipped
recursively unzipping tuples, Options of tuples and Results of tuples
-
rubbl_core
Core types and traits for Rubbl, a Rust package for astrophysics
-
non-empty-slice
Non-empty slices
-
kast-util
kast
-
chandeliers-err
Internal error message generators for the Chandeliers project
-
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
-
arraybox
A box with fixed capacity, backed by a byte array (it can be stored on the stack too). Implements fixed capacity
ArrayBox. -
teloc
compile-time DI framework for Rust
-
tuple-traits
Additional tuple traits to enable ergonomic types
-
tuppipe
pipe operator-like implementation using tuples in Rust
-
new_type
Experimental implementation of newtypes by type level logic
-
compost
Adds a macro to decompose tuples into tuples containing a subset of their values
-
bitmagic
Rust bindings for the bitmagic library
-
nan-tag
NaN-tagged pointers in Rust, storing an f64 in the same space as a pointer
-
rvs-c-api
C-API for Rvs - A library for defining and evaluating random variables using a simple DSL
-
cereal
data serialisation library
-
test-results
A series of utility macros for outputting testing results
-
gep
gep, a better pointer arithmetic library -
derive-ex
Improved version of the macro to implement the traits defined in the standard library
-
strong
Strongly typed String
-
vec-utils
vector utilities
-
ctti
Compile-time type information
-
cascade-error
Error cascade: more information about error
-
parsin
minimalistic CLI (Command-Line Interface) parser for Rust
-
const_power_of_two
working with constant generics that are powers of two
-
nagios-range
types to parse and operate on Nagios ranges
-
veccell
variant of Vec with interior mutability
-
as-result
Traits for converting types which may be interpreted as or into a result
-
close-err
Add .close() to file-like types, for error handling
-
zisvalidator
A validator for struct and enum
-
kv-derive
Derive struct conversions from and to key-value vectors
-
doxed
making Rust doc strings available at runtime
-
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
-
inheritance
Avoiding code repetition in Rust with OOP inheritance
-
vec-string
To print Vec<Display>
-
trait-union
Stack-allocated trait objects
-
blackboxmc_general
Helper functions for BlackboxMC
-
cgp-error-extra
Context-generic programming error components
-
fastpeek
A different way to peek iterators
-
chain-debug
Injecting debug without rewriting chain-calling code
-
fstrings-rust
Python3 fstring interpolation in Rust
-
log_err
Log error messages from Unwrap and Expect with log crate
-
fstrings
Python3 fstring interpolation in Rust
-
cisness
Runtime 'live witness' of two types being the same
-
project-uninit
Macros for safe references to and initialization of fields in MaybeUninit structs
-
makeit
Compile-time checked Builder pattern
derivemacro with zero-memory overhead -
hexhex
hexadecimal conversion 🪄
-
lifelink
Erase covariant lifetime parameters from anything, with generic associated types
-
iter-comprehensions
iterator comprehensions
-
audi
Generic listener abstraction
-
isnt
Inverted versions of boolean-valued stdlib functions
-
controlflow_inspect
inspect_* methods for ControlFlow
-
telocs
compile-time DI framework for Rust
-
derive_convert
Derives 'impl (Try)From for Self' and 'impl (Try)From<Self>'
-
declarative_enum_dispatch
Declarative macro generating boilerplate for enum dispatch
-
malvolio
programmatically generating HTML
-
iterator-sorted
Stable functions for checking iterator sorting
-
rusty-value
Create a generic inspectable value from any rust type
-
numeric-enum-macro
A declarative macro for type-safe enum-to-numbers conversion
-
grouping_by
allows the user to group an iterator by various ways
-
spawn_timeout
Call a subroutine after a constant time interval
-
pkbuffer
Buffer objects made for arbitrary casting and addressing!
-
common-error
High performance universal error code management for Rust in Rust
-
disuse
The way to notify the implementation which return value is disuse
-
borrow_channel
A channel for borrows
-
async_t
zero-cost async-traits
-
chained
lazily chaining functions
-
pyo3_special_method_derive_lib
Automatically derive Python dunder methods for your Rust code
-
orion-async
Eliminate this constraint for performance - the local variables of asynchronous functions must implement Send Trait
-
lexington
A very simple library for lexing / parsing
-
swamp-core
Initializes the Swamp core library module, defining primitive type aliases and registering intrinsic functions
-
smart
dynamically-dispatched smart pointers
-
pipeop
Adding the pipe operator to Rust with a declarative macro
-
error-code
Error code
-
anyhow_ext
Extension of anynow
-
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
len_constraints
Traits and types to implement type-pinned length constraints in your API
-
tartan-c-enum
Define FFI-safe enums that support unknown values
-
bogdan_hello_macro
adds the method hello_macro that generates a greeting based on the name of the struct
-
cmp_any
Comparison for &dyn types
-
hexga_array
that impl trait / new functions for array
-
davenport
Ergonomic thread-local workspaces for intermediate data
-
fallible-option
Fallible is an Option with inverted Try-semantics
-
assert_ok
A macro that asserts a Result is Ok
-
nclosure
composable, nameable closure types with separated states and functionality for use in APIs where anonymous types are unavailable
-
maplit2
Collection helper libraries and “literal” macros for HashMap, HashSet, BTreeMap, and BTreeSet
-
cap-std
Capability-based version of the Rust standard library
-
const_guards
An attribute macro for compile time constraints on const generics
-
either-future
Future for Either<impl Future, impl Future>
-
i2u
Common useful functions, that are Zero cost abstractions using generics, to easily convert numbers to binary, hex, octal, and convert any type that implements Debug into a String
-
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.
-
to_unit
ToUnit; Any type to () syntax sugar
-
chain_tools
A set of traits allowing for more a erganomic style of chain programming
-
intern-all
A safe and predictable interner for data of mixed and arbitrary type
-
io-cast
a high-level io function similar to Python's input function
-
sql-table-macros
Helper macros to generate SQL table definitions
-
error_log
struct-based Error-Handling
-
delegare
delegate struct easy
-
endian_trait
A trait for Endianness conversions that can be implemented on most types
-
variadic_closure
Support for dynamically created and called closures with variable number of arguments
-
py-comp
A macro implementing a Python-like generator expression
-
sod-log
Service Oriented Design - Log Integrations
-
constant
evaluation tools for Rust
-
negative-impl
Negative trait implementations on stable Rust
-
iter-builder
Iterator builder with chain calls
-
arrcat
Array concatenation
-
linq
Language Integrated Query in Rust
-
inarybay
Graph-based binary format (de)serializer generator
-
warned
struct Warned<T, W> { value: T, warnings: Vec<W> }, which represents a value with warnings
-
not-so-fast
data validation with derive macro
-
keepops
Extension traits for keeping the input of mapping functions
-
slyce
Python-like slices
-
scsys-core
core primitives and utilities for the scsys ecosystem
-
larc
Lazy Arc/Weak pointers
-
result-inspect
Adds the missing Result::inspect() function
-
serde_str_helpers
Helpers for using serde with strings
-
niceowner
A stupid library that allows you to own a value, even if it comes from a reference. No cloning.
-
rcrefcell
Wrapper type for Rc<RefCell<A>>
-
openssl-errors
Custom error library support for the openssl crate
-
build-deftly
Derive custom builders, using the derive-deftly macro system
-
input-stream
IO streams similar to C++'s streams
-
instancebuilder
Convenient way of managing dependency injection
-
iterpipes
Compositional, pipes-style stream processing
-
commandspec
Rust macro to build std::process::Command objects with shell syntax. Uses macro_rules! and works on stable.
-
debug_unwraps
Extension traits for debug only checked unwrapping
-
frunk_utils
working with frunk
-
vec_vec
When dealing with
Vec<Vec<T>>is unavoidable -
enum_derive
macros for deriving additional functionality for enums
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
cex
Checked exception simulation
-
argley
Turn a struct into arguments for a
Command -
stringlit
A macro to convert from str to String
-
arch-into
safe type conversions between pointer-sized types (usize/isize) and types with fixed size
-
value-enum
Macro for generating enums associated with values
-
kozo
syntax sugars for structs
-
ryu_floating_decimal
Fast floating point to floating decimal conversion. See the crate 'ryu' for more details
-
effective
An effects library, an alternative to keyword generics
-
cartesian_array_product
Arrays of the cartesian product of a set of items
-
object-safe
Implement object-unsafe traits for trait objects
-
spawn_interval
Call a subroutine at a constant time interval
-
scones
Generates simple constructors for structs
-
columnation-master
An experimental columnar arena
-
rewrap
Result<Result<T, E>, F>->Result<T, F> -
static-cow
Cowat the type level: a framework of traits for writing types that are generic over ownership of their contents -
nvim-types
Rust bindings to the Neovim C types
-
structural-convert
Derive conversion traits (From, Into, TryFrom, TryInto) when fields are structurally similar in enums or structs
-
bin-pool
A small crate for interning binary slices
-
litenum
minimal convertion utilities between literal and enum
-
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
-
vec_filter
Vec Filter is a Rust library to filter a vector of structs based on a query string. It allows you to specify filter conditions on struct fields with a simple query syntax. The library provides a custom derive macro…
-
fast_async_trait
Fast async traits for Rust
-
kathy
Const-evaluated swift-style keypaths
-
shrinkwraprs
Auto-derive for Rust conversion traits -- make working with newtypes a breeze
-
rooting-forms
Generates HTML (rooting) forms from structures
-
fn_block
defining macros for calling blocks or expressions in a closure
-
sbatch-rs
sbatch command generator
-
look_inside
Look inside structs, enums, and unions!
-
wurm
Non-fatal, strongly typed errors
-
arcerror
thin wrappers around Arc<T> and Rc<T> where T: Error. Impls Error for both of these types. No unsafe, no dependencies.
-
rnet-gen
Generator for rnet
-
board_game_range
A set of iterators for target ranges in a square tile based board game
-
io-window
Seekable I/O adapter that limits operations to a byte range
-
type-layout
Derivable trait to view the layout of a struct, useful for debugging
-
slip
A hassle-free utility to encrypt error handling strings in your public binaries to protect your business logic
-
ref-portals
Safely use (stack) references outside their original scope
-
spawns-core
Async runtime agnostic thread context task spawner for Rust
-
trait_enum
Easy enum wrapper that implements all traits that the wrapped objects implement
-
mopa-maintained
My Own Personal Any: get your own Any with additional functionality
-
buffer
Safe, write-only, generics-free buffer abstraction
-
mediator
pattern in Rust
-
ezexec
API to execute binaries or shell commands via
std::process::Command -
iter-n
functions returning impl Iterator to return one of several distinct types
-
cargo-toml-builder
A builder for generating Cargo.toml files
-
kind-derive
Derive generator the kind compiler
-
rstring-builder
String builder type
-
orderless
Orderless/named functions in Rust.
add!(b = 2); // 4. -
first-err
Find the first Err in Iterator<Item = Result<T, E>> and allow iterating continuously
-
dntk-matrix
Statically sized matrix using a definition with const generics (only for nightly)
-
array_ex
Easy and powerful compile-time array initialization
-
generics2
macros for parsing generics (with optional where clause) in
macro_rules!- enhanced fork of generics -
stringy
A tiny Rust crate for generating byte-sized enums that represent a fixed, ordered set of &str data
-
rollbar
Track and report errors, exceptions and messages from your Rust application to Rollbar
-
combin-iterator
Some usefull facilities for combining iterators
-
sashay
Type-erased and lifetime-erased references and slices
-
dyn_partial_eq
PartialEq macros for trait objects
-
mixed_array
Construct arrays of mixed types
-
clonesure
A helper macro to create closures which will clone its environment
-
prev-iter
Iterator which allows you to view the previous element
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
enum_to_enum
Derives possibly effectful conversions between enums
-
arr
A heap based fixed-sized array
-
close
Trait + smart pointer for manual object destruction
-
dom_renderer
rendering html (or other DOMs) strings
-
unwrap-overflow-ops
arithmetic operations that always panic on overflow
-
surprise-me
Derive macro to generate random type instances
-
traitobject
Unsafe helpers for working with raw trait objects
-
bswap
byte-swapping integers, pointers, and slices
-
literalext
A helper crate for interpreting proc-macro
Literalvalues -
bitread
in Rust is designed to efficiently convert small binary data into Rust structs
-
write-only
References/slices that provide write-access, but no read-access
-
http-problem
A HTTP APIs focused error handling library
-
gemstone
collection of utilities
-
option_into_controlflow
Option into ControlFlow conversion
-
nearly_eq
Nearly(Approximately) equal traits and assertion
-
vec-iter
Lazy collection of iterated element, implementing iterators for random access
-
unsaef
Macros to erase scope information from tokens
-
arraytools
A variety of helpful methods for working with fixed-size arrays
-
imgref-iter
A small crate for iterating over the rows or columns of
imgrefbuffers -
com-scrape-types
Support code for bindings generated with com-scrape
-
array-fu
Construct arrays using simple syntax
-
tuple-fn
call functions and closures with tuple of arguments
-
menv
Pulling in arguments from environment variables
-
ground-env
Parse env variables by defining a struct
-
atomik
Generic Atomic type
-
one-of
Macro to represent a type that can be converted either
FromorTryIntothe given types -
rvs-parser
Parser for Rvs - A library for defining and evaluating random variables using a simple DSL
-
shellder-macros
A lightweight, type-safe dependency injection and application framework for Rust inspired by Spring