-
hashbrown
port of Google's SwissTable hash map
-
indexmap
A hash table with consistent order and fast iteration
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
phf
Runtime support for perfect hash function data structures
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
rangemap
Map and set data structures whose keys are stored as ranges. Contiguous and overlapping ranges that map to the same value are coalesced into a single range
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
roaring
A better compressed bitset - pure Rust implementation
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
bit-set
A set of bits
-
tinystr
A small ASCII-only bounded length string representation
-
slotmap
data structure
-
rpds
Persistent data structures with structural sharing
-
bimap
Bijective maps
-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
enumset
creating compact sets of enums
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
modular-bitfield
Easily define bitfield types with modular building blocks
-
jaq-json
JSON values for jaq
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
skiplist
in Rust for fast insertion and removal, including a normal skiplist, ordered skiplist, and skipmap
-
histogram
A collection of histogram data structures
-
yrs
High performance implementation of the Yjs CRDT
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
smartstring
Compact inlined strings
-
radix_trie
Generic radix trie data-structure
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
range-set-blaze
Integer sets as fast, sorted integer ranges; Maps with integer-range keys; Full set operations
-
ecow
Compact, clone-on-write vector and string
-
faststr
string library that reduces the cost of clone
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
bit-vec
A vector of bits
-
good_lp
Mixed Integer Linear Programming for Rust, with an user-friendly API. This crate allows modeling LP problems, and lets you solve them with various solvers.
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
ego-tree
Vec-backed ID-tree
-
nonempty-collections
Correct-by-construction non-empty collections
-
bitmaps
Fixed size boolean arrays
-
rowan
generic lossless syntax trees
-
fixedbitset
bitset collection
-
generator
Stackfull Generator Library in Rust
-
intaglio
UTF-8 string and byte string interner and symbol table
-
bloomfilter
Bloom filter implementation
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
ringbuffer
A fixed-size circular buffer
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
linked_hash_set
HashSet with insertion ordering
-
dary_heap
A d-ary heap
-
cordyceps
Mycelium intrusive data structures
-
hybrid-array
Hybrid typenum-based and const generic array types designed to provide the flexibility of typenum-based expressions while also allowing interoperability and a transition path to const generics
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
xorf
implementing xor filters - faster and smaller than bloom and cuckoo filters
-
iddqd
Maps where keys borrow from values, including bijective and trijective maps
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
croaring
Rust wrapper for CRoaring
-
smallstr
String-like container based on smallvec
-
cita_trie
Modified Patricia Tree (aka Trie)
-
stable-vec
A Vec-like collection which guarantees stable indices and features O(1) element deletion (semantically similar to
Vec<Option<T>>). Useful for allocations in graphs or similar data structures. -
intmap
Specialized HashMap for integer keys
-
fastbloom
The fastest Bloom filter in Rust. No accuracy compromises. Full concurrency support and compatible with any hasher.
-
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
egg
egraphs
-
imbl
Immutable collection datatypes
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
daggy
A directed acyclic graph data structure library. It is Implemented on top of petgraph's Graph data structure and attempts to follow similar conventions where suitable.
-
gix-merge
gitoxide project implementing merge algorithms
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
thin-vec
A Vec that takes up less space on the stack
-
hashbag
An unordered multiset implementation using a hash bag
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
bitfield-struct
Struct-like procedural macro for bitfields
-
smallbitvec
A bit vector optimized for size and inline storage
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
im
Immutable collection datatypes
-
cardinality-estimator
estimating the cardinality of distinct elements in a stream or dataset
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
lsm-tree
A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)
-
qfilter
Efficient bloom filter like datastructure, based on the Rank Select Quotient Filter (RSQF)
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
slice-dst
Slice-based custom DSTs
-
vers-vecs
A collection of succinct data structures supported by fast implementations of rank and select queries
-
space
providing abstractions for spatial datastructures and search
-
orx-split-vec
An efficient dynamic capacity vector with pinned element guarantees
-
immutable-chunkmap
A fast immutable map and set with batch insert and update methods, COW operations, and big O efficient implementations of set and merge operations
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
i24
working with 24-bit integers
-
micromap
The fastest alternative to HashMap, for maps smaller than 20 keys
-
trie-hard
Fast implementation of a trie data structure
-
tick
primitives to interact with and manipulate machine time
-
newtype-uuid
Newtype wrapper around UUIDs
-
bytesbuf
Types for creating and manipulating byte sequences
-
spade
Delaunay triangulations for the rust ecosystem
-
atree
An arena based tree structure with removal support
-
ringmap
A hash table with consistent deque-like order and fast iteration
-
lean_string
Compact, clone-on-write string
-
blart
adaptive radix tree packaged as a BTreeMap replacement
-
smallbox
Small Boxoptimization: store small item on stack and fallback to heap for large item -
opentelemetry-resource-detectors
A collection of community supported resource detectors for OpenTelemetry
-
boa_interner
String interner for the Boa JavaScript engine
-
string
A UTF-8 encoded string with configurable byte storage
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
typed_floats
Types for handling floats with type checking at compile time
-
i256
Optimized implementations of 256-bit signed and unsigned integers
-
ndarray-stats
Statistical routines for the n-dimensional array data structures provided by ndarray
-
orx-tree
A beautiful tree 🌳 with convenient, efficient, parallelizable growth, mutation and traversal features
-
vart
An immutable versioned adaptive radix trie
-
blobby
Iterator over simple binary blob storage
-
crop
A pretty fast text rope
-
range-collections
Sets and maps of ranges, backed by smallvec
-
ph
data structures based on perfect hashing
-
str-buf
Static string buffer
-
fast_radix_trie
Memory-efficient trie data structures based on radix tree
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
arrow-data
Array data abstractions for Apache Arrow
-
fqdn
FQDN (Fully Qualified Domain Name)
-
tar-no-std
read Tar archives (by GNU Tar) in
no_stdcontexts with zero allocations. The crate is simple and only supports reading of “basic” archives, therefore no extensions, such as GNU Longname… -
rust-rule-engine
blazing-fast Rust rule engine with RETE algorithm, backward chaining inference, and GRL (Grule Rule Language) syntax. Features: forward/backward chaining, pattern matching, unification…
-
intervaltree
generic implementation of an immutable interval tree
-
zerofrom
trait for constructing
-
csaf-walker
work with CSAF data
-
bytes-utils
Additional utilities for working with the bytes crate
-
ordinal-map
Ordinal trait to map values to integers and efficient maps and sets for such types
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
grid
Dynamic generic 2D data structure
-
tree_iterators_rs
built to provide you with the iterators to easily work with tree data structures in Rust
-
las
Reads and writes point clouds stored in the ASPRS las file format
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
vecmap-rs
A vector-based map and set implementation
-
orx-priority-queue
Priority queue traits and high performance d-ary heap implementations
-
array-macro
Array multiple elements constructor syntax
-
byteview
Thin, immutable zero-copy slice type
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
dataflow-rs
A lightweight rules engine for building IFTTT-style automation and data processing pipelines in Rust. Define rules with JSONLogic conditions, execute actions, and chain workflows.
-
vec_map
map based on a vector for small integer keys
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
iset
Map and set with interval keys (x..y)
-
highergraphen-cli
Command-line workflows for HigherGraphen
-
modql
Model Query Language support
-
oxiblas-matrix
Matrix types and views for OxiBLAS
-
indexset
A two-level BTree with fast iteration and indexing operations
-
nexus-ascii
Fixed-capacity ASCII strings for high-performance systems
-
arrow-digest
Stable hashes for Apache Arrow
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
cc-traits
Common collection traits
-
slotmap-careful
Wrap the slotmap crate and prevent key reuse
-
qwt
Quad Wavelet Tree
-
ohno
High-quality Rust error handling
-
bitm
bit and bitmap (bit vector) manipulation
-
saorsa-gossip-crdt-sync
Delta-CRDTs for Saorsa Gossip: OR-Set, LWW-Register with anti-entropy sync
-
iptrie
IPv4/v6 prefixes lookup structures (based on tries)
-
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
typemap_rev
A hashmap, but stores types as keys
-
uluru
fast, LRU cache implementation
-
interavl
An optimised interval tree for efficient interval stabbing
-
btree-range-map
B-tree range map implementation
-
nexus-collections
Slab-backed intrusive collections for low-latency systems
-
narrow
Apache Arrow
-
redactable
Automatic redaction of sensitive data in structs for safe logging and debugging
-
portgraph
Data structure library for directed graphs with first-level ports
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
quantities
Unit-safe computations with quantities
-
itybity
An itty bitty crate providing bit iterators and bit iterator accessories
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
short-uuid
generate and parse short uuids
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
jsonbb
A binary representation of json value, optimized for parsing and querying
-
fpdec
Decimal floating-point arithmetic
-
rvf-types
RuVector Format core types -- segment headers, enums, flags
-
sucds
Succinct data structures in Rust
-
platform-data
Data types and traits for the LinksPlatform
-
keyvi
key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
phf_shared
Support code shared by PHF libraries
-
log-once
Collection of helper macros for logging some events only once
-
collection_tools
General purpose tools to manipulate collections( containers like Vec/HashMap/HashSet )
-
cranelift-entity
Data structures using entity references as mapping keys
-
embed-collections
A collection of memory efficient and intrusive data structures
-
sage-codegen
Code generator for compiling Sage to Rust
-
static-files
help automate static resource collection
-
timed-map
Lightweight map implementation that supports expiring entries and fully compatible with both std and no_std environments
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
ankurah-storage-common
Ankurah storage engine common libraries
-
mangadex-api-input-types
A collection input types for mangadex-api
-
uwheel
Embeddable Aggregate Management System for Streams and Queries
-
dlv-list
Semi-doubly linked list implemented using a vector
-
lru-slab
Pre-allocated storage with constant-time LRU tracking
-
binary-layout
allows type-safe, inplace, zero-copy access to structured binary data. You define a custom data layout and give it a slice of binary data, and it will allow you to read and write the…
-
nodit
Discrete Interval Tree Data-Structures, which are based off BTreeMap
-
stac
SpatioTemporal Asset Catalog (STAC) specification
-
enum-table
creating tables with enums as key
-
sync-ptr
Sync & Send wrappers for raw pointer's and function pointers in rust
-
gpt_disk_io
GPT (GUID Partition Table) disk IO no_std library
-
submap
B-Tree map for pub/sub services
-
dogma
Named,MaybeNamed,Labeled,MaybeLabeled,Collection, andCollectionMuttraits -
data_privacy
Data annotation and redaction system providing a robust way to manipulate sensitive information
-
reactive_stores
Stores for holding deeply-nested reactive state while maintaining fine-grained reactive tracking
-
small_btree
that add SmallBTreeMap data structure
-
ironbeam
A batch processing clone of Apache Beam in Rust
-
validit
Validate data structures internal state
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
circular-queue
A circular buffer-like queue
-
alizarin-core
Core data structures and algorithms for Arches heritage graph and tile processing
-
value-ext
Serde Json Value Extension Trait and Json Utilities
-
xml-builder
Easy and highly-configurable XML builder/writer
-
panproto-lens
Bidirectional lens combinators for panproto
-
soa-rs
A Vec-like structure-of-arrays container
-
json-number
JSON number parsing and storage
-
cactus
Immutable parent pointer tree
-
aam-rs
Abstract Alias Mapping (AAM) framework for aliasing and maping aam files
-
cdg_api
interact with api.congress.gov
-
succinctly
High-performance succinct data structures for Rust
-
linearize
Types that are enumerable and an array-backed map
-
snowflake_me
A distributed unique ID generator inspired by Twitter's Snowflake
-
atomicow
A
Cow-like data structure where owned data is stored inside anArc -
snowid
generating SnowID - a Snowflake-like timestamp-based distributed unique identifier
-
ordered_hash_map
HashMap which preserves insertion order
-
idiolect-records
Rust record types mirroring the dev.idiolect.* Lexicon family
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
sorted_vector_map
maps and sets backed by sorted vectors
-
ftree
A very fast fenwick tree implementation
-
rust_dynamic
Support for dynamically-typed values in run-time
-
vibe-graph-core
Core domain model for the Vibe-Graph neural OS
-
parallel_frontier
Queue-like frontier for breath-first visits on graphs that supports constant-time concurrent pushes and parallel iteration
-
dup-indexer
Create a non-duplicated index from Strings, static str, Vec, or Box values
-
domain-key
High-performance, domain-driven, type-safe key system for Rust
-
merkletree
Light merkle tree implementation with SPV support and dependency agnostic
-
circom-prover
Circom prover is a Rust library for generating and verifying proofs for Circom circuits
-
deferred-map
High-performance generational arena using handle-based deferred insertion with O(1) operations
-
fp-library
A functional programming library for Rust featuring your favourite higher-kinded types and type classes
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
cgp
Main crate for using context-generic programming
-
jsonata-core
High-performance Rust implementation of JSONata query and transformation language
-
bytes-str
A string type that is backed by bytes crate
-
base-traits
base traits (for Rust)
-
pathmap
A key-value store with prefix compression, structural sharing, and powerful algebraic operations
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
know
Framework for Rust
-
basic_trie
Trie implementation in Rust
-
xot
Full-featured XML tree library for Rust
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
seatbelt
Resilience and recovery mechanisms for fallible operations
-
bridgetree
A space-efficient Merkle tree designed for linear appends with witnessing of marked leaves, checkpointing & state restoration
-
mzpeaks
representing peaks in mass spectrometry data
-
tinyset
Size-optimized sets
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
tskit
rust interface to tskit
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
synheart-flux
On-device compute engine for HSI-compliant human state signals
-
undoredo
Undo-redo for Rust using deltas, snapshots, or commands
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
packedvec
Store vectors of integers efficiently
-
tensorlogic-adapters
Symbol tables, axis metadata, and domain masks for TensorLogic
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
nybbles
Efficient nibble-sized (4-bit) byte sequence data structure
-
sparse_set_container
A container based on sparse set. Stable keys, O(1) lookup, cache-friendly iterations, and no hashing.
-
smol_bitmap
A space-efficient bitmap with inline storage optimization for small bitmaps
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
rsmarisa
Pure Rust port of marisa-trie: a static and space-efficient trie data structure
-
trie-root
In-memory patricia trie operations
-
bitflag-attr
A macro to generate bitflags structures from C-like enums
-
cueue
High performance SPSC circular byte buffer with batch operations
-
tirea-state
Typed state management with derive macros, CRDT lattice merge, and deterministic patch replay
-
crdt-lite
A lightweight, column-based CRDT implementation in Rust
-
coreason-manifest
Rust bindings for the CoReason Hollow Data Plane
-
pfds
Purely Functional Data Structures
-
ck-core
Core types and utilities for ck semantic search tool
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
merkl
MerkleTree, embedded friendly implementation
-
equivalent
Traits for key comparison in maps
-
cumulo-dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
bin_file
Mangling of various file formats that conveys binary information (Motorola S-Record, Intel HEX, TI-TXT and binary files)
-
entity_data
A container for entity component data
-
uor-foundation
UOR Foundation — typed Rust traits for the complete ontology. Import and implement.
-
crtx-memory
Memory lifecycle, salience, decay policies, and contradiction objects
-
intrval
Generic intervals (ranges) library
-
trees
General purpose tree data structures
-
rart
High-performance Adaptive Radix Tree implementation with SIMD optimizations
-
xmltv
electronic program guide (EPG) parser and generator using serde
-
compressed-intvec
Space-efficient integer vectors with fixed-width, variable-length, and sequence-oriented encodings
-
frozen-collections
Fast partially-immutable collections
-
ordered-multimap
Insertion ordered multimap
-
range-set
Smallvec-backed containers of sorted integer ranges
-
kcr_apps_kubeblocks_io
Kubernetes Custom Resource Bindings
-
type-map
typemap container with FxHashMap
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
tagged-core
A lightweight tagged type abstraction for type-safe IDs, etc
-
pcode-ir
P-code intermediate representation types for SLEIGH-generated decoders
-
exint
generic signed and unsigned integers
-
kotoba-graph
High-performance graph data structures for Kotoba graph processing system
-
fibonacci_heap
A high-performance Fibonacci Heap implementation in Rust with generic type support
-
blumer
A high-performance, bit-optimized bloom filter library for Rust
-
cityjson
Types and accessor methods for representing semantic 3D city models in Rust, implementing the CityJSON specifications
-
spart
A collection of space partitioning tree data structures for Rust
-
slice_ring_buf
A ring buffer implementation optimized for working with slices
-
delay_map
HashMap collections whose entries expire after a given time
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
fixed_deque
A fixed size VecDeque to match Python Deque
-
octofhir-fhirpath-model
Value types and FHIR model support for FHIRPath implementation
-
ntex-bytes
Types and traits for working with bytes (bytes crate fork)
-
steel-gen
Code generation crates for use within steel
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
tiff-core
Shared TIFF/BigTIFF types: byte order, tag types, tag values, sample traits, and format constants
-
xgx_intern
A high-performance, Hash-based value interner with custom handle types
-
thread_aware
Facilities to support thread-isolated state
-
int-interval
A small, no_std half-open interval algebra library for primitive integer types
-
doubloon
Money datatype that supports both statically and dynamically typed currencies
-
segment-array
Segment array (growable, append-only) data structure
-
among
A general purpose sum type with three cases: the enum
Amongwith variantsLeft,MiddleandRight. A three-way counterpart toEither, withno_std,serde,futuresandtokiointegrations. -
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
sorted-index-buffer
array based sorted map with u64 keys
-
bit_ops
Common bit-oriented operations on primitive integer types with a focus on
no_stdandconstcompatibility. Unlike other crates that provide tooling to create sophisticated high-level types with bitfields… -
bloom2
Fast, compressed, 2-level bloom filter and bitmap
-
count-min-sketch
Count-min-sketch implementation
-
id_tree
creating and modifying Tree structures
-
robin-sparkless
PySpark-like DataFrame API in Rust on Polars; no JVM
-
tetengo_trie
A trie library implemented with a double array
-
awint
Arbitrary width integers
-
flatten_objects
A container that stores numbered objects. Each object can be assigned with a unique ID.
-
geotiff-core
Shared GeoTIFF types: GeoKey directory, CRS, affine transforms, and tag constants
-
plain_trie
Classic trie implementation capable of mapping any T to char iterator
-
smallvec-wrapper
Macro and common structs to play with
smallvec -
zust-dynamic
Dynamic value model for Zust scripts, with JSON, MessagePack, bytes, and typed vectors
-
obeli-sk-small-btree
that add SmallBTreeMap data structure
-
idlset
Fast u64 set operations library
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
tag_ptr
that enables a pointer to be associated with a tag of type
usize -
tether-map
Order-preserving linked hash map with O(1) reordering
-
nexus-timer
High-performance timer wheel with O(1) insert and cancel
-
i_shape
iShape is a compact and efficient library specifically designed for representing 2D data structures using IntPoint
-
lexime-trie
A char-wise Double-Array Trie with zero dependencies
-
lattix
Knowledge graph substrate: core types + basic algorithms + formats
-
hi_sparse_bitset
Hierarchical sparse bitset. Incredibly high performance. Compact memory usage.
-
matreex
matrix implementation
-
cow_vec
A vector-like container optimized for efficient cloning with copy-on-write semantics
-
easy-tree
efficient tree structure library for Rust with recursive traversal
-
gix-hashtable
that provides hashtable based data structures optimized to utilize ObjectId keys
-
bitvec_helpers
BitVec based bitstream reader and writer
-
sif-itree
immutable, flat interval tree
-
gjstore
generational, garbage collected, json store
-
pie_core
A high-performance, index-based data structure toolkit. Provides an arena allocator (ElemPool) used to build a cache-friendly PieList (doubly-linked list) and FibHeap (priority queue).
-
veks-anode
Self-describing binary wire formats for structured metadata (MNode), predicate trees (PNode), and annotation nodes (ANode)
-
orn
A generic implementation of a sum type (or discriminated union). It provides
enum Or<T1, T2, ..., N>types as a counterpart to tuples. -
rustdf
interacting with Bruker TDF formatted Raw Data
-
cljrs-value
Runtime Value type and persistent collections for clojurust
-
idmap
Efficient maps of integer id keys to values, backed by an underlying
Vec -
mule-map
A hybrid between a HashMap and a lookup table
-
spider_agent_types
Pure data types and constants for spider_agent automation. Zero heavy dependencies.
-
netcrab
creating and exporting Petri nets
-
phf_generator
PHF generation logic
-
indexical
indexed collections
-
differential-dogs3
Advanced join patterns in differential dataflow
-
libro
Cryptographic audit chain — tamper-proof event logging with hash-linked entries and verification
-
xor_name
Xor Type
-
matchy-ip-trie
Binary IP trie for matchy database lookups (internal)
-
xtri
A fast, memory-efficient radix tree (compressed trie) implementation in Rust with UTF-8 support
-
xsd-types
XSD data types
-
paginator-rs
Pagination trait for Rust collections
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
rsf-cli
Ranked Spreadsheet Format - Deterministic column ordering based on cardinality
-
nostr-bbs-pod-worker
Pod Worker: Solid pods + R2 storage + WAC ACL (nostr-bbs)
-
elusion
modern DataFrame / Data Engineering / Data Analysis library that combines the familiarity of DataFrame operations (like those in PySpark, Pandas, and Polars) with the power of SQL query building…
-
pineappl
not an extension of APPLgrid
-
sparsevec
Compress vectors using row displacement
-
uuid-rng-internal
Private implementation details of the uuid crate
-
toml-query
work with toml::Value objects more conveniently
-
bacnet-emb
A bacnet library for embedded systems (no_std)
-
crdt-graph
An op-based 2P2P-Graph CRDT implementation in Rust
-
mutaig
Mutable AIGs designed for equivalence checking
-
fvm_ipld_kamt
Sharded IPLD Map implementation with level skipping
-
heavykeeper
finding Top-K elephant flows with high precision and low memory footprint
-
bitree
A no_std-compatible binary indexed tree (Fenwick tree) for efficient prefix sums
-
sized-chunks
Efficient sized chunk datatypes
-
qubit-value
Type-safe value container framework with unified abstractions for single values, multi-values, and named values with complete serde support
-
array_range_query
High-performance generic segment tree and lazy segment tree implementations in Rust for efficient range queries, range updates, and interval operations. Supports custom monoid operations with zero-cost abstractions.
-
kcr_kueue_x_k8s_io
Kubernetes Custom Resource Bindings
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
optional
supplies a number of Option-like primitive types
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
beach_map
slotmap
-
ndstruct
Structures for N-dimensions
-
flighthook
event bus types and schemas
-
seoul
trait Isomorphism
-
im-lists
Persistent unrolled linked lists and vlists
-
moduforge-transform
不可变数据结构与事务系统基础
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
lat-long
Geographic latitude/longitude coordinate types with multiple numeric backends
-
obeli-sk-tag-ptr
that enables a pointer to be associated with a tag of type
usize -
truc
Rust code generator for safe, fixed size, evolving records
-
pi_append_vec
Only supports append vectors, lock free
-
mesh-sieve
Modular, high-performance Rust library for mesh and data management, designed for scientific computing and PDE codes
-
relmath-rs
Relation-first mathematics and scientific computing in Rust
-
unsigned-float
Unsigned floating-point formats for non-negative numeric domains
-
router_prefilter
Fast prefix-based prefiltering for router pattern matching
-
array-concat
Macros for concatenating const arrays
-
edtui-jagged
A jagged array data structure for the edtui editor
-
cow_hashbrown
port of Google's SwissTable hash map with copy-on-write support
-
nary_tree
A vec-backed tree structure with tree-specific generational indexes
-
fides
cryptographic primitives
-
rust-hll
HLL that is compatible with the Aggregate Knowledge HLL Storage Spec
-
jolt-protocol
Protocol types for jolt daemon IPC
-
lctree
Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees
-
foxstash-db
Database layer for foxstash — collections, filtering, hybrid search, WAL persistence, and concurrent access
-
vectree
Vector-buffered tree collection with pre-/post-order, depth-first, mutable/immutable iterator
-
sql-json-path
SQL/JSON Path implementation in Rust
-
exaloglog
space-efficient approximate distinct counting (Ertl 2024). 43% smaller than HyperLogLog with the same estimation error.
-
avila-atom
Atomic computational structures - Option, Result, Vec, HashMap built from nucleus
-
octaindex3d
3D Spatial Indexing and Routing System based on BCC lattice with truncated octahedral cells
-
pi_slotmap
Slotmap data structure
-
i_tree
Expiration key tree. Usable in algorithms like swipe line. Only for uniq elements
-
runfiles
lookup library for Bazel-built Rust binaries and tests
-
converge
Layered configuration, can be expressed in a single line of code. The
Convergetrait merges instances of structures into a new instance of a structure. TheConvergetrait can be derived… -
meminterval
interval-tree in Rust made to store memory mappings
-
std-macro-extensions
A collection of macro extensions for Rust's standard library data structures, simplifying the creation and manipulation of common collections such as HashMap, Vec, and more
-
sundo
Snapshot-based undo/redo library with support for persistent data structures
-
lock_free_hashtable
Lock-free (almost) insertion only hashtable
-
bc-envelope-pattern
Pattern matcher for Gordian Envelope
-
card-est-array
Infrastructure for managing large arrays of cardinality estimators
-
diamond-types-extended
Unified CRDT library with ergonomic API - fork of diamond-types
-
champ-trie
Persistent hash map based on CHAMP — canonical form, O(1) structural equality via AdHash, COW structural sharing
-
lsph
Learned Spatial HashMap
-
ball-tree
K-nearest neighbors
-
bumparaw-collections
A small set of bumpalo-backed collections for low-level operations
-
flex_array
A
#[no_std]flexible array much like std::Vec but with custom indices and length and capacity types -
bytearray-ringbuffer
A no_std, no-alloc ring buffer for variable-length byte slices in Rust
-
hashrope
Hash rope: a BB[2/7] balanced binary tree with polynomial hash metadata for O(log n) concat, split, substring hashing, and O(log q) repetition encoding
-
array-init
Safe wrapper for initializing fixed-size arrays
-
btree-vec
A growable array (vector) implemented using a B-tree
-
static-lang-word-lists
Runtime decompressed statically-included word lists
-
plotnik-bytecode
Bytecode format and runtime types for Plotnik
-
petgraph-live
Generic generation-keyed graph cache, disk snapshot, and graph algorithms for petgraph 0.8
-
wavltree
An intrusive Weak AVL Tree
-
fastset
Fast set implementation for dense, bounded integer collections, optimized for quick updates and access
-
array2d
A fixed sized two-dimensional array
-
bitstring
traits and implementations
-
ruvix-vecgraph
Kernel-resident vector and graph stores for RuVix Cognition Kernel (ADR-087)
-
pna
PNA(Portable-Network-Archive) decoding and encoding library
-
marrow
Minimalist Arrow interop
-
typedflake
A Snowflake-style ID generator library with newtype-driven design
-
cap_vec
A no_std heap-backed vector with fixed compile-time maximum capacity
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
rh-hl7-fhir-r4-core
Generated FHIR types from hl7.fhir.r4.core package version 4.0.1
-
rsdict
Fast static rank and select data structure
-
either-or-both
The enums EitherOrBoth with the three variants Left, Right, Both and Either with the Left and Right variants
-
logic_tracer
Recognize a logic proposition and trace its truth value, also generate a truth table (still in development)
-
trit-vsa
Balanced ternary arithmetic library with bitsliced storage and VSA operations
-
rpos
Cursor Manager on Table
-
path_resolver
trie-based data structure to track and resolve relative path ownership across multiple packages
-
ph-temp
data structures based on perfect hashing
-
pgm-extra
high-performance learned index structures for Rust
-
diff_json
A powerful JSON diff library for Rust
-
tagged-types
Define strongly typed wrappers over base types with minimal boilerplate
-
flatk
Flat layout abstraction toolkit
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
capped_collections
Collections with compile-time set capacities
-
cool-diff
Compact, context-preserving diffs of structured data (serde_json::Value)
-
defaultmap
HashMap with an automatic default for missing keys
-
hyperloglockless
High-performance HyperLogLog with bias correction and full concurrency support
-
merkql
Embedded event log with Kafka-compatible semantics and merkle tree integrity verification
-
hylic-pipeline
Typestate pipelines and sugar traits over hylic lifts
-
array-deque
Fixed-capacity circular buffer implementations: heap-allocated ArrayDeque and stack-allocated StackArrayDeque. Efficient O(1) operations, no_std support.
-
brk_fjall
Log-structured, embeddable key-value storage engine
-
minarrow
Apache Arrow-compatible, Rust-first columnar data library for high-performance computing, native streaming, and embedded workloads. Minimal dependencies, ultra-low-latency access, automatic 64-byte SIMD alignment…
-
simplehash
fast Rust library implementing common non-cryptographic hash functions: FNV, MurmurHash3, CityHash, and Rendezvous hashing
-
surrealdb-strand
A scalable, distributed, collaborative, document-graph database, for the realtime web
-
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
-
segmented-vec
A vector with stable element addresses using segmented allocation and O(1) index-to-segment mapping
-
apollonius
N-dimensional Euclidean geometry for Rust: points, vectors, lines, segments, hyperspheres, hyperplanes, AABBs, triangles, and a unified intersection API—all with const generics
-
vibe-graph-automaton
Foundational graph automaton with temporal state evolution and rule-driven transitions
-
omega-core
Core types and traits for ExoGenesis Omega universal intelligence orchestration system
-
wabi_tree
Order-statistic B-tree map and set with O(log n) rank operations. Drop-in replacements for BTreeMap/BTreeSet.
-
bounded_graph
A thin newtype wrapper for
petgraphto assist in the creation of graphs with restrictions on their edges -
binary-greedy-meshing
A port of https://github.com/cgerikj/binary-greedy-meshing to Rust
-
polars-formula
High-performance formula parsing and materialization library for Polars DataFrames with R/Formulaic/Patsy style syntax
-
platform-trees
Trees methods for linksplatform
-
kbd
Pure-logic hotkey engine — key types, modifier tracking, binding matching, layer stacks, sequence resolution. No platform dependencies.
-
dot2
generating Graphviz DOT language files for graphs
-
fast-sparse-merkle-tree
Fast Sparse Merkle Tree (SMT) library in Rust, using TurboSHAKE128 as default hash function
-
keyring_map
A hash map with multiple keys per value using a ring structure to minimize allocations
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
scdata
High-performance Rust library for constructing sparse single-cell UMI count data with deterministic MatrixMarket export
-
reconcile
A reconciliation service to sync a key-value map over multiple instances
-
caches
popular caches (support no_std)
-
treeclocks
Various Tree Clock data-structures and utilities
-
agnix-rules
Validation rules for agnix - agent configuration linter
-
sbits
Succinct data structures: near-optimal space with efficient queries
-
spacetimedb-data-structures
Assorted data structures used in spacetimedb
-
stringtape
A tape class for strings arrays compatible with Apache Arrow
-
fillet
An efficient thin pointer based contiguous collection
-
colorthief-dataset
Static xkcd color-hierarchy table with pre-computed LAB used by
colorthieffor human-vocabulary color naming -
rshyper
focuses on hypergraphs
-
cmsketch
A count min sketch implementation in Rust
-
const-secret
A
no_stdcrate for compile-time encrypted secrets -
smartbuf
A high-performance buffered reader with background thread pre-fetching and full seek support
-
splinter-rs
A compressed bitmap format optimized for small, sparse sets of u32s with zero-copy querying
-
scry-index
A concurrent sorted key-value map backed by learned index structures
-
float16
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
modmap
Universal module map schema for codebase structure representation
-
aatree
in Rust
-
rustdoc_ir
An Intermediate Representation for Rust types and functions
-
wildbird
Rust Framework 🐦
-
trk-io
TrackVis (*.trk) reader and writer
-
radix-heap
Fast monotone priority queues
-
safety-net
A reference-counted netlist library for EDA tools
-
inc-complete
writing incremental computations that re-execute the minimum number of steps when an input is changed
-
obeli-sk-boa-interner
String interner for the Boa JavaScript engine
-
adflib
handle amiga disk files
-
hybridmap
Hybrid map using smallvec and the std hashmap
-
vecset
A vector-based sorted map, set and keyed-set implementation
-
rs-ecs
reasonably simple entity component system
-
ddsketchy
DD Sketch in Rust
-
neobit
Zero-dependency, lightweight bitflags with readable debug output
-
stacked_errors
high level error propogation with software controlled backtraces
-
tree-ds
manipulate tree data structures
-
chunked_vec
A vector-like data structure that stores elements in fixed-size chunks for better memory management
-
automerge-cat
CRDTs as categorical colimits, built on comp-cat-rs
-
gcollections
Generic traits over Rust collections library
-
philharmonic-store
Storage substrate traits for the Philharmonic workflow orchestration system: content store, identity store, entity store. Backend-agnostic; implementations in companion crates.
-
falcon
A Binary Analysis Framework in Rust
-
cvkg-anim
Cyber Viking Kvasir Graph (CVKG) - High-fidelity agentic UI framework
-
field_access
Dynamically access struct fields
-
riskless
A pure Rust implementation of Diskless Topics
-
cuda-async
Safe Async CUDA support via Async Rust
-
ptr_hash
A high-throughput minimal perfect hash function
-
hyperlane-process-guard
A process guard service based on Hyperlane web framework for remote script execution and process management
-
unique_id_lookup
Associative Array specifically designed for integer keys. Significant performance boost over conventional hash maps.
-
scepter
Composable primitives for planet-scale time-series routing, indexing, and aggregation
-
agentic-evolve-core
Pattern library engine for AI agents - crystallizes and reuses verified code patterns
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
stac-server
SpatioTemporal Asset Catalog (STAC) API server
-
dsq-functions
Built-in functions and registry for dsq
-
cfixed-string
Pass Rust strings to C with potentially not needing heap allocation
-
data-stream
serialization library based on streams
-
gpt_disk_types
GPT (GUID Partition Table) disk data types no_std library
-
ux-primitives
Graphics Primitives for Angular Rust
-
petricheck
symbolic model checker for Petri Nets
-
undo
An undo-redo library
-
wordvec
A compact
SmallVec<T>-like container with onlyalign_of::<T>()overhead for small stack-only instances -
etl-unit
Semantic data model for ETL units — qualities and measurements over subjects and time. Built on Polars.
-
ultragraph
Hypergraph data structure
-
ttgraph
Typed/Transactional Graph container
-
formualizer-sheetport
SheetPort runtime: bind manifests to workbooks, validate IO, and run sessions deterministically
-
tiny-counter
Track event counts across time windows with fixed memory and fast queries
-
rpds-pathtree
Immutable, path-addressable tree data structure
-
orx-fixed-vec
An efficient fixed capacity vector with pinned element guarantees
-
orx-selfref-col
SelfRefCol is a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees
-
rustpix-core
Core traits and types for rustpix pixel detector processing
-
graph-api-lib
Core library for the graph-api ecosystem - a flexible, type-safe API for working with in-memory graphs in Rust
-
kcr_operator_tigera_io
Kubernetes Custom Resource Bindings
-
caldir-core
Shared types for caldir ecosystem (Event, protocol types)
-
rust-rule-miner
Automatic rule discovery from historical data using association rule mining, sequential pattern mining, and graph-based pattern matching. Generates and executes rules with rust-rule-engine integration.
-
tagid
Defines a newtype labeled tagging for different types of ids
-
geoff-ontology
Vocabulary loading, fuzzy matching, and mapping resolution for Geoff
-
fontspector-checkapi
developing checks for the fontspector font QA tool
-
html-mumu
HTML manipulation and tools plugin for the Lava/MuMu language
-
eytzinger
implements the "eytzinger" (aka BFS) array layout
-
eastl-rs
EASTL binary-compatible Rust implementations
-
puruda
Pure Rust DataFrame
-
arrlist
A generic, heap-allocated dynamic array
-
digit-bin-index
A high-performance, O(P) data structure for weighted random sampling of binned probabilities, ideal for large-scale simulations
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
compvec
Compressing integer vectors
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
gotgraph
A type-safe, scope-aware graph library that leverages Rust's type system to prevent common graph-related bugs at compile time
-
arithmetic-nonmax
Integer types that cannot be the maximum value, allowing for memory layout optimization and intuitive arithmetic operations
-
anima-tagger-core
Data model, project config, and sidecar I/O for anima-tagger — a tag/caption editor for local Stable Diffusion LoRA datasets
-
fastbit
A fast, efficient, and pure Rust bitset implementation for high-performance data indexing and analytics
-
firims
fixed range integer maps and sets
-
multi_ranged
Efficient data structures for representing and manipulating ranges of discrete values
-
small-fixed-array
providing fixed length immutable collections with a low memory footprint
-
diet-xml
Probably the simplest, most approachable XML builder for Rust
-
typeid_prefix
that implements a type-safe version of the TypePrefix section of the
TypeIDSpecification -
suggest
A minimal library to provide similar name suggestions like "Did you mean?"
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
robinxx_map
High-performance, thread-safe open-addressing hash map using Robin Hood displacement & xxHash3
-
leanbridgetree
Space-efficient Merkle tree designed for linear appends with witnessing of marked leaves
-
optarray
Resizable Arrays in Optimal Time and Space
-
djotters
Djot (Markdown) parser that runs at hyper speeds!
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
enum-collections
EnumMap implemented in safe rust
-
rdf-model
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
ref_str
Compressed borrowed-or-shared string types for no_std Rust
-
heapless_graphs
composable graphs for no_alloc environments
-
rangeset
Integer collection backed by ranges with set operation support
-
intervalmap
An interval set/map library inspired by Boost.Icl
-
moduforge-model
不可变数据结构与事务系统基础
-
more_collections
Additional collections not found in std::collections
-
petgraph-decypher
Build petgraph graphs from OpenCypher queries
-
pi_slot
lock free Slotmap data structure
-
rbtree
the rbtree for Rust
-
arena-terms
A lightweight, arena-backed representation of Prolog–like terms
-
evicting_cache_map
An Evicting LRU cache supporting prune hooks
-
comparable_test
comparing data structures in Rust, oriented toward testing
-
odht
hash tables that can be mapped from disk into memory without the need for up-front decoding
-
attuned-cli
CLI tool for Attuned development and testing
-
hybrid-array-arcium-fork
Hybrid typenum-based and const generic array types designed to provide the flexibility of typenum-based expressions while also allowing interoperability and a transition path to const generics
-
rumpsteak-types
Core session types for Rumpsteak - matching Lean definitions
-
schema-catalog
Types for the JSON Schema catalog format (schema-catalog.json)
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
d-ary-heap
Generic d-ary heap priority queue supporting min/max via comparator, with O(1) item lookup for updates. Features configurable arity, efficient priority updates, and cross-language API compatibility
-
pbt
Property-based testing with
derivemacros, aware of mutual induction & instantiability -
lib-sokoban
Sokoban: compact, efficient data structures packed into contiguous byte arrays
-
surge-network
Surge network — canonical power-system domain model
-
uuid-base32hex
UUIDs with a base32hex string representation
-
keymaps
standardized encoding for key codes
-
voxtree
sparse voxel 64-tree implementation in rust
-
perl-semantic-facts
Neutral semantic fact vocabulary for Perl analysis layers
-
bitwheel
High-performance fixed capacity timer wheel
-
mappy-core
Core maplet data structure implementation
-
smooth-json
opinionated, customizable utility to flatten serde_json Value variants into serde_json Objects ready for use in columnar or table-like usages
-
cf-colo-hint
Cloudflare colo to Durable Objects location hint mapping
-
zarray
Cache-optimized 2D and 3D arrays using Morton order (aka Z-order) Z-indexed storage, with a convenient API for common 2D and 3D access patterns. Use of zarray in place of a Vec of Vecs often improves performance…
-
libwebnovel
enabling users to get chapters of a webnovel, with multiple available backends
-
flat-tree
Series of functions to map a binary tree to a list
-
onebuck
An efficient unordered dynamically-sized data structure
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
superintervals
Interval overlap library
-
bigraph
Different representations with implemented operations on bigraphs
-
metadata-gen
A powerful Rust library for extracting, validating, and processing metadata in YAML, TOML, and JSON formats from any content or data file
-
varpulis
Detect temporal patterns in event streams — in Rust, in milliseconds, in 10 lines. Install with: cargo install varpulis-cli
-
bplus_store
Copy-on-write B+ tree with page-aligned storage, split/merge, and crash-safety primitives
-
aliasable
Basic aliasable (non unique pointer) types
-
zust-root
Addressable object tree and storage abstractions for Zust runtime integrations
-
uuid-rs
Universally Unique IDentifier (UUID)
-
isx
Traits for checking certain conditions of values
-
keyed-set
Keyed Set: a hashbrown-based HashSet that indexes based on projections of its elements
-
naan
A fast, easy, and tasty functional programming prelude
-
ucm-core
Core types and traits for the Unified Content Model
-
feagi_data_structures
The most core library, defines the basic data types used by FEAGI, as well as some processors to modify them
-
fixed-slice-deque
A fixed size deque implementation
-
graph-clonable-ref
A fast, thread-safe cloneable reference that preserves reference structure during deep cloning
-
snowball_stemmers_rs
all Snowball stemming algorithms
-
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
thunderation
Fast arena-based map with compact generational indices
-
notatype
Types for Ordinary
-
shardtree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
short-id
Tiny crate for generating short, URL-safe, random or time-ordered IDs
-
pasture-core
A framework for working with point cloud data
-
rust-tls-duplex-stream
Full Duplex stream Wrapper around rust-tls
-
collections-gpui-unofficial
Standard collection types used by Zed and GPUI
-
dagex
A pure Rust DAG executor supporting implicit node connections, branching, and config sweeps
-
plain-ds
Plain data structures
-
vicardi
JSON VCardArray Generator that uses Serde
-
any-rope
A fast and robust arbitrary rope for Rust. Based on Ropey.
-
codewalk
Walk code trees with binary detection, bounded reads, and scanner-oriented filtering
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections
-
sigma-types
Types checked for an invariant
-
higher-graphen-structure
Structural primitives for HigherGraphen spaces, contexts, morphisms, and topology
-
vec-belt
Multi-threaded bulk-append, single-threaded consume
Vec<T> -
dictionary_bitmap_trie
Bitmap trie backed autocomplete and search
-
ni
Small limited alloc-free named identifier
-
diffus
Finds the difference between two instances of any data structure. Supports: collections, Strings, Maps etc. Uses LCS where applicable. Also supports derive via
diffus-derive. -
klingt
Lock-free audio graph library with message-passing parameter control
-
ordag
A high-performance DAG engine with static alias proofing. Validates graph topology before execution to eliminate runtime borrow checks and data races.
-
clustered-fast-trie
Ordered integer set (u32/u64/u128) for data with locality. O(1) range counting. Stable O(log log U) latency.
-
better_peekable
Peekable iterator like std::iter::Peekable but allows for peeking n items ahead instead of just one
-
naija-geo
Nigerian geopolitical zones, states and local government areas (LGAs) — all 6 zones, 37 states and 774 LGAs with navigation helpers
-
slimvec
Dynamic array with a smaller inline-size
-
merkle-cbt
generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
cantrip
Practical extension methods for standard Rust collections
-
spqr-tree
A representation of the SPQR tree in Rust with support for I/O
-
xlstream-core
Core value and error types for the xlstream streaming Excel evaluator
-
ooroo
A fast, compiled rule engine with a text-based DSL
-
slabmap
HashMap-like collection that automatically determines the key
-
libdawg
A fast, memory-efficient DAWG (Directed Acyclic Word Graph) for word validation and prefix queries
-
multigraphrs
A versatile, strategy-pattern based MultiGraph library supporting directed, undirected, and weighted graphs
-
tracker
A macro to track changes on structs
-
secfinding
Universal security finding types — Severity, Evidence, Finding, FindingKind
-
orbweaver
designed for effortless construction and analysis of graph data structures
-
dyn-slice
&[dyn Trait] implementation, inspired by a Reddit thread
-
whale
A lock-free, dependency-tracking primitive for incremental computation
-
sphere-n-rs
N-Sphere Code Generation in Rust
-
fm-index
FM index and its variant implementations for Rust
-
normalize_interval
Normalizing interval library
-
filetreelist
filetree abstraction based on a sorted path list, supports key based navigation events, folding, scrolling and more
-
loro-delta
Loro internal library. It's used as a delta between two versions of text or lists. It's also an efficient Rope.
-
formspec-lint
Formspec Linter — 8-pass static analysis pipeline
-
do-notation
Monadic do syntactic sugar
-
hypeerlog
A fast, distributable, and lightweight HyperLogLog implementation with bias correction
-
bhc-index
Typed indices for efficient and safe indexing
-
io_core
A no_std I/O foundation for Rust
-
cpx-coords
power the rust-quantum project, this library provides a robust
Cpxtype, specifically optimized for the intensive complex number multiplications required for quantum gate applications and tensor product operations… -
semx_cpumask
CPU 位掩码，支持原子操作与迭代
-
min-max-heap
An efficient, double-ended priority queue
-
oxidd-rules-bdd
Binary decision diagrams (BDDs) for OxiDD
-
rstared
decorator that adds rstar::RTree to collections such as HashMap, BTreeMap, StableVec, thunderdome::Arena
-
mirror_id
Decentralized 128-bit ID generator for distributed systems
-
dot-structures
The structrures to support graphviz-rust library
-
bolt-quadtree
High-performance loose quadtree for 2D collision queries
-
hodgepodge
Lightweight dataset crate of enums for prototyping, teaching, and experimentation
-
deferred-cell
A single-assignment, weak reference wrapper for cyclic node graphs with late initialization
-
clone_cell
A Cell that works with a restrictive form of Clone
-
data_reader
A data loading library for data scientist
-
thermogram
Plastic memory capsule with 4-temperature tensor states (hot/warm/cool/cold), bidirectional transitions, and hash-chained auditability
-
sbol-ontology
Offline ontology facts (EDAM, SBO, SO, GO, CHEBI, CL) for SBOL 3 validation, plus a runtime cache for opt-in extension ontologies (NCIT, custom)
-
tuplez
Tuples represented in recursive form
-
cseq
compact sequences
-
opejson
Surgical JSON manipulation macros for Rust. (Strict, Genesis, and Law modes)
-
psrutils
few utilities to facilitate pulsar science projects in rust
-
quilibrium-verkle
Verkle trie implementation with KZG commitments for Quilibrium
-
range-map
Maps and sets implemented using ranges
-
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
bilock
A minimal spin-lock based two-handle
Arc<Mutex<T>>replacement -
axpoll
polling I/O events and waking up tasks
-
pdatastructs
probabilistic data structures
-
eventfold
Lightweight, append-only event log with derived views — your application state is a fold over an event log
-
skippy
Highly flexible worst-case O(log n) intrusive skip list
-
ec-validator
High-performance validation for Ecuadorian government IDs (cédula, RUC) and financial data (IBAN)
-
rotbl
Read Only Table
-
ptrie
Generic trie data structure implementation (prefix tree) with support for different key and value types, and functions to search for common prefixes or postfixes
-
key-node-list
Doubly-linked list that stores key-node pairs
-
bitarena
A bitset-accelerated generational arena optimized for sparse iteration
-
ndarray-layout
definitions and transformations for multi-dimensional array data layouts
-
malt
Merkle Append-Only Log Tree (RFC 9162 §2.1)
-
spatialtree
A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)
-
solvent
Dependency Resolver library
-
widetorah
Rust SDK for WideTorah -- Tanakh, Talmud, Mishnah, Rashi commentary, parashot, and Jewish encyclopedia via the widetorah.com API
-
shunter
An experimental streaming pipeline library for Rust providing a composable DSL for building data pipelines
-
singletonThread
thread in a singleton
-
bed-utils
manipulating genomic range objects
-
deep_causality_tensor
Tensor data structure for for deep_causality crate
-
strict
collections with strict bounds
-
mdcs-compaction
Compaction, pruning and stability subsystem for the Carnelia MDCS
-
zakat-ledger
Event sourcing, timeline simulation, and Hawl tracking for Zakat calculations
-
verdant-themes
A collection of themes for verdant
-
graphcore
Base data structure to represent and manipulate property graph
-
ooecs
Object-oriented entity-component-system
-
slice-cell
A
Cell<[T]>-like mutable slice, that allows slice-like APIs -
multi-map
Like a std::collection::HashMap, but allows you to use either of two different keys to retrieve items
-
ordered
A wrapper for adding arbitrary partial/total order to a type
-
rune-graph
Embedded directed property graph: nodes, edges, labels, key-value properties, traversal, and shortest path
-
disjoint-sets
Three union-find implementations
-
oats-rs
Short, unique ids without the hassle of random uuids
-
user-error
UserFacingError is an error crate that allows you to pretty print your errors and error chain for consumption by the end user. If you implement the UFE trait, the default implementation…
-
migs
A SQL migration script collection library with compile-time registration
-
valkyrie-ast
Strong typed abstract syntax tree of valkyrie language
-
graphlink
A memory-safe, relational in-memory graph database
-
higher-free-macro
macro that creates a (naive) Free Monad type based on a user-supplied Functor. It uses the traits from the "higher" crate. This macro is a port of the Control.Monad.Free part of the…
-
gap-buf
Generic gap buffer
-
bv
Bit-vectors and bit-slices
-
type-set
A set of heterogeneous types
-
flake-schemas
inspecting the contents of a flake
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
flex
Flexible borrowing and ownership for Rust
-
rdf-types
Data-structures and traits definitions for RDF
-
array-queue
Fixed size bidirectional queues based on arrays
-
gaze-types
Shared value contracts for Gaze
-
unbound
Locally nameless representation with automatic capture-avoiding substitution and alpha equivalence
-
paginator-utils
Shared pagination response structures
-
boarddown-schema
Shared schema types for BoardDown
-
uniques
Analyze items in a slice and calculate the unique, first, duplicate, and subsequent items and their indices
-
unbounded-interval-tree
An interval tree working with inclusive/exclusive bounds, as well as unbounded intervals. Provides helpers to fetch overlapping intervals, and difference of intervals.
-
lnc-core
Core types and primitives for LANCE - TLV, SortKey, LoanableBatch, buffer pool
-
opsforge
Rust trait definitions for the MESA 11 Manufacturing Operations Management functions
-
nzfcc
New Zealand Financial Category Codes (NZFCC) library
-
kempt
Ordered collection types with no unsafe code and no_std support
-
provekit-bn254-multiplier
Optimized BN254 field multiplication
-
elephantry-extras
A collection of additional components for elephantry
-
smol_bit_vec
A tiny, bit-packed bit vector with Small Vector Optimization (SVO)
-
satteri-arena
Arena allocator and binary buffer primitives for Sätteri
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
wideholy
Rust SDK for WideHoly -- cross-religion scripture search, verse comparison, religious calendar, and commentary via the wideholy.com API
-
rocketman
A modular(ish) jetstream consumer
-
rose_bloom
A concurrent growing element size linked list with stable pointers
-
stack_collections
Stack-allocated collections for Rust
-
suffixarrayview
Creates a view of a suffix array
-
phago-agents
Reference agent implementations using Phago biological primitives
-
small-collections
A collection of data structures optimized for small-buffer scenarios that reside on the stack and seamlessly spill to the heap
-
ranged_bitmap
A high-performance bitmap library
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
tedium
A fast and easy TDMS Library for Rust
-
smodel
Symbol semantic modeling for Rust
-
crtx-store
SQLite persistence: migrations, repositories, transactions
-
slotted-egraphs
E-Graphs with name binding
-
slotmap_microlib
A micro library for slot map data structure
-
disjoint
Fast and safe implementation of the disjoint-set data structure
-
yslib
ysaf standard library
-
browser-controller-types
Shared protocol types for browser-controller CLI and mediator
-
c_vec
Structures to wrap C arrays
-
lum_libs
Serves as a central collection and re-export of all external crates used in the lum framework to ensure consistent dependency versions across the framework
-
bytetable
High-performance data structures indexed by u8
-
tarot-card-meanings
Complete 78-card tarot deck with all card meanings, daily tarot card, yes or no readings. Includes upright and reversed meanings, love and career interpretations. By Deckaura (https://deckaura.com)
-
agentic-reality
Existential grounding system for AI agents — deployment awareness, resource proprioception, reality physics
-
wacore-appstate
Appstate for WhatsApp protocol
-
crusty_cards
Playing Card and Deck Library
-
chiralmap
Left-Right map using IndexMap
-
openligadb
API
-
range-mutex
A
Mutex<[T]>-like type, that allows locking different ranges separately -
hashslab
A hash table with data accessible by index
-
zotron-types
Shared types for the Zotron Zotero bridge (OCR/embedding providers, RPC protocol, PDF evidence)
-
ndshape
fast linearization of N-dimensional array indices
-
bsp-tree
Binary Space Partitioning (BSP) tree useful for 3D rendering. Works with flat polygons (triangles, quads, etc.).
-
pretty_graph
toolbox to build and working with graphs
-
index-ext
Index slices with arbitrary ints and as arrays
-
use-element
Small chemical element primitives and lookup helpers for RustUse
-
brarchive
Bedrock Archives in Rust
-
omega-memory
12-tier cosmic memory system with automatic consolidation (Instant → Omega)
-
superset_map
Map that stores distinct supersets based on the total order defined
-
mset
/ multiset / bag implementation
-
a2ui-core
Core logic for the A2UI protocol: traits, negotiation, validation, prompt building
-
opensearch_query_builder
Opensearch query builder
-
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
evict
Page eviction policies: LRU, LRU-k, LIRS, SLRU etc
-
slotmapd
orlp/slotmap fork where serialization cycle doesn't change observable behavior
-
odsek
Lazy, pull-based composition of mathematical interval sets with open/closed endpoints, no_std-compatible
-
neco-nodegraph
necosystems series node graph data model with port-typed nodes and edges
-
qtruss
finite-element solver for trusses
-
hibitset
Hierarchical bit set structure
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
streamies
More features for your streams
-
list_ordered_hashmap
An insertion-ordered hash map that provides O(1) (amortized) insertion, lookup, update and removal
-
oxigdal-core
Core abstractions for OxiGDAL - Pure Rust GDAL reimplementation with zero-copy buffers and cloud-native support
-
mikufans-proto
gRPC APIs for Mikufans
-
titans_memory
Titans Memory: Neural-inspired memory system for AIngle AI agents
-
balanced-tree-index
constant-time manipulation of a complete binary tree with a flat in-memory representation
-
ax-sym
High-performance scoped symbol table for compilers, linters, and LSP servers — backed by axhash-map (AES-NI accelerated hashing)
-
jaggedarray
Multidimensional jagged array
-
btree-slab
A memory compact Slab-based B-tree implementation
-
navan
Rust type bindings for the Navan (formerly TripActions) Bookings API
-
wrapbin
binary newtype as wrapped Cow u8 array
-
gpui_sum_tree
A sum tree data structure, a concurrency-friendly B-tree
-
ans-types
Shared types for the Agent Name Service (ANS) ecosystem
-
hpkg
A native Rust crate to parse Haiku's binary package and repo formats
-
un-motion-frame
UNMotion と関連プロジェクト向けのトランスポート非依存モーションフレームスキーマ。
-
zbq
Linux SPMC zero-copy shared-memory IPC queue, with optional FD passing
-
chat-prompts
Chat prompt template
-
tailcall-chunk
persistent data structure for efficient append and concatenation operations
-
weighted-list
Data structures for weighted randomisation
-
tex_engine
A modular crate for building TeX engines
-
drainlib
DRAIN log parsing algorithm
-
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
disjoint-ranges
Ranges with gaps
-
blocklist
The project is based on blocklistproject. It provides perfect hash map/set structures for fast lookup of blocklisted items.
-
calimero-wasm-abi
WASM-level ABI v1 for Calimero applications
-
copy-stack-vec
A no_std, fixed-capacity, stack-allocated Copy vector for Copy types, with no unsafe code by default
-
vec_historic
Rust Undo Collection
-
pulith-resource
Composable resource description types for Pulith
-
cbsk_socket
socket callback tool
-
lox
Fast polygon mesh library with different data structures and traits to abstract over those
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
redwing
A copy-on-write, branching byte-stream library backed by a piece table and delta log
-
art
adaptive radix trie
-
semi-persistent
data structures, e-graphs, and recursion schemes
-
nori_inference
Fast probabilistic inference for ambiguous observation-entity mappings
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
kotoba-routing
Declarative, graph-based HTTP routing engine for the Kotoba ecosystem
-
oximedia-pipeline
Declarative media processing pipeline DSL — typed filter graph, node composition, and execution planning for OxiMedia
-
widegita
Rust SDK for WideGita -- Bhagavad Gita, Upanishads, Yoga Sutras, Hindu deities, and Sanskrit encyclopedia via the widegita.com API
-
nusy-graph-query
Graph-native semantic search for Arrow RecordBatches — embeddings, traversal, hybrid ranking, and caching
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
astrodyn_quantities
Phantom-tagged typed quantities (Position, Velocity, ...) for orbital dynamics
-
aisle
Metadata-driven Parquet pruning for Rust: Skip irrelevant data before reading
-
gpui_rn_sum_tree
A sum tree data structure (fork for React Native GPUI)
-
tinysetqueue
A tiny, allocation-free FIFO queue with direct-mapped membership tracking for dense integer domains
-
packo
Packed datastructure with self referential indexing
-
uid_store
Generate random uid strings containing letters, numbers, or base62 values
-
reflow_assets
Content-addressed asset database conventions for Reflow workflows
-
ct-demo
Pythagorean triple snapping via sorted-Vec binary search (snap_kdtree)
-
typed-bytes
Fully typed data size units (IEC and SI) with operator overloading
-
fugue-tinyset
Size-optimized sets
-
clonelicious
macro library that simplifies cloning and closure execution. The
clone!macro automatically clones variables and immediately executes the closure with the cloned values, streamlining… -
ndtensor
An n-dimensional tensor
-
signalk
parse signalk maritime data
-
range_minimum_query
Range Minimum Query (RMQ) is used on arrays to find the position of an element with the minimum value between two specified indices
-
assoc
Treat vectors like associative arrays
-
neco-tree
Generic ID-bearing tree with cursor-based navigation
-
gollum-kb-oc
OpenCypher Knowledge Base for Gollum
-
gctree
cache-friendly, graph-like, arena-allocated datastructures
-
mapgraph
A directed graph that can also be used as an arbitrary map
-
diffkit
diffing and patching sequences and nested structures
-
yulang-sources
Source-set collection, realms, compilation units, and syntax artifacts for Yulang
-
weak-table2
Weak hash maps and sets, with a fast backend
-
cutoff-common
A collection of common utilities and helpers used across Cutoff projects
-
bitvec-rs
Bit vector with guaranteed
[u8]representation and the ability to get safe immutable and mutable views into its internal vector for easy I/O -
total-maps
Maps where every possible key has an associated value
-
h3o-ice
Frozen{Map,Set} for H3 cells, based on finite state transducers
-
dsq-core
Core functionality for dsq - data processing with jq syntax
-
re_string_interner
string interning library
-
dsq-shared
Shared types and utilities for DSQ crates
-
rtree_rs
R-tree for Rust
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
veclite
A lightweight, ergonomic wrapper around Vec<T> that implements Display
-
graph-api-petgraph
Integration between graph-api and petgraph - use graph-api's traversal system with petgraph structures
-
statevec
Facade crate for building schema-first deterministic StateVec domain plugins
-
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
f3l_search_tree
3D Point Cloud Library
-
mergle
A data structure with fast merging and comparison
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
minidom
A small, simple DOM implementation on top of rxml, targeting the subset of XML useful for XMPP
-
libcint-src
libcint (C library) source or build specification
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
mdcs-delta
Delta-state CRDT machinery for the Carnelia Merkle-Delta CRDT Store
-
pulith-source
Composable source abstractions and planning for Pulith
-
ggapi
communicating with start.gg's API
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
array-linked-list
A data structure, which combines the advantages of dynamic arrays and linked lists
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
snid
Polyglot sortable identifier protocol with UUID v7-compatible ordering and extended identifier families
-
fugue-iset
Map and set with interval keys (x..y)
-
ruvector-metrics
Prometheus-compatible metrics collection for Ruvector vector databases
-
pimalaya-tui
Collection of crossterm widgets shared accross Pimalaya projects
-
more_ranges
Range types not provided in the standard library
-
walker-extras
Additional functionality for SBOM and CSAF walker
-
elizaos-plugin-experience
Experience learning plugin for elizaOS - Rust implementation
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
bitvek
bit vector implementation
-
zkcg-verifier
ZKCG proof verifier supporting Halo2 circuits and zkVM execution receipts
-
gpui_collections
Standard collection type re-exports used by Zed and GPUI
-
graphix
representing undirected graphs using a compressed adjacency list
-
rt_ref
Internal
Reftypes forrt_refandrt_vec -
xorfilter-rs
Xor Filters: Faster and Smaller Than Bloom and Cuckoo Filters
-
medea-reactive
Reactive mutable data containers
-
risc0-povw
Core library for RISC Zero Proof of Verifiable Work (PoVW)
-
sugars_builders
Builder pattern utilities and abstractions for the cyrup-sugars ecosystem
-
chronicle-graph
Event-centric narrative knowledge graphs with temporal verification
-
dmfr-dataset-reader
Reads transitland folder and outputs graph of valid feeds and operators
-
uts-bmt
Binary Merkle Tree implementation for Universal Timestamps in Rust
-
auto-concat-array
Concatenate fixed-size arrays on stable Rust with automatic array length inference
-
fleet-api-rs
Fleet API structures generated by kopium from upstream CRDs
-
xtrie
A high-performance Adaptive Radix Tree (ART) — memory-efficient trie with prefix search, range queries, and ordered iteration
-
dndtree
DND-Tree dynamic connectivity data structure
-
swiss-table
An educational Rust implementation of the Swiss Table hash map algorithm
-
edifact-primitives
Shared EDIFACT primitive types — zero dependencies
-
michis_collection_cursor
A cursor which wraps an indexable collection, providing a movable position which points to an index of the collection. Useful for things like history, undo-redo systems, or timelines.
-
rb_tree
A Red Black Tree implementation in Rust
-
bevy_archive
An experimental ECS world snapshot system built on Bevy, featuring structured archetype storage and manifest-based serialization
-
quickbloom
An industry-grade, highly scalable Bloom filter with lock-free concurrency, blocked layout, and automatic persistence
-
threshold
data structures
-
normalize-package-index
Package index ingestion from distro and language registries
-
off-grid-primitives
Core data structures and logic for the Off-Grid exchange: spot market (L1/L2/L3), order books, matching engine, and account balances
-
fffl
A contiguous First-fit Freelist
-
digit-sequence
Sequence of u8 digits
-
unitx
A general-purpose library for units and quantities
-
obzenflow-idkit
Phantom-typed ULID identifiers for ObzenFlow - type-safe IDs for native and WASM
-
ergo_avltree_rust
cryptographically authenticated dictionary based on AVL tree
-
triple_buf_64
A cheap lock-free triple buffer data structure that stores 64 bits of data
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
succparen
Succinct data structures library for balanced parentheses representation
-
xtask-toolkit
A collection of useful tools for xtask building
-
osom_lib_entropy
OS-backed entropy collection for osom_lib
-
wae-schema
WAE Schema - 数据结构定义与验证
-
logvec
A cache-friendly Bentley-Saxe logarithmic array data structure
-
tinyvec_string
tinyvec based string types
-
lignin
A virtual DOM structure, primarily for web use
-
praborrow
framework - A distributed systems framework for Rust
-
composable-indexes
In-memory collections with composable indexes
-
goldleaf
A thin wrapper over MongoDB to make it shine!
-
type_slicer
型付きメモリスライサー
-
lazily
Lazy reactive signals with dependency tracking and cache invalidation
-
syntastica-themes
A collection of themes for syntastica
-
fqdn-trie
FQDN (Fully Qualified Domain Name) lookup structures (based on tries)
-
hylic
Composable tree computation: monoidal catamorphisms with parallel execution
-
a-tree
A dynamic data structure for efficiently indexing arbitrary boolean expressions
-
approx_collections
Collections using approximate floating-point comparison
-
ratio-interner
Ratio's value interner library
-
mago-reflection
Offers data structures and APIs to represent and inspect PHP code elements—like classes, functions, and interfaces—enabling introspection and analysis
-
paginate
framework agnostic pagination crate, that is especially suited for databases, slices and collections. Paginate calculates the range of pages indexes, making it ideal for accessing slices…
-
merc_lts
Implements labelled transition systems for various I/O formats using a general LTS trait
-
retworkx
A python graph library implemented in Rust
-
simd-lookup
High-performance SIMD utilities for fast table lookups, compression and data processing
-
rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
typeshift
Zod-like parse, validation, and JSON Schema flow for Rust types
-
cbsk_base
locked version cargo crates
-
origin-types
Shared wire-format types for Origin — the personal agent memory system
-
forrust_fire_tracing
Tracing integration for
forrust_fire_tree -
tiered-vector
Tiered Vectors
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
rinq
Type-safe, zero-cost LINQ-inspired query engine for Rust — filter, sort, aggregate, window analytics, parallel execution, and statistical extensions
-
product-farm-core
Core domain types for Product-FARM rule engine
-
python-packed-resources
Manage data structures containing Python resources
-
microkelvin
tree traversal over annotated data structures
-
f1r3fly-rspace-plus-plus
F1r3fly Tuple Space implementation in Rust - high-performance storage and pattern matching
-
mashmap
A flat HashMap that supports multiple entries per key
-
dawg
Directed Acyclic Word Graph
-
flow-mumu
Stream transform tools plugin for the Lava language
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
arraylist
wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
sevec
A fast, pure Rust implementation of the segmented array data structure
-
ware
middleware chains
-
heapix
providing heap data structures
-
seg_lib
A collection of segment tree variants
-
cell-grid
2d grid container
-
sigmars
sigmahq rule collections
-
arena_tree_rs
A high-performance, feature-rich Arena Tree library for Rust
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
materials
Data on rocks, elements, metals, etc
-
leveled-hash-map
structure to separate values into different levels with keys. Every key-value entry which is not at the top level has a parent key at the superior level. Keys at the same level are unique…
-
coca
Data structures with constant capacity
-
ecsx
Entity Component System eXtended
-
options
The package provides a data structure for managing named parameters
-
polytype
A Hindley-Milner polymorphic typing system
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
varlen
Ergonomic variable-length types
-
layered
Build composable async services with layered middleware
-
formualizer-eval
High-performance Arrow-backed Excel formula engine with dependency graph and incremental recalculation
-
mindset
A pure functional state machine library built on Stillwater's Effect system
-
bittle
Zero-cost bitsets over native Rust types
-
philiprehberger-id-gen
Unified ID generation: ULID, UUIDv7, NanoID, and Snowflake
-
concise_vec
A concise, highly optimized vector implementation leveraging const generics in Rust
-
jgd-rs
generating realistic JSON data using declarative schema definitions
-
idbag
A bag of integers
-
qlib-rs
A flexible in-memory database library
-
faster_bloom
A standard and scalable Bloom filter implementation in Rust with configurable error tolerance and automatic scaling
-
entid
generating and validating type-safe, prefixed entity identifiers based on UUIDs and ULIDs
-
eight-booleans
A small Rust library to store and manipulate 8 booleans in a single byte
-
kn0sys_ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
lookupvec
Container with Vec-like properties that also offers O(1) lookup of items based on an id field
-
gentoo-interner
String interning for Gentoo-related crates
-
gen-tui
Graph visualization widget system for Gen
-
bumpish
A set of collections using bump allocations
-
rt-pods-client
Official Client for RtPods
-
linked-hash-table
A linked hash table implementation for insert-order iteration and efficient lookups
-
rez-next-suites
Suite management for Rez Next - manages collections of resolved contexts
-
image-ndarray
Zero-copy implementations for the Image crate to convert to and from ndarrays
-
taco-interval-ta
allowing you to obtain a threshold automaton with an (symbolic) interval abstraction applied to it. This crate is part of the TACO toolsuite.
-
rt-events-dag
Type-safe event DAG topology. Edges are event types; structural checks are walks.
-
corevm-codec
CoreVM codec collection. Used to encode and decode output streams produced by the guest.
-
scanstate
Generic scan checkpoint, journal, and progress primitives for pause/resume workflows
-
fhirpathrs
Fhirpath implementation in Rust
-
beap
Bi-parental heap data structure implementation in Rust
-
cmrdts
A collection of Commutative Replicated Data Types (CmRDTs) implemented in pure Rust
-
smolset
" An unordered set of elements optimized for small sizes. This is a fork of the original library with overhauled internals, better fallback perforamance (O(1) insert and find) and more features!
-
rust-keypaths
A static dispatch, faster alternative to rust-key-paths - Type-safe, composable keypaths for Rust with superior performance
-
tugger-file-manifest
Interact with lists of files through a storage-agnostic interface
-
dendron
Generic tree data structure
-
compact-rc
Low-memory reference-counting pointers
-
packable
packing and unpacking binary representations
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
garlic
A collection of random side projects
-
queue-file
lightning-fast, transactional, file-based FIFO
-
vecdeque-stableix
Deque with stable index values
-
flatarray
flattened iterator, that acts as if it still was an iterator of iterator
-
mikel_binary_tree
search binary tree implementation
-
ocm-types
Types required to implement the OpenCloudMesh filesharing protocol
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
queues
Efficient FIFO Queue data structures
-
uintx
Unaligned unsigned integers with exact size in memory and arithmetic operations for them
-
openrouter-provider
Type definitions for the OpenRouter Provider API contract (https://openrouter.ai/docs/guides/for-providers)
-
predisposition
Three-valued boolean types with different predispositions for the unknown case
-
deep_causality_sparse
Spare matrix data structure for for deep_causality crate
-
aleph-filter
The Aleph Filter — an infinitely expandable probabilistic data structure with O(1) insert, query, and delete
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
tiled_parse_tree
Tree data structure
-
hit-data
Hierarchical Indexed Typed data structure
-
vp-avl
A combined Vantage-Point AVL tree, to make VP trees updateable
-
pypinindia
Indian pincode lookup and geographical information
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
anchors
async incremental computations
-
zed-sum-tree
A sum tree data structure, a concurrency-friendly B-tree
-
appendlist
An append-only list that preserves references to its elements
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
bplus-index
Arena-backed B+Tree for in-memory sorted indexes. Zero unsafe, cache-friendly, supports non-unique keys.
-
nexus-bits
Bit field packing for integer IDs
-
segtri
Segment tree with customizable data type and update operations
-
surface-grid
providing data structures for square-tiled grids wrapped around the surface of certain objects
-
hnsw_vector_search
High-performance semantic search using HNSW and ONNX embeddings
-
fenwick
tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
hecs-hierarchy
Hierachy implementation for Hecs ECS
-
uninum
A robust, ergonomic unified number type for Rust with automatic overflow handling, type promotion, and cross-type consistency
-
echelon
O(1) amortized priority queue. Adaptive Ladder Queue for heavy-tailed distributions.
-
bitboard64
A 64-bit bitboard useful for chess programming
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
pbn
Programming by Navigation types and traits
-
bypond
A highly untested and undocumented complete tree library
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
sif-kdtree
immutable, flat k-d tree
-
traiter
Traits collection
-
wybr
Collection of preferential voting methods
-
gapbuf
Generic gap buffer
-
zngur-def
Data types that define the structure of a zng file
-
codedash-schemas
Stable public schema for codedash code metrics output — JSON Schema + Rust types
-
bit-int
An arbitrary fixed bit-width integer library
-
oxidart
High-performance Adaptive Radix Tree with TTL, DFA pattern matching, and atomic counters
-
dyn_trie
Dynamic trie is trie capable of mapping any T to any char iterator
-
palindromeda
Palindrome number generator and checker at blazing speed
-
rstrie
A generalized Trie implementation for Rust
-
text-span
Struct covering areas of text
-
theymx
A small Rust library for handling DMX data
-
intrusive-lru-cache
An LRU cache implementation using intrusive data structures
-
enum-tag
Proc. macro for generating enum discriminant types.
-
map_vec
The Map and Set APIs backed by Vec
-
astrie
High-performance hybrid data structure that combines the benefits of tries and B+ trees to provide efficient key-value storage with adaptive behavior based on data patterns
-
griddle
A HashMap variant that spreads resize load across inserts
-
half-2
Fork of starkat99/half-rs. Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types.
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
prefix_array
A generic container for searching on prefixes of keys
-
pi_world
ecs world
-
attribute-search-engine
Generic search engine for rows with attributes using different matchers
-
xenon_types
Common types for Xbox 360 (Xenon) file formats and protocols
-
pofk_algorithm
A collection of efficient algorithms implemented in Rust for real-world projects
-
parser_fuck
parser combinator library
-
range_bounds_map
[
RangeBoundsMap] and [RangeBoundsSet], Data Structures for storing non-overlapping intervals based of [BTreeMap] -
reflow_asset_registry
Asset registry client for Reflow — resolves content-addressed URIs and ML model manifests
-
CartesianTree
Build hierarchical Cartesian coordinate systems to easily transform poses
-
field-collex
Collections implemented on block-based idea . (Do not ask me why
Field;> ) -
offset-vec
Packer for Vec and String etc, for all methods index add a offset
-
minuet
Extended memory systems built on amari-holographic
-
intrex
Intrusive collections with items addressed by indices
-
aograph
AND-OR graph data structures and algorithms
-
cve
Mappings for parsing the CVE JSON files
-
backgammon_engine
Backgammon engine in Rust: state representation, legal move generation, and deterministic afterstate transitions for agent/RL development
-
qutee
A quadtree implementation
-
rok-ids
CUID2, ULID, UUID v7, Snowflake, and NanoID generators for the rok ecosystem
-
adar-registry
Advanced Architecture (ADAR) is a collection of architectural tools that help you write more readable and performant code
-
range_map_vec
range map data structure backed by a Vec
-
singlevec
Vec-like container optimized for storing only a single item
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
cow_hashmap
Hashmap with copy-on-write semantics that requires no locks
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
bit_manipulation
lightweight Rust crate for seamless management and validation of up to 128 option states. Empower your applications with efficient, flexible, and intuitive option handling, ensuring…
-
flagged_cl_args
Command line argument parsing
-
linear-hashtbl
Linear probing hash table
-
standing-relations
Standing relations over a shifting dataset optimized for 'feedback loop' scenarios
-
schema-registry-analytics
Analytics engine for usage tracking, metrics collection, and reporting
-
polars-structpath
dynamically accessing nested Rust structures using path notation
-
prio-graph
A lazily populated directed acyclic graph with top-level priority ordering
-
triple-r
Macros to for the recuerdame crate
-
cpx-mat2by2
power the rust-quantum project, this library provides a robust AltMat type for a single qubit, specifically optimized for the intensive complex number multiplications required for quantum…
-
stateset-primitives
Strongly-typed primitive types for StateSet iCommerce
-
b-tree
A persistent B+ tree using freqfs
-
unnamed_entity
Strongly-typed indexing for vectors and other structures
-
bitstring-trees
Trees based on bitstrings
-
text-style
Types and conversions for styled text
-
codemap
A data structure for efficiently storing source code position and span information (e.g. in a compiler AST), and mapping it back to file/line/column locations for error reporting and suggestions.
-
gtfs-geojson
converter for GTFS to GeoJSON formats
-
forest-ds
secure tree structure
-
zetamesh_flags
zetamesh-flags is a minimal Rust library for rule-based validation of state combinations
-
point-nd
flexible no-std struct to model points on axes of any dimensions
-
floating_bar
Representing rational numbers using the floating-bar number type
-
rustpower-sol-klu
A very basic KLU-based sparse linear solver unsafe wrapper
-
dsa64
64-byte aligned data structures for high-performance computing
-
verdant-queries
Collection of tree-sitter queries for verdant
-
quantor
Declarative quantifiers for filtering, validation, and testing in Rust
-
oxirs-rule
Forward/backward rule engine for RDFS, OWL, and SWRL reasoning
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
tritools
A collection of tools
-
patina_internal_collections
Collection types to the DXE Core
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
ts_dynbitset
dynamically-growable bitset based on ts_bitset
-
circular_doubly_linked_list
A high-performance Circular Doubly Linked List implementation in Rust
-
mtgjson
Unofficially provided lightweight models of the data provided by MTGJSON
-
identity_map
Identity-based maps
-
infinite-db-frp
A unified facade for the infinite-db frp backend: graph modeling, weaving, signals, runtime, and storage with feature-gated subsystems
-
philharmonic
workflow orchestration system — meta-crate re-exporting the entire crate family. Depends on all published library crates; feature-gates connector implementations so consumers can…
-
id_collections
Index-oriented programming in Rust
-
oracle_omen_core
Core types and abstractions for oracle.omen deterministic agent framework
-
suff_collections
Fast realization of suffix array and suffix tree
-
stack-queue
Heapless auto-batching queue
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
ferro-projections
Service projection definitions for the Ferro framework
-
id-map
Data structure of values indexed by IDs
-
stack-allocator
A stack-based memory allocator with optional fallback to a global/secondary allocator
-
cvkg-flow
Node-based graph components for CVKG
-
blas-array2
Parameter-optional BLAS wrapper by ndarray::Array (Ix1 or Ix2)
-
unsized-vec
Like Vec, but for unsized values
-
iotdb
Apache IotDB Client written in Rust
-
dia-i18n
-
merc_data
Defines data expressions on top of terms that are compatible with the mCRL2 toolset
-
qrqrpar
A QR code generator supporting rMQR
-
bit-byte-bit
Implements a bit string using a collection of bytes
-
sarif_rust
A comprehensive Rust library for parsing, generating, and manipulating SARIF (Static Analysis Results Interchange Format) v2.1.0 files
-
seq-map
Sequential Map
-
bare-rust
Rust bindings for Bare
-
tree_by_path
A tree data structure featuring nodes addressable using a &Vec<usize> path and avoiding recursion and run-time borrow checking
-
truncate-integer
Truncate integers
-
gram-diagnostics
Shared LSP-compatible diagnostic types for gram-data and cypher-data
-
strumbra
Umbra-style strings (also known as German strings)
-
aviutl2-alias
AviUtl2のエイリアスデータを操作するためのライブラリ
-
scryer-modular-bitfield
Allows to easily define bitfield types with modular building blocks. This is a forked version of the modular-bitfield crate with tweaks for use by Scryer Prolog.
-
roussillon-type-system
A type system for a programming language
-
btree-ondisk
BTree structure on persistent storage in userspace
-
rten-model-file
Machine-learning oriented matrix multiplication
-
crdt-data-types
High-performance CRDT library with dual pathways: JSON-native for web APIs and Cap'n Proto zero-copy for binary transport
-
cmn-substrate
CMN protocol core — Ed25519 signatures, BLAKE3 tree hashing, JSON schema validation, URI parsing, and JCS canonicalization. Zero I/O, WASM-compatible.
-
rtdlib
TDLib for rust
-
gcn-assembler
GCN assembler for Gaia project
-
michis_undo_redo
undo/redo system, inspired by Godot Engine's UndoRedo object
-
bo4e
BO4E (Business Objects for Energy) - Rust implementation
-
simple-grid
2d-grid structure
-
asset-importer-rs-scene
Scene module for asset-importer-rs
-
hash_cons
A type-safe hash-cons library
-
csf
compressed static functions (maps) that use perfect hashing and value compression
-
swamp-eval
tree-walking interpreter for executing the Swamp Abstract Semantic Graph (ASG) from
swamp-semantic. Primarily for debugging/testing, not performance. -
crdt-merge
Conflict-free merge, dedup & diff for any dataset. Powered by CRDTs.
-
open_menu_standard
OpenMenuStandard (OMS) specification
-
bhc-data-structures
Common data structures for the BHC compiler
-
ittybitty
An itty bitty bitset to hold your itty bitty bits
-
spanley
my generic string span, his name is Spanley
-
array-plus-extra
An array type that holds N+EXTRA elements with const generic parameters, providing safe slice access to contiguous memory
-
task-local-extensions
Task-local container for arbitrary data
-
rust_flightweather
Decodes METAR and TAF
-
safe_index
Type-safe indexes
-
iowrap
Small helpers for using io::Read/io::Write
-
gufo-webp
Data structure for WebP images
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
serde_save_lib
JSON handler for serde data with I/O capabilities
-
mlua-lshape
mlua wrapper for lshape — Schema-as-Data validator + LuaCATS codegen, Pure Lua vendored via include_str!
-
array_buf
Highly optimized fixed-capacity deque buffer stored on the stack
-
semi-persistent-containers
Semi-persistent core data structures with O(1) snapshots and O(k) restore
-
roughly
Probabilistic data structures for Rust — because sometimes close enough is good enough
-
rust-tagged
A lightweight tagged type abstraction for type-safe IDs, etc
-
bund_blobstore
Multifunctional data storage
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
progscrape-application
progscrape.com application logic
-
paft-market
Market data models and requests for paft
-
loc_api
interact with the loc.gov API
-
unordered-pair
A tuple struct representing an unordered pair
-
livestock-rs
comprehensive library and CLI tool for managing, identifying, and working with livestock breeds, growth rates, and health. Designed to support farming and ranching applications, breed registries…
-
median-accumulator
fast, space-efficient, generic accumulator for computing median
-
unsafe-tools
A collection of tools making safer unsafe Rust
-
rc-vec
RcVec based on Rc and can be converted from Rc without allocation
-
lru-st
A package providing a Vec based doubly linked list implementation and related data structures
-
zhifeng_impl_barnes_hut_tree
implements Barns-Hut Tree for accelerated N-body force calculation
-
u24
An unsigned 24-bit integer type
-
token_trie
A high-performance Radix Trie implementation with sorted children for efficient binary search operations
-
wt-indexset
Fork of original indexset which is used for worktable
-
temporal_segment_log
Temporal Segment Log (TSL): High-throughput time-ordered data structure
-
sortedlist-rs
A fast sorted list data structure in rust
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
sharded
Safe, fast, and obvious concurrent collections
-
tincan
A lightweight reactive state management library for Rust
-
retaker
ecs implementation
-
char_index
efficient charwise indexing into a string
-
rostl-oram
Oblivious RAM (ORAM) implementations
-
blazemap
Implements a vector-based slab-like map with an interface similar to that of HashMap, and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
windowed-infinity
data structure representing an infinite sequentially writable u8 vector of which a small view has writes to it preserved. This is primarily useful when implementing CoAP block-wise transfers…
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
prefix-sum-vec
Compressed storage for highly repeating elements, with
O(log n)lookups -
lodtree
help create octrees and quadtrees for chunked level of detail
-
lru-mem
An LRU cache implementation bounded by memory
-
scp-event-log
Verifiable Merkle event log for SCP (Shared Context Protocol)
-
linked-data-schema
Generates SHACL from Rust structure
-
serde-ordered
A procedural macro for deserializing ordered arrays into keyed structs using Serde
-
pin-list
A safe
Pin-based intrusive doubly linked list -
irange
A data structure to store and manipulate ranges of integers with set operations
-
graphix_io
reading and writing graphs from and to text files, based on the graphix crate
-
emap
A map with a fixed capacity and integers as keys
-
tuplities-ref
A trait for getting tuples of references from tuples
-
nibble_vec
Vector data-structure for half-byte values
-
shannon-nu-plugin-engine
Functionality for running Nushell plugins from a Nushell engine
-
plane-2d
Continuous 2D data structure representing infinite 2d plane
-
cvx-graph
Knowledge graph for ChronosVector — typed entities, relations, and multi-hop reasoning
-
alot
A forbid-unsafe, generational slot map with usize-sized IDs
-
scarf-syntax
A helper crate of scarf for expressing a SystemVerilog concrete syntax tree
-
rexsgdata
Scatter-Gather Data Descriptors
-
ferogram-session
Session persistence types and storage backends for ferogram
-
bidimap
Bijective maps
-
cntp_config
support for reading Contemporary.toml files
-
closed-interval-set
Unions of closed intervals as containers of pairs
-
comparer
track changes in a HashMap/DashMap over several iterations
-
fey_grid
2D grid data structure and related traits
-
gen_value
indexes and values with generations for vectors
-
radixmap
Rust-based Radix Tree for fast prefix lookup, supporting named param, glob, regex
-
rustac
Command line interface for rustac
-
paramodel-trials
Paramodel trial-set and trial-result layer: TrialSet, SamplingStrategy, TrialStatus, TrialResult, Metrics, ArtifactRef, TrialProvenance
-
luru
A custom implemented hash map that has a fixed amount
-
espalier
Very simple flattened tree structure
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
uv-once-map
internal component crate of uv
-
agb_hashmap
no_std hashmap implementation intended for use in the
agblibrary -
circbuf
A growable circular buffer for working with bytes
-
cortenforge-capture-utils
Capture helpers and recorder sinks (JSON, overlays, pruning) for the CortenForge stack
-
bmap
A bitmap with an internal counter
-
type-rules
easily constrain a struct
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
ref_kind
Different reference kinds
-
kcr_workloads_kubeblocks_io
Kubernetes Custom Resource Bindings
-
sliding-ring
Cache-friendly sliding ring buffer keyed to an anchor coordinate for ultra-low-latency workloads
-
contack
easy contact library
-
dynarg
mechanism for dynamic robust argument handling
-
eros-engine-core
Pure-domain types and rules for the eros-engine AI companion engine: persona, six-dimensional affinity, PDE decisions, and ghost-message logic with no I/O
-
re_blueprint_tree
The UI for the blueprint tree in the left panel
-
thinset
A data structure for sparse sets of unsigned integers that sacrifices space for speed
-
trie
A highly general and customizable trie library
-
support
A collection of helper methods for Rust projects
-
bom-kit
A flexible Bill of Materials (BOM) management library for assembly planning with substitutes and unit conversions
-
exo-temporal
Temporal memory coordinator with causal structure for EXO-AI cognitive substrate
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
hextree
Location to value mapping
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
bitvector
in Rust
-
thin-string
A String with a smaller stack footprint
-
diffo
Semantic diffing for Rust structs via serde
-
enso-data
A collection of useful data structures
-
compact-calendar
Compact representation of a set of days based on a bit-maps
-
segment-tree
Quickly perform interval queries or modifications
-
nexcore-id
Zero-dependency UUID implementation for NexVigilant Core ecosystem
-
typed_graph
Staticly typed graph library
-
unobtanium-text-pile
Turns HTML into externally annotated plain text that is optimized for being serialized to the postcard format
-
rustywallet-bloom
Fast and memory-efficient Bloom Filter with counting support for rustywallet
-
compactor
A collection which compresses old data
-
elicitor-types
Core types for the elicit crate - presentation-agnostic survey definitions
-
skipfree
lockfree skiplist
-
collectable
Fallible, no_std-friendly collection traits
-
luka
working with graphs
-
shortlist
An efficient data structure to track the largest items pushed to it
-
multidimension
High-level manipulation of multi-dimensional arrays
-
higher
Functors, Applicatives, Monads and other bad ideas
-
sweetrpg-kv-objects
Objects for Key-value store
-
drtahash
A non-cryptographic hash function using AES-NI for high performance
-
maplike
Derive macros for maplike
-
exo-resource-tree
WeftOS exo-resource-tree: hierarchical resource namespace with Merkle integrity
-
roadmap
model a project roadmap as a directed acyclic graph
-
dayendar
advanced days calendar operations
-
generational_token_list
A doubly-linked list backed by generational-arena
-
indexedlinkedhashmap
An indexable LinkedHashMap. The user defines the data structure that controls order.
-
gridly
managing fixed-size 2D spaces
-
fav_utils
Fav's utils crate; A collection of utilities and data structures for the fav project
-
lull-spec
Lull spec library
-
nodedb-types
Portable type definitions shared between NodeDB Origin and NodeDB-Lite
-
pulz-arena
A generational arena allocator with compact generational indices
-
range-tree-rs
A range tree implement for slab allocator
-
spimdisasm
MIPS disassembler
-
aircraft_icao_country
aircraft ICAO codes and their country of origin
-
entropy-map
Ultra-low latency hash map using minimal perfect hash functions and compact encoding of values, minimizing memory footprint and storage size for efficient data retrieval
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
trie_hard_rs
Fast, memory-efficient Trie (prefix tree) implementation with autocomplete support - Rust implementation
-
pvec
RRB-Tree based persistent vector implementation
-
iot_driver_core
iot driver core
-
redmaple
offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
aph_disjoint_set
Disjoint set implementation with optimized memory usage and ability to detach elements
-
limited-queue
a limited queue that overrides the oldest data if trying to push a data when the queue is full
-
arr-rs
arrays library
-
stac-extensions
Manage STAC extensions (https://stac-extensions.github.io/)
-
waremax-metrics
Metrics collection and reporting for Waremax
-
moa_cpumask
CPU 位掩码，支持原子操作与迭代
-
triple_arena
Regular, Chain, Surjection, and Ordered Arenas supporting non-Clone types, deletion, and more
-
rucksack-lib
The rucksack core library
-
hashheap
data structures that combine a hashmap and a min/max priority heap, with main operations requiring O(1) or O(log n) time
-
runtime-context
A runtime context providing type storage and management
-
lockerroom
Readers-writer access to individual cells of your collection!
-
monarch_data
Data types and utilities handling
-
higher-graphen-reasoning
Reasoning primitives and engines for HigherGraphen invariants, obstructions, completion, model checking, and abstract interpretation
-
smallbitset
series of allocation free sets capable of holding small integer values
-
hotel
Collection Data-structure to associate values with keys
-
fingertrees
Immutable persisten finger trees
-
indexmap-rmw
hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
eqmap
Technology Mapping w/ E-Graphs
-
efin
6-digit IRS Electronic Filing Identification Number (EFIN) type
-
hifa-xml-schema
Structure generator from XSD source file
-
indexed_vec
IndexVecfromlibrustc_data_structures -
typwire
Rust types for the Typst plugin system
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
gen-models
Models for the gen sequence graph and version control system
-
moka-cht
Lock-free resizeable concurrent hash table
-
azalea-inventory
Representations of various inventory data structures in Minecraft
-
slas
Static Linear Algebra System
-
jerky
Succinct on-disk data structures in Rust
-
space_engineers_compat
Compatibility types for Space Engineers data structures (DateTime, Guid, math, bitfields, etc.)
-
ord-by-set
providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
settrie
Fast subset and superset queries
-
widesutra
Rust SDK for WideSutra -- Buddhist scriptures, Tipitaka, Pali Canon, Buddhist concepts, and figures via the widesutra.com API
-
compt
A complete binary tree visitor library
-
envish
Search for environment variables
-
inexor-rgf-core-di
Inexor - Reactive Graph Flow - Dependency Injection
-
vecmin
VecMinandVecOnenewtype wrapper aroundVecthat enforces a minimum length at compile time -
write_x86_64
help you write x86_64 assembly code
-
elizaos-plugin-trajectory-logger
Trajectory logging plugin for elizaOS - Rust implementation
-
statiki
Static friendly data structures
-
dolang-ext-compile
Runtime compilation extension for the Do language
-
copyspan
An alternative to
Range<T>that has a defined memory layout and implementsCopy -
vec-option
A space optimized version of
Vec<Option<T>>that stores the discriminant seperately -
ffi-toolkit
A collection of functions useful for working with the Rust FFI
-
ux-dataflow
Data Processing Library
-
astro-math
Astronomy math algorithms for telescope control and sky transforms
-
merkle_light
Light merkle tree implementation with SPV support and dependency agnostic
-
semver-eq
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
isideload-simple-file-manifest
Interact with lists of files through a storage-agnostic interface
-
oxigdal-temporal
Multi-temporal raster analysis for OxiGDAL - Time series, change detection, phenology, and data cube operations
-
broom
An ergonomic tracing garbage collector that supports mark 'n sweep garbage collection
-
crdf-dpo
Double Pushout (DPO) graph rewriting for CRDF RDF graphs
-
prism3-value
Type-safe value container framework with unified abstractions for single values, multi-values, and named values with complete serde support
-
cistring
A string type that preserve case, but compares insensitiveley
-
daedalus-registry
Node registry and plugin bundle loader for Daedalus graphs
-
rstl-queue
Queue data structures for rstl crates
-
linear_collections
Map and Set types backed by linear data structures
-
pacr-types
The PACR 6-tuple — physically annotated causal records for AI agents
-
xml-schema
Structure generator from XSD source file
-
forrust_fire_tree
A tree data structure
-
crispii_bits
Bit-related functionality for Rust's native u{int} types (usize excluded)
-
ascent-byods-rels
data structures for Ascent relations, made possible by Ascent's BYODS feature
-
jse
JSE (JSON Structural Expression) interpreter for Rust - AST-based architecture
-
large_int
An ease-of-use unbounded signed integer
-
widebible
Rust SDK for WideBible -- Bible verses, books, people, places, cross-references, and study tools via the widebible.com API
-
yrs_tree
implementing a CRDT-based tree data structure powered by Yrs
-
slashcrux
Shared vocabulary types for the Slash and Crux agentic Rust ecosystem
-
hashmap-mem
Fast, low-overhead in-memory hashmap implementation optimized for performance using fxhash
-
no_debug
Helper types to omit debug info for select values
-
embed-struct
embedding data structures
-
precedence-net
Create and analyse precedence networks
-
boost_charconv
Boost C++ library boost_charconv packaged using Zanbil
-
admissibility-kernel
Deterministic context slicing with cryptographic admissibility verification for conversation DAGs
-
ism
ODNI ISM (Information Security Marking) schema package, vendored. Designed as a build-dependency for codegen. SHA-256 verified at compile time.
-
cirno_store
containing motivational phrases in Japanese and Russian
-
prehash
storing values with precomputed hashes
-
noindexmap
hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
neco-history
Tree-based edit history with undo/redo and automatic checkpointing
-
brownstone
building fixed-size arrays
-
veripb-formula
VeriPB library to handle pseudo-Boolean constraints, formulas, and more data structures
-
beetle_bits
A collection of bit-based types. Currently only u1 (1bit uint) and f3 (3bit float) are implemented
-
cynos-incremental
Incremental View Maintenance (IVM) for Cynos database
-
snowflake-ng
Dead easy and high performance
snowflakeimplemented in Rust -
onigiri
handling chars
-
sequencetree
a new type of collection to store keys and their corresponding values
-
mutcursor
Safely stores mutable references to parent nodes, for backtracking during traversal of tree & graph structures
-
emcee
Python's emcee affine-invariant mcmc ensemble sampler
-
ism-data
ODNI public XML schema metadata: package list and namespace registry. For schema files, see the per-package ism-{pkg} crates.
-
vecgraph-store
Persistent storage module for vecgraph, built on top of kvwrap
-
gevi_error
A flavor of error types and error handling that I like
-
fenwick-bit-tree
Slighly over-engineered FenwickTree implmentation
-
graphy-watch
File watcher and incremental re-indexing for graphy
-
libwebnovel-storage
A complement to libwebnovel: this package handles downloading and organizing collections of followed webnovels
-
kcr_security_profiles_operator_x_k8s_io
Kubernetes Custom Resource Bindings
-
river-layout-toolkit
Write River layouts in Rust with ease
-
map-macro
Declarative macros for statically initializing collections
-
phf_macros
Macros to generate types in the phf crate
-
stable-map
A hash map with temporarily stable indices
-
im-pathtree
Immutable, path-addressable tree data structure
-
wplot
Plot interface
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
hashbrown_tstd
port of Google's SwissTable hash map
-
bbse
Backward Binary Search Encoding — minimal and deterministic scheme for sorted domains
-
rep
A small tool for representation/class invariants
-
opt_struct
Optional collections
-
multi_containers
Ergonomically work with multiple values per key
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
rotated-array-set
An ordered set supporting O(1) rank and O(√n) inserts and deletes
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
displays_types
Shared display-related data types used across the displays crate and platform backends
-
raphy
A graph data structure library
-
art-tree
The Adaptive Radix Tree
-
snowflaked
creating and working with snowflake ids
-
commitlog
Sequential, disk-backed commit log library
-
singletons
Type-keyed data structures: SingletonSet stores one instance per type, SingletonMap<V> maps types to values
-
cocktailfyi
Cocktail recipes, ABV calculation, calorie estimation, and flavor profiling — async API client for cocktailfyi.com
-
mzdata-spectra
A subset of
mzdata’s traits and spectrum data model -
shiplog-schema
Canonical shiplog schema: events, coverage manifests, workstreams, and bundle types
-
agentic-commerce-protocol
Type definitions for the Agentic Commerce Protocol specification
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
ordinary-types
Types for Ordinary
-
indexed-table
A tiny in-memory indexed table
-
siraph
A node-based digital signal processing crate
-
rbtset
A set based on a RB-Tree for efficient operations
-
hash-link
Keep elements insert order while searchable by hash
-
tudi
There, inside the game's two-dimensional universe, life was simple
-
monstertruck-assembly
Assembly data structures using a directed acyclic graph (DAG)
-
data-source
that fetches data from different sources
-
generic-btree
Generic BTree for versatile purposes
-
ploc-bvh
A Bounding Volume Hierarchy based on PLOC
-
medianheap
A median heap for keeping track of a running median
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
hash_ring
Consistent Hashing library for Rust
-
reactive-signals
dx-first scope-based fine-grained reactive system
-
panoradix
A generic map and a set, both backed by a Radix tree
-
crtx-retrieval
Hybrid retrieval over memory views (lexical + salience; vectors later)
-
aversion
Versioned data structures with auto-upgrading
-
rstl-trie
Generic trie data structure for rstl crates
-
phago
Self-evolving knowledge substrates through biological computing primitives
-
z_table
lookup functions for the standard normal table, also called Z table
-
ts_array256
fast sparse 256-element array with configurable backing storage
-
ttmap
Trivial implementation of type map
-
lace_codebook
Contains the Lace codebook specification as well as utilities for generating defaults
-
stack-map
constant-size associative container for building higher-level data structures out of
-
rose_tree
An indexable tree data structure with a variable and unbounded number of branches per node. It is Implemented on top of petgraph's Graph data structure and attempts to follow similar conventions where suitable.
-
parselnk
Parse windows .lnk files in pure rust
-
weak-map
BTreeMap with weak references
-
phyz-gravity
Layered gravity solver from constant-g to post-Newtonian corrections for phyz
-
binarystream
binary stream for Node.js
-
gpui_rn_collections
Standard collection type re-exports (fork for React Native GPUI)
-
grid-tree
Pixel quadtrees and voxel octrees
-
stac-io
Input and output (I/O) for the SpatioTemporal Asset Catalog (STAC)
-
sorla-provider-core
Shared SoRLa provider contracts and metadata
-
statevec-model
Core schema, record, command, event, IDL, and registry types for StateVec
-
swink-agent-memory
Session persistence and memory management for swink-agent
-
HArcMut
mutable arc
-
flex-algo
Rust commonly used data structure and algorithms
-
pl-hlist
support for heterogeneous lists (known as
HLists), which are functional, tuple-like, strongly-typed data structures that can contain elements of differing types -
dotenv_lib
A dotenv file parser
-
merkle-tree-stream
A stream that generates a merkle tree based on the incoming data
-
segmap
Map and set data structures whose keys are stored as ranges. Contiguous and overlapping ranges that map to the same value are coalesced into a single range. Originated as a fork of Jeff Parsons' "rangemap"
-
neoset
Compact RLE-encoded event sets for efficient peer sync
-
school_library
structures to manage school-related data, including students, classes, and schools
-
pi_cancel_timer
Cancellable timer based on wheel structure
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
nonempty_tools
优雅的 Rust 非空集合类型库，在编译时保证集合非空
-
delta-collections
Data structures with revertable operations called deltas
-
holyhashmap
A hash map with stable indices
-
omango-util
Utililites
-
compact-dict
A highly customizable, open-addressing dictionary in Rust
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
iati-transform
Transformations and rollups for IATI Activity data (sum by type/year/currency)
-
multiset
Multisets/bags
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
taco-bdd
A Binary Decision Diagram (BDD) crate that provides a unified interface for the CUDD and OxiDD BDD libraries. This crate is part of the TACO toolsuite.
-
recursive_reference
way to walk on recursive structures easily and safely
-
trying
Basic trie crate
-
ordsearch
A data structure for efficient lower-bound lookups
-
object-collection
A collection that can store multiple values of types
-
auths-transparency
Append-only transparency log types, Merkle math, and tile storage for Auths
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
union-fn
Proc. macro for creating efficient "inline closures".
-
index_many
A proof of concept for indexing an slice at multiple locations at once
-
ra-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 5113ed28ea1451a13eae3a05dca0dbabfd56f587 The publishing script for this crate lives at:… -
avl
A map and a set implemented with an AVL tree
-
designal
Procedural macro for use with futures-signals
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
coalesced_intervals
Data structure for maintaining maximally-coalesced 1D intervals
-
rocketsplash-formats
Shared data types and serialization formats for Rocketsplash TUI animations
-
indexed_arena
index-based arena without deletion
-
squads-rustfsm
Define state machines that can accept events and produce commands
-
rustyhdf5-types
HDF5 type system definitions for rustyhdf5
-
apma
Adaptive Packed Memory Array (APMA) — a cache-efficient sorted associative container
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
faststr-fork
Faststr is a string library that reduces the cost of clone
-
traitgraph
Abstracting over different graph representations
-
pathmod
Re-export crate for pathmod
-
tinyvecdeq
VecDeque-like data structures -
async-func
providing macros to simplify the creation of asynchronous closures with external state captured by move. Useful for structuring asynchronous code with ease and clarity.
-
oxilean-elab
OxiLean elaborator - Surface syntax to kernel terms
-
tree-sitter-traversal2
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
gecs
A generated entity component system
-
intarsia
An extensible Rust optimization framework
-
simple_dto_mapper_derive
A derive macro for mapping DTOs with rename/transform/skip support
-
cbsk_log
log tool
-
shrink-to-fit
Recursively calls
shrink_to_fiton all elements of the container -
pulith-lock
Deterministic lock file model and lock diff for Pulith
-
openvx
1.3.1 wrapper
-
file-backed-value
lazily generated persistent values backed by a file, with the option to require a recomputation after a certain amount of time
-
minivec
A version of Vec that's only the size of a single pointer
-
sum
General-purpose sum types
-
try-lazy-init
Fallible lazy initialization
-
rdf-writer
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
numeric-statistics
Numeric Statistics: functions for min, max, average, variance, standard deviation, and more to come
-
partial-array
potentially partially-filled arrays
-
bitlab
Extracting a range of bits from a binary data source
-
array_list
A dynamic container that combines the characteristics of a Vec and a LinkedList
-
b-k-tree
Burkhard-Keller tree data structure for finding items separated by a small discrete distance
-
broomfilter
A bloom filter that sweeps away your certainty. Probably.
-
jmt-pq
PQ Jellyfish Merkle Tree
-
enum_meta
Add metadata to Enum Variants
-
arrayset
An array-backed ordered set type
-
unionfind
A union find library made for building type inference engines. Can be used as general purpose datastructure.
-
alopex-dataframe
Polars-compatible DataFrame API for Alopex DB (v0.1)
-
mori
orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
cli-tilemap
that provides basic functionality of Tilemap for CLI-based games!
-
listfree
lockfree prepend-only list
-
bdaddr
Bluetooth Device Address
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
minimizer-iter
Iterate over minimizers of a DNA sequence
-
idata
Small tools to reduce mutability
-
deep_causality_data_structures
Data structures for for deep_causality crate
-
implies
A parser for logical formulas
-
rostl-datastructures
Oblivious data structures for secure and efficient computation
-
no-copy
packer, but no implement copy
-
mco-gen
Stackfull Generator Library in Rust
-
entity
that provides entity-like constructs
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
canadensis_bit_length_set
A bit length set type used to calculate data type sizes when processing Cyphal data structure description language files
-
watermark
watermarking set for in-order insertions
-
hlc-rs
Hybrid Logical Clocks for causally correct distributed event ordering
-
omega-persistence
SQLite-based persistence layer for ExoGenesis Omega with schema migrations and transactions
-
wasm_macro
Collections of useful macros for wasm
-
sedimentree_core
Sedimentree: a hash-linked CRDT storage structure with fragments, commits, and content-addressed blobs
-
parallel_vec
A generic contiguous collection of heterogenous values
-
anymap2
A safe and convenient store for one value of each type
-
struct-reflection
obtaining struct field names at runtime through reflection-like capabilities
-
gqls
GQL Schema, with support for ORB-style API generation
-
advanced_collections
advanced data structures (collections). Includes counter (hash-bag, multiset), disjoint set (union-find, merge-find), circular buffer (cyclic buffer) and interval (range)
-
cock-tier
Measure the power level of a peen
-
formualizer-common
Core value, reference, and error types shared across the Formualizer parser and engine
-
kcr_kafka_banzaicloud_io
Kubernetes Custom Resource Bindings
-
barectf-parser
parse barectf-generated CTF trace data
-
mappy-client
Client library for mappy maplet data structures
-
unique-pointer
UniquePointerdata structure that makes extensive use ofunsaferust to provide a shared pointer across other data structures -
patricia_router
Radix Tree implementation for Rust
-
inplace-vec-builder
Build a vec from a vec, in place
-
recoverable
Recovery information and classification for resilience patterns
-
sum-tree-gpui-unofficial
A sum tree data structure, a concurrency-friendly B-tree
-
default-vec2
Vec-like data structure with default elements and a bitset built using it -
avltriee
Customized version of AVLTree library.Process the same value in the third branch. One data is immovable from one row, and positional relationships such as left, right, and parent are all referenced by row numbers…
-
segmentmap
A collection that maintains insertion order
-
butils
shared by software included in BSuccinct
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
export-resolver
A PE (Portable Executable) parser which will dynamically resolve virtual addresses of functions loaded in a PE. It will store these function virtual addresses in a structure for retrieval at the developers behest.
-
linear-map
A map implemented by searching linearly in a vector
-
miny
Box<T> with small value optimization
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
merkle-heapless
Statically-allocated Merkle Tree and Mountain Range
-
axion-data
A high-performance data processing library written in Rust, providing DataFrame and Series functionality similar to pandas
-
rustc-ap-graphviz
Automatically published version of the package
graphvizin the rust-lang/rust repository from commit 10c2316a6bf7cf9255f991e06e82ce692e6f84d5 The publishing script for this crate lives at: https://github… -
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
orx-imp-vec
ImpVecstands for immutable push vector 👿, it is a data structure which allows appending elements with a shared reference -
rive-models
Revolt API models for the Rive ecosystem
-
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
grid-engine
A flexible and efficient library for managing 2D grid-based layouts with automatic collision handling and dynamic vertical expansion
-
search_trail
manager of variables that can save and restore their values
-
ternary-tree
Ternary Search Trees, with no unsafe blocks
-
sortedvec
a sorted vector that enables quick lookups
-
influxdb-dispatcher
Batch metrics collection using influxdb
-
rust-bloomfilter
bloom filter implementation in Rust programming language
-
sipha-analysis
Grammar-agnostic scope extents and definition collection for sipha syntax trees (LSP support)
-
oximedia-clips
Professional clip management and logging system for OxiMedia
-
fr-trie
Fuzzy Radix Trie
-
historian
a high performance zero-config histogram implementation
-
tld
Top Level domain static hash map, tld list is obtained from of iana.org
-
rand_pool
Create a pool of random numbers pre generated thread safe
-
lumberjack
Read and modify constituency trees
-
scope-cell
temporary, scope-bound, and thread-safe mutation of data in Rust
-
succinct
data structures for Rust
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
hibit_tree
Hierarchical bitmap tree. Integer-key map that can intersect FAST.
-
taskchain
A block-based, non-circular double-linked list implementation for Rust
-
stavec
Stack-allocated vector with static capacity
-
ferreus_bbfmm
Parallel black box fast multipole method (BBFMM) library
-
shiftnanigans
contains different iteration data structures for either iterating or for shifting iteratively forward and backward
-
list-any
Type erased slices and Vecs
-
sequential-id-alloc
sequential ID allocator that guarantees sequential allocation
-
lazy-cogs
Lazy Cogs is a implementation of lazy clonable data structures
-
enum-toggles
A generic Rust library for managing toggles/flags using enums and bitvec
-
pgm_index
Ultra-fast learned PGM-Index for efficient sorted key lookup with bounded error
-
set_genome
A genetic data structure for neuroevolution algorithms
-
debounce
Data structures and helpers for debouncing a stream of events: removing duplicate events occurring closely in time
-
aligned-utils
Common utilities to work with aligned values and allocation
-
incremental-map
combinators for incremental immutable maps (see crate
incremental) -
convenient-skiplist
Convenient and Performant SkipList with serde support
-
kando-core
Core library for kando – a keyboard-first Kanban board
-
word-dictionary
data structure for word mapping. It can be used for language translation.
-
frp-plexus
Shared primitives for the infinite-db frp backend: typed IDs, SPC encoding, types, and values
-
vslab
container with persistent unique keys to access stored values
-
zcstring
High-performance zero-copy string handles for Serde, backed by arcstr
-
fuid
A UUID-compatible identifier in a friendly base-62 format
-
jvs-packets
that provide structures for JVS protocols
-
dda-rs
Pure Rust Delay Differential Analysis engine
-
quickphf_codegen
Code generator for creating static maps and sets for use with quickphf
-
blockset-lib
BLOCKSET internal library
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
serde_map
Mapbased onVecfor serialization purposes -
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
win-variant
that aims to provide a more ergonomic way of working with variants in winapi based projects
-
netlist
generic netlist data structure for VLSI design
-
boxing
cross-platform implementations for NaN and ptr boxes
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
rj
reactive json
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
chinese-validator
Core validation logic for Chinese data (address,id_card, license_plate,name, phone, postal_code,qq,username,etc.)
-
boolvec
A vector of boolean stored contiguously in memory
-
hash-rings
Implementations of various hash rings
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
faultline_core
Canonical domain models, identifiers, and manifests for FaultLine
-
fixed-index-vec
A vector-like data structure whose indices do not change when elements are removed
-
baz-tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
hkalbasi-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
construe
Compile-Time Growable Array: Vec & String for const!
-
winpty-rs-windows-collections
Windows collection types
-
chat4n6-plugin-api
Shared plugin API types for the chat4n6 forensic toolkit
-
ndcopy
Fast N-dimensional array memcpy
-
widequran
Rust SDK for WideQuran -- Quran surahs, ayahs, hadith, tafsir, and Islamic encyclopedia via the widequran.com API
-
ministd
Rewriting Rust's standard library for fun (no_std)
-
aion-lib-arraymap
A wrapper around Vec<T> with a freelist. Preserves index validity on mutations without heavy generation counters.
-
lr_trie
Left-Right trie is trie capable of mapping any string to any string
-
csc411_rpegio
A collection functions to handle rpeg data i/o. Intended for use in URI's CSC 411 class.
-
rdftk_skos
data model for the Simple Knowledge Organization System (SKOS) vocabulary
-
indexlist1
A doubly linked list, backed by a vector
-
tree-rizzen-yazston
Tree Library using the Any trait for data
-
reputation-types
Core types and data structures for the KnowThat Reputation Engine
-
unsafe_list
Linux 风格侵入式双向链表
-
v9
A slim data engine for Data Oriented Design
-
delatin
Fast TIN generation using Delaunay triangulation
-
std_collections_reexport
Re-exports of std HashMap, HashSet, and DefaultHasher for use by determinizable_collections
-
minsize
Collections with a statically known minimum size (using const generics)
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
frp-domain
Domain model for the frp graph: atoms, blocks, ports, edges, and metadata
-
ppar
Persistent immutable array
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
snowflake
A module for generating guaranteed process unique IDs
-
soavec
A vector-like data structure for conventient growable Struct-of-Arrays creation and manipulation
-
list-zipper
a zipper data structure for sequenceable data types
-
hashify
Fast perfect hashing without dependencies
-
string_manipulation_utf8
String manipulation functions using character indexing (UTF-8) instead of bytes
-
xio_base_datatypes
XIO base data structures
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
gamma
Graph primitives and traversals for Rust
-
generic_constants
Traits providing type-generic numeric constants (Zero, One, ..., OneHundredTwentySeven) implemented across common integer and float types
-
a2ui-types
Typed data models for the A2UI protocol (v0.8 & v0.9)
-
fluxus-api
High-level API for Fluxus stream processing engine
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
corresponding
Move corresponding fields between structs
-
muds
Minimalistic Data Structures and Entity-Component-System Library
-
radix_trees
Various radix tree (trie) data structures
-
fast-ordered-buffer
A faster buffering implementation for asynchronous streams, trading off memory usage for speed
-
value_pool
implements a ValuePool struct that makes the creation of self-referential data structures easier and safer
-
rosary
About Rose Trees
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
seq_watcher
A pair of structures for monitoring a stream of data for one or more sequences
-
seq-str
Flat collections of strings etc
-
timer-queue
Pure, minimal, and scalable timers
-
simple-graph
Graph library with ability to serialize/deserialize Trivial Graph Format
-
light-curve-common
Common tools for light-curve-* packages
-
key-paths-iter
Query builder and iteration over rust-key-paths KpType for Vec collections
-
attuned-core
Core types and traits for Attuned - human state representation for LLM systems
-
predicates
boolean-valued predicate functions
-
rshyper-algo
implements various algorithms for the rshyper framework
-
landfill
Various types for dealing with on-disk data
-
domain-lookup-tree
A tree structure in Rust optimized for looking up domain names, with wildcard support
-
oxc_index
Newtype-style helpers for
Vecandusize -
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
verdant-cache-core
Persistent agent-trace dependency graph with content-hashed nodes over incr-concurrent (part of the verdant agent-loop cache)
-
geosite-rs
that parses geosite.dat file format
-
beat_saber_map
Read and write Beat Saber maps with Rust
-
fn-store
A dynamic persistent value store using closure type as key and storing its return value
-
clnooms
Assembly-level implementation of interesting data types
-
expiration_list
A datastructure for items that expire
-
hattrie
A high-performance, cache-conscious, ordered map for string keys, based on the HAT-trie paper
-
fuzzy-search
collections for fuzzy search
-
associated_list
An associated list, for cases when the key implements neither Hash nor Ord
-
vec-strings
Store any string efficiently in an immutable way
-
rust_redux
A Redux-like state management library for Rust
-
mutable
keep track of changes in structures
-
hgg
Approximate nearest neighbor search collection
-
insrcdata
Embed static data as source code
-
dge-gen
building a computational graph to be executed distributely
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
cortenforge-models
Burn-based model definitions (LinearDetector/ConvolutionalDetector) for the CortenForge stack
-
froop
A functional reactive stream library for rust
-
zkcg-common
Shared types, errors, and utilities for the ZKCG protocol
-
simd-intervaltree
A SIMD-accelerated interval tree with zero-allocation queries
-
ring_pair
Tiny fixed-size ring buffer specialized for exactly two elements
-
cortenforge-data-contracts
Data contracts for run manifests and capture metadata used across the CortenForge stack
-
dothocanhnau_phong_thuy
Du lieu quy chuan ban tho va vach ngan phong tho Canh Nau, Thach That. Chuan phong thuy Lo Ban 2026.
-
bitf
procedural macro to easily create a bitfield out of a struct
-
fenny
working with Fenwick trees
-
arraystring
Fixed capacity stack based generic string
-
graphy-search
Full-text and fuzzy search for graphy
-
dugong-graphlib
Graph data structure APIs used by dugong (port of dagrejs/graphlib)
-
betterunion
safe union-like structure which uses the turbofish operator for reads and writes
-
cbloom
Concurrent implementation of Bloom filters
-
densevec
Map like collection with usize indices that stores values contiguosly
-
neopdf_capi
C language interface to NeoPDF
-
pulse-system-types
Shared contract types for the pulse-null plugin ecosystem
-
rustz
functional programming in Rust
-
regroup
regrouping arrays
-
extarray
Space-Efficient Extensible Arrays
-
syntastica-queries
Collection of tree-sitter queries for syntastica
-
bitvec_simd
bitvec with SIMD
-
box-collections
A no_std compatible implementation of the collection crate
-
lace_data
Data definitions and data container definitions for Lace
-
bktree
BK-tree datastructure
-
radix_route_matcher
A high-performance route matching library based on Radix Tree
-
ineru
Neural-inspired memory system for AIngle AI agents
-
binary-vec
A sorted vector that uses binary search
-
atomic_ptr_cell
Safe no_std repr(transparent) wrapper for AtomicPtr and &AtomicPtr with an api similar to a cell
-
minecraft-command-types
AST like structure for Minecraft commands
-
task-collection
Types for managing and waiting on groups of tasks
-
contigious-tree
Write and read tree graphs to and from contigious blocks of memory
-
tf_playlist
The playlist feature used in Tubefeeder
-
zellij_widgets
A wiget library for zellij
-
dcel
doubly-connected edge list
-
ligature
Ligature's data model in Rust
-
use-atomic-number
Atomic-number validation and lookup helpers for RustUse chemistry crates
-
libnv
Safe and rustic wrapper around libnv-sys
-
pointcloud
An accessor layer for goko
-
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
tinymap
A map structure that stores its data on the stack
-
atelier_base
Core data structures and I/O tools for the atelier-rs engine
-
plod
deriving plain old data
-
ord-collections
offering collections which are pre-sorted automatically
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
openvet-tree
Content-addressed Merkle search tree (dense skip-tree) for OpenVet
-
hydroperfox-smodel
Semantic modeling for Rust
-
perfgate-types
Versioned receipt/config contracts and JSON schemas for perfgate
-
literally
Macro literals for members of std::collections
-
msgpack_simple
Simplified, easy to use, pure Rust MessagePack implementation focused on handling dynamic data structures
-
indexed_json
Index json files like a database
-
dsa_abc
basic data structure and algorithms. Usability and performance is priority
-
ztimer
A block-based, non-circular double-linked list implementation for Rust
-
convergio-provisioning
Node provisioning — sync config, keys, binary to remote peers
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
pokeapi-model
Data structures for PokéAPI v2
-
fwdlist
A simply linked (forward) list
-
sweeper
A foundation for Minesweeper implementations in Rust
-
extended-rational
implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
asbytes
Traits for viewing data as byte slices or consuming data into byte vectors. Relies on bytemuck for POD safety.
-
zrl
zrl (zhrexx's Rust Library) is a collection of smaller and bigger handwritten libraries
-
type-erased-table
A column-oriented based raw data storage
-
steru
-
exprz
An Expression Library
-
fxd
Fixed-point decimal implementation
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
gzbbinarydoc
json like object structure to organize data.supported data types are binary(Vec<u8>),string,i64,f64,null,Vec<self> and hashmap<string,self>. the document can be parsed from and to a vec<u8>.
-
chainmap
mutability of intermediate maps
-
rs-statemachine
COLA-style state machine with fluent API
-
luthor
A collection of lexers for various languages/formats, and the tools required to build them
-
kg-utils
Various collections and utilities
-
pax-properties-coproduct
Static container for program-variable data structures and polymorphic components
-
convergent
Lightweight, composable CRDTs for decentralized systems
-
tosca-stack
A variant of the tosca library crate for stack-oriented devices
-
tilecoding
Dr. Richard S. Sutton's tile coding software.
-
expiremap
Key-Value map where each value has a custom expiry time
-
phago-rag
Biological RAG — query interface on self-organizing Hebbian knowledge graph
-
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
lykoi_data
data
-
sugars_collections
Efficient collection types including ZeroOneOrMany and OneOrMany with array tuple syntax support
-
upair
Unordered pair data structure
-
tyght-map
A static type map implementation
-
rudac
common data structures and algorithms
-
static-heap-array
A statically sized array which lives on the heap, allowing it to have a size that does not need to be known at runtime
-
fionn-diff
JSON diff/patch/merge for fionn
-
fallback
A helper library to implement fallback mechaism
-
lobby-queue
Const-size queue-like data structure
-
graphrefly-structures
GraphReFly reactive data structures (reactiveMap, reactiveList, reactiveLog, reactiveIndex)
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
weave-draft
representing and manipulating weaving drafts
-
herolib-sid
SmartID - Short, human-readable, collision-free identifiers
-
dltree
Doubly linked tree with leaf-considering typing
-
pq-tree
consecutive ones property (C1P) and graph planarity testing
-
data_tree
Hierarchical data tree with pathing and search support
-
lhlist
Labeled heterogeneous lists
-
smt-circom
Sparse Merkle Tree, compatible with circom proofs
-
data_hook
A lightweight data collection facade
-
modupipe
A modular and extensible ETL-like pipeline builder
-
qipu-core
Core domain logic for Qipu knowledge management system
-
chinese-rand
Random generation of data structures in Chinese, using Rust
-
optionee
The macro to create option struct easily
-
inspector
General purpose inspection for popular data structures
-
plato-ghostable
Ghostable lifecycle — mark tiles/agents for active/ghost/resurrected states
-
higher-graphen-runtime
Runtime workflow orchestration APIs for HigherGraphen
-
ndim
N-dimensional array for numerals in Rust similar to NumPy
-
bisetmap
fast and thread-safe two-way hash map of sets. It is best suited where you need to associate two collumns uniquely. Each key is associated to one or more other unique values. The structure…
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
msiz_rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
open-coroutine-timer
The time utils
-
polystore
Polymorphic data store
-
rocstr
An immutable fixed capacity stack based generic copy string
-
cds
Collection of Optimized Data Structures
-
arq
manage Arq Backup data formats
-
mem-vec
Vector store trait and Qdrant implementation for MemOS
-
smol-atlas
2D rectangular bin packing with optional item removal
-
dst
Data structures for DSTs
-
kool_bloom_filter
A standard and scalable Bloom filter implementation in Rust with configurable error tolerance and automatic scaling
-
dependency-graph
building and resolving dependency graphs
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
guzzle
A derivable trait for consuming key value pairs into structs
-
open-payments-iso20022-acmt
Open Payments - Message Parsing Library - ISO20022 ACMT
-
shortguid
Short URL-safe Base64 encoded UUIDs
-
overtone
An API for creation and management of rich (as in rich-text) musical-ish projects
-
cphf
Compile-time perfect hash function data structures
-
smallbytes
= SmallVec + impl BufMut (from the bytes crate)
-
iroh-metrics
metrics for iroh
-
double_linked_list
High-performance doubly-linked list with smart pointer support and memory pool optimization
-
graphrepresentations
providing efficient abstract implementations of different graph representations
-
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
patternize
provide macros and traits to create design pattern
-
cycler
A simultainious write/read data structure
-
histogram-sampler
Sampling from a distribution given by a histogram
-
bidirectional-map
A two-way map data structure for small keys and values
-
twovec
A data structure for storing 2 types of data in a packed, heap allocated array
-
ittapi
High-level Rust bindings for ittapi
-
bstree-file-readonly
Query read-only binary-search tree file, supporting billions of entries in files of tens of GB
-
kurobako_problems
A collection of black-box optimization problems
-
internode
Smart references to your graph nodes
-
liblet
learning about formal languages and grammars
-
enumoid
Enum Indexed Containers
-
singletonset
SingletonSetdata structure, which makes it easy to store a single instance each of various types within a single set -
multi_key_map
a hash table that shares one value across multiple keys
-
malwaredb-api
Common API endpoints and data types for MalwareDB components
-
char-list
A persistent string type with the same API as a linked-list of characters
-
ordered_hashmap
Ordered Hashmap implementation to overcome arbitrary order of key-values problem in Rust
-
type-freak
Collection of typed data structures, trait operators and aliases
-
artsy
ART Tree data structure library
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
dsa_sport
revision material for undergrads
-
set-trie
A trie for fast subset and superset queries
-
purse
Bag data structure implementation in Rust
-
etin
5-digit IRS Electronic Transmitter Identification Number (ETIN) type
-
use-crate
Composable crate identity and metadata primitives for RustUse
-
char-buf
A writable, fixed-length
charbuffer usable inno_stdenvironments -
pinned_vec
Vec-like data structure whose elements never move
-
simple-observable
observable pointer for mutable and immutable data
-
range-traits
Ranges related traits
-
fairqueue
Spatially distancing fair queue. A kind of queue for sequential round-robin processing.
-
iron_runtime_state
Runtime state management for Iron Cage agents
-
minimal_signals
minimal API for working with signals
-
doubly
Doubly-linked lists in Rust
-
jitlist
blazingly fast revolutionary data structure
-
prefix-tree-rs
A Trie (prefix tree) implementation
-
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
-
limq
Queue with a controller for monitoring queue elements
-
boarddown
Local-first, file-based Kanban storage engine with sync capabilities
-
suffix_trie
Suffix trie for searching
-
groupex
Syncronization primitive that allows acquire lock by index
-
stac-validate
json-schema validation for the Rust implementation of the STAC specification
-
kollect
Collections made ergonomic for gamedev usecases
-
statemachine-rs
A statemachine crate which have zero dependencies
-
nonoverlapping_interval_tree
Map data structure keyed on (non-overlapping) ranges that allows lookup of a point within a range. Can be no_std (with use of alloc crate).
-
array-box
Create Rust vector from C data, either owned or not owned
-
cbsk_timer
rayon thread runtime
-
goodreads
deserializing a Goodreads library export
-
stable-id
mainly deals with issuing and maintaining stability of indices
-
miniconf
Serialize/deserialize/access reflection for trees
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
wccg-models
WCCG Data
-
beehive
collections for 3D hexagonal maps
-
graphlib_rust
Dagre's Graphlib implementation in Rust
-
gridbugs
Collection of re-exported crates for building roguelike games
-
tessera-design-toolkit-core
Core library for Tessera Design Toolkit (TDT) - engineering artifact management with requirements, risks, BOMs, tolerance analysis, and full traceability
-
expiring-atomic-filter
Thread-safe approximate membership filter with time-based expiration
-
use-chemistry
Composable chemistry primitives for RustUse
-
tournament-kway
k-way merge using a tournament tree
-
simple-ref-fn
function wrappers that do not require virtual tables
-
lookup-tables
High performance & compile-time customizable lookup tables
-
common-tree
common tree lib
-
pdforg-core
Core data types for PDF Office — documents, cells, slides
-
soak
Transform a struct into arrays of its fields
-
yaxpeax-core
program analysis for machine code
-
arraysetcell
A fixed-capacity, vector-like array with interior mutability and no ordering guarantees
-
bloom-filter-yss
bloom filter for me or you
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
cursorvec
Cursored vector container
-
loose-semver
Loose parser for Semantic Versioning
-
bankarr
Array-like but growable vectors
-
scopegraphs-prust-lib
fork of prust for scopegraphs
-
forrustts
Tools for forward simulation with tree sequence recording
-
densemap
A collection data structure that is permanently accessible by unique keys and fast iterable
-
sprsdata
Data structures based on sparse and dense arrays
-
adts
Common abstract data type traits and implementations
-
chesspos
Basic structs for representing chess squares
-
wrapped_slab
WrappedSlab: Auto-generate newtype idiom based on a Slab
-
stack-vector
Vec-like wrapper for an array allocated on the stack
-
bufferbuffer
Double Buffer design pattern from 'Game Programming Patterns' by Robert Nystrom
-
fenwick-tree
binary indexed tree (Fenwick tree) data structure in Rust
-
ascii-dag
Zero-dependency, no_std compatible ASCII DAG renderer. Visualize error chains, dependency trees, and graphs in the terminal.
-
mdcs-core
Core CRDT types and traits for the Carnelia Merkle-Delta CRDT Store
-
ef_rs
Elias-Fano encoding scheme
-
graphlib
powerful rust library for the graph data-structure
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
foreign_vec
Unofficial implementation of Apache Arrow spec in safe Rust
-
RustyDSA
A libary for Rust data structure
-
contexts
Implements a type for treating several hashmaps as one
-
patternutils
Tiny utility library for some common design patterns
-
bengbenge
inifity array for round-robin dns, beng, beng
-
composite_types
Compose type definitions in the style of typescript
-
sliceable-ring-buffer
A double-ended queue that Deref's into a slice
-
double-map
A HashMap with double key to single data/value
-
retriever
embedded in-memory data store for rust applications
-
flat-veb
Fast implementation of vEB trees without internal allocation
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
campo
Easily create and handle bit fields
-
dsu-tree
A non-invasive disjoint-set-like data structure implementation
-
rust-constraint
constraint satisfaction problem (CSPs)
-
sys-mumu
System calls and tools plugin for the Mumu ecosystem
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
fast_trie_tree
A fast
TrieTreefor multiple data types -
raw-btree
Generic B-Tree implementation
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
many-to-many
creating many-to-many data structures with the ability to query either side, useful for applications such as pubsub. Like a fusion between
bimapandmultimap. -
rs-merkle-tree
Merkle tree implementation in Rust with configurable storage backends and hash functions. Fixed depth and incremental only. Optimized for fast proof generation.
-
extindex
Persisted immutable index
-
elastic-array-plus
Elastic vector backed by fixed size array
-
block-array-cow
In memory array de-duplication, useful for efficient storing of a history of data versions
-
validbr
data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
restorable
An iterator adapter for saving and restoring iterator state
-
streams
A collection of stream-extensions that are missing in the
futurescrate -
make-message-bus
Generate a pub-sub bus for use in async applications
-
cmus-status
structure cmus status data
-
milvus-sdk-rust
The official Milvus Rust SDK
-
colorfyi
Color conversion, WCAG contrast, and color space lookup — async API client for colorfyi.com
-
mofurun
Multi variant Optimized Fun U....okay Mofu is just a cute name okay. Experimental implementation of Vec that stores the state of the underlying array through its enum.
-
oxigdal-qc
Quality control and validation suite for OxiGDAL - Comprehensive data integrity checks for geospatial data
-
discrete_range_map
DiscreteRangeMap and DiscreteRangeSet, Data Structures for storing non-overlapping discrete intervals based off BTreeMap
-
datastructures
A variety of data structures for learning purpose
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
willowtree
Lazily evaluated trees
-
magnetise
asses the similarity between SQL queries
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16coordinates. -
xsparseset
sparse set
-
fns
add common fn, eg: debounce, throttle
-
quadtree_simple
quadtree implementation
-
attr
attris a library to provide external access to a datastructure through a typed path object, using all type information known about the data structure at hand -
subset-map
A map where the keys are subsets of an initial set of elements
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
bose_einstein
A data structure that efficiently partitions elements into two sets
-
subranges
manage non-interssecting integer intervals
-
simple-file-manifest
Interact with lists of files through a storage-agnostic interface
-
merkle
tree implementation with support for generation of inclusion proofs
-
justly
justified containers
-
arrow
Apache Arrow
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
named_colors
that provides named colors in RGB and Hexadecimal formats
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
plato-fleet-graph
Fleet graph engine — adjacency lists, centrality, community detection, shortest paths
-
foldlist
A mutable list with fast folding
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
app_properties
reading application properties from a file
-
rstl-collection
Core collection and disposable traits for rstl crates
-
rcbytes
Rc version bytes crate
-
kcr_opensearch_opster_io
Kubernetes Custom Resource Bindings
-
uuidv7
UUIDv7 implementation
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
slablit
Literal for slab creation
-
collectivity
Generic collection traits
-
oramacore_ptrie
Generic trie data structure implementation (prefix tree) with support for different key and value types, and functions to search for common prefixes or postfixes
-
deltastruct
Allows defining deltas for tagged structs for later application
-
chain-map
A chain of maps with a single view into the aggregated values
-
omega-loops
7 temporal cognitive loops from Reflexive (1ms) to Transcendent (10y) for multi-scale processing
-
elizaos-plugin-planning
Planning and task management plugin for elizaOS (Rust)
-
tuplities-option
Traits for working with tuples of Options
-
rahashmap
Fork of standard library HashMap with additional functionality
-
equivalent-flipped
Similar to
equivalentcrate, but flipsKandQ -
tokmd-substrate
Shared repo substrate context for cross-sensor coordination
-
merkle-tree-bulletin-board
A public bulletin board based upon Merkle trees
-
pas
strided slice
-
gtars-scoring
Small, rust utility to compute read overlaps of fragments files over a universe
-
dynp
Dynamic property system that emphasizes the use of the Newtype pattern
-
range_union_find
A union-find data structure for ranges
-
sparseset
A Sparse Set
-
spaceindex
-
array2ds
Package for handling sized 2d arrays in rust, without the usage of the keyword unsafe cuz why not
-
validiter
Iterator adapters for validating iterations
-
hl7v2-model
Core data model for HL7 v2 messages
-
philharmonic-types
Cornerstone types for the Philharmonic workflow orchestration system: content-addressed JSON, phantom-typed UUID identities, SHA-256 hashes, and millis-since-epoch timestamps
-
go-heap-rs
Golang's heap written in Rust
-
teardown_tree
A binary search tree that supports fast clone and delete-range operations
-
zot
Option-like enums for working with ordered collections of zero, one, or two items (
Zot), or ordered collections of one or two items (Ot) -
identified_vec
Like HashSet but retaining INSERTION order and without
Hashrequirement on the Element type -
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
barcodefyi
Barcode format lookup, symbology reference, and standard encyclopedia -- async API client for barcodefyi.com
-
zjctl-proto
Protocol types for zjctl RPC communication
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
qualified_do
Composable _qualified_ do expressions for Rust, supporting monad- and applicative-like structures
-
eldek-tad
A project for learning Abstract Data Types (ADTs) in Rust. Heavily inspired by Java's implementation.
-
dade
data definition for Rust structures
-
xtree
general purpose tree data structure
-
range-filters
High-performance range filter implementation - DIVA (VLDB 2025 Best Research Paper)
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
sliding_extrema
Queue data structure with support for an O(1) extrema function over contents (for example, to obtain min and max over a sliding window of samples)
-
hedge
An index based half-edge mesh implementation
-
pi_sinfo
used to describe the 'structure', that is, the meta information of the structure
-
retrace
Safe, generic rollback log with predictable latency
-
embassy-mock
An unofficial collection of mocked types for the Embassy framework
-
lambda-runtime-types
Common structures for lambda architecture
-
hdrhistogram
A port of HdrHistogram to Rust
-
osmgraph
Convert OSM queries into graphs
-
cdl-list-rs
A circular doubly linked list implementation using Rc<T> and RefCell<T>
-
nstree
construct branched 'namespace strings' for nested subcomponents, often for logging
-
monistode-assemblers
A collection of assemblers for the monistode set of architectures
-
lending-library
A key-value store that loans full ownership of items
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
hora-id
A 64-bit time-based sorted unique ID generator that includes the current time in the ID
-
eoplus
A lexer and parser for Endless Online EO+ scripts
-
kotoba-schema
Graph Schema Definition and Validation for Kotoba
-
contiguous_collections
collections backed by flat contiguous arrays
-
struct-compression-analyzer
Analyzes the bit distribution of packed structures
-
nl-compiler
AIG and Verilog frontend compilers
-
cartesian-tree
Construct a Cartesian Tree from a Slice in Linear Time
-
mheap
Flexible binary heaps
-
uniqer_rs
flexible library for generating various types of unique IDs using a builder pattern
-
hson
JSON like format for HTML. Allow querying the data through searching methods similar to client-side DOM queries methods
-
aggregate-map
Collect key-values pairs into a mapping from keys to collections of values
-
wide
help you go wide
-
grangers
working with genomic ranges and annotations
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
planck
Lightweight, modular utility crates for Rust
-
swamp-script-source-map-lookup
Source map lookup for Swamp
-
building_blocks_partition
Acceleration structures for spatial queries on voxel data
-
priority_container
Datastructure to find n biggest/smallest items within a large set
-
flatbuffers-owned
that enables a more flexible usage of FlatBuffers
-
isomorphism
2 directional hashmaps
-
taganak-core
RDF types and interfaces from Taganak (Transactional, Aggregating Graph Architecture for Networking and Access to Knowledge)
-
multipath
split file path, like
/home/{user,admin}/file.txt -
sized-vec
Type level sized vectors
-
activitist
Models of ActivityPub
-
pogo-masterfile-types
Generated Rust types for the Pokémon GO masterfile, with a typed parse_masterfile dispatcher
-
membuffer
A very fast flat memory buffer used to deserialize at a fast speed
-
jsondiffpatch
JSON diff & patch (object and array diff, text diff, multiple output formats)
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
bitint
Integer types that have a logical size measured in bits
-
try_reserve
Stable implementation of the TryReserveError from std for custom collections
-
ra-ap-rustc_graphviz
Automatically published version of the package
rustc_graphvizin the rust-lang/rust repository from commit 5113ed28ea1451a13eae3a05dca0dbabfd56f587 The publishing script for this crate lives at:… -
indexmap-amortized
hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
html-json-extract
A package for parse some data from html.scripts
-
handy
providing handles and handlemaps
-
simploxide-bindgen
SimpleX-Chat API types and client generator
-
rds-tensors
Rust Data Science Tensors crate
-
dashmap-shard
port of Google's SwissTable hash map
-
arrow-graph-git
Graph-native git primitives on Arrow RecordBatches — commit, checkout, merge, diff, blame, rebase
-
numas
multidimensional array for efficient computing
-
displays_logical_types
Shared logical display data types used by the displays crate and platform backends
-
read-copy-update
locking primitive
-
graphrefly-graph
GraphReFly Graph container, describe/observe, content-addressed snapshots
-
lazy_vec
A lazily initialized (but eagerly allocated) Vec-like datastructure
-
erased-type-arena
A type-erased allocation arena with proper dropping
-
atlas-rb-tree
A textbook implementation of a Red-Black Tree
-
actions
Software without side-effects. Redo and Undo. Macro's.
-
rust-prelude-plus
Higher-order functions built on top of keypaths for type-safe functional programming
-
flammkuchen
Some data structures for fun and flammkuchen (e.g. a 2d grid which permits negative indices)
-
taco-zcs-model-checker
Model Checker constructing an abstract counter system encoded into BDDs to verify threshold automata. This model checker is part of the TACO toolsuite.
-
sharedvec
A fast but limited collection for storing values of a single type
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
triangle_matrix
Triangle matrix indexing operations
-
relational_types
Manage relations between objects
-
lockfree-cuckoohash
lockfree cuckoo hashmap
-
pl-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
roers
prepare augmented annotations for single-cell RNA-seq analysis
-
qlrumap
An LRU HashMap with an optional passive ttl feature
-
memtally
A wrapper for some collection types that keeps track of indirectly allocated heap memory
-
ecoord-core
Core primitives and operations for transforming between 3D coordinate frames
-
chunky
Abstract storage of heterogeneously-sized entity-collections
-
fixedvec
A heapless version of the Rust vector type
-
bst-hashmap
A binary tree implementation with a hashmap-inspired interface
-
bookfile
A container file format with chapters and an index
-
simple-matrix
generic matrix library
-
string-mumu
String functions and tools plugin for the Lava / Mumu language
-
chainbuf
Fast chained buffers
-
swiss-eph-data
Embedded ephemeris data files for swiss-eph (Swiss Ephemeris)
-
index_vec
Newtype-style helpers for
Vecandusize -
sbbf-rs-safe
Split block bloom filter implementation
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
array_manipulation
Methods for manipuling arrays in a Vec-like fashion. It will (probably) get into core once const expressions get less experimental.
-
synesthetic-validator
Validation helpers for Synesthetic operator and graph definitions
-
spatialize
collection of spatial data structures used for efficent spatial partitioning
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
kodiak-taxonomy
manage generic taxonomies supporting unique features
-
rsurf
A data structure providing range query filtering with Fast Succinct Tries
-
priority-expiry-cache
A cache that evicts items based on their priority and expiry time (LRU + TTL) Add (O(1)), Get (O(1)), Evict (O(1)) in both time and space
-
erased_set
A set of erased types
-
alist
Association list offering fast lookups while preserving insertion order
-
mkargs
Build command arguments
-
string-newtype
New Type idiom helper for string-like types
-
slotmap-slice-fork
Fork of slotmap
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
range-split
splitting sequences with range parameters
-
oxigdal-index
Pure-Rust spatial index (R-tree) for OxiGDAL vector data
-
cloudr
that offers an abstract data structure for storing and managing values without moving them. It provides efficient key-value insertion, retrieval, and removal operations, allowing you to conveniently handle your data…
-
boxed_array_ringbuffer
A ring buffer of fixed size, that uses a boxed array as storage, therefore avoiding re-allocations when converting from Vec or to VecDeque
-
sea-plus
A collection of useful extensions for SeaORM
-
brie-tree
A fast B+ Tree implementation that uses integer keys
-
keyarray
modeling and managing mutually exclusive states (keys in a key array)
-
sqlx-data-params
Data parameter utilities for SQLx-Data - advanced pagination (Serial/Slice/Cursor), dynamic filtering, sorting, and type-safe query parameters for database operations
-
cluConstData
Compile-time macros for building persistent data structures in no_std and const environments. Supports buffer composition, and numeric formatting.
-
nimble-steps
Nimble Steps Collections
-
logify
A high-performance, portable boolean logic engine. Turns abstract logic into optimized data structures that can be serialized, cached, and evaluated against arbitrary user data (Bitmaps, Sets, JSON, etc)
-
hprtree
A Hilbert-Packed-R-Tree implementation for rust
-
sparse_set
sparse set data structure
-
one_way_slot_map
SlotMap with minimal restrictions on Keys and Values
-
win-idispatch
that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
partial
Optional monad with fake variant
-
bufferring
Ring buffers for Rust
-
ruchei-collections
Collections to support the implementation of ruchei
-
deep_causality_ast
AST data structure for deep_causality crate
-
sdsl
interface for the Succinct Data Structure Library
-
tiny-artnet-bytes-no-atomic
Vendored copy of Bytes fork for use in tiny-artnet. Types and traits for working with bytes
-
multi-stash
Vector-based arena data structure that reuses vacant slots
-
btree_experiment
implements a BTreeMap similar to std::collections::BTreeMap
-
bitsvec
A bit vector with the Rust standard library's portable SIMD API
-
swimos_multi_reader
SwimOS Stream Aggregator
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
expiringdict
A dict / HashMap whose items expire over time
-
median-heap
A median heap implementation in Rust, used to keep track of a running median of a sequence of numbers
-
steel-imbl
Immutable collection datatypes
-
persistent-kv
Persistent key-value store
-
tan-lints
A collection of lints for the Tan Language
-
array_map
Map backed array for fixed size keys with O(1) performance
-
whiskeyfyi
Whiskey encyclopedia with expressions, distilleries, and regions — async API client for whiskeyfyi.com
-
inline-css
Embed CSS directly in your Rust code
-
engcon
macros to define (eng)ineering (con)tracts on data-structure level
-
libveritas
Offline verification library for Spaces protocol certificates and zone records
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
recursive_array
arrays using recrusive data structures to avoid limitations of the rust compiler
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
expiringmap
a HashMap-backed TTL map
-
u64_array_bigints
biginteger library based on u64 arrays
-
segarray
A fast, growable array type with no copies
-
the-zipper
zipper is a data structure that allows you to traverse and modify a tree-like structure efficiently. It provides a way to navigate through the tree while keeping track of the context…
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
ahtable
Array Hash Table implementation
-
apint
Arbitrary precision integers library
-
lutra-arrow
Arrow format conversion for Lutra: converting between Arrow RecordBatch and Lutra binary values
-
color_names
map [r, g, b] values to the color name it corresponds to. Note that this lib is rather large and can increase compile time drastically.
-
dynprops
Creating and extending objects with typed dynamic properties
-
dynamic-list
A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
-
datastruct
A pure-data structure builder
-
extra_collections
Some possibly useful collections mostly intended for personal use
-
faultline_geometry
Geometry abstractions and spatial metric contracts for FaultLine
-
crtx-session
Session-close pipeline: ingest, reflect, and commit memories to pending_mcp_commit
-
btreemultimap
A multimap implementation with range support
-
statevec-api
Runtime host APIs and plugin ABI types for StateVec domain plugins
-
sets_multisets
API for working with sets and multisets of elements of type usize
-
nlist
inline-allocated list with statically tracked length
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
ensure
target state of an object
-
telltale-types
Core session types for Telltale - matching Lean definitions
-
grids
2D grid data structure for games
-
dge-runtime
executing distributed computational graph
-
sliding_tree
A tree that grows from the leaves and recedes from the root
-
banyan
Persistent indexable tree data structure
-
kodiak-sets
manage generic sets supporting unique features
-
span-map
A data structure for efficiently managing sets of values over spans/ranges
-
stride
A strided slice type
-
vec-entries
Entry API for iterating over and removing elements from a
Vec -
lineartree
tree data structure for rust
-
hexarr
working with hexagonal grids
-
knot0-types
Rust types generated from Knot0 JSON Schemas
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
lim-bit-vec
Limited bit vectors
-
arrav
Sentinel-based heapless vector
-
cumulfreqtable
A Cumulative Frequency Table implemented with a Binary Indexed Tree
-
nihonshufyi
Sake guide with rice varieties, breweries, and tasting notes — async API client for nihonshufyi.com
-
mt-kahypar
A statically-linked Mt-KaHyPar
-
cgp-core
Context-generic programming core traits
-
tokmd-analysis-types
Analysis receipt contracts for tokmd
-
priq
Array implementation of the min/max heap
-
marisa-ffi
Rust FFI bindings for libmarisa - a space-efficient trie data structure
-
sparse_map
A sparse map with stable generational keys
-
threshold-dict
A data structure to find smallest key that is larger than the query
-
tongrams
Tons of N-grams
-
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII's gridd)
-
incrementalmerkletree-testing
Common types, interfaces, and utilities for testing Merkle tree data structures
-
gufo-tiff
Data structure for TIFF images
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
immutable-avl
An Immutable map and set implement for rust based on an AVL tree
-
dequemap
A no_std compatible implementation of the dequemap crate
-
mdcs-merkle
Merkle-Clock DAG for causal history tracking in the Carnelia MDCS
-
runtime-sized-array
A variable-length array, also called runtime-sized
-
arbitrary-int
Modern and lightweight implementation of u2, u3, u4, ..., u127
-
iter-group
grouping (key,value) iterators into maps of collections
-
nb-tree
Very simple tree structure with generic node and branch data
-
pipebuf
Efficient byte-stream pipe buffer
-
butterfly-common
Common utilities for the butterfly-osm toolkit
-
wildland-catlib
Wildland Catalog Library client
-
rsor
Reusable slice of references
-
typescript-definitions-ufo-patch
serde support for exporting Typescript definitions
-
tiny-test
tiny-testis collection of functions simplifying test assertions in rust -
offset
Glorified offsets for arbitrary structures
-
libarena
Arena allocated graph implementation
-
fast_forward
Quering collections blazing fast
-
hilbert_curve_generator
A WIP Hilbert Space-Filling Curve Coordinate Generator
-
smartcardfyi
Smart card platform reference, EMV standard lookup, and Java Card encyclopedia -- async API client for smartcardfyi.com
-
exhaustive-map
An exhaustive map for types with finite inhabitants
-
unicase_collections
Collection of UniCase datastructures
-
id_sys
data structures which can be marked such that they only work with similarly marked integer data types
-
cbsk_log_tokio
log tool, using tokio as the runtime
-
artie_common
Common Library for Artie Rust Projects
-
secretmangle
mangling sensitive data in memory with a random key
-
fast_collections
noheap zero copy collections
-
jirachi
A collision resistant runtime agnostic key-generator
-
uuid47
lightweight library for converting between UUIDv7 and UUIDv4 facade
-
obsessive_peek
An iterator adapter to peek at future elements without advancing the cursor of the underlying iterator
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
stateset-protocol
Wire-format types for StateSet sync protocol — envelopes, batches, Merkle proofs
-
datazoo
Bitset and jagged array data structures
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
rshyper-hmap
implements the hypermap implementation (a map-based hypergraph) for the rshyper framework
-
automap
pattern to implement key-value maps where the value type contains the key type
-
holidayfyi
Holiday dates, Easter calculation, and 200+ country calendars — async API client for holidayfyi.com
-
hayami
general use symbol table
-
iterlist
Linked list with a cursor based api
-
rstmdb-core
State machine engine for rstmdb - definitions, transitions, guard evaluation
-
weakheap
Weak Heap data structure implementation in Rust
-
ds-bst
Binary search tree implementation
-
lightning-containers
A set of lock-free data structures
-
linked-list
An alternative implementation of std::collections::LinkedList
-
strune
directional knowledge structure library for building linked references and word books
-
semver-store
An HashMap structure that uses semver strings as keys
-
frp-loom
Storage traits and in-memory implementations for the frp graph layer
-
drthashbrown
port of Google's SwissTable hash map
-
trans-gen-kotlin
Generating Kotlin trans code
-
compare
Experimental comparators for collections to be generic over
-
largeint
that supports large integer arithmetic
-
tinyid
A tiny ID type that's like UUID except shorter and easier for a user to type in
-
booking_kit
A powerful and extensible booking toolkit for Rust — featuring core data structures, flexible status logic, and seamless integration into any reservation system
-
xdag
DAG(Directed Acyclic Graph) lib
-
const-vec
Vec-like data structure with immutable push method
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
hyperbitbit
data structure
-
guppy
Track and query Cargo dependency graphs
-
mumu-test
Test suite plugin for the Lava language
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
data_structure_traits
data structure collection traits
-
light-curve-interpol
Interpolations tools for time series
-
oxrdf_elevont
Basic data structures related to RDF
-
array-mumu
Array tools plugin for the Mumu ecosystem
-
bytesbox
ByteBox is a high-performance hash map implementation optimized for byte slices. It efficiently maps keys and values of type Vec<u8>, providing full ownership of the data. ByteBox uses…
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
Project2
Implementations of red black tree and AVL tree
-
open-payments-iso20022-reda
Open Payments - Message Parsing Library - ISO20022 REDA
-
kcr_mutations_gatekeeper_sh
Kubernetes Custom Resource Bindings
-
rdf-format
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
freezable
immutable data
-
markov-generator
Highly customizable library for building Markov chains and generating random data
-
wunderkammer
Entity-Component storage for tiny games
-
nonempty-containers
Fast, zero-cost conversion, and fully inter-operable nonempty container types
-
copse
Direct ports of the standard library’s BTreeMap, BTreeSet and BinaryHeap collections, but that sort according to a specified total order rather than the
Ordtrait -
uguid
GUID (Globally Unique Identifier) no_std library
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
linked-vector
A hybrid linked list and vector data structure
-
itempool
trait for managing pools of reusable items with discard/recycle support
-
partitions
A disjoint-sets/union-find implementation that allows for efficient iteration over elements of a set
-
distancefyi
Haversine distance calculation and travel time estimation — async API client for distancefyi.com
-
oxa-types
Rust types generated from the OXA schema
-
future-fn
providing macros to simplify the creation of asynchronous closures with external state captured by move. Useful for structuring asynchronous code with ease and clarity.
-
frp-signal
Lifecycle and telemetry signal contracts for frp persistence flows
-
hicollections
C-liked Collections
-
dcosl-core
Pure DCoSL protocol types, tag builders, and utilities — no network, no CLI
-
rdf-fusion-model
RDF Fusion Model
-
colony
A fast associative data-structure that chooses its own keys
-
big_enum_set
creating sets of enums with a large number of variants
-
golomb-coded-set
BIP158 Golomb-Coded Set data structure
-
hexga_array_vec
A vector with fixed capacity, backed by an array based on arrayvec
-
croaring-sys
Raw bindings to CRoaring
-
higher-graphen-core
Shared primitive types and contracts for HigherGraphen
-
bitworks
meant to provide easy to use bitsets with emphasis on safety
-
equivalence
Trait and derive macro for comparing and hashing types modulo an equivalence relation
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
spark-signals
A standalone reactive signals library for Rust - fine-grained reactivity for any application
-
german-str-borrow
German/Umbra-style strings. Data is borrowed, static, or inlined
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
typed_index_collection
Manage collection of objects
-
serde_either
set to enums to deserialize and serialize data that can either be string, struct or vec
-
ladata
& modular data model
-
shoo
blackjack games and trainers
-
pretree
package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
pathlink
A URL type whose path can also be used as a filesystem path, for Rust
-
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
bfield
B-field datastructure implementation in Rust
-
loro_fractional_index
Fraction index for Loro. Fork and modified from jamsocket/fractional_index
-
yrs-kvstore
Generic persistence layer over Yrs documents
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
kotoba-cid
Content ID (CID) system for Kotoba graph processing
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
pulz-bitset
bitset implementation
-
typed_polars
A statically-typed wrapper around Polars for compile-time type safety
-
json-node
A way to work with JSON as a node tree
-
rs_transducers
transducers for Rust
-
mini_uuid
A small and URL-safe UUID crate for Rust
-
elizaos-plugin-memory
Memory management plugin for ElizaOS (Rust)
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
poetrie
Poetic trie crafted with intetion to ease searching of rhymes for poems
-
froggy
prototype for the Component Graph System programming model. It aims to combine the convenience of composition-style Object-Oriented Programming with the performance close to Entity-Component Systems
-
kd-tree-rs
k-d tree
-
polars-structpath-types
Common objects for polars-structpath and polars-structpath-derive
-
trie-rs
Memory efficient trie (prefix tree) and map library based on LOUDS
-
hashed-array-tree
Hashed Array Trees
-
ringo-buff
Ring buffers for bytes, with heap and stack storage
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
lazy_simd
Trait based SIMD acceleration and safe abstraction
-
faex
A fast and efficient Compact Data Structures Library
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
rust_multistack
Support for two-dimentional stacks for the Rust programming language
-
intsplit
splitting numeric types into their binary component arrays
-
rc-hashmap
A HashMap with reference-counted key-value entries
-
cosmic_undo_2
Undo and redo done the right-way
-
disk-ringbuffer
lock free on disk ringbuffer to be used in the implementation of Franz
-
trailer
Store a type with an associated buffer in contiguous memory
-
rfidfyi
RFID tag and reader reference, EPC standard lookup, and frequency band encyclopedia -- async API client for rfidfyi.com
-
sequential_gen
sequential generator
-
thread_aware_macros_impl
Macros for the thread_aware crate
-
binartree
Binary Tree realisation
-
hkalbasi-rustc-ap-rustc_graphviz
Automatically published version of the package
rustc_graphvizin the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
awid
Small, simple, universally unique identifiers
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
canutils-lib
A collection of types for working with CAN bus data
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
pciids
parse the pci.ids data file
-
anvaya
ECS like dynamic storage in ~500 LOC
-
simple-undo
Easy to use undo-redo library
-
portdiff
Data structure for fast local graph rewriting
-
gentrix
that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
palettevec
A palette compressed vector library for potentially insane runtime compression ratios
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
brewfyi
Coffee variety guide with roasting, brewing methods, and origins — async API client for brewfyi.com
-
tui-vfx-types
Framework-agnostic foundation types for the tui-vfx ecosystem
-
whirlybird
generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
eztd
Quick start Rust
-
slots
Fixed size data structure with constant-time operations
-
skiplist-rs
Skip list is a kind of ordered map and can store any value inside. See skip list wikipedia page to learn more about this data structure.
-
s3vectors-metadata-filter
A flexible and efficient Rust library for filtering data using S3 Vectors Metadata Filter
-
hashcons
Hash cons'ing for compact representations of shared, immutable data structures
-
kukoo
lockfree cuckoo hashmap
-
persistent_rope
An immutable persistent rope data structure
-
critbit
Map and Set based on critical bit trees
-
tree-iter
iterating over tree structures
-
displays_physical_types
Shared physical display data types used by the displays crate and platform backends
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
arc-bytes
A reference-counted byte buffer
-
atomic-slot
lock-free, atomic slot for transferring ownership of Box<T>
-
mvbitfield
Generates types to work with bit-aligned fields
-
building_blocks_storage
Efficient storage for maps on sparse or dense, 2D and 3D integer lattices
-
dynamic_bitset
A dynamic bitset using a vector to store 32 bit unsigned integers. Provides a serde feature flag to enable Serialization and Deserialization of bitset
-
cutoff_list
A linked-list structure where each element tracks how many predefined "cutoff points" precede or coincide with its position in the list sequence
-
louds
LOUDS implementation for Rust
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
stac-duckdb
Client for querying stac-geoparquet using DuckDB
-
ndarray-histogram
Histogram support for n-dimensional arrays
-
touch-selection
Selection data structure intended for touch and single button devices
-
single_byte_hashmap
HashMap for storing singular bytes as keys
-
amalgamator
A set/map like data structure that allows you to combine members together
-
regd-testing
regd testing is a collection of utilities designed to simplify testing in regd projects
-
sweetrpg-model-core
Core model definitions for SweetRPG
-
merkle-lite
fast, and composable binary Merkle tree and proof for Rust Crypto hash functions
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
reversible
A generic wrapper struct that provides reversible editing capabilities
-
ax_banyan
Persistent indexable tree data structure
-
segmented_string
an immutable string type built from array segments, similar to clojure's persistent vector, with unicode grapheme/width support
-
arenas
Arena data structure for efficiently adding & removing items with stable IDs
-
functype-core
Core functional programming types for Rust
-
aabel-multihash-rs
extends Hasher trait. The added functionality allows users to get sequeces of hash values. It can be used inside of implementations of probabilistic data structures such bloom filter or count-min.
-
vecbool
bit vector built on top of Vec<u8>
-
extended-collections
An extension to the collections in the standard library with various data structures
-
benchmark-counters
Light-weight data structures to help with monitoring and benchmarking
-
gtrie
Generic trie implementation with a support of different key and value types
-
vinofyi
Wine encyclopedia with grapes, regions, and food pairings — async API client for vinofyi.com
-
lottie-data
Data structures for Lottie animations
-
ts_bitset
compact, efficient, non-allocating bitset
-
data-buffer
low-level data buffer type useful for IO and in homogeneous collections
-
tbytes
A tiny library for reading and writing typed data into buffers
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
cmp_wrap
Let you compare structes by context
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/History -
jsonpath-rust
basic functionality to find the set of the data according to the filtering query
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
keylist
Elixir keyword list in Rust
-
rexis-graph
Rexis Graph - Graph-based agent orchestration with hybrid state management and memory integration
-
append-only
Append only versions of std data structures
-
evidentsource-core
Core types for the EvidentSource event sourcing platform
-
hyphen-core
Canonical hyphen diagnostic logic — no_std + alloc compatible
-
fido-types
Shared types for the Fido social platform
-
vec-x
structure
VecXto manage fixed-length arrays, supporting numeric operations and assignment operations betweenVecXand scalar values -
moa_unsafe_list
Linux 风格侵入式双向链表
-
fplist
An immutable, persistent, singly-linked list
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
another_radix_trie
Rust built radix tree library
-
zond
standard rust collections but with collecting statistics
-
foyer-intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
prototty_menu
Prototty menus
-
hv-alchemy
Heavy Alchemy - the black arts of transmutation, wrapped for your safe usage and enjoyment
-
pg_filters
helper to generate postgres sql for pagination, sorting and filtering
-
passive
A trio of marker traits to classify passive data structures
-
grdf
Generalized RDF graphs and datasets
-
oxionnx-core
Core types for OxiONNX — Tensor, Graph, OpKind, Operator trait, and error types
-
bitarr
A fast and efficient Rust implementation of a BitSet, supporting multiple backing stores
-
global-registry
A global type registration system for Rust
-
prefix_tree_map
generic prefix tree (trie) map with wildcard capture support
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
boomphf-patched
Scalable and Efficient Minimal Perfect Hash Functions (version modified by Piotr Beling)
-
rand-select
a tiny choice selector
-
generational_array
A small package to handle generational arrays and prevent the ABA problem while reusing unused space
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
prefix-tree
A map and set interfaces using trie data structure
-
smallgraph
A small graph based on smallvec
-
varflags
exporting varflags macro, allowing to use unit-like enums in conjunction with Varflags struct to create easy to use bitflags data structure defined over enum variants
-
bounded
numeric types
-
prust-lib
Persistent & Immutable Data Structures in Rust
-
ecstatic
Statically-typed ECS library
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
tuplities-debug
A trait for debug formatting of tuples
-
simple_ringbuf
Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
disjoint-collections
Disjoint-set data structures
-
libreda-splay
Splay map and splay set data structures
-
get-full-year
An unofficial Rust client for getfullyear.com that helps you get the full year
-
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits-sized unsigned integer elements -
paft-aggregates
Aggregated info snapshots built on paft primitives
-
bittyset
A BitSet type for manipulating bit sets
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
unsure
handling unsure (optional) values that might fail, with an additional rejection variant
-
atelier_dcml
Distributed Convex Machine Learning for the atelier-rs engine
-
crtx-verifier
Pure independent-witness reducer for trusted release/compliance evidence (ADR 0041)
-
radyx
A basic radix tree implementation
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
kcr_rocketmq_apache_org
Kubernetes Custom Resource Bindings
-
restor
A dynamic resource storage system in rust
-
algods
A collection of data structures and algorithms
-
decoded-char
wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
combinations
give you all the combinations of values in a vec
-
kn0sys-ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
grit-bitvec
BitVec, a vector type that can store fixed-width data with irregular bit widths
-
final
Wrap a value in a type that does not give out mutable references
-
siebencorgie/jakar-tree
-
scoped_stack
A scoped stack data structure
-
pfx
A prefix tree (map and set), implemented without any unsafe
-
mapack
mapbox vector tiles
-
traitgraph-dimacs-io
Functions to read and write graphs in DIMACS format
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
cbor-tag-index
Tag index
-
default-vec
A specialized vector that has a default value
-
omega-meta-sona
Self-Optimizing Neural Architecture (META-SONA) with evolutionary search and fitness evaluation
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
fcsd
Front-coding string dictionary
-
splay
native implementation of a Splay Tree for Rust. Splay Trees are self-balancing binary search trees which adapt dynamically to lookups over time to allow common access patterns to frequently have better than log(n)…
-
div-int
Rational numbers with a compile-time denominator
-
cacheline-ef
Per-cacheline encoding of sorted integer sequences
-
avl-cont
A contiguous AVL Tree
-
ab-merkle-tree
High-performance Merkle Tree and related data structures (Merkle Mountain Range, Sparse Merkle Tree)
-
chtholly_tree
Rust bindings for Chtholly Tree
-
path-value
Universal type and access property(s) by path
-
nurku-rs_container
Derive macros for different kinds of containers
-
hubs
The horribly unsafe buffer structure
-
bl-range-set
working with range sets
-
more_collection_macros
Adds new macros to rust for creating collections
-
symbolfyi
Symbol encoding in 11 formats and Unicode property lookup — async API client for symbolfyi.com
-
vec_key_value_pair
A drop-in replacement for std::HashMap and std::HashSet that use Vec on the backend
-
nebz
an immutable non-empty bytes container
-
arboriter
A tree traversal primitive for Rust, inspired by Tyler Glaiel's blog post
-
worldinterface-core
Core domain types for WorldInterface: FlowSpec, IDs, Descriptor, Receipt
-
slotmap-fork-otter
Slotmap data structure - temporary fork for Otter
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
swamp-core-extra
Rust runtime implementations for Swamp core library collections (Vec, Map, Grid, Stack, etc.)
-
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
embedded-async-helpers
staticfriendly helpers for async on embedded -
cycle_map
Implementations of bi-directionally accessible hashmaps
-
broomdog
A type-erased map with 'indefinite loanership'
-
gpsd-json
parsing GPSD JSON protocol messages without dependencies on libgps
-
hashable_weak
A hashable weak pointer
-
stable_node_set
An ordered set with handles to values
-
Xorfilter
No alloc membership approximation
-
hashable-map
Wrappers for HashMap and HashSet that implement Hash
-
swaybar-types
building swaybar status commands in rust
-
timefyi
Timezone operations, business hours, and sunrise/sunset — async API client for timefyi.com
-
small-ord-set
A set data-structure represented by a sorted
SmallVec -
zbq-sys
SPMC zero-copy IPC queue
-
secured_linked_list
A cryptographically secured and provable linked list
-
qrcodefyi
QR code type reference, version lookup, and encoding encyclopedia -- async API client for qrcodefyi.com
-
anyval
A lightweight, dynamically‑typed value container for Rust that works like a scripting language
-
eclectic
Experimental collection traits
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
kd_interval_tree
Implements a K-dimensional interval tree, for fast interval-overlap lookup. Binary-tree based implementation, i.e. O(log(n)) lookups.
-
smolvec
A lightweight vector implementation with small-vector optimization for rust
-
armature-collab
Real-time collaboration with CRDTs and Operational Transformation for Armature framework
-
nslice
Structures for interpreting slices of variable length as arrays
-
mrkl
Generic, minimalist, parallelizable Merkle tree
-
byte_set
Efficient sets of bytes
-
two_three
A two-three (2-3) tree implementation in Rust. Includes a map and set interface
-
higher-graphen-interpretation
Domain interpretation packages, templates, mappings, projections, and lift adapters for HigherGraphen
-
distant-protocol
Protocol library for distant, providing data structures used between the client and server
-
beerfyi
Beer style guide with BJCP styles, hops, malts, and yeast — async API client for beerfyi.com
-
packbytes
Convert structures to and from packed representavises - byte arrays of fixed size that live on stack
-
littlechestnutgames-trie
A generalized trie implementation for quick prefix searching
-
no_vec
modifying sized arrays
-
fukurow-rules
Rule traits and constraint validation (SHACL equivalent) for Fukurow reasoning
-
skp-validator-actix
Actix Web integration for skp-validator - high-performance validation for Actix services
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
overlay-map
A two-layered map data structure for Rust that tracks current and previous values for each key — with zero-clone, in-place state transitions
-
front-vec
Efficiently-prependable Vec and String types
-
frp-weave
Graph weaving policy contracts for the frp domain layer
-
compressed_vec
Floating point and integer compressed vector library, SIMD-enabled for fast processing/iteration over compressed representations
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
kvv-efa-api
Rust bindings for the KVV (Karlsruher Verkehrs Verbund) "EFA"-API
-
quotient-filter
A quotient filter implementation
-
triskell
A tri-partite ring buffer
-
emojifyi
Emoji metadata, encoding, and Unicode Emoji 16.0 lookup — async API client for emojifyi.com
-
namefyi
Korean romanization, Five Elements, and CJK stroke lookup — async API client for namefyi.com
-
nodedb-crdt
CRDT engine with SQL constraint validation and dead-letter queue
-
ordered-map
A HashMap, with the capability of accessing the keys and values in order
-
wired
WIP: Collection of embeddable database models for Rust
-
fricgan
performing basic input and output on bytes
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
structbuf
Capacity-limited structured data buffer
-
skog
Adobe's stlab::forest data structure
-
portable-string
Static-length strings without any allocations
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
pi_slotmap_tree
A tree structure implemented by dense memory linked list
-
nfcfyi
NFC chip reference, NDEF type lookup, and contactless standard encyclopedia -- async API client for nfcfyi.com
-
autocomplete
Auto-complete feature using Trie data structure
-
tsil_cev
LinkedList on Vec
-
applejack
Radix tree
-
dot_tree
Create, query and store binary trees
-
trans-gen-dlang
Generating D trans code
-
dynamic-matrix
work with matrices
-
tinysearch-cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
local_vec
fixed-capacity vector allocated on the stack
-
ropey
A fast and robust text rope for Rust
-
tree-mapper
generating a hierarchical mapping of files and directories represented as a HashMap. The mapping reflects the directory structure and file levels, allowing for efficient retrieval and…
-
ism-ic-genc
ODNI IC-GENC schema package, vendored. Designed as a build-dependency for codegen. SHA-256 verified at compile time.
-
coglog-core
CogLog core library — data types, validation, and pure advance logic
-
contiguous_bitset
Stores a set of
bytemuck::Contiguousvalues encoded as bits -
collect-rs
Special and custom Collections and Containers (for Rust)
-
atomic_lifo
Lock free thread-safe lifo for rust
-
heapq
Priority Queue with scoring function
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
boost_concept_check
Boost C++ library boost_concept_check packaged using Zanbil
-
backtracking_iterator
generic iterator with an item history, capable of backtracking and forgetting
-
faultline_sync
Local-first synchronization models and operation envelopes for FaultLine
-
packed_array
Packed Array aka sparse set structure with compile-time known size
-
loaf
Why have a slice when you can have a loaf?
-
attuned-store
Storage traits and in-memory backend for Attuned
-
bytering
A ring buffer specialized for vectored reading and writing in blocking and async I/O
-
ix-id
Hash-based ID generation for Ixchel
-
ABtree
AVL and Btree for rust
-
segmented_array
Segmented array (growable, append-only) data structure
-
labelgraph
graph implementation, allowing random access to nodes via labels
-
aabel-identifier-rs
defines identifier behavior, such comparing them, or generating sequences of identifiers
-
iron_rose
Invertable Bloom Filters & Strata Estimators as found in https://www.ics.uci.edu/~eppstein/pubs/EppGooUye-SIGCOMM-11.pdf
-
zsling
Rust Wrapper around a Sequentially lockign (SeqLock) Ring Buffer written in Zig
-
rdf-reader
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
open-payments-iso20022-pain
Open Payments - Message Parsing Library - ISO20022 PAIN
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
contextual
deal with data in context
-
hedel-rs
A Hierarchical Doubly Linked List
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
indexland
Rust Collections with Newtype Indices
-
nimrodshn-btree
A persistent copy-on-write B+Tree implementation, designed as an index for a key-value store, inspired by SQLite
-
asimov-sdk
ASIMOV Software Development Kit (SDK) for Rust
-
bipbuffer
Simon Cooke's Bip-Buffer
-
seg-tree
segment tree library
-
extract_map
A HashMap for memory efficent storage of value types which contain their own keys
-
min-heap
A Min Priority Queue implemented as a Thin Wrapper around BinaryHeap from the Standard Library
-
bit-vec-omnitool
A vector of bits
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
enum-ref
Proc. macro for generating enum discriminant types.
-
cbsk_log_rayon
log tool, using tokio as the runtime
-
arrowmax
High-performance Arrow data stack: columnar storage, zero-copy streaming, and schema codegen
-
wasefire-slice-cell
Slice with dynamic borrow checking
-
b100m-filter
The fastest bloom filter in Rust. No accuracy compromises. Use any hasher.
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
weak-lists
Lists with weak references and concurrent iteration and modification
-
kcr_dataprotection_kubeblocks_io
Kubernetes Custom Resource Bindings
-
memcell
providing a MemoryCell struct, which stores a current and previous value
-
pathtree
An immutable tree data structure for fast path operations
-
distri-a2a
A2A protocol types for the Distri ecosystem
-
streamhist
streaming histogram
-
a2ui-validation
JSON Schema validation engine for A2UI protocol messages
-
sesstype
Multiparty Session Types
-
key_set
KeySet representing concepts of All, None, Some(list), and AllExceptSome(list), with basic set calculations (intersection, difference, inverse)
-
shelves
Storing values referenced by a unique typed index
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
workit
single-threaded work queueing utility
-
simple-collection-macros
configurable macros for maps and sets
-
hydroperx-sem
Semantic entities for Rust
-
fionn-crdt
CRDT implementations for fionn
-
spigal
fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
flat_enum
Expand nested enum into flattened enum
-
caffeine
Collection of data structures I'm writing for fun. Originally written for use with my crafting interpeters tutorial implementation.
-
either-both
An enum similar to the well-known
Either, but with aBothvariant -
tiny-bitstream
Standard implementation of a classic bitstream library
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
staticstep
truly zero-cost alternatives to
Iterator::step_byfor both incrementing and decrementing any type that satisfiesRangeBounds<T: Copy + Default + Step> -
crio
An easy to use persistent data storage library
-
dogged
Persistent vector, similar to Clojure
-
frbf
robust, and efficient implementation of the Bloom Filter data structure in Rust
-
blefyi
Bluetooth Low Energy chip reference, GATT profile lookup, and beacon encyclopedia -- async API client for blefyi.com
-
const-size-flatten
Flatten and FlatMap with constant inner iterator size
-
language-objects
Work with language objects for localization
-
lurk-elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
file-mumu
File handling function and steams plugin for the Lava language
-
merged_range
rangeset that can merge overlap
-
lookups
Improve the data retrieval operations for collections
-
pgat
Proxy GAT: Abstractions for generic proxy views with GAT to enable generic container types
-
an-rope
an rope for large text documents
-
bloom_filter_plus
rust_bloom_filter
-
index-map
A map with automatically generated usizes as keys
-
jsonmap
store values of multiple types value in one Map
-
no_std_collections
Auxiliary structures and traits for using dynamically resizable arrays (Vectors) in flexible environments, supporting both std and no_std contexts
-
collidea
Collision-prone memory-efficient collections
-
tagged-tree
A tree-like data structure where the values are tagged
-
types
Shared types and DTOs for the Liturgy workspace
-
inline-str
Efficent and immutable string type, backed by inline-array
-
kvstructs
General basic key-value structs for Key-Value based storages
-
planspec-core
Core types and validation for PlanSpec declarative work orchestration
-
pollination
An experimental library exposing hybrid Raft and CRDT primitives
-
blocked-vec
A vector of byte blocks behaving like files
-
linkedin-csv
Structs defined to hold the data as exported from LinkedIn
-
treelike
A trait to abstract over trees, and simplify implementing them, all in one handy crate
-
loaned
Safely move values with live inner borrows
-
mattbusel-mem-graph
Knowledge graph primitives: entities, relationships, typed properties, BFS/DFS traversal
-
simple-vec-collections
Collections implemented using Vec
-
indextreemap
A BTreeMap implementation that allows for key and or positional insertion and retreival
-
modern-multiset
A hash multiset implementation
-
num-bigint
Big integer implementation for Rust
-
scratchbuffer
A Vec<u8> like data-structure, that can be used as slices of different types
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
usize-set
Set data structures optimized to store sparsely distributed usize values
-
altdeque
An alternative deque implementation
-
runar-schemas
Protobuf schema types for Runar (ServiceMetadata, etc.)
-
twie
fast and compact prefix tries
-
merkle-log
"Merkle Tree-Structured Log" defined in the paper "Transparent Logs for Skeptical Clients." https://research.swtch.com/tlog
-
pbloom
A portable bloom filter implementation in Rust
-
mumu-array
Array tools plugin for the MuMu/Lava language
-
mux-radix-tree
A full-featured radix tree implementation
-
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
flat_map
A compact map stored as a vector of key, value pairs
-
variant-map
defines maps to store variants of enums
-
objectionable
storage of unsized types inline inside allocated objects
-
merkl-redb
MerkleTree, embedded friendly implementation with redb backend
-
rubbl_visdata
Preliminary work on generic data structures for radio interferometric visibility data
-
teafyi
Tea variety guide with brewing parameters and teaware — async API client for teafyi.com
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
lesbar-text
String extensions and queries for legible text
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
know_yaml
The KNOW Framework for Rust
-
xsd
XSD.rs
-
ensf594-project-mmap
Final project for the ENSF 594 course of the University of Calgary, summer 2022
-
microstr
Stack-allocated string with fixed capacity
-
bit-set-omnitool
A set of bits
-
trie-generic
A trie with generic content
-
atom_table
Assign easy-to-handle typed IDs to large, hard to handle things like strings
-
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
fast-list
A doubly linked list using SlotMap for improved cache locality, and to solve the ABA problem
-
eureka-mmanager-core
The core package for the eureka-mmanager crate
-
nostd-bv
Bit-vectors and bit-slices
-
structures
collection data structures
-
nsrb
Nifty Simple Ring Buffer (aka circular buffer) is a no_std library that provides 2 macros to easily create fixed circular buffer on the stack
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
kcr_instana_io
Kubernetes Custom Resource Bindings
-
lighter
Macro for rewriting string matches as tries
-
fpdec-core
Common constants and functions for crate fpdec
-
deep-diff
A small crate to deeply diff serde_json::Value trees
-
bitmac
Structure for accessing to single bits
-
fixed-collections
Dynamically allocated ungrowable collections
-
bloomy
Bloom filter using only two hash functions
-
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
hashvec
A HashMap/Vector hybrid: efficient, ordered key-value data storage
-
tzarrays
Optimal resizable Arrays
-
gauze
Probabilistic set membership filters with a simple interface
-
const_queue
A stack-only, no_std queue using const generics
-
json_to_struct
Convert JSON into Rust structs for efficient and type-safe data management
-
running_buffer
data types for keeping track of changing values, allowing analysis in trends and histories
-
cobt
A Cache-Oblivious B-Tree implementation in Rust
-
fontfyi
Google Fonts metadata, CSS generation, and font pairing — async API client for fontfyi.com
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
abstract-bits
Turn any combination of bit and byte fields into a structs
-
prefix_dictionary
Data structure similar to a dictionary, but enabling search for prefixes
-
ascii_num
digit to ascii numbers
-
typed_id
Make your IDs strongly typed!!
-
phago-viz
Browser-based real-time visualization for Phago colonies
-
copy-range
core::ops::Range et al, but Copy and IntoIterator
-
compactmap
Compact Vec-based map that choses assigns IDs for your values on it's own. Very similar to Slab.
-
eitherq
Queue which support two different types
-
slotmap_fork_lmondada
Slotmap data structure
-
bytes-quilt
data structure for tracking random-access writes to a buffer
-
tokmd-types
Core data types and contracts for tokmd. Tier 1 stability.
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
automatic-relations
Tree automatic relations
-
jmt-blake3
Jellyfish Merkle Tree based on BLAKE3 hash function
-
nanobox
NanoBoxoptimization: store small item on stack and fallback to heap for large item -
open-payments-fednow
Open Payments - Message Parsing Library - FedNow
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
dyn_list
A linked list that can hold dynamically sized values in its nodes
-
mapro
A tiny macro library for creating std::collections
-
dcbor
Deterministic CBOR ("dCBOR") for Rust
-
seq-set
A Set collection that maintains insertion order
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
compressed-sparse-fiber
Compressed sparse fiber implementation for Rust
-
bstree
A Binary Search Tree written in Rust
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
data_privacy_macros_impl
Macros for the data_privacy crate
-
cbsk_unique
unique value generator
-
num-bigint-dig
Big integer implementation for Rust
-
omega-agentdb
Advanced vector database with ruvector integration for agent storage and skill management
-
static-box
A stack-allocated box that stores trait objects
-
higher-graphen-evidence
Evidence, confidence, causal, and prover bridge records for HigherGraphen
-
rope_rd
A Read/Seek rope implementation
-
offset-views
Create and index offset views of arrays, slices, strings, etc
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
unitfyi
Unit conversion across 220 units and 20 categories — async API client for unitfyi.com
-
ttl-queue
A queue that drops its content after a given amount of time
-
crtx-reflect
Reflection orchestration, prompts, candidate parsing, and schema validation
-
armory
a fast pool for storing lots of objects of one type without fragmenting
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
faultline_compute
Execution backend abstractions for FaultLine
-
fusefilter
No alloc membership approximation
-
schema-registry-core
Core types and traits for the LLM Schema Registry platform
-
compressed_map
'Static functions': compressed maps with the keys removed
-
container_traits
Traits for container types
-
kn0sys_ndarray_rand
Constructors for randomized arrays.
randintegration forndarray. -
btree_network
A generic network (undirected graph) data structure
-
fral
Functional random-access lists
-
bitset-matrix
Space-efficient, row-major 2D bitset matrix with fast bitwise ops
-
vector2
2D vector library
-
hj_ds
A data structure library for Rust
-
vec-2-10-10-10
A 32-bit vector, where 2 bits are dedicated for alpha, and 30 bits are dedicated for color. Compatible with GL_UNSIGNED_INT_2_10_10_10_REV vertex attribute format.
-
schema2struct
Convert a JSON schema into Rust structs for efficient and type-safe data management
-
identifier
Generate 128 bits id structs easily
-
std_collection_traits
Abstraction of operations in std collection types
-
tuco
Tuco can automatically generate tuple representations of simple types. This is helpful if you want to create an API using plain types. Or if you want to provide an easy way to convert between types.
-
zkcg-zkvm-host
host for zkvm
-
enid
parse Encrypted Numeric Identifiers
-
tree-mumu
Creates Linux
tree-style renderings of MuMu values -
tuplities-flatten-nest
Traits for flattening nested tuples and nesting flat tuples
-
vector_mapp
A Vec based map
-
latestmap
latest map
-
typerat
Type-level rational numbers based on
typenum -
treaplist
A Treap-based list implementation
-
faultline_diff
Diff and change classification contracts for FaultLine
-
bloomfilter-rust
A bloomfilter implementation in Rust
-
tinybitset
Generic implementation of small, fixed size, copyable bitsets
-
dlist
List data structure based on AVL tree. It can store elements which have dimension and quickly search for elements by distance from 0.
-
dcl_data_structures
Moved to: https://crates.io/crates/deep_causality_data_structures
-
trans-gen-python
Generating Python trans code
-
rdf-query
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
banyan-utils
work with banyan trees
-
borsa-core
Core types, connector traits, and time-series utilities for the borsa financial data ecosystem
-
timed_set
timed set in Rust to store elements for a given time period
-
any_key
Dynamically typed keys for associative arrays
-
output_iter
An iterator that performs calculation during iteration
-
deqmap
A double-ended queue with optional keys
-
dst-container
Containers for DST objects
-
rotbuf
Queue implementation wrapped around the
Bytescrates’ BytesMut data structure -
variant-set
A set-like data structure for enum variants, allowing you to store at most one value for each variant of an enum
-
anylist
a list type for any type
-
flashtext
algorithm to search and replace keywords in given text
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
learn_together
Curated collection of lists of useful resources to learn Rust together
-
no-order
A transparent wrapper to ignore ordering and hashing of any value
-
rand_map
A map that creates a random handle on insertion to use when retrieving
-
maybe
An enum similar to Option but can also represent undefined values
-
rust_list
Singly linked list in Rust, with macros for easy instantiation
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
swimos_errors
SwimOS Error Utilties
-
mini-linked-list
A package containing a minimal i32 LinkedList implementation
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
attuned-qdrant
Qdrant storage backend for Attuned
-
kcr_volsync_backube
Kubernetes Custom Resource Bindings
-
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
rshyper-core
implements the core functionality of rshyper, focusing on providing the essential components that compose a hypergraph
-
cons-rs
containing a Cons data structure
-
delete_if_not
unsafely in-place delete function
-
rs-collections
generic collections (no dependency on std)
-
treers
Sedgewick's tree maps
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
fixedbitset-stack
A forked version of FixedBitSet that supports const generics
-
bit-vec_serde
A vector of bits
-
kcr_quay_redhat_com
Kubernetes Custom Resource Bindings
-
bloomz
A fast, flexible Bloom filter library for Rust with parallel operations support
-
drinkfyi
Beverage encyclopedia hub for cocktails, wine, beer, and more — async API client for drinkfyi.com
-
hashtree
A Merkle Tree implementation in Rust
-
bittree
O(1) find functions in a special data structure called a bit tree
-
paged
Read and create read-only paged database files
-
shared-vec
Efficient shared container types
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
bugu
Cuckoo Filter: Practically Better Than Bloom
-
collect
An experimental extension of std::collections
-
sakurai
Performant, general-purpose data structures
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
indextree-ng
Arena based tree structure by using indices instead of reference counted pointers. Fork of indextree by Sascha Grunert which allows to remove nodes
-
unrolled-linked-list
unrolled linked list in rust
-
skip-list
Implementing a skip list with rust
-
pgdb_to_struct
CLI application to generate Rust struct files from PostgreSQL database tables
-
btree_graph
A generic graph data structure
-
bs
bitset with small-set (single-word) optimization
-
arbutus
Trees
-
mqfilters
Highly optimized approximate membership query filters (bloom, cuckoo, xor, quotient) with SIMD support
-
wolf-graph
Data structures and algorithms for working with graphs with reference or value semantics
-
pointer_vec
The PointerVec works same as the std Vec structure except the Vec has a size of 3 usize (pointer, length, capacity). This crate provides a replacement that has a size of 1 pointer.
-
deferred_vector
A deferred vector implementation
-
uvector
access two slices as a single continuous vector
-
unicodefyi
Unicode character lookup with 17 encodings — async API client for unicodefyi.com
-
just-string
Container for various kinds of strings
-
nexum
collection of commonly used data structures
-
sketches
Probabilistic data structures for scalable approximate analytics
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
ctxmap
A collection that can store references of different types and lifetimes
-
associative_positional_list
AssociativePositionalList is a list-like container in which each value is associated with an index, but unlike other list containers, the index for a value can be determined efficiently
-
graff
manipulating graphs
-
bitbloom
A no_std Bloom filter implementation
-
gguppy_data
Traits and adapters used by gguppy for dataframe access
-
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
shared_bytes
Owned string and byte slices
-
terrain-graph
Graph Library for Rust
-
mrslac
sparse matrix data structures
-
minimizer-queue
Fast computation of minimizers using a monotone queue
-
bitsetium
One stop shop for all bitset needs
-
mmap_json_file
parse, count, filter JSON files using memory mapped io library
-
ati
Introduces the
Attrait, which allows collections to be indexed byu|i{8,16,32,64,128}andisize. Supports Python-like negative index, where -1 is last element. -
stonks
Sets that allow borrowing while inserting entries
-
lesbar
String types that must encode legible text
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
specado-schemas-temp
Provider and prompt schema validation helpers for Specado
-
bitstr
contiguous sequence of bits in memory
-
rs-bush
Bush data structure
-
object-chain
Ad-hoc structure builder
-
semx_unsafe_list
Linux 风格侵入式双向链表
-
tourney
A small package for generating and simulating tournaments of various structures
-
tree-automata
Term Rewriting Systems
-
typeslice
type-level slices
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
test-mumu
Test suite plugin for the Lava language
-
circularbuf
Rust fixed size circular (ring) buffer
-
higher-graphen-projection
Projection definitions, selectors, results, and renderers for HigherGraphen
-
boost_date_time
Boost C++ library boost_date_time packaged using Zanbil