-
hashbrown
port of Google's SwissTable hash map
-
indexmap
A hash table with consistent order and fast iteration
-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
phf
Runtime support for perfect hash function data structures
-
roaring
A better compressed bitset - pure Rust implementation
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
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
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
bit-set
A set of bits
-
slotmap
data structure
-
tinystr
A small ASCII-only bounded length string representation
-
bimap
Bijective maps
-
rpds
Persistent data structures with structural sharing
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
ego-tree
Vec-backed ID-tree
-
enumset
creating compact sets of enums
-
modular-bitfield
Easily define bitfield types with modular building blocks
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
yrs
High performance implementation of the Yjs CRDT
-
skiplist
in Rust for fast insertion and removal, including a normal skiplist, ordered skiplist, and skipmap
-
faststr
string library that reduces the cost of clone
-
intaglio
UTF-8 string and byte string interner and symbol table
-
ecow
Compact, clone-on-write vector and string
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
generator
Stackfull Generator Library in Rust
-
croaring
Rust wrapper for CRoaring
-
bitmaps
Fixed size boolean arrays
-
bit-vec
A vector of bits
-
smartstring
Compact inlined strings
-
rowan
generic lossless syntax trees
-
range-set-blaze
Integer sets as fast, sorted integer ranges; Maps with integer-range keys; Full set operations
-
fixedbitset
bitset collection
-
jaq-json
JSON values for jaq
-
nonempty-collections
Correct-by-construction non-empty collections
-
linked_hash_set
HashSet with insertion ordering
-
ringbuffer
A fixed-size circular buffer
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
bloomfilter
Bloom filter implementation
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
dary_heap
A d-ary heap
-
radix_trie
Generic radix trie data-structure
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
cordyceps
Mycelium intrusive data structures
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
intmap
Specialized HashMap for integer keys
-
iddqd
Maps where keys borrow from values, including bijective and trijective maps
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
smallstr
String-like container based on smallvec
-
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. -
xorf
implementing xor filters - faster and smaller than bloom and cuckoo filters
-
ndarray-stats
Statistical routines for the n-dimensional array data structures provided by ndarray
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
thin-vec
A vec that takes up less space on the stack
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
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
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
lsm-tree
A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)
-
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.
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
egg
egraphs
-
im
Immutable collection datatypes
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
array-init
Safe wrapper for initializing fixed-size arrays
-
bitfield-struct
Struct-like procedural macro for bitfields
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
cardinality-estimator
estimating the cardinality of distinct elements in a stream or dataset
-
slice-dst
Slice-based custom DSTs
-
fastbloom
The fastest Bloom filter in Rust. No accuracy compromises. Full concurrency support and compatible with any hasher.
-
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
-
hashbag
An unordered multiset implementation using a hash bag
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
micromap
The fastest alternative to HashMap, for maps smaller than 20 keys
-
gix-hashtable
that provides hashtable based data structures optimized to utilize ObjectId keys
-
boa_interner
String interner for the Boa JavaScript engine
-
ph
data structures based on perfect hashing
-
weak-table
Weak hash maps and sets
-
cita_trie
Modified Patricia Tree (aka Trie)
-
orx-split-vec
An efficient dynamic capacity vector with pinned element guarantees
-
space
providing abstractions for spatial datastructures and search
-
datalogic-rs
A fast, type-safe Rust implementation of JSONLogic for evaluating logical rules as JSON. Perfect for business rules engines and dynamic filtering in Rust applications.
-
newtype-uuid
Newtype wrapper around UUIDs
-
i24
working with 24-bit integers
-
smallbitvec
A bit vector optimized for size and inline storage
-
equivalent
Traits for key comparison in maps
-
spade
Delaunay triangulations for the rust ecosystem
-
str-buf
Static string buffer
-
orx-priority-queue
Priority queue traits and high performance d-ary heap implementations
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
qfilter
Efficient bloom filter like datastructure, based on the Rank Select Quotient Filter (RSQF)
-
tick
primitives to interact with and manipulate machine time
-
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…
-
typed_floats
Types for handling floats with type checking at compile time
-
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
smallbox
Small Boxoptimization: store small item on stack and fallback to heap for large item -
crop
A pretty fast text rope
-
string
A UTF-8 encoded string with configurable byte storage
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
opentelemetry-resource-detectors
A collection of community supported resource detectors for OpenTelemetry
-
i256
Optimized implementations of 256-bit signed and unsigned integers
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
ohno
High-quality Rust error handling
-
miniconf
Serialize/deserialize/access reflection for trees
-
range-collections
Sets and maps of ranges, backed by smallvec
-
arrow-digest
Stable hashes for Apache Arrow
-
vart
An immutable versioned adaptive radix trie
-
nexus-ascii
Fixed-capacity ASCII strings for high-performance systems
-
iroh-metrics
metrics for iroh
-
orx-tree
A beautiful tree 🌳 with convenient, efficient, parallelizable growth, mutation and traversal features
-
indexset
A two-level BTree with fast iteration and indexing operations
-
vers-vecs
A collection of succinct data structures supported by fast implementations of rank and select queries
-
fqdn
FQDN (Fully Qualified Domain Name)
-
zerofrom
trait for constructing
-
tree_iterators_rs
built to provide you with the iterators to easily work with tree data structures in Rust
-
bytes-utils
Additional utilities for working with the bytes crate
-
lean_string
Compact, clone-on-write string
-
imbl
Immutable collection datatypes
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
typemap_rev
A hashmap, but stores types as keys
-
csaf-walker
work with CSAF data
-
ordinal-map
Ordinal trait to map values to integers and efficient maps and sets for such types
-
array-macro
Array multiple elements constructor syntax
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
intervaltree
generic implementation of an immutable interval tree
-
modql
Model Query Language support
-
portgraph
Data structure library for directed graphs with first-level ports
-
blobby
Iterator over simple binary blob storage
-
quantities
Unit-safe computations with quantities
-
grid
Dynamic generic 2D data structure
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
datasketches
A software library of stochastic streaming algorithms (a.k.a. sketches)
-
phf_generator
PHF generation logic
-
vecmap-rs
A vector-based map and set implementation
-
cc-traits
Common collection traits
-
btree-range-map
B-tree range map implementation
-
blart
adaptive radix tree packaged as a BTreeMap replacement
-
log-once
Collection of helper macros for logging some events only once
-
vec_map
map based on a vector for small integer keys
-
seatbelt
Resilience and recovery mechanisms for fallible operations
-
small_btree
that add SmallBTreeMap data structure
-
byteview
Thin, immutable zero-copy slice type
-
narrow
Apache Arrow
-
grovedb-path
Path extension crate for GroveDB
-
nodit
Discrete Interval Tree Data-Structures, which are based off BTreeMap
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
timed-map
Lightweight map implementation that supports expiring entries and fully compatible with both std and no_std environments
-
oxiblas-matrix
Matrix types and views for OxiBLAS
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
short-uuid
generate and parse short uuids
-
qwt
Quad Wavelet Tree
-
open-payments-iso20022-acmt
Open Payments - Message Parsing Library - ISO20022 ACMT
-
interavl
An optimised interval tree for efficient interval stabbing
-
ringmap
A hash table with consistent deque-like order and fast iteration
-
uwheel
Embeddable Aggregate Management System for Streams and Queries
-
sucds
Succinct data structures in Rust
-
slotmap-careful
Wrap the slotmap crate and prevent key reuse
-
snowflake_me
A distributed unique ID generator inspired by Twitter's Snowflake
-
calimero-storage
Core Calimero infrastructure and tools
-
fast_radix_trie
Memory-efficient trie data structures based on radix tree
-
redactable
Automatic redaction of sensitive data in structs for safe logging and debugging
-
dogma
Named,MaybeNamed,Labeled,MaybeLabeled,Collection, andCollectionMuttraits -
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
uuid-rng-internal
Private implementation details of the uuid crate
-
ankurah-storage-common
Ankurah storage engine common libraries
-
collection_tools
General purpose tools to manipulate collections( containers like Vec/HashMap/HashSet )
-
saorsa-gossip-crdt-sync
Delta-CRDTs for Saorsa Gossip: OR-Set, LWW-Register with anti-entropy sync
-
static-files
help automate static resource collection
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
cranelift-entity
Data structures using entity references as mapping keys
-
range-set
Smallvec-backed containers of sorted integer ranges
-
pfds
Purely Functional Data Structures
-
submap
B-Tree map for pub/sub services
-
llm_models_spider
Auto-updated registry of LLM model capabilities (vision, audio, etc.)
-
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…
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
miyabi-types
Core type definitions for Miyabi - Autonomous AI Development Operations Platform
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
bitm
bit and bitmap (bit vector) manipulation
-
las
Reads and writes point clouds stored in the ASPRS las file format
-
soa-rs
A Vec-like structure-of-arrays container
-
sync-ptr
Sync & Send wrappers for raw pointer's and function pointers in rust
-
validit
Validate data structures internal state
-
keyvi
key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
circular-queue
A circular buffer-like queue
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
bitflag-attr
A macro to generate bitflags structures from C-like enums
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
rsmarisa
Pure Rust port of marisa-trie: a static and space-efficient trie data structure
-
algorithm
about algorithm data structure, now has ttl with lru/lru-k/lfu/arc and slab/rbtree/roaring_bitmap/timer_wheelss, 关于算法常用的数据结构
-
tensorlogic-adapters
Symbol tables, axis metadata, and domain masks for TensorLogic
-
bridgetree
A space-efficient Merkle tree designed for linear appends with witnessing of marked leaves, checkpointing & state restoration
-
cdg_api
interact with api.congress.gov
-
xml-builder
Easy and highly-configurable XML builder/writer
-
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
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).
-
linearize
Types that are enumerable and an array-backed map
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
reactive_stores
Stores for holding deeply-nested reactive state while maintaining fine-grained reactive tracking
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
basic_trie
Trie implementation in Rust
-
rvf-types
RuVector Format core types -- segment headers, enums, flags
-
ftree
A very fast fenwick tree implementation
-
rust_dynamic
Support for dynamically-typed values in run-time
-
cgp
Main crate for using context-generic programming
-
merkl
MerkleTree, embedded friendly implementation
-
packedvec
Store vectors of integers efficiently
-
bytes-str
A string type that is backed by bytes crate
-
json-number
JSON number parsing and storage
-
pumpkin-conflict-resolvers
The conflict resolvers of the Pumpkin constraint programming solver
-
pstd
parts of Rust std library ( different implementations, features not yet stabilised etc )
-
lru-slab
Pre-allocated storage with constant-time LRU tracking
-
enum-table
creating tables with enums as key
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
itybity
An itty bitty crate providing bit iterators and bit iterator accessories
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
pathmap
A key-value store with prefix compression, structural sharing, and powerful algebraic operations
-
oxirs-vec
Vector index abstractions for semantic similarity and AI-augmented querying
-
crdt-lite
A lightweight, column-based CRDT implementation in Rust
-
snowid
generating SnowID - a Snowflake-like timestamp-based distributed unique identifier
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
value-ext
Serde Json Value Extension Trait and Json Utilities
-
synheart-flux
On-device compute engine for HSI-compliant human state signals
-
deferred-map
High-performance generational arena using handle-based deferred insertion with O(1) operations
-
sql-json-path
SQL/JSON Path implementation in Rust
-
gpt_disk_types
GPT (GUID Partition Table) disk data types no_std library
-
bitwheel
High-performance fixed capacity timer wheel
-
tag_ptr
that enables a pointer to be associated with a tag of type
usize -
sparse_set_container
A container based on sparse set. Stable keys, O(1) lookup, cache-friendly iterations, and no hashing.
-
embed-collections
A collection of memory efficient and intrusive data structures
-
data_privacy
Data annotation and redaction system providing a robust way to manipulate sensitive information
-
xot
Full-featured XML tree library for Rust
-
know
Framework for Rust
-
xgx_intern
A high-performance, Hash-based value interner with custom handle types
-
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.
-
smol_bitmap
A space-efficient bitmap with inline storage optimization for small bitmaps
-
jsonata-core
High-performance Rust implementation of JSONata query and transformation language
-
cueue
High performance SPSC circular byte buffer with batch operations
-
ck-core
Core types and utilities for ck semantic search tool
-
nybbles
Efficient nibble-sized (4-bit) byte sequence data structure
-
dup-indexer
Create a non-duplicated index from Strings, static str, Vec, or Box values
-
spart
A collection of space partitioning tree data structures for Rust
-
kotoba-graph
High-performance graph data structures for Kotoba graph processing system
-
id_tree
creating and modifying Tree structures
-
merkletree
Light merkle tree implementation with SPV support and dependency agnostic
-
ordered_hash_map
HashMap which preserves insertion order
-
trie-root
In-memory patricia trie operations
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
bloom2
Fast, compressed, 2-level bloom filter and bitmap
-
awint
Arbitrary width integers
-
entity_data
A container for entity component data
-
xmltv
electronic program guide (EPG) parser and generator using serde
-
nary_tree
A vec-backed tree structure with tree-specific generational indexes
-
trees
General purpose tree data structures
-
exint
generic signed and unsigned integers
-
kcr_apps_kubeblocks_io
Kubernetes Custom Resource Bindings
-
alimentar
Data Loading, Distribution and Tooling in Pure Rust
-
ordered-multimap
Insertion ordered multimap
-
mzpeaks
representing peaks in mass spectrometry data
-
rsf-cli
Ranked Spreadsheet Format - Deterministic column ordering based on cardinality
-
hexser
Zero-boilerplate hexagonal architecture with graph-based introspection
-
stacked_errors
high level error propogation with software controlled backtraces
-
stac-server
SpatioTemporal Asset Catalog (STAC) API server
-
idlset
Fast u64 set operations library
-
xsd-types
XSD data types
-
doubloon
Money datatype that supports both statically and dynamically typed currencies
-
grovedb-version
Versioning library for Platform
-
segment-array
Segment array (growable, append-only) data structure
-
const-secret
A
no_stdcrate for compile-time encrypted secrets -
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
sparsevec
Compress vectors using row displacement
-
tskit
rust interface to tskit
-
among
The enum
Amongwith variantsLeft,MiddleandRightis a general purpose sum type with three cases -
octaindex3d
3D Spatial Indexing and Routing System based on BCC lattice with truncated octahedral cells
-
bytesbuf
Types for creating and manipulating byte sequences
-
wordvec
A compact
SmallVec<T>-like container with onlyalign_of::<T>()overhead for small stack-only instances -
fixed_deque
A fixed size VecDeque to match Python Deque
-
ndstruct
Structures for N-dimensions
-
bin_file
Mangling of various file formats that conveys binary information (Motorola S-Record, Intel HEX, TI-TXT and binary files)
-
uluru
fast, LRU cache implementation
-
ddsketchy
DD Sketch in Rust
-
merkql
Embedded event log with Kafka-compatible semantics and merkle tree integrity verification
-
aisle
Metadata-driven Parquet pruning for Rust: Skip irrelevant data before reading
-
robin-sparkless
PySpark-like DataFrame API in Rust on Polars; no JVM
-
delay_map
HashMap collections whose entries expire after a given time
-
orn
A generic implementation of a sum type (or discriminated union). It provides
enum Or<T1, T2, ..., N>types as a counterpart to tuples. -
count-min-sketch
Count-min-sketch implementation
-
dlv-list
Semi-doubly linked list implemented using a vector
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
succinctly
High-performance succinct data structures for Rust
-
forge-manifest
Hierarchical capability manifest for Code Mode tool discovery
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
boomphf
Scalable and Efficient Minimal Perfect Hash Functions
-
bitvec_helpers
BitVec based bitstream reader and writer
-
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… -
lib-sokoban
Sokoban: compact, efficient data structures packed into contiguous byte arrays
-
cow_vec
A vector-like container optimized for efficient cloning with copy-on-write semantics
-
frozen-collections
Fast partially-immutable collections
-
matreex
matrix implementation
-
spacetimedb-data-structures
Assorted data structures used in spacetimedb
-
i_shape
iShape is a compact and efficient library specifically designed for representing 2D data structures using IntPoint
-
smartbuf
A high-performance buffered reader with background thread pre-fetching and full seek support
-
vibe-graph-core
Core domain model for the Vibe-Graph neural OS
-
worktable
in-memory storage
-
flighthook
event bus types and schemas
-
moduforge-transform
不可变数据结构与事务系统基础
-
thread_aware
Facilities to support thread-isolated state
-
compressed-intvec
Space-efficient integer vectors for Rust. Offers a fixed-width implementation for O(1) mutable and atomic access, and a variable-width implementation that uses instantaneous codes and…
-
rustdf
interacting with Bruker TDF formatted Raw Data
-
generic_singleton
allowing for generic singleton patterns
-
cow_hashbrown
port of Google's SwissTable hash map with copy-on-write support
-
netcrab
creating and exporting Petri nets
-
toml-query
work with toml::Value objects more conveniently
-
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… -
plain_trie
Classic trie implementation capable of mapping any T to char iterator
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
router_prefilter
Fast prefix-based prefiltering for router pattern matching
-
mutaig
Mutable AIGs designed for equivalence checking
-
array-concat
Macros for concatenating const arrays
-
easy-tree
efficient tree structure library for Rust with recursive traversal
-
pi_append_vec
Only supports append vectors, lock free
-
fides
cryptographic primitives
-
indexical
indexed collections
-
meminterval
interval-tree in Rust made to store memory mappings
-
im-lists
Persistent unrolled linked lists and vlists
-
edtui-jagged
A jagged array data structure for the edtui editor
-
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.
-
small-collections
A collection of data structures optimized for small-buffer scenarios that reside on the stack and seamlessly spill to the heap
-
trit-vsa
Balanced ternary arithmetic library with bitsliced storage and VSA operations
-
xml2arrow
Efficiently convert XML data to Apache Arrow format for high-performance data processing
-
xtri
A fast, memory-efficient radix tree (compressed trie) implementation in Rust with UTF-8 support
-
avila-atom
Atomic computational structures - Option, Result, Vec, HashMap built from nucleus
-
instructors
Type-safe structured output extraction from LLMs. The Rust instructor.
-
paginator-rs
Pagination trait for Rust collections
-
rart
High-performance Adaptive Radix Tree implementation with SIMD optimizations
-
kcr_operator_tigera_io
Kubernetes Custom Resource Bindings
-
bacnet-emb
A bacnet library for embedded systems (no_std)
-
seoul
trait Isomorphism
-
relastic
lib inspired by Serilog for application-wide logging to Elastic
-
tetengo_trie
A trie library implemented with a double array
-
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… -
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
wavltree
An intrusive Weak AVL Tree
-
xor_name
Xor Type
-
fastset
Fast set implementation for dense, bounded integer collections, optimized for quick updates and access
-
kbd
Pure-logic hotkey engine — key types, modifier tracking, binding matching, layer stacks, sequence resolution. No platform dependencies.
-
domain-key
High-performance, domain-driven, type-safe key system for Rust
-
apollonius
N-dimensional Euclidean geometry for Rust: points, vectors, lines, segments, hyperspheres, hyperplanes, AABBs, triangles, and a unified intersection API—all with const generics
-
vectree
Vector-buffered tree collection with pre-/post-order, depth-first, mutable/immutable iterator
-
tinyset
Size-optimized sets
-
zed-sum-tree
A sum tree data structure, a concurrency-friendly B-tree
-
mesh-sieve
Modular, high-performance Rust library for mesh and data management, designed for scientific computing and PDE codes
-
html-mumu
HTML manipulation and tools plugin for the Lava/MuMu language
-
rpds-pathtree
Immutable, path-addressable tree data structure
-
btree-vec
A growable array (vector) implemented using a B-tree
-
sized-chunks
Efficient sized chunk datatypes
-
iset
Map and set with interval keys (x..y)
-
hi_sparse_bitset
Hierarchical sparse bitset. Incredibly high performance. Compact memory usage.
-
defaultmap
HashMap with an automatic default for missing keys
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
sundo
Snapshot-based undo/redo library with support for persistent data structures
-
rsdict
Fast static rank and select data structure
-
beach_map
slotmap
-
undoredo
Delta-based undo-redo decorator for collections such as HashMap, BTreeMap, StableVec, thunderdome::Arena, rstar::RTree. No need to implement commands.
-
rust-hll
HLL that is compatible with the Aggregate Knowledge HLL Storage Spec
-
cooklang-find
finding and managing Cooklang recipes in the filesystem
-
champ-trie
Persistent hash map based on CHAMP — canonical form, O(1) structural equality via AdHash, COW structural sharing
-
eytzinger-interpolation
Eytzinger array layout with interpolative search support
-
flex_array
A
#[no_std]flexible array much like std::Vec but with custom indices and length and capacity types -
bounded_graph
A thin newtype wrapper for
petgraphto assist in the creation of graphs with restrictions on their edges -
differential-dogs3
Advanced join patterns in differential dataflow
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
ptr_hash
A high-throughput minimal perfect hash function
-
tree-ds
manipulate tree data structures
-
lctree
Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees
-
pi_world
ecs world
-
reconcile
A reconciliation service to sync a key-value map over multiple instances
-
oxigdal-qc
Quality control and validation suite for OxiGDAL - Comprehensive data integrity checks for geospatial data
-
uor-foundation
UOR Foundation — typed Rust traits for the complete ontology. Import and implement.
-
jolt-protocol
Protocol types for jolt daemon IPC
-
i_tree
Expiration key tree. Usable in algorithms like swipe line. Only for uniq elements
-
gotgraph
A type-safe, scope-aware graph library that leverages Rust's type system to prevent common graph-related bugs at compile time
-
infra-compass-db
Parse and manage the NREL's INFRA-COMPASS data
-
mule-map
A hybrid between a HashMap and a lookup table
-
tasru
A method to map and understand dwarf symbol information
-
ooroo
A fast, compiled rule engine with a text-based DSL
-
idmap
Efficient maps of integer id keys to values, backed by an underlying
Vec -
brk_fjall
Log-structured, embeddable key-value storage engine
-
wabi_tree
Order-statistic B-tree map and set with O(log n) rank operations. Drop-in replacements for BTreeMap/BTreeSet.
-
lattix
Knowledge graph substrate: core types + basic algorithms + formats
-
thermogram
Plastic memory capsule with 4-temperature tensor states (hot/warm/cool/cold), bidirectional transitions, and hash-chained auditability
-
spider_agent_types
Pure data types and constants for spider_agent automation. Zero heavy dependencies.
-
array2d
A fixed sized two-dimensional array
-
pna
PNA(Portable-Network-Archive) decoding and encoding library
-
lexime-trie
A char-wise Double-Array Trie with zero dependencies
-
phf_shared
Support code shared by PHF libraries
-
snowball_stemmers_rs
all Snowball stemming algorithms
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
wildbird
Rust Framework 🐦
-
tagged-types
Define strongly typed wrappers over base types with minimal boilerplate
-
ttgraph
Typed/Transactional Graph container
-
gix-merge
gitoxide project implementing merge algorithms
-
aliasable
Basic aliasable (non unique pointer) types
-
plotnik-bytecode
Bytecode format and runtime types for Plotnik
-
pgm-extra
high-performance learned index structures for Rust
-
polars-formula
High-performance formula parsing and materialization library for Polars DataFrames with R/Formulaic/Patsy style syntax
-
bitstring
traits and implementations
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
hyperloglockless
High-performance HyperLogLog with bias correction and full concurrency support
-
rpos
Cursor Manager on Table
-
logic_tracer
Recognize a logic proposition and trace its truth value, also generate a truth table (still in development)
-
smallvec-wrapper
Macro and common structs to play with
smallvec -
bumparaw-collections
A small set of bumpalo-backed collections for low-level operations
-
rustpix-core
Core traits and types for rustpix pixel detector processing
-
uuid-rs
Universally Unique IDentifier (UUID)
-
enum-collections
Collections data structures optimized for Enum, initializable at runtime
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
superintervals
Interval overlap library
-
flatk
Flat layout abstraction toolkit
-
open-payments-iso20022-reda
Open Payments - Message Parsing Library - ISO20022 REDA
-
fast-sparse-merkle-tree
Fast Sparse Merkle Tree (SMT) library in Rust, using TurboSHAKE128 as default hash function
-
heapless_graphs
composable graphs for no_alloc environments
-
atomicow
A
Cow-like data structure where owned data is stored inside anArc -
flatten_objects
A container that stores numbered objects. Each object can be assigned with a unique ID.
-
plain-ds
Plain data structures
-
armature-collab
Real-time collaboration with CRDTs and Operational Transformation for Armature framework
-
dagex
A pure Rust DAG executor supporting implicit node connections, branching, and config sweeps
-
puruda
Pure Rust DataFrame
-
keymaps
standardized encoding for key codes
-
undo
An undo-redo library
-
omega-core
Core types and traits for ExoGenesis Omega universal intelligence orchestration system
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
rumpsteak-types
Core session types for Rumpsteak - matching Lean definitions
-
segmented-vec
A vector with stable element addresses using segmented allocation and O(1) index-to-segment mapping
-
dot2
generating Graphviz DOT language files for graphs
-
rbtree
the rbtree for Rust
-
stringtape
A tape class for strings arrays compatible with Apache Arrow
-
nexus-timer
High-performance timer wheel with O(1) insert and cancel
-
radix-heap
Fast monotone priority queues
-
key-paths-iter
Query builder and iteration over rust-key-paths KpType for Vec collections
-
treeclocks
Various Tree Clock data-structures and utilities
-
card-est-array
Infrastructure for managing large arrays of cardinality estimators
-
tagged-core
A lightweight tagged type abstraction for type-safe IDs, etc
-
caldir-core
Shared types for caldir ecosystem (Event, protocol types)
-
ultragraph
Hypergraph data structure
-
hodgepodge
Lightweight dataset crate of enums for prototyping, teaching, and experimentation
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
data-stream
serialization library based on streams
-
graph-api-lib
Core library for the graph-api ecosystem - a flexible, type-safe API for working with in-memory graphs in Rust
-
schema-catalog
Types for the JSON Schema catalog format (schema-catalog.json)
-
ordered
A wrapper for adding arbitrary partial/total order to a type
-
trk-io
TrackVis (*.trk) reader and writer
-
dsq-functions
Built-in functions and registry for dsq
-
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
-
unique_id_lookup
Associative Array specifically designed for integer keys. Significant performance boost over conventional hash maps.
-
modmap
Universal module map schema for codebase structure representation
-
cmsketch
A count min sketch implementation in Rust
-
rshyper
focuses on hypergraphs
-
binary-greedy-meshing
A port of https://github.com/cgerikj/binary-greedy-meshing to Rust
-
sif-itree
immutable, flat interval tree
-
bijux-atlas-core
Domain primitives and deterministic core contracts for bijux-atlas
-
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
-
multi_ranged
Efficient data structures for representing and manipulating ranges of discrete values
-
chunked_vec
A vector-like data structure that stores elements in fixed-size chunks for better memory management
-
kcr_kueue_x_k8s_io
Kubernetes Custom Resource Bindings
-
libdawg
A fast, memory-efficient DAWG (Directed Acyclic Word Graph) for word validation and prefix queries
-
adflib
handle amiga disk files
-
bigraph
Different representations with implemented operations on bigraphs
-
rs-ecs
reasonably simple entity component system
-
inc-complete
writing incremental computations that re-execute the minimum number of steps when an input is changed
-
blockbucket
Read Write Delete (block u8: key, data) to bucket file
-
lsph
Learned Spatial HashMap
-
ball-tree
K-nearest neighbors
-
petricheck
symbolic model checker for Petri Nets
-
libwebnovel
enabling users to get chapters of a webnovel, with multiple available backends
-
ranged_bitmap
A high-performance bitmap library
-
caches
popular caches (support no_std)
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
float16
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
rdf-model
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
moduforge-model
不可变数据结构与事务系统基础
-
field_access
Dynamically access struct fields
-
slimvec
Dynamic array with a smaller inline-size
-
fixed-slice-deque
A fixed size deque implementation
-
compact-dict
A highly customizable, open-addressing dictionary in Rust
-
pi_slotmap
Slotmap data structure
-
safety-net
A reference-counted netlist library for EDA tools
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
ux-primitives
Graphics Primitives for Angular Rust
-
oracle_omen_core
Core types and abstractions for oracle.omen deterministic agent framework
-
hashify
Fast perfect hashing without dependencies
-
agnix-rules
Validation rules for agnix - agent configuration linter
-
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…
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
boarddown-schema
Shared schema types for BoardDown
-
orx-fixed-vec
An efficient fixed capacity vector with pinned element guarantees
-
attuned-cli
CLI tool for Attuned development and testing
-
orx-selfref-col
SelfRefCol is a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees
-
uninum
A robust, ergonomic unified number type for Rust with automatic overflow handling, type promotion, and cross-type consistency
-
opejson
Surgical JSON manipulation macros for Rust. (Strict, Genesis, and Law modes)
-
digit-bin-index
A high-performance, O(P) data structure for weighted random sampling of binned probabilities, ideal for large-scale simulations
-
linked-hash-table
A linked hash table implementation for insert-order iteration and efficient lookups
-
pw-core
Shared types for PromptWallet - OpenAI-compatible chat API types, artifacts, and extensions
-
more_collections
Additional collections not found in std::collections
-
quilibrium-verkle
Verkle trie implementation with KZG commitments for Quilibrium
-
arena-terms
A lightweight, arena-backed representation of Prolog–like terms
-
comparable_test
comparing data structures in Rust, oriented toward testing
-
any-rope
A fast and robust arbitrary rope for Rust. Based on Ropey.
-
spqr-tree
A representation of the SPQR tree in Rust with support for I/O
-
tagid
Defines a newtype labeled tagging for different types of ids
-
fm-index
FM index and its variant implementations for Rust
-
eastl-rs
EASTL binary-compatible Rust implementations
-
small-fixed-array
providing fixed length immutable collections with a low memory footprint
-
flat-tree
Series of functions to map a binary tree to a list
-
rangeset
Integer collection backed by ranges with set operation support
-
marrow
Minimalist Arrow interop
-
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…
-
clustered-fast-trie
Ordered integer set (u32/u64/u128) for data with locality. O(1) range counting. Stable O(log log U) latency.
-
laurier
ratatui helper library
-
diet-xml
Probably the simplest, most approachable XML builder for Rust
-
bumpish
A set of collections using bump allocations
-
arithmetic-nonmax
Integer types that cannot be the maximum value, allowing for memory layout optimization and intuitive arithmetic operations
-
slotted-egraphs
E-Graphs with name binding
-
openresponses
API types, generated from the OpenAPI specification
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
typeid_prefix
that implements a type-safe version of the TypePrefix section of the
TypeIDSpecification -
cfixed-string
Pass Rust strings to C with potentially not needing heap allocation
-
odht
hash tables that can be mapped from disk into memory without the need for up-front decoding
-
neodata
Streaming fixed-memory 16-ary merkle tree with backend-agnostic storage
-
minuet
Extended memory systems built on amari-holographic
-
optarray
Resizable Arrays in Optimal Time and Space
-
more_ranges
Range types not provided in the standard library
-
orbweaver
designed for effortless construction and analysis of graph data structures
-
intervalmap
An interval set/map library inspired by Boost.Icl
-
djotters
Djot (Markdown) parser that runs at hyper speeds!
-
aleo-core
Data model for Leo documents (DAG=Directed - Acylic - Graph)
-
ph-temp
data structures based on perfect hashing
-
trie-hard
Fast implementation of trie data structure
-
compvec
Compressing integer vectors
-
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…
-
keyed-set
Keyed Set: a hashbrown-based HashSet that indexes based on projections of its elements
-
normalize_interval
Normalizing interval library
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
tirea-state
Typed view + JSON patch library for deterministic immutable state management
-
tracker
A macro to track changes on structs
-
art
adaptive radix trie
-
loro-delta
Loro internal library. It's used as a delta between two versions of text or lists. It's also an efficient Rope.
-
ni
Small limited alloc-free named identifier
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
unbound
Locally nameless representation with automatic capture-avoiding substitution and alpha equivalence
-
svd-rs
A CMSIS-SVD base structures
-
eventfold
Lightweight, append-only event log with derived views — your application state is a fold over an event log
-
mappy-core
Core maplet data structure implementation
-
voxtree
sparse voxel 64-tree implementation in rust
-
ucm-core
Core types and traits for the Unified Content Model
-
oxidd-rules-bdd
Binary decision diagrams (BDDs) for OxiDD
-
clone_cell
A Cell that works with a restrictive form of Clone
-
ndarray-layout
definitions and transformations for multi-dimensional array data layouts
-
singletonThread
thread in a singleton
-
firims
fixed range integer maps and sets
-
vibe-graph-automaton
Foundational graph automaton with temporal state evolution and rule-driven transitions
-
spatialtree
A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)
-
ans-types
Shared types for the Agent Name Service (ANS) ecosystem
-
splinter-rs
A compressed bitmap format optimized for small, sparse sets of u32s with zero-copy querying
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
onebuck
An efficient unordered dynamically-sized data structure
-
seq-map
Sequential Map
-
bv
Bit-vectors and bit-slices
-
phago-agents
Reference agent implementations using Phago biological primitives
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
ggapi
communicating with start.gg's API
-
naan
A fast, easy, and tasty functional programming prelude
-
oats-rs
Short, unique ids without the hassle of random uuids
-
quantor
Declarative quantifiers for filtering, validation, and testing in Rust
-
suggest
A minimal library to provide similar name suggestions like "Did you mean?"
-
evict
Page eviction policies: LRU, LRU-k, LIRS, SLRU etc
-
wrapbin
binary newtype as wrapped Cow u8 array
-
sugars_collections
Efficient collection types including ZeroOneOrMany and OneOrMany with array tuple syntax support
-
feagi_data_structures
The most core library, defines the basic data types used by FEAGI, as well as some processors to modify them
-
riskless
A pure Rust implementation of Diskless Topics
-
tinysetqueue
A tiny, allocation-free FIFO queue with direct-mapped membership tracking for dense integer domains
-
mindset
A pure functional state machine library built on Stillwater's Effect system
-
key-node-list
Doubly-linked list that stores key-node pairs
-
tuplez
Tuples represented in recursive form
-
notatype
Types for Ordinary
-
pasture-core
A framework for working with point cloud data
-
bhc-index
Typed indices for efficient and safe indexing
-
srb-lens
Static analysis tool for Sorbet-typed Ruby projects — extracts method signatures, call graphs, and type information from Sorbet's CFG, symbol table, and parse tree
-
flex
Flexible borrowing and ownership for Rust
-
superset_map
Map that stores distinct supersets based on the total order defined
-
vec-belt
Multi-threaded bulk-append, single-threaded consume
Vec<T> -
neobit
Zero-dependency, lightweight bitflags with readable debug output
-
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
-
cf-colo-hint
Cloudflare colo to Durable Objects location hint mapping
-
lnc-core
Core types and primitives for LANCE - TLV, SortKey, LoanableBatch, buffer pool
-
tuplities
A collection of utilities for working with tuples in Rust
-
klingt
Lock-free audio graph library with message-passing parameter control
-
tailcall-chunk
persistent data structure for efficient append and concatenation operations
-
bevy_archive
An experimental ECS world snapshot system built on Bevy, featuring structured archetype storage and manifest-based serialization
-
slabmap
HashMap-like collection that automatically determines the key
-
vecset
A vector-based sorted map, set and keyed-set implementation
-
monstertruck-assembly
Assembly data structures using a directed acyclic graph (DAG)
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
heavykeeper
finding Top-K elephant flows with high precision and low memory footprint
-
bytes-cast
Safely re-interpreting &[u8] bytes as custom structs without copying, for efficiently reading structured binary data
-
tedium
A fast and easy TDMS Library for Rust
-
gpt_disk_io
GPT (GUID Partition Table) disk IO no_std library
-
uniques
Analyze items in a slice and calculate the unique, first, duplicate, and subsequent items and their indices
-
shardtree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
range-mutex
A
Mutex<[T]>-like type, that allows locking different ranges separately -
valkyrie-ast
Strong typed abstract syntax tree of valkyrie language
-
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… -
graus-db
A high-performance, thread-safe key-value embedded data store
-
kotoba-routing
Declarative, graph-based HTTP routing engine for the Kotoba ecosystem
-
hashslab
A hash table with data accessible by index
-
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
-
medea-reactive
Reactive mutable data containers
-
tex_engine
A modular crate for building TeX engines
-
whale
A lock-free, dependency-tracking primitive for incremental computation
-
deferred-cell
A single-assignment, weak reference wrapper for cyclic node graphs with late initialization
-
array-linked-list
A data structure, which combines the advantages of dynamic arrays and linked lists
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
cactus
Immutable parent pointer tree
-
hypeerlog
A fast, distributable, and lightweight HyperLogLog implementation with bias correction
-
copy-stack-vec
A no_std, fixed-capacity, stack-allocated Copy vector for Copy types, with no unsafe code by default
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
recoco
A Rust-only fork of CocoIndex, a modular, high-performance ETL and data transformation library
-
aatree
in Rust
-
mikufans-proto
gRPC APIs for Mikufans
-
data_reader
A data loading library for data scientist
-
swiss-table
An educational Rust implementation of the Swiss Table hash map algorithm
-
tree_arena
An arena allocated tree
-
isx
Traits for checking certain conditions of values
-
fibonacci_heap
A high-performance Fibonacci Heap implementation in Rust with generic type support
-
short-id
Tiny crate for generating short, URL-safe, random or time-ordered IDs
-
do-notation
Monadic do syntactic sugar
-
diskann-providers
DiskANN is a fast approximate nearest neighbor search library for high dimensional data
-
range-map
Maps and sets implemented using ranges
-
psrutils
few utilities to facilitate pulsar science projects in rust
-
arraylist
wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
blocklist
The project is based on blocklistproject. It provides perfect hash map/set structures for fast lookup of blocklisted items.
-
nzfcc
New Zealand Financial Category Codes (NZFCC) library
-
idbag
A bag of integers
-
gctree
cache-friendly, graph-like, arena-allocated datastructures
-
rust-tls-duplex-stream
Full Duplex stream Wrapper around rust-tls
-
composable-indexes
In-memory collections with composable indexes
-
diffkit
diffing and patching sequences and nested structures
-
array-deque
Fixed-capacity circular buffer implementations: heap-allocated ArrayDeque and stack-allocated StackArrayDeque. Efficient O(1) operations, no_std support.
-
cutoff-common
A collection of common utilities and helpers used across Cutoff projects
-
slice-cell
A
Cell<[T]>-like mutable slice, that allows slice-like APIs -
graphcore
Base data structure to represent and manipulate property graph
-
atelier
a Computational Workshop for Market Microstructure Modeling, Synthetic Simulation and Historical Replay
-
pdatastructs
probabilistic data structures
-
sbits
Succinct data structures: near-optimal space with efficient queries
-
typed-bytes
Fully typed data size units (IEC and SI) with operator overloading
-
disjoint-ranges
Ranges with gaps
-
bsp-tree
Binary Space Partitioning (BSP) tree useful for 3D rendering. Works with flat polygons (triangles, quads, etc.).
-
hecs-hierarchy
Hierachy implementation for Hecs ECS
-
btree-slab
A memory compact Slab-based B-tree implementation
-
deep_causality_tensor
Tensor data structure for for deep_causality crate
-
hpkg
A native Rust crate to parse Haiku's binary package and repo formats
-
zakat-ledger
Event sourcing, timeline simulation, and Hawl tracking for Zakat calculations
-
kempt
Ordered collection types with no unsafe code and no_std support
-
a-tree
A dynamic data structure for efficiently indexing arbitrary boolean expressions
-
min-max-heap
An efficient, double-ended priority queue
-
jaggedarray
Multidimensional jagged array
-
arkts
reversing HarmonyOS Arkts bytecode files
-
seg_lib
A collection of segment tree variants
-
nexus-collections
SLUB allocator backed intrusive collections for low-latency systems
-
elephantry-extras
A collection of additional components for elephantry
-
solvent
Dependency Resolver library
-
fffl
A contiguous First-fit Freelist
-
hibitset
Hierarchical bit set structure
-
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
-
jgd-rs
generating realistic JSON data using declarative schema definitions
-
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…
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
array_list
A dynamic container that combines the characteristics of a Vec and a LinkedList
-
mergle
A data structure with fast merging and comparison
-
smodel
Symbol semantic modeling for Rust
-
packo
Packed datastructure with self referential indexing
-
veclite
A lightweight, ergonomic wrapper around Vec<T> that implements Display
-
kn0sys_ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
strict
collections with strict bounds
-
microkelvin
tree traversal over annotated data structures
-
evicting_cache_map
An Evicting LRU cache supporting prune hooks
-
diffo
Semantic diffing for Rust structs via serde
-
f3l_search_tree
3D Point Cloud Library
-
ndtensor
An n-dimensional tensor
-
stateset-primitives
Strongly-typed primitive types for StateSet iCommerce
-
cbsk_socket
socket callback tool
-
collect_failable
A trait for collecting values into a container which has an invariant to uphold and whose construction may fail
-
opensearch_query_builder
Opensearch query builder
-
merkle-cbt
generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
stack_collections
Stack-allocated collections for Rust
-
roussillon-type-system
A type system for a programming language
-
rd-util
collection library for resctl-demo
-
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
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. -
uid_store
Generate random uid strings containing letters, numbers, or base62 values
-
suffixarrayview
Creates a view of a suffix array
-
dsq-core
Core functionality for dsq - data processing with jq syntax
-
f1r3fly-rspace-plus-plus
F1r3fly Tuple Space implementation in Rust - high-performance storage and pattern matching
-
queue-file
lightning-fast, transactional, file-based FIFO
-
chat-prompts
Chat prompt template
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
stac
SpatioTemporal Asset Catalog (STAC) specification
-
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.
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
canon-core
Core data models and traits for Canon Protocol — verifiable, censorship-resistant knowledge sharing for AI
-
circular_doubly_linked_list
A high-performance Circular Doubly Linked List implementation in Rust
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
disjoint
Fast and safe implementation of the disjoint-set data structure
-
gap-buf
Generic gap buffer
-
field-collex
Collections implemented on block-based idea . (Do not ask me why
Field;> ) -
streamies
More features for your streams
-
entid
generating and validating type-safe, prefixed entity identifiers based on UUIDs and ULIDs
-
flatcontainer
A flat container representation for Rust
-
c_vec
Structures to wrap C arrays
-
exo-temporal
Temporal memory coordinator with causal structure for EXO-AI cognitive substrate
-
optional
supplies a number of Option-like primitive types
-
typesense_codegen
Types for typesense generated with openapi spec
-
either-or-both
The enums EitherOrBoth with the three variants Left, Right, Both and Either with the Left and Right variants
-
flow-mumu
Stream transform tools plugin for the Lava language
-
type-set
A set of heterogeneous types
-
pi_slot
lock free Slotmap data structure
-
u24
An unsigned 24-bit integer type
-
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…
-
pretty_graph
toolbox to build and working with graphs
-
soplex-rs
Safe Rust bindings for the SoPlex LP solver
-
better_peekable
Peekable iterator like std::iter::Peekable but allows for peeking n items ahead instead of just one
-
oxigdal-stac
STAC (SpatioTemporal Asset Catalog) support for OxiGDAL - Pure Rust cloud-native geospatial catalog
-
crusty_cards
Playing Card and Deck Library
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
array-queue
Fixed size bidirectional queues based on arrays
-
packed-uints
Array of uints that scales from u4 to u32 to minimize wasted space while still being fast
-
eight-booleans
A small Rust library to store and manipulate 8 booleans in a single byte
-
cseq
compact sequences
-
dsq-shared
Shared types and utilities for DSQ crates
-
h3o-ice
Frozen{Map,Set} for H3 cells, based on finite state transducers
-
tincan
A lightweight reactive state management library for Rust
-
lookupvec
Container with Vec-like properties that also offers O(1) lookup of items based on an id field
-
qtruss
finite-element solver for trusses
-
mago-reflection
Offers data structures and APIs to represent and inspect PHP code elements—like classes, functions, and interfaces—enabling introspection and analysis
-
slotmapd
orlp/slotmap fork where serialization cycle doesn't change observable behavior
-
weighted-list
Data structures for weighted randomisation
-
flagged_cl_args
Command line argument parsing
-
index-ext
Index slices with arbitrary ints and as arrays
-
vicardi
JSON VCardArray Generator that uses Serde
-
prism3-value
Type-safe value container framework with unified abstractions for single values, multi-values, and named values with complete serde support
-
corevm-codec
CoreVM codec collection. Used to encode and decode output streams produced by the guest.
-
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
array-plus-extra
An array type that holds N+EXTRA elements with const generic parameters, providing safe slice access to contiguous memory
-
vortex-vector
Vortex in-memory canonical data format
-
intrusive-lru-cache
An LRU cache implementation using intrusive data structures
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
dig-network-block
Primitives for DIG L2 block structure: header/body types, roots, and consensus emissions
-
crdt-data-types
High-performance CRDT library with dual pathways: JSON-native for web APIs and Cap'n Proto zero-copy for binary transport
-
slice_ring_buf
A ring buffer implementation optimized for working with slices
-
vec_historic
Rust Undo Collection
-
signalk
parse signalk maritime data
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
quake-util
using Quake file formats
-
sevec
A fast, pure Rust implementation of the segmented array data structure
-
type_slicer
型付きメモリスライサー
-
xorfilter-rs
Xor Filters: Faster and Smaller Than Bloom and Cuckoo Filters
-
fastbit
A fast, efficient, and pure Rust bitset implementation for high-performance data indexing and analytics
-
tinyvec_string
tinyvec based string types
-
cve
Mappings for parsing the CVE JSON files
-
lox
Fast polygon mesh library with different data structures and traits to abstract over those
-
tld
Top Level domain static hash map, tld list is obtained from of iana.org
-
cbsk_base
locked version cargo crates
-
graphix
representing undirected graphs using a compressed adjacency list
-
fqdn-trie
FQDN (Fully Qualified Domain Name) lookup structures (based on tries)
-
miny
Box<T> with small value optimization
-
product-farm-core
Core domain types for Product-FARM rule engine
-
graphy-core
Core graph data structures and persistence for graphy
-
fingertrees
Immutable persisten finger trees
-
pofk_algorithm
A collection of efficient algorithms implemented in Rust for real-world projects
-
ratio-interner
Ratio's value interner library
-
re_string_interner
string interning library
-
backgammon_engine
Backgammon engine in Rust: state representation, legal move generation, and deterministic afterstate transitions for agent/RL development
-
materials
Data on rocks, elements, metals, etc
-
calimero-wasm-abi
WASM-level ABI v1 for Calimero applications
-
ceres-core
Core types, business logic, and services for Ceres
-
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
-
runtime-context
A runtime context providing type storage and management
-
octofhir-fhirpath-model
Value types and FHIR model support for FHIRPath implementation
-
digit-sequence
Sequence of u8 digits
-
cell-grid
2d grid container
-
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
admissibility-kernel
Deterministic context slicing with cryptographic admissibility verification for conversation DAGs
-
mapgraph
A directed graph that can also be used as an arbitrary map
-
dawg
Directed Acyclic Word Graph
-
ndshape
fast linearization of N-dimensional array indices
-
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
-
polars-structpath
dynamically accessing nested Rust structures using path notation
-
mset
/ multiset / bag implementation
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
neoset
Compact RLE-encoded event sets for efficient peer sync
-
anymap2
A safe and convenient store for one value of each type
-
merc_lts
Implements labelled transition systems for various I/O formats using a general LTS trait
-
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 -
paginator-utils
Shared pagination response structures
-
simd-lookup
High-performance SIMD utilities for fast table lookups, compression and data processing
-
options
The package provides a data structure for managing named parameters
-
lru-st
A package providing a Vec based doubly linked list implementation and related data structures
-
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…
-
fhirpathrs
Fhirpath implementation in Rust
-
gpui_collections
Standard collection type re-exports used by Zed and GPUI
-
rdf-types
Data-structures and traits definitions for RDF
-
approx_collections
Collections using approximate floating-point comparison
-
tiled_parse_tree
Tree data structure
-
array_buf
Highly optimized fixed-capacity deque buffer stored on the stack
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
elizaos-plugin-trajectory-logger
Trajectory logging plugin for elizaOS - Rust implementation
-
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.
-
graphy-search
Full-text and fuzzy search for graphy
-
cmrdts
A collection of Commutative Replicated Data Types (CmRDTs) implemented in pure Rust
-
mikel_binary_tree
search binary tree implementation
-
static-lang-word-lists
Runtime decompressed statically-included word lists
-
jitlist
blazingly fast revolutionary data structure
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
linear-hashtbl
Linear probing hash table
-
gapbuf
Generic gap buffer
-
walker-extras
Additional functionality for SBOM and CSAF walker
-
maplike
Traits for common operations over maps, sets, (stable) vectors. Has built-ins for std, stable-vec, thunderdome, rstar, rstared.
-
mashmap
A flat HashMap that supports multiple entries per key
-
smooth-json
opinionated, customizable utility to flatten serde_json Value variants into serde_json Objects ready for use in columnar or table-like usages
-
codedash-schemas
Stable public schema for codedash code metrics output — JSON Schema + Rust types
-
gen-tui
Graph visualization widget system for Gen
-
pimalaya-tui
Collection of crossterm widgets shared accross Pimalaya projects
-
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.
-
pypinindia
Indian pincode lookup and geographical information
-
agentic-commerce-protocol
Type definitions for the Agentic Commerce Protocol specification
-
balanced-tree-index
constant-time manipulation of a complete binary tree with a flat in-memory representation
-
arbor-graph
Graph schema and relationship tracking for Arbor
-
segtri
Segment tree with customizable data type and update operations
-
fukurow-rules
Rule traits and constraint validation (SHACL equivalent) for Fukurow reasoning
-
rt_ref
Internal
Reftypes forrt_refandrt_vec -
rocketman
A modular(ish) jetstream consumer
-
wasefire-slice-cell
Slice with dynamic borrow checking
-
anchors
async incremental computations
-
dmfr-dataset-reader
Reads transitland folder and outputs graph of valid feeds and operators
-
hnsw_vector_search
High-performance semantic search using HNSW and ONNX embeddings
-
sortedlist-rs
A fast sorted list data structure in rust
-
succparen
Succinct data structures library for balanced parentheses representation
-
hextree
Location to value mapping
-
rb_tree
A Red Black Tree implementation in Rust
-
rstrie
A generalized Trie implementation for Rust
-
qlib-rs
A flexible in-memory database library
-
token_trie
A high-performance Radix Trie implementation with sorted children for efficient binary search operations
-
flatarray
flattened iterator, that acts as if it still was an iterator of iterator
-
CartesianTree
Build hierarchical Cartesian coordinate systems to easily transform poses
-
bitvek
bit vector implementation
-
schema-registry-analytics
Analytics engine for usage tracking, metrics collection, and reporting
-
limited-queue
a limited queue that overrides the oldest data if trying to push a data when the queue is full
-
compress-json-rs
Store JSON data in a space-efficient compressed form, with round-trip compression/decompression
-
typwire
Rust types for the Typst plugin system
-
map_vec
The Map and Set APIs backed by Vec
-
stac-validate
json-schema validation for the Rust implementation of the STAC specification
-
ergo_avltree_rust
cryptographically authenticated dictionary based on AVL tree
-
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
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
disjoint-sets
Three union-find implementations
-
unitx
A general-purpose library for units and quantities
-
lignin
A virtual DOM structure, primarily for web use
-
spimdisasm
MIPS disassembler
-
praborrow
framework - A distributed systems framework for Rust
-
linker-set
Declarative programming via linker-constructed arrays
-
smartcardfyi
Smart card platform reference, EMV standard lookup, and Java Card encyclopedia -- async API client for smartcardfyi.com
-
syntastica-themes
A collection of themes for syntastica
-
dinvoke_data
Structures and data types definitions for dinvoke
-
surface-grid
providing data structures for square-tiled grids wrapped around the surface of certain objects
-
rtree_rs
R-tree for Rust
-
csf
compressed static functions (maps) that use perfect hashing and value compression
-
zkcg-zkvm-guest
RISC0 zkVM guest program for proof execution in the ZKCG framework
-
triple-r
Macros to for the recuerdame crate
-
gibblox-mbr
Block reader for MBR partitions
-
list_ordered_hashmap
An insertion-ordered hash map that provides O(1) (amortized) insertion, lookup, update and removal
-
retworkx
A python graph library implemented in Rust
-
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… -
gpui_rn_collections
Standard collection type re-exports (fork for React Native GPUI)
-
ware
middleware chains
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
packable
packing and unpacking binary representations
-
lorosurgeon
Derive macros for bidirectional serialization between Rust types and Loro CRDT containers
-
plane-2d
Continuous 2D data structure representing infinite 2d plane
-
xuko
Rust utility library
-
queues
Efficient FIFO Queue data structures
-
total-maps
Maps where every possible key has an associated value
-
indexed_arena
index-based arena without deletion
-
multi-map
Like a std::collection::HashMap, but allows you to use either of two different keys to retrieve items
-
id_collections
Index-oriented programming in Rust
-
dotenv_lib
A dotenv file parser
-
alot
A forbid-unsafe, generational slot map with usize-sized IDs
-
libcint-src
libcint (C library) source or build specification
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
obzenflow-idkit
Phantom-typed ULID identifiers for ObzenFlow - type-safe IDs for native and WASM
-
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…
-
wybr
Collection of preferential voting methods
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
merc_data
Defines data expressions on top of terms that are compatible with the mCRL2 toolset
-
minidom
A small, simple DOM implementation on top of rxml, targeting the subset of XML useful for XMPP
-
omega-memory
12-tier cosmic memory system with automatic consolidation (Instant → Omega)
-
identity_map
Identity-based maps
-
zetamesh_flags
zetamesh-flags is a minimal Rust library for rule-based validation of state combinations
-
trie_hard_rs
Fast, memory-efficient Trie (prefix tree) implementation with autocomplete support - Rust implementation
-
image-ndarray
Zero-copy implementations for the Image crate to convert to and from ndarrays
-
appendlist
An append-only list that preserves references to its elements
-
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…
-
polytype
A Hindley-Milner polymorphic typing system
-
theymx
A small Rust library for handling DMX data
-
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.
-
re_tf
Rerun spatial transform processing
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
jmt-pq
PQ Jellyfish Merkle Tree
-
varlen
Ergonomic variable-length types
-
iron_types
Shared types and data structures for Iron Cage AI agent management
-
rs-statemachine
COLA-style state machine with fluent API
-
strumbra
Umbra-style strings (also known as German strings)
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
closed-interval-set
Unions of closed intervals as containers of pairs
-
fixed_heap
A fixed-size heap structure with manually provided stateful comparison function
-
forest-ds
secure tree structure
-
rostl-oram
Oblivious RAM (ORAM) implementations
-
oxigdal-temporal
Multi-temporal raster analysis for OxiGDAL - Time series, change detection, phenology, and data cube operations
-
diff_json
A powerful JSON diff library for Rust
-
cow_hashmap
Hashmap with copy-on-write semantics that requires no locks
-
assoc
Treat vectors like associative arrays
-
attribute-search-engine
Generic search engine for rows with attributes using different matchers
-
graph-api-petgraph
Integration between graph-api and petgraph - use graph-api's traversal system with petgraph structures
-
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…
-
cynos-incremental
Incremental View Maintenance (IVM) for Cynos database
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
floating_bar
Representing rational numbers using the floating-bar number type
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
parser_fuck
parser combinator library
-
range_map_vec
range map data structure backed by a Vec
-
mdcs-core
Core CRDT types and traits for the Carnelia Merkle-Delta CRDT Store
-
wt-indexset
Fork of original indexset which is used for worktable
-
radix_trees
Various radix tree (trie) data structures
-
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:… -
beap
Bi-parental heap data structure implementation in Rust
-
heapix
providing heap data structures
-
stack-allocator
A stack-based memory allocator with optional fallback to a global/secondary allocator
-
lru-mem
An LRU cache implementation bounded by memory
-
nlist
inline-allocated list with statically tracked length
-
lull-spec
Lull spec library
-
dendron
Generic tree data structure
-
snowflaked
creating and working with snowflake ids
-
palindromeda
Palindrome number generator and checker at blazing speed
-
rustyhdf5-types
HDF5 type system definitions for rustyhdf5
-
forrust_fire_tracing
Tracing integration for
forrust_fire_tree -
embed-struct
embedding data structures
-
hit-data
Hierarchical Indexed Typed data structure
-
dia-i18n
-
text-span
Struct covering areas of text
-
bhc-data-structures
Common data structures for the BHC compiler
-
indexed-table
A tiny in-memory indexed table
-
radixmap
Rust-based Radix Tree for fast prefix lookup, supporting named param, glob, regex
-
cli-tilemap
that provides basic functionality of Tilemap for CLI-based games!
-
bypond
A highly untested and undocumented complete tree library
-
simd-intervaltree
A SIMD-accelerated interval tree with zero-allocation queries
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
labeledarray
labeled n-dimensional arrays with spatial-aware helpers for geospatial and scientific workflows
-
unordered-pair
A tuple struct representing an unordered pair
-
enum-toggles
A generic Rust library for managing toggles/flags using enums and bitvec
-
atree
An arena based tree structure with removal support
-
gtfs-geojson
converter for GTFS to GeoJSON formats
-
sif-kdtree
immutable, flat k-d tree
-
oxihuman-core
Core data structures, algorithms, and asset management for OxiHuman
-
layered
Build composable async services with layered middleware
-
bitboard64
A 64-bit bitboard useful for chess programming
-
deep_causality_sparse
Spare matrix data structure for for deep_causality crate
-
hash-link
Keep elements insert order while searchable by hash
-
singletons
Type-keyed data structures: SingletonSet stores one instance per type, SingletonMap<V> maps types to values
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
gevi_error
A flavor of error types and error handling that I like
-
retaker
ecs implementation
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
crispii_bits
Bit-related functionality for Rust's native u{int} types (usize excluded)
-
traiter
Traits collection
-
iron_runtime_state
Runtime state management for Iron Cage agents
-
unnamed_entity
Strongly-typed indexing for vectors and other structures
-
datavalue-rs
High-performance Arena-based alternative to serde_json::Value
-
nibble_vec
Vector data-structure for half-byte values
-
range-tree-rs
A range tree implement for slab allocator
-
pbn
Programming by Navigation types and traits
-
aograph
AND-OR graph data structures and algorithms
-
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
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
offset-vec
Packer for Vec and String etc, for all methods index add a offset
-
rust-keypaths
A static dispatch, faster alternative to rust-key-paths - Type-safe, composable keypaths for Rust with superior performance
-
dyn_trie
Dynamic trie is trie capable of mapping any T to any char iterator
-
mtgjson
Unofficially provided lightweight models of the data provided by MTGJSON
-
range_bounds_map
[
RangeBoundsMap] and [RangeBoundsSet], Data Structures for storing non-overlapping intervals based of [BTreeMap] -
adar-registry
Advanced Architecture (ADAR) is a collection of architectural tools that help you write more readable and performant code
-
gen_value
indexes and values with generations for vectors
-
michis_undo_redo
undo/redo system, inspired by Godot Engine's UndoRedo object
-
sweetrpg-kv-objects
Objects for Key-value store
-
vp-avl
A combined Vantage-Point AVL tree, to make VP trees updateable
-
garlic
A collection of random side projects
-
blefyi
Bluetooth Low Energy chip reference, GATT profile lookup, and beacon encyclopedia -- async API client for blefyi.com
-
coca
Data structures with constant capacity
-
titans_memory
Titans Memory: Neural-inspired memory system for AIngle AI agents
-
qutee
A quadtree implementation
-
enum-tag
Proc. macro for generating enum discriminant types.
-
nonempty_tools
优雅的 Rust 非空集合类型库，在编译时保证集合非空
-
segment-tree
Quickly perform interval queries or modifications
-
risc0-povw
Core library for RISC Zero Proof of Verifiable Work (PoVW)
-
arrayset
An array-backed ordered set type
-
higher
Functors, Applicatives, Monads and other bad ideas
-
open-payments-iso20022-admi
Open Payments - Message Parsing Library - ISO20022 ADMI
-
data-source
that fetches data from different sources
-
singlevec
Vec-like container optimized for storing only a single item
-
radix_route_matcher
A high-performance route matching library based on Radix Tree
-
pin-list
A safe
Pin-based intrusive doubly linked list -
standing-relations
Standing relations over a shifting dataset optimized for 'feedback loop' scenarios
-
generic-btree
Generic BTree for versatile purposes
-
minecraft-command-types
AST like structure for Minecraft commands
-
rustpower-sol-klu
A very basic KLU-based sparse linear solver unsafe wrapper
-
support
A collection of helper methods for Rust projects
-
hifa-xml-schema
Structure generator from XSD source file
-
bitstring-trees
Trees based on bitstrings
-
text-style
Types and conversions for styled text
-
typed_graph
Staticly typed graph library
-
soavec
A vector-like data structure for conventient growable Struct-of-Arrays creation and manipulation
-
fillet
An efficient thin pointer based contiguous collection
-
range-filters
High-performance range filter implementation - DIVA (VLDB 2025 Best Research Paper)
-
copyspan
An alternative to
Range<T>that has a defined memory layout and implementsCopy -
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
tritools
A collection of tools
-
sigma-types
Types checked for an invariant
-
chiralmap
Left-Right map using IndexMap
-
rstared
decorator that adds rstar::RTree to collections such as HashMap, BTreeMap, StableVec, thunderdome::Arena
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
point-nd
flexible no-std struct to model points on axes of any dimensions
-
numeric-statistics
Numeric Statistics: functions for min, max, average, variance, standard deviation, and more to come
-
blas-array2
Parameter-optional BLAS wrapper by ndarray::Array (Ix1 or Ix2)
-
dsa_abc
basic data structure and algorithms. Usability and performance is priority
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
open_menu_standard
OpenMenuStandard (OMS) specification
-
river-layout-toolkit
Write River layouts in Rust with ease
-
bom-kit
A flexible Bill of Materials (BOM) management library for assembly planning with substitutes and unit conversions
-
daedalus-registry
Node registry and plugin bundle loader for Daedalus graphs
-
enso-data
A collection of useful data structures
-
vecdeque-stableix
Deque with stable index values
-
suff_collections
Fast realization of suffix array and suffix tree
-
task-local-extensions
Task-local container for arbitrary data
-
leetcode-trees-rs
Tree Node LeetCode problems
-
gufo-webp
Data structure for WebP images
-
compactor
A collection which compresses old data
-
tensorism
Multidimensional arrays with bounds included in the type system
-
gen-models
Models for the gen sequence graph and version control system
-
unsafe-tools
A collection of tools making safer unsafe Rust
-
compact-calendar
Compact representation of a set of days based on a bit-maps
-
tudi
There, inside the game's two-dimensional universe, life was simple
-
iotdb
Apache IotDB Client written in Rust
-
iowrap
Small helpers for using io::Read/io::Write
-
knot0-types
Rust types generated from Knot0 JSON Schemas
-
smt-circom
Sparse Merkle Tree, compatible with circom proofs
-
hotel
Collection Data-structure to associate values with keys
-
rustywallet-bloom
Fast and memory-efficient Bloom Filter with counting support for rustywallet
-
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.
-
ordsearch
A data structure for efficient lower-bound lookups
-
nexus-bits
Bit field packing for integer IDs
-
cow_map
A map that starts as static PHF (compile-time) and promotes to HashMap on first write
-
mago-token
Defines the data structures and enumerations representing PHP tokens
-
sarif_rust
A comprehensive Rust library for parsing, generating, and manipulating SARIF (Static Analysis Results Interchange Format) v2.1.0 files
-
graphy-watch
File watcher and incremental re-indexing for graphy
-
bit-int
An arbitrary fixed bit-width integer library
-
spanley
my generic string span, his name is Spanley
-
tree_by_path
A tree data structure featuring nodes addressable using a &Vec<usize> path and avoiding recursion and run-time borrow checking
-
hashheap
data structures that combine a hashmap and a min/max priority heap, with main operations requiring O(1) or O(log n) time
-
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!
-
vecmin
VecMinandVecOnenewtype wrapper aroundVecthat enforces a minimum length at compile time -
prio-graph
A lazily populated directed acyclic graph with top-level priority ordering
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
jerky
Succinct on-disk data structures in Rust
-
sorted-index-buffer
array based sorted map with u64 keys
-
uintx
Unaligned unsigned integers with exact size in memory and arithmetic operations for them
-
loc_api
interact with the loc.gov API
-
gpui_sum_tree
A sum tree data structure, a concurrency-friendly B-tree
-
agb_hashmap
no_std hashmap implementation intended for use in the
agblibrary -
prefix_array
A generic container for searching on prefixes of keys
-
aviutl2-alias
AviUtl2のエイリアスデータを操作するためのライブラリ
-
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…
-
expiration_list
A datastructure for items that expire
-
snowflake-ng
Dead easy and high performance
snowflakeimplemented in Rust -
skipfree
lockfree skiplist
-
rtdlib
TDLib for rust
-
bbse
Backward Binary Search Encoding — minimal and deterministic scheme for sorted domains
-
yrs_tree
implementing a CRDT-based tree data structure powered by Yrs
-
tether-map
Order-preserving linked hash map with O(1) reordering
-
griddle
A HashMap variant that spreads resize load across inserts
-
lodtree
help create octrees and quadtrees for chunked level of detail
-
pathmod
Re-export crate for pathmod
-
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)
-
dothocanhnau_phong_thuy
Du lieu quy chuan ban tho va vach ngan phong tho Canh Nau, Thach That. Chuan phong thuy Lo Ban 2026.
-
rust_flightweather
Decodes METAR and TAF
-
unobtanium-text-pile
Turns HTML into externally annotated plain text that is optimized for being serialized to the postcard format
-
forrust_fire_tree
A tree data structure
-
slice-rbtree
A slice-based Red-black tree
-
mmdb
A std-collection-like database
-
safe_index
Type-safe indexes
-
bo4e
BO4E (Business Objects for Energy) - Rust implementation
-
waremax-metrics
Metrics collection and reporting for Waremax
-
rc-vec
RcVec based on Rc and can be converted from Rc without allocation
-
qlrumap
An LRU HashMap with an optional passive ttl feature
-
triple_arena
Regular, Chain, Surjection, and Ordered Arenas supporting non-Clone types, deletion, and more
-
fixer-fix
Generated FIX protocol types for fixer
-
rust-tagged
A lightweight tagged type abstraction for type-safe IDs, etc
-
iati-transform
Transformations and rollups for IATI Activity data (sum by type/year/currency)
-
double_linked_list
High-performance doubly-linked list with smart pointer support and memory pool optimization
-
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.
-
roadmap
model a project roadmap as a directed acyclic graph
-
proto-blue-repo
AT Protocol repository: MST, CAR files, commits, block storage
-
type-rules
easily constrain a struct
-
dugong-graphlib
Graph data structure APIs used by dugong (port of dagrejs/graphlib)
-
graphix_io
reading and writing graphs from and to text files, based on the graphix crate
-
comparer
track changes in a HashMap/DashMap over several iterations
-
dynarg
mechanism for dynamic robust argument handling
-
unsized-vec
Like Vec, but for unsized values
-
axion-data
A high-performance data processing library written in Rust, providing DataFrame and Series functionality similar to pandas
-
elizaos-plugin-personality
Character evolution and self-modification plugin for elizaOS - Rust implementation
-
id-map
Data structure of values indexed by IDs
-
zhifeng_impl_barnes_hut_tree
implements Barns-Hut Tree for accelerated N-body force calculation
-
compact-rc
Low-memory reference-counting pointers
-
pedant-types
Shared types for pedant capability analysis
-
sharded
Safe, fast, and obvious concurrent collections
-
string_manipulation_utf8
String manipulation functions using character indexing (UTF-8) instead of bytes
-
ux-dataflow
Data Processing Library
-
stateset-protocol
Wire-format types for StateSet sync protocol — envelopes, batches, Merkle proofs
-
apma
Adaptive Packed Memory Array (APMA) — a cache-efficient sorted associative container
-
astro-math
Astronomy math algorithms for telescope control and sky transforms
-
beetle_bits
A collection of bit-based types. Currently only u1 (1bit uint) and f3 (3bit float) are implemented
-
scarf-syntax
A helper crate of scarf for expressing a SystemVerilog concrete syntax tree
-
prefix-sum-vec
Compressed storage for highly repeating elements, with
O(log n)lookups -
fuid
A UUID-compatible identifier in a friendly base-62 format
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
gnostr-filetreelist
filetree abstraction based on a sorted path list, supports key based navigation events, folding, scrolling and more
-
phyz-gravity
Layered gravity solver from constant-g to post-Newtonian corrections for phyz
-
try-lazy-init
Fallible lazy initialization
-
aion-lib-arraymap
A wrapper around Vec<T> with a freelist. Preserves index validity on mutations without heavy generation counters.
-
dcel
doubly-connected edge list
-
emap
A map with a fixed capacity and integers as keys
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
rexsgdata
Scatter-Gather Data Descriptors
-
bittle
Zero-cost bitsets over native Rust types
-
fenwick
tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
irange
A data structure to store and manipulate ranges of integers with set operations
-
weak-map
BTreeMap with weak references
-
aph_disjoint_set
Disjoint set implementation with optimized memory usage and ability to detach elements
-
types
Shared types and DTOs for the Liturgy workspace
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
vec-option
A space optimized version of
Vec<Option<T>>that stores the discriminant seperately -
kcr_workloads_kubeblocks_io
Kubernetes Custom Resource Bindings
-
bitvector
in Rust
-
squads-rustfsm
Define state machines that can accept events and produce commands
-
espalier
Very simple flattened tree structure
-
smol-atlas
2D rectangular bin packing with optional item removal
-
contack
easy contact library
-
ref_kind
Different reference kinds
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
thinset
A data structure for sparse sets of unsigned integers that sacrifices space for speed
-
avl
A map and a set implemented with an AVL tree
-
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.
-
simple-grid
2d-grid structure
-
ploc-bvh
A Bounding Volume Hierarchy based on PLOC
-
vslab
container with persistent unique keys to access stored values
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
linear_collections
Map and Set types backed by linear data structures
-
rustkernel-temporal
RustKernels Temporal domain kernels
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
thin-string
A String with a smaller stack footprint
-
trie
A highly general and customizable trie library
-
oxa-types
Rust types generated from the OXA schema
-
merkle-tree-stream
A stream that generates a merkle tree based on the incoming data
-
faststr-fork
Faststr is a string library that reduces the cost of clone
-
monarch_data
Data types and utilities handling
-
pvec
RRB-Tree based persistent vector implementation
-
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
-
shortlist
An efficient data structure to track the largest items pushed to it
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
multidimension
High-level manipulation of multi-dimensional arrays
-
cntp_config
support for reading Contemporary.toml files
-
cortenforge-capture-utils
Capture helpers and recorder sinks (JSON, overlays, pruning) for the CortenForge stack
-
rocstr
An immutable fixed capacity stack based generic copy string
-
bit-byte-bit
Implements a bit string using a collection of bytes
-
stac-io
Input and output (I/O) for the SpatioTemporal Asset Catalog (STAC)
-
commitlog
Sequential, disk-backed commit log library
-
dayendar
advanced days calendar operations
-
ocm-types
Types required to implement the OpenCloudMesh filesharing protocol
-
indexedlinkedhashmap
An indexable LinkedHashMap. The user defines the data structure that controls order.
-
expiring-atomic-filter
Thread-safe approximate membership filter with time-based expiration
-
fey_grid
2D grid data structure and related traits
-
hash_ring
Consistent Hashing library for Rust
-
truncate-integer
Truncate integers
-
faultline_core
Canonical domain models, identifiers, and manifests for FaultLine
-
generational_token_list
A doubly-linked list backed by generational-arena
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
rfidfyi
RFID tag and reader reference, EPC standard lookup, and frequency band encyclopedia -- async API client for rfidfyi.com
-
aircraft_icao_country
aircraft ICAO codes and their country of origin
-
eqmap
Technology Mapping w/ E-Graphs
-
phago
Self-evolving knowledge substrates through biological computing primitives
-
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…
-
extarray
Space-Efficient Extensible Arrays
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
mco-gen
Stackfull Generator Library in Rust
-
redmaple
offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
rdf-writer
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
ministd
Rewriting Rust's standard library for fun (no_std)
-
opt_struct
Optional collections
-
ord-by-set
providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
libwebnovel-storage
A complement to libwebnovel: this package handles downloading and organizing collections of followed webnovels
-
rucksack-lib
The rucksack core library
-
ascent-byods-rels
data structures for Ascent relations, made possible by Ascent's BYODS feature
-
rocketsplash-formats
Shared data types and serialization formats for Rocketsplash TUI animations
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
serde-ordered
A procedural macro for deserializing ordered arrays into keyed structs using Serde
-
lockerroom
Readers-writer access to individual cells of your collection!
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
binary-vec
A sorted vector that uses binary search
-
nu-plugin-engine
Functionality for running Nushell plugins from a Nushell engine
-
stack-queue
Heapless auto-batching queue
-
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…
-
hattrie
A high-performance, cache-conscious, ordered map for string keys, based on the HAT-trie paper
-
raphy
A graph data structure library
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
foldlist
A mutable list with fast folding
-
elicitor-types
Core types for the elicit crate - presentation-agnostic survey definitions
-
lace_codebook
Contains the Lace codebook specification as well as utilities for generating defaults
-
openrouter-provider
Type definitions for the OpenRouter Provider API contract (https://openrouter.ai/docs/guides/for-providers)
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
arr-rs
arrays library
-
statiki
Static friendly data structures
-
settrie
Fast subset and superset queries
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
ffi-toolkit
A collection of functions useful for working with the Rust FFI
-
iot_driver_core
iot driver core
-
file-backed-value
lazily generated persistent values backed by a file, with the option to require a recomputation after a certain amount of time
-
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.
-
write_x86_64
help you write x86_64 assembly code
-
traitgraph
Abstracting over different graph representations
-
cbsk_log
log tool
-
indexed_vec
IndexVecfromlibrustc_data_structures -
inexor-rgf-core-di
Inexor - Reactive Graph Flow - Dependency Injection
-
moka-cht
Lock-free resizeable concurrent hash table
-
sortedvec
a sorted vector that enables quick lookups
-
semver-eq
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
dcosl-core
Pure DCoSL protocol types, tag builders, and utilities — no network, no CLI
-
ferreus_bbfmm
Parallel black box fast multipole method (BBFMM) library
-
taskchain
A block-based, non-circular double-linked list implementation for Rust
-
broom
An ergonomic tracing garbage collector that supports mark 'n sweep garbage collection
-
patternize
provide macros and traits to create design pattern
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
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 -
parallel_vec
A generic contiguous collection of heterogenous values
-
aglaea
Automatic Grammar Lifting with Assisted Entity Annotation
-
generic_constants
Traits providing type-generic numeric constants (Zero, One, ..., OneHundredTwentySeven) implemented across common integer and float types
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
leanbridgetree
Space-efficient Merkle tree designed for linear appends with witnessing of marked leaves
-
chinese-validator
Core validation logic for Chinese data (address,id_card, license_plate,name, phone, postal_code,qq,username,etc.)
-
precedence-net
Create and analyse precedence networks
-
medianheap
A median heap for keeping track of a running median
-
large_int
An ease-of-use unbounded signed integer
-
prehash
storing values with precomputed hashes
-
sparseset
A Sparse Set
-
drtahash
A non-cryptographic hash function using AES-NI for high performance
-
idata
Small tools to reduce mutability
-
formualizer-common
Core value, reference, and error types shared across the Formualizer parser and engine
-
coalesced_intervals
Data structure for maintaining maximally-coalesced 1D intervals
-
luka
working with graphs
-
hora-id
A 64-bit time-based sorted unique ID generator that includes the current time in the ID
-
simple_dto_mapper_derive
A derive macro for mapping DTOs with rename/transform/skip support
-
rj
reactive json
-
panoradix
A generic map and a set, both backed by a Radix tree
-
rostl-datastructures
Oblivious data structures for secure and efficient computation
-
enum_meta
Add metadata to Enum Variants
-
entity
that provides entity-like constructs
-
delta-collections
Data structures with revertable operations called deltas
-
flatmap
Fast and Efficient Linear Map and Set for small collections
-
brownstone
building fixed-size arrays
-
ittybitty
An itty bitty bitset to hold your itty bitty bits
-
agentic-memory
Binary graph-based memory system for AI agents
-
gridly
managing fixed-size 2D spaces
-
snowflake
A module for generating guaranteed process unique IDs
-
runfiles
Bazel runfiles support for cargo
-
omango-util
Utililites
-
open-coroutine-timer
The time utils
-
onigiri
handling chars
-
winpty-rs-windows-collections
Windows collection types
-
sequencetree
a new type of collection to store keys and their corresponding values
-
fenwick-bit-tree
Slighly over-engineered FenwickTree implmentation
-
grid-tree
Pixel quadtrees and voxel octrees
-
cbsk_timer
rayon thread runtime
-
HArcMut
mutable arc
-
ix-id
Hash-based ID generation for Ixchel
-
stavec
Stack-allocated vector with static capacity
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
b-k-tree
Burkhard-Keller tree data structure for finding items separated by a small discrete distance
-
hashmap-mem
Fast, low-overhead in-memory hashmap implementation optimized for performance using fxhash
-
extindex
Persisted immutable index
-
scope-cell
temporary, scope-bound, and thread-safe mutation of data in Rust
-
hashbrown_tstd
port of Google's SwissTable hash map
-
pulz-arena
A generational arena allocator with compact generational indices
-
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
-
rep
A small tool for representation/class invariants
-
multi_containers
Ergonomically work with multiple values per key
-
compt
A complete binary tree visitor library
-
zcstring
High-performance zero-copy string handles for Serde, backed by arcstr
-
default-vec2
Vec-like data structure with default elements and a bitset built using it -
butils
shared by software included in BSuccinct
-
envish
Search for environment variables
-
rotated-array-set
An ordered set supporting O(1) rank and O(√n) inserts and deletes
-
art-tree
The Adaptive Radix Tree
-
brie-tree
A fast B+ Tree implementation that uses integer keys
-
pgm_index
Ultra-fast learned PGM-Index for efficient sorted key lookup with bounded error
-
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.
-
bloom-filter-yss
bloom filter for me or you
-
raw-btree
Generic B-Tree implementation
-
xml-schema
Structure generator from XSD source file
-
siraph
A node-based digital signal processing crate
-
patina_internal_collections
Collection types to the DXE Core
-
ordinary-types
Types for Ordinary
-
uniqer_rs
flexible library for generating various types of unique IDs using a builder pattern
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
patricia_router
Radix Tree implementation for Rust
-
box-collections
A no_std compatible implementation of the collection crate
-
circbuf
A growable circular buffer for working with bytes
-
implies
A parser for logical formulas
-
jse
JSE (JSON Structural Expression) interpreter for Rust - AST-based architecture
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
smallbitset
series of allocation free sets capable of holding small integer values
-
brk_rolldown_plugin_chunk_import_map
Rolldown plugin for chunk import mapping
-
multiset
Multisets/bags
-
attuned-core
Core types and traits for Attuned - human state representation for LLM systems
-
z_table
lookup functions for the standard normal table, also called Z table
-
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
-
fluxus-api
High-level API for Fluxus stream processing engine
-
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…
-
ttmap
Trivial implementation of type map
-
stack-map
constant-size associative container for building higher-level data structures out of
-
lightspeed_logger
LightSpeed
-
map-macro
Declarative macros for statically initializing collections
-
reactive-signals
dx-first scope-based fine-grained reactive system
-
ppar
Persistent immutable array
-
emcee
Python's emcee affine-invariant mcmc ensemble sampler
-
grid-engine
A flexible and efficient library for managing 2D grid-based layouts with automatic collision handling and dynamic vertical expansion
-
msgpack_simple
Simplified, easy to use, pure Rust MessagePack implementation focused on handling dynamic data structures
-
bijux-atlas-model
Persisted atlas data models and serde contracts
-
indexed_json
Index json files like a database
-
deep_causality_data_structures
Data structures for for deep_causality crate
-
vec-strings
Store any string efficiently in an immutable way
-
muds
Minimalistic Data Structures and Entity-Component-System Library
-
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.
-
wplot
Plot interface
-
oxilean-elab
OxiLean elaborator - Surface syntax to kernel terms
-
rotbl
Read Only Table
-
school_library
structures to manage school-related data, including students, classes, and schools
-
ruchei-collections
Collections to support the implementation of ruchei
-
hirpdag
procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
densevec
Map like collection with usize indices that stores values contiguosly
-
holyhashmap
A hash map with stable indices
-
boarddown
Local-first, file-based Kanban storage engine with sync capabilities
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
recursive_reference
way to walk on recursive structures easily and safely
-
slas
Static Linear Algebra System
-
pi_cancel_timer
Cancellable timer based on wheel structure
-
mori
orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
mzdata-spectra
A subset of
mzdata’s traits and spectrum data model -
host-port-pair
Host-port pair type
-
tree-sitter-traversal2
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
phf_macros
Macros to generate types in the phf crate
-
hash-rings
Implementations of various hash rings
-
union-fn
Proc. macro for creating efficient "inline closures".
-
reputation-types
Core types and data structures for the KnowThat Reputation Engine
-
designal
Procedural macro for use with futures-signals
-
aversion
Versioned data structures with auto-upgrading
-
hybridmap
Hybrid map using smallvec and the std hashmap
-
sum
General-purpose sum types
-
no-copy
packer, but no implement copy
-
minsize
Collections with a statically known minimum size (using const generics)
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
oak-structure
AST-based document structure and symbol tree generation for the Oak framework
-
advanced_collections
advanced data structures (collections). Includes counter (hash-bag, multiset), disjoint set (union-find, merge-find), circular buffer (cyclic buffer) and interval (range)
-
struct-reflection
obtaining struct field names at runtime through reflection-like capabilities
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
nfcfyi
NFC chip reference, NDEF type lookup, and contactless standard encyclopedia -- async API client for nfcfyi.com
-
simple-triplestore
graph database for storing triples with support for custom node and edge properties
-
segmentmap
A collection that maintains insertion order
-
minimizer-iter
Iterate over minimizers of a DNA sequence
-
syntastica-queries
Collection of tree-sitter queries for syntastica
-
wasm_macro
Collections of useful macros for wasm
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
kcr_security_profiles_operator_x_k8s_io
Kubernetes Custom Resource Bindings
-
uuidv7
UUIDv7 implementation
-
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… -
sugars_builders
Builder pattern utilities and abstractions for the cyrup-sugars ecosystem
-
partial-array
potentially partially-filled arrays
-
dwbase-metrics
DWBase: agent-first immutable atom store, components, and tools
-
sea-plus
A collection of useful extensions for SeaORM
-
rand_pool
Create a pool of random numbers pre generated thread safe
-
gpui_rn_sum_tree
A sum tree data structure (fork for React Native GPUI)
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
persistent-kv
Persistent key-value store
-
im-pathtree
Immutable, path-addressable tree data structure
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
bdaddr
Bluetooth Device Address
-
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
kollect
Collections made ergonomic for gamedev usecases
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
libnv
Safe and rustic wrapper around libnv-sys
-
mutcursor
Safely stores mutable references to parent nodes, for backtracking during traversal of tree & graph structures
-
aligned-utils
Common utilities to work with aligned values and allocation
-
betterunion
safe union-like structure which uses the turbofish operator for reads and writes
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
zjctl-proto
Protocol types for zjctl RPC communication
-
froop
A functional reactive stream library for rust
-
sequential-id-alloc
sequential ID allocator that guarantees sequential allocation
-
limq
Queue with a controller for monitoring queue elements
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
watermark
watermarking set for in-order insertions
-
string-newtype
New Type idiom helper for string-like types
-
index_many
A proof of concept for indexing an slice at multiple locations at once
-
cock-tier
Measure the power level of a peen
-
synesthetic-validator
Validation helpers for Synesthetic operator and graph definitions
-
canadensis_bit_length_set
A bit length set type used to calculate data type sizes when processing Cyphal data structure description language files
-
orx-pinned-vec
PinnedVectrait defines the interface for vectors which guarantee that elements added to the vector are pinned to their memory locations unless explicitly changed -
word-dictionary
data structure for word mapping. It can be used for language translation.
-
formualizer-sheetport
SheetPort runtime: bind manifests to workbooks, validate IO, and run sessions deterministically
-
mattbusel-mem-graph
Knowledge graph primitives: entities, relationships, typed properties, BFS/DFS traversal
-
kcr_kafka_banzaicloud_io
Kubernetes Custom Resource Bindings
-
cmtree
A generic Cartesian Merkle Tree implementation
-
mappy-client
Client library for mappy maplet data structures
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
herolib-sid
SmartID - Short, human-readable, collision-free identifiers
-
fairqueue
Spatially distancing fair queue. A kind of queue for sequential round-robin processing.
-
sliceable-ring-buffer
A double-ended queue that Deref's into a slice
-
tinyvecdeq
VecDeque-like data structures -
openvx
1.3.1 wrapper
-
fwdlist
A simply linked (forward) list
-
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"
-
rust-bloomfilter
bloom filter implementation in Rust programming language
-
data_hook
A lightweight data collection facade
-
fr-trie
Fuzzy Radix Trie
-
rustz
functional programming in Rust
-
indexlist1
A doubly linked list, backed by a vector
-
eldek-tad
A project for learning Abstract Data Types (ADTs) in Rust. Heavily inspired by Java's implementation.
-
gufo-tiff
Data structure for TIFF images
-
construe
Compile-Time Growable Array: Vec & String for const!
-
gamma
Graph primitives and traversals for Rust
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
lykoi_data
data
-
ring_pair
Tiny fixed-size ring buffer specialized for exactly two elements
-
rive-models
Revolt API models for the Rive ecosystem
-
rshyper-algo
implements various algorithms for the rshyper framework
-
timer-queue
Pure, minimal, and scalable timers
-
static-collections
Implementations of fixed-capacity collection types
-
influxdb-dispatcher
Batch metrics collection using influxdb
-
search_trail
manager of variables that can save and restore their values
-
flex-algo
Rust commonly used data structure and algorithms
-
mdcs-compaction
Compaction, pruning and stability subsystem for the Carnelia MDCS
-
lumberjack
Read and modify constituency trees
-
fast-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
debounce
Data structures and helpers for debouncing a stream of events: removing duplicate events occurring closely in time
-
string-mumu
String functions and tools plugin for the Lava / Mumu language
-
atomic_ptr_cell
Safe no_std repr(transparent) wrapper for AtomicPtr and &AtomicPtr with an api similar to a cell
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
set_genome
A genetic data structure for neuroevolution algorithms
-
netlist
generic netlist data structure for VLSI design
-
sets_multisets
API for working with sets and multisets of elements of type usize
-
lazy-cogs
Lazy Cogs is a implementation of lazy clonable data structures
-
veripb-formula
VeriPB library to handle pseudo-Boolean constraints, formulas, and more data structures
-
campo
Easily create and handle bit fields
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
steel-imbl
Immutable collection datatypes
-
win-variant
that aims to provide a more ergonomic way of working with variants in winapi based projects
-
tiered-vector
Tiered Vectors
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
taganak-core
RDF types and interfaces from Taganak (Transactional, Aggregating Graph Architecture for Networking and Access to Knowledge)
-
jvs-packets
that provide structures for JVS protocols
-
quickphf_codegen
Code generator for creating static maps and sets for use with quickphf
-
canutils-lib
A collection of types for working with CAN bus data
-
list-any
Type erased slices and Vecs
-
cbloom
Concurrent implementation of Bloom filters
-
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
-
boxing
cross-platform implementations for NaN and ptr boxes
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
malwaredb-api
Common API endpoints and data types for MalwareDB components
-
inplace-vec-builder
Build a vec from a vec, in place
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
baz-tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
fenny
working with Fenwick trees
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
fuzzy-search
collections for fuzzy search
-
tree-rizzen-yazston
Tree Library using the Any trait for data
-
elizaos-plugin-memory
Memory management plugin for ElizaOS (Rust)
-
fn-store
A dynamic persistent value store using closure type as key and storing its return value
-
fixed-index-vec
A vector-like data structure whose indices do not change when elements are removed
-
succinct
data structures for Rust
-
tokmd-analysis-types
Analysis receipt contracts for tokmd
-
recoverable
Recovery information and classification for resilience patterns
-
omega-persistence
SQLite-based persistence layer for ExoGenesis Omega with schema migrations and transactions
-
catalan
binary tree of n variables where the parent node represents a function and the child node represents a value
-
weave-draft
representing and manipulating weaving drafts
-
chainbuf
Fast chained buffers
-
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
foreign_vec
Unofficial implementation of Apache Arrow spec in safe Rust
-
tugger-file-manifest
Interact with lists of files through a storage-agnostic interface
-
artsy
ART Tree data structure library
-
csc411_rpegio
A collection functions to handle rpeg data i/o. Intended for use in URI's CSC 411 class.
-
minivec
A version of Vec that's only the size of a single pointer
-
v9
A slim data engine for Data Oriented Design
-
oxc_index
Newtype-style helpers for
Vecandusize -
histogram-sampler
Sampling from a distribution given by a histogram
-
linear-map
A map implemented by searching linearly in a vector
-
dge-gen
building a computational graph to be executed distributely
-
trying
Basic trie crate
-
steru
-
bitf
procedural macro to easily create a bitfield out of a struct
-
geosite-rs
that parses geosite.dat file format
-
xio_base_datatypes
XIO base data structures
-
seq-str
Flat collections of strings etc
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
blockset-lib
BLOCKSET internal library
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
unique-pointer
UniquePointerdata structure that makes extensive use ofunsaferust to provide a shared pointer across other data structures -
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
lambda-runtime-types
Common structures for lambda architecture
-
fast-ordered-buffer
A faster buffering implementation for asynchronous streams, trading off memory usage for speed
-
ternary-tree
Ternary Search Trees, with no unsafe blocks
-
corresponding
Move corresponding fields between structs
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
sprsdata
Data structures based on sparse and dense arrays
-
insrcdata
Embed static data as source code
-
bitlab
Extracting a range of bits from a binary data source
-
rosary
About Rose Trees
-
zkcg-common
Shared types, errors, and utilities for the ZKCG protocol
-
stac-extensions
Manage STAC extensions (https://stac-extensions.github.io/)
-
pax-properties-coproduct
Static container for program-variable data structures and polymorphic components
-
flat_map
A compact map stored as a vector of key, value pairs
-
shrink-to-fit
Recursively calls
shrink_to_fiton all elements of the container -
seq_watcher
A pair of structures for monitoring a stream of data for one or more sequences
-
shiftnanigans
contains different iteration data structures for either iterating or for shifting iteratively forward and backward
-
boolvec
A vector of boolean stored contiguously in memory
-
simple-graph
Graph library with ability to serialize/deserialize Trivial Graph Format
-
landfill
Various types for dealing with on-disk data
-
delatin
Fast TIN generation using Delaunay triangulation
-
zellij_widgets
A wiget library for zellij
-
shortguid
Short URL-safe Base64 encoded UUIDs
-
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
bitvec_simd
bitvec with SIMD
-
lr_trie
Left-Right trie is trie capable of mapping any string to any string
-
swamp-script-source-map-lookup
Source map lookup for Swamp
-
monistode-assemblers
A collection of assemblers for the monistode set of architectures
-
beat_saber_map
Read and write Beat Saber maps with Rust
-
faultline_compute
Execution backend abstractions for FaultLine
-
clnooms
Assembly-level implementation of interesting data types
-
data_tree
Hierarchical data tree with pathing and search support
-
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
associated_list
An associated list, for cases when the key implements neither Hash nor Ord
-
mem-vec
Vector store trait and Qdrant implementation for MemOS
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
mutable
keep track of changes in structures
-
char-list
A persistent string type with the same API as a linked-list of characters
-
tokmd-substrate
Shared repo substrate context for cross-sensor coordination
-
domain-lookup-tree
A tree structure in Rust optimized for looking up domain names, with wildcard support
-
hgg
Approximate nearest neighbor search collection
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
ef_rs
Elias-Fano encoding scheme
-
html-json-extract
A package for parse some data from html.scripts
-
arraystring
Fixed capacity stack based generic string
-
drthashbrown
port of Google's SwissTable hash map
-
lace_data
Data definitions and data container definitions for Lace
-
hprtree
A Hilbert-Packed-R-Tree implementation for rust
-
quadtree_simple
quadtree implementation
-
telltale-types
Core session types for Telltale - matching Lean definitions
-
xsparseset
sparse set
-
fallback
A helper library to implement fallback mechaism
-
exprz
An Expression Library
-
try_reserve
Stable implementation of the TryReserveError from std for custom collections
-
type-freak
Collection of typed data structures, trait operators and aliases
-
oot_bitset
A no‑frills, zero‑overhead bit flag system
-
wrapped_slab
WrappedSlab: Auto-generate newtype idiom based on a Slab
-
regroup
regrouping arrays
-
barcodefyi
Barcode format lookup, symbology reference, and standard encyclopedia -- async API client for barcodefyi.com
-
sys-mumu
System calls and tools plugin for the Mumu ecosystem
-
wccg-models
WCCG Data
-
rudac
common data structures and algorithms
-
qipu-core
Core domain logic for Qipu knowledge management system
-
task-collection
Types for managing and waiting on groups of tasks
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
predicates
boolean-valued predicate functions
-
tf_playlist
The playlist feature used in Tubefeeder
-
slotmap-slice-fork
Fork of slotmap
-
merkle_light
Light merkle tree implementation with SPV support and dependency agnostic
-
cortenforge-data-contracts
Data contracts for run manifests and capture metadata used across the CortenForge stack
-
stack-vector
Vec-like wrapper for an array allocated on the stack
-
ord-collections
offering collections which are pre-sorted automatically
-
pointcloud
An accessor layer for goko
-
sipha-analysis
Grammar-agnostic scope extents and definition collection for sipha syntax trees (LSP support)
-
doubly
Doubly-linked lists in Rust
-
hydroperfox-smodel
Semantic modeling for Rust
-
obsessive_peek
An iterator adapter to peek at future elements without advancing the cursor of the underlying iterator
-
value_pool
implements a ValuePool struct that makes the creation of self-referential data structures easier and safer
-
global-registry
A global type registration system for Rust
-
rust-prelude-plus
Higher-order functions built on top of keypaths for type-safe functional programming
-
plod
deriving plain old data
-
uuid47
lightweight library for converting between UUIDv7 and UUIDv4 facade
-
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 -
ztimer
A block-based, non-circular double-linked list implementation for Rust
-
merkle-heapless
Statically-allocated Merkle Tree and Mountain Range
-
pokeapi-model
Data structures for PokéAPI v2
-
sweeper
A foundation for Minesweeper implementations in Rust
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
extended-rational
implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
graphlib
powerful rust library for the graph data-structure
-
resizing-vec
An automatic resizing vector for data with linear increasing ids
-
neopdf_capi
C language interface to NeoPDF
-
type-erased-table
A column-oriented based raw data storage
-
cortenforge-models
Burn-based model definitions (LinearDetector/ConvolutionalDetector) for the CortenForge stack
-
anyval
A lightweight, dynamically‑typed value container for Rust that works like a scripting language
-
bankarr
Array-like but growable vectors
-
beehive
collections for 3D hexagonal maps
-
skippy
Highly flexible worst-case O(log n) intrusive skip list
-
internode
Smart references to your graph nodes
-
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>.
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
chainmap
mutability of intermediate maps
-
disk-ringbuffer
lock free on disk ringbuffer to be used in the implementation of Franz
-
luthor
A collection of lexers for various languages/formats, and the tools required to build them
-
range_union_find
A union-find data structure for ranges
-
tilecoding
Dr. Richard S. Sutton's tile coding software.
-
ndcopy
Fast N-dimensional array memcpy
-
rust_redux
A Redux-like state management library for Rust
-
patternutils
Tiny utility library for some common design patterns
-
lottie-data
Data structures for Lottie animations
-
reversible
A generic wrapper struct that provides reversible editing capabilities
-
btree-ondisk
BTree structure on persistent storage in userspace
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
tyght-map
A static type map implementation
-
jsondiffpatch
JSON diff & patch (object and array diff, text diff, multiple output formats)
-
retriever
embedded in-memory data store for rust applications
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
upair
Unordered pair data structure
-
sorted_vector_map
maps and sets backed by sorted vectors
-
segmented_string
an immutable string type built from array segments, similar to clojure's persistent vector, with unicode grapheme/width support
-
lobby-queue
Const-size queue-like data structure
-
cphf
Compile-time perfect hash function data structures
-
s3vectors-metadata-filter
A flexible and efficient Rust library for filtering data using S3 Vectors Metadata Filter
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
fenwick-tree
binary indexed tree (Fenwick tree) data structure in Rust
-
dltree
Doubly linked tree with leaf-considering typing
-
pq-tree
consecutive ones property (C1P) and graph planarity testing
-
liblet
learning about formal languages and grammars
-
forrustts
Tools for forward simulation with tree sequence recording
-
cirno_store
containing motivational phrases in Japanese and Russian
-
lhlist
Labeled heterogeneous lists
-
ittapi
High-level Rust bindings for ittapi
-
scopegraphs-prust-lib
fork of prust for scopegraphs
-
contigious-tree
Write and read tree graphs to and from contigious blocks of memory
-
kurobako_problems
A collection of black-box optimization problems
-
graphlib_rust
Dagre's Graphlib implementation in Rust
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
planck
Lightweight, modular utility crates for Rust
-
tensorlogic-oxirs-bridge
RDF/GraphQL/SHACL integration and provenance tracking for TensorLogic
-
optionee
The macro to create option struct easily
-
smallbytes
= SmallVec + impl BufMut (from the bytes crate)
-
inspector
General purpose inspection for popular data structures
-
segarray
A fast, growable array type with no copies
-
polystore
Polymorphic data store
-
typed_polars
A statically-typed wrapper around Polars for compile-time type safety
-
tournament-kway
k-way merge using a tournament tree
-
memtally
A wrapper for some collection types that keeps track of indirectly allocated heap memory
-
exhaustive-map
An exhaustive map for types with finite inhabitants
-
arq
manage Arq Backup data formats
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
dst
Data structures for DSTs
-
cursorvec
Cursored vector container
-
parallel_frontier
Queue-like frontier for breath-first visits on graphs that supports constant-time concurrent pushes and parallel iteration
-
stable-id
mainly deals with issuing and maintaining stability of indices
-
timer_list
A list of timed events that will be triggered sequentially when the timer expires
-
bytearray-ringbuffer
a no_std and no-alloc ring buffer for variable-length byte slices in rust
-
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…
-
dependency-graph
building and resolving dependency graphs
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
guzzle
A derivable trait for consuming key value pairs into structs
-
sekiro
Raw structures and bindings for From Software's title Sekiro: Shadows Die Twice
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
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.
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
densemap
A collection data structure that is permanently accessible by unique keys and fast iterable
-
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…
-
graphrepresentations
providing efficient abstract implementations of different graph representations
-
cycler
A simultainious write/read data structure
-
arraysetcell
A fixed-capacity, vector-like array with interior mutability and no ordering guarantees
-
list-zipper
a zipper data structure for sequenceable data types
-
fixedvec
A heapless version of the Rust vector type
-
gtars-scoring
Small, rust utility to compute read overlaps of fragments files over a universe
-
loose-semver
Loose parser for Semantic Versioning
-
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… -
twovec
A data structure for storing 2 types of data in a packed, heap allocated array
-
bstree-file-readonly
Query read-only binary-search tree file, supporting billions of entries in files of tens of GB
-
identified_vec
Like HashSet but retaining INSERTION order and without
Hashrequirement on the Element type -
chinese-rand
Random generation of data structures in Chinese, using Rust
-
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
dyn-slice
&dyn [Trait] implementation, inspired by a Reddit thread
-
kg-utils
Various collections and utilities
-
singletonset
SingletonSetdata structure, which makes it easy to store a single instance each of various types within a single set -
rahashmap
Fork of standard library HashMap with additional functionality
-
overtone
An API for creation and management of rich (as in rich-text) musical-ish projects
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
swiss-eph-data
Embedded ephemeris data files for swiss-eph (Swiss Ephemeris)
-
double-map
A HashMap with double key to single data/value
-
alist
Association list offering fast lookups while preserving insertion order
-
mdcs-delta
Delta-state CRDT machinery for the Carnelia Merkle-Delta CRDT Store
-
dsa_sport
revision material for undergrads
-
set-trie
A trie for fast subset and superset queries
-
ordered_hashmap
Ordered Hashmap implementation to overcome arbitrary order of key-values problem in Rust
-
purse
Bag data structure implementation in Rust
-
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
-
go-heap-rs
Golang's heap written in Rust
-
aam-rs
Abstract Alias Mapping (AAM) framework for aliasing and maping aam files
-
handy
providing handles and handlemaps
-
multi-stash
Vector-based arena data structure that reuses vacant slots
-
char-buf
A writable, fixed-length
charbuffer usable inno_stdenvironments -
subranges
manage non-interssecting integer intervals
-
bl-range-set
working with range sets
-
asbytes
Traits for viewing data as byte slices or consuming data into byte vectors. Relies on bytemuck for POD safety.
-
keyarray
modeling and managing mutually exclusive states (keys in a key array)
-
expiringmap
a HashMap-backed TTL map
-
prefix-tree-rs
A Trie (prefix tree) implementation
-
suffix_trie
Suffix trie for searching
-
range-traits
Ranges related traits
-
dahl-partition
An efficient representation of a set partition
-
ringo-buff
Ring buffers for bytes, with heap and stack storage
-
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) -
dectree-rs
A decision tree implementation in Rust
-
tuplities-flatten-nest
Traits for flattening nested tuples and nesting flat tuples
-
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).
-
anvaya
ECS like dynamic storage in ~500 LOC
-
statemachine-rs
A statemachine crate which have zero dependencies
-
phago-rag
Biological RAG — query interface on self-organizing Hebbian knowledge graph
-
ineru
Neural-inspired memory system for AIngle AI agents
-
spark-signals
A standalone reactive signals library for Rust - fine-grained reactivity for any application
-
hicollections
C-liked Collections
-
goodreads
deserializing a Goodreads library export
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
-
willowtree
Lazily evaluated trees
-
gridbugs
Collection of re-exported crates for building roguelike games
-
groupex
Syncronization primitive that allows acquire lock by index
-
tessera-design-toolkit-core
Core library for Tessera Design Toolkit (TDT) - engineering artifact management with requirements, risks, BOMs, tolerance analysis, and full traceability
-
isomorphism
2 directional hashmaps
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
xtree
general purpose tree data structure
-
array2ds
Package for handling sized 2d arrays in rust, without the usage of the keyword unsafe cuz why not
-
sharedvec
A fast but limited collection for storing values of a single type
-
simple-observable
observable pointer for mutable and immutable data
-
simple-ref-fn
function wrappers that do not require virtual tables
-
pinned_vec
Vec-like data structure whose elements never move
-
soak
Transform a struct into arrays of its fields
-
grangers
working with genomic ranges and annotations
-
btree_experiment
implements a BTreeMap similar to std::collections::BTreeMap
-
mkargs
Build command arguments
-
rs_transducers
transducers for Rust
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
adts
Common abstract data type traits and implementations
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
chesspos
Basic structs for representing chess squares
-
embassy-mock
An unofficial collection of mocked types for the Embassy framework
-
bufferbuffer
Double Buffer design pattern from 'Game Programming Patterns' by Robert Nystrom
-
evidentsource-core
Core types for the EvidentSource event sourcing platform
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
array_manipulation
Methods for manipuling arrays in a Vec-like fashion. It will (probably) get into core once const expressions get less experimental.
-
justly
justified containers
-
shapemap
RDF data shapes implementation in Rust
-
wide
help you go wide
-
simple-file-manifest
Interact with lists of files through a storage-agnostic interface
-
modupipe
A modular and extensible ETL-like pipeline builder
-
pl-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
RustyDSA
A libary for Rust data structure
-
sparse_set
sparse set data structure
-
composite_types
Compose type definitions in the style of typescript
-
lending-library
A key-value store that loans full ownership of items
-
merkle
tree implementation with support for generation of inclusion proofs
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
dsu-tree
A non-invasive disjoint-set-like data structure implementation
-
rust-constraint
constraint satisfaction problem (CSPs)
-
cartesian-tree
Construct a Cartesian Tree from a Slice in Linear Time
-
triangle_matrix
Triangle matrix indexing operations
-
cds
Collection of Optimized Data Structures
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
fast_trie_tree
A fast
TrieTreefor multiple data types -
deltastruct
Allows defining deltas for tagged structs for later application
-
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. -
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
nstree
construct branched 'namespace strings' for nested subcomponents, often for logging
-
mt-kahypar
A statically-linked Mt-KaHyPar
-
nimble-steps
Nimble Steps Collections
-
tinymap
A map structure that stores its data on the stack
-
slablit
Literal for slab creation
-
enumoid
Enum Indexed Containers
-
restorable
An iterator adapter for saving and restoring iterator state
-
read-copy-update
locking primitive
-
dynp
Dynamic property system that emphasizes the use of the Newtype pattern
-
openligadb
API
-
aabb
Static AABB spatial index for 2D queries
-
simple_trie
array backed trie
-
streams
A collection of stream-extensions that are missing in the
futurescrate -
ascii-dag
Zero-dependency, no_std compatible ASCII DAG renderer. Visualize error chains, dependency trees, and graphs in the terminal.
-
bst-hashmap
A binary tree implementation with a hashmap-inspired interface
-
retrace
Safe, generic rollback log with predictable latency
-
hedge
An index based half-edge mesh implementation
-
ndim
N-dimensional array for numerals in Rust similar to NumPy
-
range-split
splitting sequences with range parameters
-
cmus-status
structure cmus status data
-
hibit_tree
Hierarchical bitmap tree. Integer-key map that can intersect FAST.
-
make-message-bus
Generate a pub-sub bus for use in async applications
-
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.
-
literally
Macro literals for members of std::collections
-
arrow
Apache Arrow
-
datastructures
A variety of data structures for learning purpose
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16coordinates. -
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)
-
merkle-tree-bulletin-board
A public bulletin board based upon Merkle trees
-
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…
-
sorbus
A tree manipulation library
-
fns
add common fn, eg: debounce, throttle
-
cast-rs
A collection of types cast for Rust
-
ecoord-core
Core primitives and operations for transforming between 3D coordinate frames
-
lightning-containers
A set of lock-free data structures
-
kcr_opensearch_opster_io
Kubernetes Custom Resource Bindings
-
croaring-sys
Raw bindings to CRoaring
-
btreemultimap
A multimap implementation with range support
-
leetcode-solutions
A collection of leetcode solution in rust
-
common-tree
common tree lib
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
contiguous_collections
collections backed by flat contiguous arrays
-
circular_vec
A fixed length vector that provides a next function that loops infinitely
-
kotoba-schema
Graph Schema Definition and Validation for Kotoba
-
numas
multidimensional array for efficient computing
-
app_properties
reading application properties from a file
-
small-world-rs
The easiest HNSW vector index you'll ever use
-
exegraph
no_std execution graph library
-
flat-veb
Fast implementation of vEB trees without internal allocation
-
rscm-core
Core traits and functionalities for the creation of reduced-complexity climate models
-
changed
change detection
-
dyn_vec
A Vec<T: ?Sized>
-
bengbenge
inifity array for round-robin dns, beng, beng
-
formualizer-eval
High-performance Arrow-backed Excel formula engine with dependency graph and incremental recalculation
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
akita_core
Akita - Mini orm for rust
-
count-min-sketch-rs
A high-performance, zero-allocation Count-Min Sketch implementation for frequency estimation
-
basedrop
Memory management tools for real-time audio and other latency-critical scenarios
-
spaceindex
-
equivalent-flipped
Similar to
equivalentcrate, but flipsKandQ -
validbr
data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
named_colors
that provides named colors in RGB and Hexadecimal formats
-
gamozolabs/rangeset
Pure Rust x86_64 bootloader and kernel
-
contexts
Implements a type for treating several hashmaps as one
-
incremental-map
combinators for incremental immutable maps (see crate
incremental) -
bidirectional-map
A two-way map data structure for small keys and values
-
twodarray
A 2D array library
-
erased-type-arena
A type-erased allocation arena with proper dropping
-
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…
-
teardown_tree
A binary search tree that supports fast clone and delete-range operations
-
signet-storage
Unified storage interface for Signet hot and cold storage
-
regex-collection
常用正则表达式合集
-
roers
prepare augmented annotations for single-cell RNA-seq analysis
-
queue-rs
queue
-
fxd
Fixed-point decimal implementation
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
rc-hashmap
A HashMap with reference-counted key-value entries
-
chain-map
A chain of maps with a single view into the aggregated values
-
ahtable
Array Hash Table implementation
-
rsleetcode
Implementations of LeetCode problem solutions in Rust
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
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.
-
rust_fixed_width
that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
nerio
generic for neural networks
-
u64_array_bigints
biginteger library based on u64 arrays
-
lazy_vec
A lazily initialized (but eagerly allocated) Vec-like datastructure
-
elastic-array-plus
Elastic vector backed by fixed size array
-
clampf
Clamped floating-point types
-
cdl-list-rs
A circular doubly linked list implementation using Rc<T> and RefCell<T>
-
normal-rust-types
A common Rust types library for the entire Normal ecosystem
-
nonempty-containers
Fast, zero-cost conversion, and fully inter-operable nonempty container types
-
eirproject/libeir_ir
Erlang ecosystem common IR
-
etf-matcher-vector-config-loader
Download and parse ETF Matcher ticker vector configurations
-
hdrhistogram
A port of HdrHistogram to Rust
-
flatten_structs
Allows inlining fields into another struct
-
plurals
singular/plural forms, mostly in English
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
subset-map
A map where the keys are subsets of an initial set of elements
-
rust_multistack
Support for two-dimentional stacks for the Rust programming language
-
grafana-dashboard
grafana import/export data serializable structures
-
differential-dataflow-master
An incremental data-parallel dataflow platform
-
hilbert_curve_generator
A WIP Hilbert Space-Filling Curve Coordinate Generator
-
version-rs
A struct for Versions, with the methods you expect
-
marisa-ffi
Rust FFI bindings for libmarisa - a space-efficient trie data structure
-
discrete_range_map
DiscreteRangeMap and DiscreteRangeSet, Data Structures for storing non-overlapping discrete intervals based off BTreeMap
-
flammkuchen
Some data structures for fun and flammkuchen (e.g. a 2d grid which permits negative indices)
-
bookfile
A container file format with chapters and an index
-
judy-wrap
Judy arrays FFI mid-level binding
-
tui-vfx-types
Framework-agnostic foundation types for the tui-vfx ecosystem
-
lineartree
tree data structure for rust
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
geomprim2d
2D geometric primitive types
-
building_blocks_partition
Acceleration structures for spatial queries on voxel data
-
openrml
(Rust Mesh Library) aims to provide a rust-native mesh processing data structures and algorithms for 3D graphics and VFX applications
-
inditech
A set of technical indicators for time series analysis
-
pulz-bitset
bitset implementation
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
nl-compiler
AIG and Verilog frontend compilers
-
wolf-derivation-graph
Adds support for memoizing data flow graphs to wolf-graph
-
viral32111-xml
XML parser crate for my Rust projects
-
iterlist
Linked list with a cursor based api
-
lookup-tables
High performance & compile-time customizable lookup tables
-
nook
Useful types with niches
-
disjoint-collections
Disjoint-set data structures
-
atlas-rb-tree
A textbook implementation of a Red-Black Tree
-
break_array
For breaking array indexing
-
gcollections
Generic traits over Rust collections library
-
lockfree-cuckoohash
lockfree cuckoo hashmap
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
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 -
ropey
A fast and robust text rope for Rust
-
funnel
data structure that makes it easy to read from multiple channels from a single source
-
mesura
A lightweight library for metrics gathering, Prometheus compatible
-
omega-loops
7 temporal cognitive loops from Reflexive (1ms) to Transcendent (10y) for multi-scale processing
-
fast_set
A set of usize with O(1) creation, add, remove, contains, and clear functions
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
struct-compression-analyzer
Analyzes the bit distribution of packed structures
-
keyed
Implement comparison traits by specifying a key
-
bagofholding
collection types. Efficient data structures that look bigger on the inside.
-
messaging
two-way messaging crate
-
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… -
one-stack-vec
OneStackVec could contain any number of item like
Vec, and it does heap allocation only when it contains more than one item -
kodiak-taxonomy
manage generic taxonomies supporting unique features
-
sized-vec
Type level sized vectors
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
jirachi
A collision resistant runtime agnostic key-generator
-
osmgraph
Convert OSM queries into graphs
-
collectivity
Generic collection traits
-
index_vec
Newtype-style helpers for
Vecandusize -
rcbytes
Rc version bytes crate
-
block-array-cow
In memory array de-duplication, useful for efficient storing of a history of data versions
-
magnetise
asses the similarity between SQL queries
-
polars-structpath-types
Common objects for polars-structpath and polars-structpath-derive
-
priq
Array implementation of the min/max heap
-
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.
-
deep_causality_ast
AST data structure for deep_causality crate
-
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
-
sot
Object Tree
-
ospf-rust-multiarray
A multi-array utils for ospf-rust
-
flatbuffers-owned
that enables a more flexible usage of FlatBuffers
-
fast_collections
noheap zero copy collections
-
greentic-session
Greentic multi-tenant session manager with in-memory and Redis backends
-
priority_container
Datastructure to find n biggest/smallest items within a large set
-
partial
Optional monad with fake variant
-
fionn-diff
JSON diff/patch/merge for fionn
-
membuffer
A very fast flat memory buffer used to deserialize at a fast speed
-
boost_concept_check
Boost C++ library boost_concept_check packaged using Zanbil
-
pas
strided slice
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
regd-testing
regd testing is a collection of utilities designed to simplify testing in regd projects
-
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
-
ordered-map
A HashMap, with the capability of accessing the keys and values in order
-
oxrdf_elevont
Basic data structures related to RDF
-
german-str-borrow
German/Umbra-style strings. Data is borrowed, static, or inlined
-
booking_kit
A powerful and extensible booking toolkit for Rust — featuring core data structures, flexible status logic, and seamless integration into any reservation system
-
qrcodefyi
QR code type reference, version lookup, and encoding encyclopedia -- async API client for qrcodefyi.com
-
bitint
Integer types that have a logical size measured in bits
-
spatialize
collection of spatial data structures used for efficent spatial partitioning
-
tiny-artnet-bytes-no-atomic
Vendored copy of Bytes fork for use in tiny-artnet. Types and traits for working with bytes
-
bit-index
A little-endian zero-indexed bitstring representation
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
libflow
grouping network flow data
-
rsurf
A data structure providing range query filtering with Fast Succinct Tries
-
yrs-kvstore
Generic persistence layer over Yrs documents
-
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…
-
alive-map
An insertion-order-preserving hash map with O(1)
.remove -
dashmap-shard
port of Google's SwissTable hash map
-
cola-crdt
A text CRDT for real-time collaborative editing
-
rds-tensors
Rust Data Science Tensors crate
-
linked-vector
A hybrid linked list and vector data structure
-
critbit
Map and Set based on critical bit trees
-
prometheus-tokio
A collection of tokio runtime metrics for prometheus consumption
-
actions
Software without side-effects. Redo and Undo. Macro's.
-
rdf-vocab
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
stride
A strided slice type
-
raii-map
Map and set types in Rust in which the presence of the entry in the data structure is tied to the lifetime of a RAII handle returned by the insertion
-
apid
Collection of type definitions from several APIs
-
inline-css
Embed CSS directly in your Rust code
-
engcon
macros to define (eng)ineering (con)tracts on data-structure level
-
rstmdb-core
State machine engine for rstmdb - definitions, transitions, guard evaluation
-
multi_key_map
a hash table that shares one value across multiple keys
-
offset
Glorified offsets for arbitrary structures
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
tinyid
A tiny ID type that's like UUID except shorter and easier for a user to type in
-
witness-core
Core types and cryptography primitives for the Witness timestamping system
-
paft-market
Market data models and requests for paft
-
threshold-dict
A data structure to find smallest key that is larger than the query
-
mapack
mapbox vector tiles
-
chunky
Abstract storage of heterogeneously-sized entity-collections
-
activitist
Models of ActivityPub
-
win-idispatch
that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII's gridd)
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
sdsl
interface for the Succinct Data Structure Library
-
collectable
Fallible, no_std-friendly collection traits
-
file_lookup
functions to search up in the file tree for a file by name
-
bitset-matrix
Space-efficient, row-major 2D bitset matrix with fast bitwise ops
-
semver-store
An HashMap structure that uses semver strings as keys
-
intrex
Intrusive doubly-linked lists with items addressed by indices
-
runtime-sized-array
A variable-length array, also called runtime-sized
-
oxigdal-core
Core abstractions for OxiGDAL - Pure Rust GDAL reimplementation with zero-copy buffers and cloud-native support
-
cbsk_log_tokio
log tool, using tokio as the runtime
-
guppy
Track and query Cargo dependency graphs
-
multipath
split file path, like
/home/{user,admin}/file.txt -
atelier_base
Core data structures and I/O tools for the atelier-rs engine
-
processing_chain
set up processing chains of large amounts of data
-
erased_set
A set of erased types
-
tan-lints
A collection of lints for the Tan Language
-
rand_set
A hash set with O(1) random element access and all standard set operations
-
orx-imp-vec
ImpVecstands for immutable push vector 👿, it is a data structure which allows appending elements with a shared reference -
vec-entries
Entry API for iterating over and removing elements from a
Vec -
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
hash_arr_map
Hash maps with an array part, like Lua's tables
-
no_debug
Helper types to omit debug info for select values
-
kodiak-sets
manage generic sets supporting unique features
-
dequemap
A no_std compatible implementation of the dequemap crate
-
sliding_tree
A tree that grows from the leaves and recedes from the root
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
syntastic
Generic abstract syntax representation
-
igraph
A graph representation data structure with a built in index on keys
-
crdt_tree
Tree Conflict-free Replicated Data Type (CRDT)
-
wunderkammer
Entity-Component storage for tiny games
-
hexarr
working with hexagonal grids
-
array-mumu
Array tools plugin for the Mumu ecosystem
-
hayami
general use symbol table
-
curri
Functional Programming Tools
-
standards
A collection of standards for international trade facilitation
-
tree-graphviz
Generate GraphViz DOT directed trees, based on an arbitrary tree structure
-
string-err
String error type
-
dynprops
Creating and extending objects with typed dynamic properties
-
datastruct
A pure-data structure builder
-
codemap2
maintained fork of the codemap crate that contains 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…
-
pciids
parse the pci.ids data file
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
trans-gen-kotlin
Generating Kotlin trans code
-
fido-types
Shared types for the Fido social platform
-
bitsvec
A bit vector with the Rust standard library's portable SIMD API
-
wolf-graph-mermaid
Adds support for generating Mermaid diagrams from wolf-graph graphs
-
arrav
Sentinel-based heapless vector
-
ensure
target state of an object
-
bufferring
Ring buffers for Rust
-
partial_const
way to handle constant and non-constant values in a unified way
-
apint
Arbitrary precision integers library
-
libarena
Arena allocated graph implementation
-
merkl-redb
MerkleTree, embedded friendly implementation with redb backend
-
rshyper-hmap
implements the hypermap implementation (a map-based hypergraph) for the rshyper framework
-
hson
JSON like format for HTML. Allow querying the data through searching methods similar to client-side DOM queries methods
-
mini_uuid
A small and URL-safe UUID crate for Rust
-
sparse_map
A sparse map with stable generational keys
-
secretmangle
mangling sensitive data in memory with a random key
-
banyan
Persistent indexable tree data structure
-
runar-schemas
Protobuf schema types for Runar (ServiceMetadata, etc.)
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
xdag
DAG(Directed Acyclic Graph) lib
-
bidiff
A bsdiff-derived binary patching tool - patch library
-
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.
-
tree-cursor
non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
cgp-core
Context-generic programming core traits
-
tiny-test
tiny-testis collection of functions simplifying test assertions in rust -
datazoo
Bitset and jagged array data structures
-
one_way_slot_map
SlotMap with minimal restrictions on Keys and Values
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
rand_map
A map that creates a random handle on insertion to use when retrieving
-
rbtset
A set based on a RB-Tree for efficient operations
-
freezable
immutable data
-
faultline_geometry
Geometry abstractions and spatial metric contracts for FaultLine
-
unicase_collections
Collection of UniCase datastructures
-
nodegraph
A data structure in rust describing a graph of nodes, where each node may contain arbitrary data
-
inline-str
Efficent and immutable string type, backed by inline-array
-
bitworks
meant to provide easy to use bitsets with emphasis on safety
-
hexga_array_vec
A vector with fixed capacity, backed by an array based on arrayvec
-
simple-matrix
generic matrix library
-
pi_sinfo
used to describe the 'structure', that is, the meta information of the structure
-
validiter
Iterator adapters for validating iterations
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
ov
a collection of traits that allow you to chain off of anything
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
itc
Interval Tree Clocks as described in the itc2008 paper
-
lim-bit-vec
Limited bit vectors
-
simple-bitrange
manipulating bit ranges which is common when working with IC registers
-
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
-
strune
directional knowledge structure library for building linked references and word books
-
chat4n6-plugin-api
Shared plugin API types for the chat4n6 forensic toolkit
-
alopex-dataframe
Polars-compatible DataFrame API for Alopex DB (v0.1)
-
ds-bst
Binary search tree implementation
-
typed_index_collection
Manage collection of objects
-
equivalence
Trait and derive macro for comparing and hashing types modulo an equivalence relation
-
shoo
blackjack games and trainers
-
sbbf-rs-safe
Split block bloom filter implementation
-
typescript-definitions-ufo-patch
serde support for exporting Typescript definitions
-
bfield
B-field datastructure implementation in Rust
-
weakheap
Weak Heap data structure implementation in Rust
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
median-heap
A median heap implementation in Rust, used to keep track of a running median of a sequence of numbers
-
aggregate-map
Collect key-values pairs into a mapping from keys to collections of values
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
fast_forward
Quering collections blazing fast
-
arbitrary-int
Modern and lightweight implementation of u2, u3, u4, ..., u127
-
dwbase-embedder-dummy
DWBase: agent-first immutable atom store, components, and tools
-
dynamic-list
A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
-
dawgdic
Port of DAFSA in safe Rust (original implementation courtesy to Susumu Yata)
-
colours
Color types for different color models with conversions between it
-
mumu-test
Test suite plugin for the Lava language
-
seq-set
A Set collection that maintains insertion order
-
kn0sys-ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
array_map
Map backed array for fixed size keys with O(1) performance
-
id_sys
data structures which can be marked such that they only work with similarly marked integer data types
-
field_accessor
A procedural macro to get and set a struct field by String dynamically
-
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
-
rsor
Reusable slice of references
-
golomb-coded-set
BIP158 Golomb-Coded Set data structure
-
balloc
Bounded allocation datastructures
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
cli_tree
A CLI tool to generate a tree of user defined nodes
-
portable-string
Static-length strings without any allocations
-
data_structure_traits
data structure collection traits
-
atomic-slot
lock-free, atomic slot for transferring ownership of Box<T>
-
automap
pattern to implement key-value maps where the value type contains the key type
-
genindex
Generational index library
-
immutable-avl
An Immutable map and set implement for rust based on an AVL tree
-
big_enum_set
creating sets of enums with a large number of variants
-
xio_instructionset
XIO instructionset data structures
-
compare
Experimental comparators for collections to be generic over
-
markov-generator
Highly customizable library for building Markov chains and generating random data
-
usage
A convenient alternative to the newtype pattern
-
cosmic_undo_2
Undo and redo done the right-way
-
gridava
2D coordinate systems
-
colony
A fast associative data-structure that chooses its own keys
-
another-option
option data type; useful when allocations are expensive
-
partitions
A disjoint-sets/union-find implementation that allows for efficient iteration over elements of a set
-
path-value
Universal type and access property(s) by path
-
setting
The styles of all graphics elements
-
recursive_array
arrays using recrusive data structures to avoid limitations of the rust compiler
-
ketsugou
merges two arrays
-
largeint
that supports large integer arithmetic
-
tongrams
Tons of N-grams
-
artie_common
Common Library for Artie Rust Projects
-
pgat
Proxy GAT: Abstractions for generic proxy views with GAT to enable generic container types
-
pathlink
A URL type whose path can also be used as a filesystem path, for Rust
-
try-push
A trait for attempting potentially expensive actions
-
planspec-core
Core types and validation for PlanSpec declarative work orchestration
-
wildland-catlib
Wildland Catalog Library client
-
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
uguid
GUID (Globally Unique Identifier) no_std library
-
rstructure
A thread-safe data structure library
-
whirlybird
generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
bose_einstein
A data structure that efficiently partitions elements into two sets
-
alignment-exporter
Proc macro providing alignment info for a user-defined struct
-
cset
Fine-grained and reversible struct transactions
-
amalgamator
A set/map like data structure that allows you to combine members together
-
xsd
XSD.rs
-
Project2
Implementations of red black tree and AVL tree
-
incrementalmerkletree-testing
Common types, interfaces, and utilities for testing Merkle tree data structures
-
append-only
Append only versions of std data structures
-
cumulfreqtable
A Cumulative Frequency Table implemented with a Binary Indexed Tree
-
pipebuf
Efficient byte-stream pipe buffer
-
stac-duckdb
Client for querying stac-geoparquet using DuckDB
-
riblt
Rateless Invertable Bloom Lookup Table (RIBLT) data structure
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
llmcc-core
llmcc brings multi-depth architecture graphs for code understanding and generation
-
miniqueue
A minimalistic single-thread job queue based on fold/reduce
-
fpdec-core
Common constants and functions for crate fpdec
-
nb-tree
Very simple tree structure with generic node and branch data
-
cobt
A Cache-Oblivious B-Tree implementation in Rust
-
trie-rs
Memory efficient trie (prefix tree) and map library based on LOUDS
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
hyperbitbit
data structure
-
simple-undo
Easy to use undo-redo library
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
generational_array
A small package to handle generational arrays and prevent the ABA problem while reusing unused space
-
batbox-approx
Approximate comparison
-
shared-vec
Efficient shared container types
-
json-node
A way to work with JSON as a node tree
-
foyer-intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
nebz
an immutable non-empty bytes container
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
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
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
span-map
A data structure for efficiently managing sets of values over spans/ranges
-
kukoo
lockfree cuckoo hashmap
-
gsrs
Generic Self Referencing Struct
-
fionn-crdt
CRDT implementations for fionn
-
bytering
A ring buffer specialized for vectored reading and writing in blocking and async I/O
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
swamp-core-extra
Rust runtime implementations for Swamp core library collections (Vec, Map, Grid, Stack, etc.)
-
bitarr
A fast and efficient Rust implementation of a BitSet, supporting multiple backing stores
-
chtholly_tree
Rust bindings for Chtholly Tree
-
poetrie
Poetic trie crafted with intetion to ease searching of rhymes for poems
-
awid
Small, simple, universally unique identifiers
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
grapes
Persistent graph data structures: Tree, Graph, Arena & more
-
bytes_deque
A growable bytes deque in Rust, providing access to the raw pointer
-
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… -
rand-select
a tiny choice selector
-
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits-sized unsigned integer elements -
lookups
Improve the data retrieval operations for collections
-
palettevec
A palette compressed vector library for potentially insane runtime compression ratios
-
vecbool
bit vector built on top of Vec<u8>
-
passive
A trio of marker traits to classify passive data structures
-
microstr
Stack-allocated string with fixed capacity
-
data-buffer
low-level data buffer type useful for IO and in homogeneous collections
-
portdiff
Data structure for fast local graph rewriting
-
pretree
package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
const-vec
Vec-like data structure with immutable push method
-
llm-optimizer-types
Core types and data structures for LLM Auto Optimizer
-
iter-group
grouping (key,value) iterators into maps of collections
-
sweetrpg-model-core
Core model definitions for SweetRPG
-
faex
A fast and efficient Compact Data Structures Library
-
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
tbytes
A tiny library for reading and writing typed data into buffers
-
pathmod_core
Core runtime for pathmod accessors
-
slotmap-fork-otter
Slotmap data structure - temporary fork for Otter
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
stable-map
A hash map with temporarily stable indices
-
arenas
Arena data structure for efficiently adding & removing items with stable IDs
-
smallgraph
A small graph based on smallvec
-
linked-data-schema
Generates SHACL from Rust structure
-
bittyset
A BitSet type for manipulating bit sets
-
very_simple_trie
A Trie or prefix tree is a specialized tree-like data structure used for efficient storage
-
min-heap
A Min Priority Queue implemented as a Thin Wrapper around BinaryHeap from the Standard Library
-
pfx
A prefix tree (map and set), implemented without any unsafe
-
prfx
Prefix Tree
-
sequential_gen
sequential generator
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
single_byte_hashmap
HashMap for storing singular bytes as keys
-
linked-list
An alternative implementation of std::collections::LinkedList
-
louds
LOUDS implementation for Rust
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
benchmark-counters
Light-weight data structures to help with monitoring and benchmarking
-
mvbitfield
Generates types to work with bit-aligned fields
-
traitgraph-dimacs-io
Functions to read and write graphs in DIMACS format
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
merkle-lite
fast, and composable binary Merkle tree and proof for Rust Crypto hash functions
-
hashcons
Hash cons'ing for compact representations of shared, immutable data structures
-
tokmd-types
Core data types and contracts for tokmd. Tier 1 stability.
-
attuned-store
Storage traits and in-memory backend for Attuned
-
ecstatic
Statically-typed ECS library
-
gentrix
that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
vbox
type erased Box of trait object
-
radyx
A basic radix tree implementation
-
prefix-tree
A map and set interfaces using trie data structure
-
stateset-core
Core domain models and business logic for StateSet iCommerce
-
eztd
Quick start Rust
-
slots
Fixed size data structure with constant-time operations
-
intsplit
splitting numeric types into their binary component arrays
-
hashed-array-tree
Hashed Array Trees
-
another_radix_trie
Rust built radix tree library
-
ndarray-histogram
Histogram support for n-dimensional arrays
-
lazy_simd
Trait based SIMD acceleration and safe abstraction
-
tree-iter
iterating over tree structures
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
cmp_wrap
Let you compare structes by context
-
libreda-splay
Splay map and splay set data structures
-
dstructs
A collection of high-performance data structures for Rust
-
reusable-vec
A Vec wrapper that allows reusing contained values
-
taskai-schema
Schema definitions for TaskAI - structured task representation for AI agents
-
hv-alchemy
Heavy Alchemy - the black arts of transmutation, wrapped for your safe usage and enjoyment
-
building_blocks_storage
Efficient storage for maps on sparse or dense, 2D and 3D integer lattices
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
bloomz
A fast, flexible Bloom filter library for Rust with parallel operations support
-
zond
standard rust collections but with collecting statistics
-
bit-vec-omnitool
A vector of bits
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
pi_slotmap_tree
A tree structure implemented by dense memory linked list
-
graphstack
Graph-structured stack
-
qu-miner-api
API definitions for communication between Quantus node and external miners
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
trailer
Store a type with an associated buffer in contiguous memory
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
prototty_menu
Prototty menus
-
kcr_forklift_konveyor_io
Kubernetes Custom Resource Bindings
-
distant-protocol
Protocol library for distant, providing data structures used between the client and server
-
index_graph
Graph library that only stores indexes from a base array
-
kd-tree-rs
k-d tree
-
extended-collections
An extension to the collections in the standard library with various data structures
-
serde_either
set to enums to deserialize and serialize data that can either be string, struct or vec
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
thread_aware_macros_impl
Macros for the thread_aware crate
-
gtrie
Generic trie implementation with a support of different key and value types
-
ligature
Ligature's data model in Rust
-
extract_map
A HashMap for memory efficent storage of value types which contain their own keys
-
indexland
Rust Collections with Newtype Indices
-
persistent_rope
An immutable persistent rope data structure
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
binartree
Binary Tree realisation
-
ramp_table
RampTable, a data structure useful for certain specialized situations
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
jui_file
file tool
-
final
Wrap a value in a type that does not give out mutable references
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
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)…
-
butterfly-common
Common utilities for the butterfly-osm toolkit
-
bounded
numeric types
-
b-tree
A persistent B+ tree using freqfs
-
keylist
Elixir keyword list in Rust
-
fplist
An immutable, persistent, singly-linked list
-
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.
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
hedel-rs
A Hierarchical Doubly Linked List
-
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/History -
prust-lib
Persistent & Immutable Data Structures in Rust
-
tagged-tree
A tree-like data structure where the values are tagged
-
avl-cont
A contiguous AVL Tree
-
truetree
Trees in Rust
-
quantus-miner-api
API definitions for communication between Quantus node and external miners
-
hubs
The horribly unsafe buffer structure
-
dynamic-grid
Dynamic grid Structure for Rust
-
fill_canvas
FillCanvas is a wrapper around a matrix with special methods to fill the cells
-
vec_key_value_pair
A drop-in replacement for std::HashMap and std::HashSet that use Vec on the backend
-
token_deque
A double-ended queue backed by a vector that allows access to interior values
-
skp-validator-actix
Actix Web integration for skp-validator - high-performance validation for Actix services
-
grafeo-core
Core graph models, indexes, and execution primitives for Grafeo
-
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
-
zkcg-verifier
Shared types, errors, and utilities for the ZKCG protocol
-
jsonpath-rust
basic functionality to find the set of the data according to the filtering query
-
skipidy
A skiplist implementation
-
handlemap
A collection that produces handles that can be used as keys to retrieve the stored items
-
merkle-log
"Merkle Tree-Structured Log" defined in the paper "Transparent Logs for Skeptical Clients." https://research.swtch.com/tlog
-
get-full-year
An unofficial Rust client for getfullyear.com that helps you get the full year
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
grit-bitvec
BitVec, a vector type that can store fixed-width data with irregular bit widths
-
slotmap_fork_lmondada
Slotmap data structure
-
simploxide-bindgen
SimpleX-Chat API types and client generator
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
schema2struct
Convert a JSON schema into Rust structs for efficient and type-safe data management
-
div-int
Rational numbers with a compile-time denominator
-
cbsk_unique
unique value generator
-
scoped_stack
A scoped stack data structure
-
nslice
Structures for interpreting slices of variable length as arrays
-
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
rdf-format
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
disjoint-hash-set
A disjoint set / union-find data structure suitable for incremental tracking of connected component identified by their hash
-
tuplities-ref
A trait for getting tuples of references from tuples
-
shelves
Storing values referenced by a unique typed index
-
ReSet-Lib
Data structure library for ReSet
-
deep-diff
A small crate to deeply diff serde_json::Value trees
-
hashable-map
Wrappers for HashMap and HashSet that implement Hash
-
vec-x
structure
VecXto manage fixed-length arrays, supporting numeric operations and assignment operations betweenVecXand scalar values -
bmap
A bitmap with an internal counter
-
tsil_cev
LinkedList on Vec
-
more_collection_macros
Adds new macros to rust for creating collections
-
forgetful
Track and forget values within a specific scope, enabling detection of repeated values
-
wolf-graph-dot
Adds support for generating Graphviz DOT files from wolf-graph graphs
-
prefix_tree_map
generic prefix tree (trie) map with wildcard capture support
-
kcr_mutations_gatekeeper_sh
Kubernetes Custom Resource Bindings
-
decoded-char
wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
siebencorgie/jakar-tree
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
unsure
handling unsure (optional) values that might fail, with an additional rejection variant
-
simple_ringbuf
Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
faultline_sync
Local-first synchronization models and operation envelopes for FaultLine
-
default-vec
A specialized vector that has a default value
-
ABtree
AVL and Btree for rust
-
memcell
providing a MemoryCell struct, which stores a current and previous value
-
hashable_weak
A hashable weak pointer
-
tree-mumu
Creates Linux
tree-style renderings of MuMu values -
arrowmax
High-performance Arrow data stack: columnar storage, zero-copy streaming, and schema codegen
-
bloom_filter_plus
rust_bloom_filter
-
fixed-collections
Dynamically allocated ungrowable collections
-
key_set
KeySet representing concepts of All, None, Some(list), and AllExceptSome(list), with basic set calculations (intersection, difference, inverse)
-
mumu-array
Array tools plugin for the MuMu/Lava language
-
segmented_array
Segmented array (growable, append-only) data structure
-
nimrodshn-btree
A persistent copy-on-write B+Tree implementation, designed as an index for a key-value store, inspired by SQLite
-
algods
A collection of data structures and algorithms
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
swaybar-types
building swaybar status commands in rust
-
cbor-tag-index
Tag index
-
touch-selection
Selection data structure intended for touch and single button devices
-
trans-gen-dlang
Generating D trans code
-
paft-aggregates
Aggregated info snapshots built on paft primitives
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
arboriter
A tree traversal primitive for Rust, inspired by Tyler Glaiel's blog post
-
pollination
An experimental library exposing hybrid Raft and CRDT primitives
-
heapq
Priority Queue with scoring function
-
weak-lists
Lists with weak references and concurrent iteration and modification
-
hashable_rc
Hashable wrappers for reference countings
-
phago-llm
LLM integration for Phago semantic intelligence
-
zsling
Rust Wrapper around a Sequentially lockign (SeqLock) Ring Buffer written in Zig
-
kvv-efa-api
Rust bindings for the KVV (Karlsruher Verkehrs Verbund) "EFA"-API
-
graphix_algs
Algorithm extensions for graphix: connected-components, contraction, and MST routines
-
local_vec
fixed-capacity vector allocated on the stack
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
frbf
robust, and efficient implementation of the Bloom Filter data structure in Rust
-
b100m-filter
The fastest bloom filter in Rust. No accuracy compromises. Use any hasher.
-
prefix_sum
prefix sum data structure
-
embedded-async-helpers
staticfriendly helpers for async on embedded -
hylo-fix
Fixed-point number types with Solana Anchor support
-
stable_node_set
An ordered set with handles to values
-
merged_range
rangeset that can merge overlap
-
restor
A dynamic resource storage system in rust
-
cacheline-ef
Per-cacheline encoding of sorted integer sequences
-
either-both
An enum similar to the well-known
Either, but with aBothvariant -
bipbuffer
Simon Cooke's Bip-Buffer
-
byte_set
Efficient sets of bytes
-
kvstructs
General basic key-value structs for Key-Value based storages
-
language-objects
Work with language objects for localization
-
array_stump
A data structure mixing dynamic array and sorted set semantics
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
treaplist
A Treap-based list implementation
-
atomic_lifo
Lock free thread-safe lifo for rust
-
wired
WIP: Collection of embeddable database models for Rust
-
grdf
Generalized RDF graphs and datasets
-
arc-bytes
A reference-counted byte buffer
-
cbsk_log_rayon
log tool, using tokio as the runtime
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
cursed-collections
Collections that (seem to) break Rust safety
-
two_three
A two-three (2-3) tree implementation in Rust. Includes a map and set interface
-
kurve
Adjacency list graph data structure
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
quotient-filter
A quotient filter implementation
-
schema-registry-core
Core types and traits for the LLM Schema Registry platform
-
omega-meta-sona
Self-Optimizing Neural Architecture (META-SONA) with evolutionary search and fitness evaluation
-
faultline_agents
Planner/executor/reviewer orchestration contracts for FaultLine
-
typed_id
Make your IDs strongly typed!!
-
broomdog
A type-erased map with 'indefinite loanership'
-
pg_filters
helper to generate postgres sql for pagination, sorting and filtering
-
applejack
Radix tree
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
sesstype
Multiparty Session Types
-
front-vec
Efficiently-prependable Vec and String types
-
setbits
Create an unsigned integer with the high/low
nbits set to1 -
wrapping
slices and arrays
-
mdcs-merkle
Merkle-Clock DAG for causal history tracking in the Carnelia MDCS
-
triskell
A tri-partite ring buffer
-
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
-
secured_linked_list
A cryptographically secured and provable linked list
-
ladata
& modular data model
-
fusefilter
No alloc membership approximation
-
packbytes
Convert structures to and from packed representavises - byte arrays of fixed size that live on stack
-
valet
Stores your objects and gives you a tag to retrieve them later
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
tiny-bitstream
Standard implementation of a classic bitstream library
-
boomphf-patched
Scalable and Efficient Minimal Perfect Hash Functions (version modified by Piotr Beling)
-
maybe
An enum similar to Option but can also represent undefined values
-
pbloom
A portable bloom filter implementation in Rust
-
spigal
fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
no_vec
modifying sized arrays
-
kd_interval_tree
Implements a K-dimensional interval tree, for fast interval-overlap lookup. Binary-tree based implementation, i.e. O(log(n)) lookups.
-
linkedin-csv
Structs defined to hold the data as exported from LinkedIn
-
compressed_vec
Floating point and integer compressed vector library, SIMD-enabled for fast processing/iteration over compressed representations
-
free-algebra
Types for constructing free algebras over sets
-
num-bigint
Big integer implementation for Rust
-
skog
Adobe's stlab::forest data structure
-
gauze
Probabilistic set membership filters with a simple interface
-
graphific
graph data structure library
-
pathtree
An immutable tree data structure for fast path operations
-
kcr_rocketmq_apache_org
Kubernetes Custom Resource Bindings
-
push-while-ref
push while having a reference
-
backtracking_iterator
generic iterator with an item history, capable of backtracking and forgetting
-
simple-collection-macros
configurable macros for maps and sets
-
fast-list
A doubly linked list using SlotMap for improved cache locality, and to solve the ABA problem
-
sedimentree_core
Sedimentree: a hash-linked CRDT storage structure with fragments, commits, and content-addressed blobs
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
flat_enum
Expand nested enum into flattened enum
-
banyan-utils
work with banyan trees
-
mrkl
Generic, minimalist, parallelizable Merkle tree
-
simple-binary-tree
binary tree view representation
-
anylist
a list type for any type
-
autocomplete
Auto-complete feature using Trie data structure
-
twie
fast and compact prefix tries
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
collect-mac
collect!macro, which can be used to easily construct arbitrary collections, includingVec,String, andHashMap. It also endeavours to construct the collection with a single allocation, where possible. -
dynamic-matrix
work with matrices
-
running_buffer
data types for keeping track of changing values, allowing analysis in trends and histories
-
littlechestnutgames-trie
A generalized trie implementation for quick prefix searching
-
collidea
Collision-prone memory-efficient collections
-
unempty
Non-empty data structures for Rust
-
ascii_num
digit to ascii numbers
-
dastral
Reduce boilerplate code, learn data structures & algorithms with Dastral
-
modern-multiset
A hash multiset implementation
-
eclectic
Experimental collection traits
-
caffeine
Collection of data structures I'm writing for fun. Originally written for use with my crafting interpeters tutorial implementation.
-
collect-rs
Special and custom Collections and Containers (for Rust)
-
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.
-
loaf
Why have a slice when you can have a loaf?
-
dag-cbor-references
Extract blake3 ipld links from dag-cbor blocks
-
interval-rbtree
An interval tree implementation using Red-Black Tree as its underlying data structure
-
asimov-sdk
ASIMOV Software Development Kit (SDK) for Rust
-
blocked-vec
A vector of byte blocks behaving like files
-
compactmap
Compact Vec-based map that choses assigns IDs for your values on it's own. Very similar to Slab.
-
causal-length
CRDT's based on causal length sets
-
kerrex-gdnative-sys
Bindings to the GDNative C API
-
simple-bst
A bst implementation
-
abstract-bits
Turn any combination of bit and byte fields into a structs
-
ipfrs-core
Core content-addressing primitives and data structures for IPFRS
-
simple-canvas
generic 2 dimensional canvas struct
-
object-collection
A collection that can store multiple values of types
-
crio
An easy to use persistent data storage library
-
dot_tree
Create, query and store binary trees
-
seg-tree
segment tree library
-
rt_map
Runtime managed mutable borrowing from a map
-
Xorfilter
No alloc membership approximation
-
ax_banyan_utils
work with banyan trees
-
variant-map
defines maps to store variants of enums
-
shared_bytes
Owned string and byte slices
-
ndarrow
Zero-copy bridge between Apache Arrow and ndarray
-
labelgraph
graph implementation, allowing random access to nodes via labels
-
boost_move
Boost C++ library boost_move packaged using Zanbil
-
specado-schemas-temp
Provider and prompt schema validation helpers for Specado
-
identifier
Generate 128 bits id structs easily
-
enum-ref
Proc. macro for generating enum discriminant types.
-
ensf594-project-mmap
Final project for the ENSF 594 course of the University of Calgary, summer 2022
-
aabel-identifier-rs
defines identifier behavior, such comparing them, or generating sequences of identifiers
-
ent-rs
Entropy and randomness analysis tool for binary files (Rust port of ent.hpp)
-
packed_array
Packed Array aka sparse set structure with compile-time known size
-
interval-map
A vector-based, non-duplicate range-keyed, sorted array
-
simid
Universally Unique IDentifier (UUID)
-
gridd
A generic, dirt-simple, two-dimensional grid
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
streamhist
streaming histogram
-
bytes-quilt
data structure for tracking random-access writes to a buffer
-
smolvec
A lightweight vector implementation with small-vector optimization for rust
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
objectionable
storage of unsized types inline inside allocated objects
-
elaru
Memory safe implementation of LRU cache
-
dogged
Persistent vector, similar to Clojure
-
atelier_dcml
Distributed Convex Machine Learning for the atelier-rs engine
-
hardly-trie
efficient trie data structure implementation
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
flat_collections
Lightweight and memory-efficient associative data structures
-
tzarrays
Optimal resizable Arrays
-
boost_container
Boost C++ library boost_container packaged using Zanbil
-
jsonmap
store values of multiple types value in one Map
-
fral
Functional random-access lists
-
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.
-
usize-set
Set data structures optimized to store sparsely distributed usize values
-
lurk-elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
diamond-types-extended
Unified CRDT library with ergonomic API - fork of diamond-types
-
char_index
efficient charwise indexing into a string
-
molten-core
Core domain models, traits, and types for the Molten document and workflow management system
-
gguppy_data
Traits and adapters used by gguppy for dataframe access
-
dyn_list
A linked list that can hold dynamically sized values in its nodes
-
simple-vec-collections
Collections implemented using Vec
-
no_std_collections
Auxiliary structures and traits for using dynamically resizable arrays (Vectors) in flexible environments, supporting both std and no_std contexts
-
test-mumu
Test suite plugin for the Lava language
-
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
-
hydroperx-sem
Semantic entities for Rust
-
yagraphc
working with Graph data structures and common algorithms on top of it
-
scratchbuffer
A Vec<u8> like data-structure, that can be used as slices of different types
-
bloomy
Bloom filter using only two hash functions
-
vecless
A minimal, Vec-free, singly linked list with Display support and ergonomic APIs
-
fvm_ipld_kamt
Sharded IPLD Map implementation with level skipping
-
mux-radix-tree
A full-featured radix tree implementation
-
synthax
Synthesize syntax with quasiquoting plugins
-
treelike
A trait to abstract over trees, and simplify implementing them, all in one handy crate
-
unsized_enum
Unsized enum implementation
-
copy-range
core::ops::Range et al, but Copy and IntoIterator
-
std_collection_traits
Abstraction of operations in std collection types
-
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
dcl_data_structures
Moved to: https://crates.io/crates/deep_causality_data_structures
-
kcr_dataprotection_kubeblocks_io
Kubernetes Custom Resource Bindings
-
workit
single-threaded work queueing utility
-
indextreemap
A BTreeMap implementation that allows for key and or positional insertion and retreival
-
nvpair-rs
Safe and rustic wrapper around nvpair
-
tiny-bit-flags
Generate bit-flags struct and methods
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
lesbar
String types that must encode legible text
-
armory
a fast pool for storing lots of objects of one type without fragmenting
-
structures
collection data structures
-
contextual
deal with data in context
-
sorted-list
SortedList data structure which allows mapping an Ord key to multiple distinct PartialEq values
-
typedflake
A Snowflake-style ID generator library with newtype-driven design
-
hashvec
A HashMap/Vector hybrid: efficient, ordered key-value data storage
-
altdeque
An alternative deque implementation
-
mapro
A tiny macro library for creating std::collections
-
ninja-files-data
Core data structures for ninja files
-
nostd-bv
Bit-vectors and bit-slices
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
sketches
Probabilistic data structures for scalable approximate analytics
-
dot3
generating Graphviz DOT language files for graphs
-
kn0sys_ndarray_rand
Constructors for randomized arrays.
randintegration forndarray. -
pointer-value-pair
A pair of a pointer and a small integer packed into a pointer-sized object
-
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
-
const_queue
A stack-only, no_std queue using const generics
-
atom_table
Assign easy-to-handle typed IDs to large, hard to handle things like strings
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
intset
Various integer set data structures, each efficient for different operations
-
ttl-queue
A queue that drops its content after a given amount of time
-
prefix_dictionary
Data structure similar to a dictionary, but enabling search for prefixes
-
computed_map
proc-macro crate for generating indexed maps with computed fields and indicies
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
nanobox
NanoBoxoptimization: store small item on stack and fallback to heap for large item -
bstree
A Binary Search Tree written in Rust
-
trie-generic
A trie with generic content
-
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
fcdb-graph
Graph operations and traversal for FCDB
-
automatic-relations
Tree automatic relations
-
pgdb_to_struct
CLI application to generate Rust struct files from PostgreSQL database tables
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
an-rope
an rope for large text documents
-
rope_rd
A Read/Seek rope implementation
-
small-ord-set
A set data-structure represented by a sorted
SmallVec -
just-string
Container for various kinds of strings
-
jmbl
A high performance CRDT
-
bitmac
Structure for accessing to single bits
-
jmt-blake3
Jellyfish Merkle Tree based on BLAKE3 hash function
-
rust_list
Singly linked list in Rust, with macros for easy instantiation
-
functype-core
Core functional programming types for Rust
-
bit-set-omnitool
A set of bits
-
index-map
A map with automatically generated usizes as keys
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
dst-container
Containers for DST objects
-
dcbor
Deterministic CBOR ("dCBOR") for Rust
-
to-offset
developer-friendly methods to manipulate strings with character indices
-
valord-map
A dictionary sorted by values
-
bm-le
Little endian 256-bit layer for binary merkle trie with ssz compatibility and extensions
-
eitherq
Queue which support two different types
-
variant-set
A set-like data structure for enum variants, allowing you to store at most one value for each variant of an enum
-
bitbloom
A no_std Bloom filter implementation
-
bloomfilter-rust
A bloomfilter implementation in Rust
-
borsa-core
Core types, connector traits, and time-series utilities for the borsa financial data ecosystem
-
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.
-
tuplities-option
Traits for working with tuples of Options
-
rdf-reader
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
bugu
Cuckoo Filter: Practically Better Than Bloom
-
unrolled-linked-list
unrolled linked list in rust
-
stac-async
Asynchronous I/O for stac-rs
-
learn_together
Curated collection of lists of useful resources to learn Rust together
-
compressed_map
'Static functions': compressed maps with the keys removed
-
arbutus
Trees
-
dlist
List data structure based on AVL tree. It can store elements which have dimension and quickly search for elements by distance from 0.
-
static-box
A stack-allocated box that stores trait objects
-
zkcg-zkvm-host
host for zkvm
-
wolf-graph
Data structures and algorithms for working with graphs with reference or value semantics
-
enid
parse Encrypted Numeric Identifiers
-
mdarray
Multidimensional array for Rust
-
mycelial-crdt
mycelial crdt
-
timed_set
timed set in Rust to store elements for a given time period
-
slot-vec
A high-performance, reusable slot container for Rust, providing efficient insertion, removal, and iteration of elements
-
data_privacy_macros_impl
Macros for the data_privacy crate
-
distri-types
Shared message, tool, and config types for Distri
-
skip-list
Implementing a skip list with rust
-
kcr_instana_io
Kubernetes Custom Resource Bindings
-
rmat
minimal implementation of two-dimensional matrix algebra
-
phago-viz
Browser-based real-time visualization for Phago colonies
-
hamst
Hash Array Mapped Shareable Trie
-
bloom_filter_plush
rust_bloom_filter
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
omega-agentdb
Advanced vector database with ruvector integration for agent storage and skill management
-
len-trait
Len trait for collectons
-
btree_network
A generic network (undirected graph) data structure
-
cons-rs
containing a Cons data structure
-
open-payments-iso20022-pain
Open Payments - Message Parsing Library - ISO20022 PAIN
-
treers
Sedgewick's tree maps
-
hashtree
A Merkle Tree implementation in Rust
-
content-tree
An efficient data structure for compacted RLE data
-
mini-linked-list
A package containing a minimal i32 LinkedList implementation
-
trans-gen-go
Generating Go trans code
-
sakurai
Performant, general-purpose data structures
-
df-derive
Procedural derive macro for efficiently converting Rust structs into Polars DataFrames
-
offset-views
Create and index offset views of arrays, slices, strings, etc
-
im-rope
Unicode strings backed by RRB vectors
-
minimizer-queue
Fast computation of minimizers using a monotone queue
-
no-order
A transparent wrapper to ignore ordering and hashing of any value
-
compressed-sparse-fiber
Compressed sparse fiber implementation for Rust
-
freezie
small library that disables mutation for the contained type
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
know_yaml
The KNOW Framework for Rust
-
fcsd
Front-coding string dictionary
-
priority-queue-rs
Priority Queue is more specialized data structure than Queue. Like ordinary queue, priority queue has same method but with a major difference. In Priority queue items are ordered by…
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
lighter
Macro for rewriting string matches as tries
-
ring_buffer_max
Keep track of the max value of ring buffer in linear time
-
projected-hash-map
projected HashMap over HashSet
-
type-pools
A data structure to store values of multiple types
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
typerat
Type-level rational numbers based on
typenum -
faultline_diff
Diff and change classification contracts for FaultLine
-
attuned-qdrant
Qdrant storage backend for Attuned
-
delete_if_not
unsafely in-place delete function
-
history-buffer
A fixed capacity, write-only, ring buffer
-
index-set
bitset implementation with support for atomic operations
-
minimal_perfect_hash
Fast minimal perfect hashing (PT-style): per-bucket seeds, deterministic build, O(1) lookups
-
expiremap
Key-Value map where each value has a custom expiry time
-
container_traits
Traits for container types
-
rshyper-core
implements the core functionality of rshyper, focusing on providing the essential components that compose a hypergraph
-
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
paged
Read and create read-only paged database files
-
vector2
2D vector library
-
graphsearch
graph search and representation library
-
rotbuf
Queue implementation wrapped around the
Bytescrates’ BytesMut data structure -
head
Common types with inline headers, such as HeaderVec for Vec
-
any_key
Dynamically typed keys for associative arrays
-
rs-bucket-filter
Skips slow scans using cache, bloom filter,
-
fixedbitset-stack
A forked version of FixedBitSet that supports const generics
-
mqfilters
Highly optimized approximate membership query filters (bloom, cuckoo, xor, quotient) with SIMD support
-
bit-vec_serde
A vector of bits
-
tinybitset
Generic implementation of small, fixed size, copyable bitsets
-
iblt
Invertible bloom lookup table implementation
-
json_to_struct
Convert JSON into Rust structs for efficient and type-safe data management
-
output_iter
An iterator that performs calculation during iteration
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
nexum
collection of commonly used data structures
-
terrain-graph
Graph Library for Rust
-
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
-
hj_ds
A data structure library for Rust
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
flowerbloom
fast bloom filter implementation with thorough documentation and tests
-
anat-rs
represent natural numbers as well-founded sets
-
lazy_list
Lazily-populated lists, finite or infinite
-
robyn
MLIR sidekick
-
serde_map
Mapbased onVecfor serialization purposes -
oxigdal-metadata
Metadata standards support for OxiGDAL - ISO 19115, FGDC, INSPIRE, DataCite, DCAT
-
rs-bush
Bush data structure
-
deqmap
A double-ended queue with optional keys
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
llist
Lisp-style singly-linked list
-
wasmflow-interface
Types used by the Wasmflow tool chain
-
zk-kit-pmt
Generic for storage Merkle Tree (sparse & fixed-size) in Rust
-
trie_map
A trie with good iterator support backed by a hashmap
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
elu
Traits and implementations for EVAL-LINK-UPDATE data structures
-
vmcircbuf
A circular buffer that magically wraps around without any copying
-
kappendlist
Append to a growable list in O(1) without needing &mut
-
collect
An experimental extension of std::collections
-
my-stack
stack implementation in Rust
-
borsa-types
Shared Borsa-specific data transfer objects built on top of paft
-
chargrid_menu
chargrid menus
-
astack
offers a Stack data structure with fixed capacity capable of fast LIFO operations
-
bs
bitset with small-set (single-word) optimization
-
json-mumu
JSON tools and JSON Schema plugin for the Mumu ecosystem
-
styc
Typesystem definition SDK
-
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
-
btreec
Rust bindings for btree.c
-
flats
flattens nested structures into a flat single dimension map
-
bittree
O(1) find functions in a special data structure called a bit tree
-
bytes_to_type
facilitate byte conversion to specified types using macro generation
-
winvec
Windowed Vector (TTL) Collection for Rust
-
fallacy-hash
fallible hash collections
-
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.
-
btreelist
A list data structure that has efficient insertion and removal in the middle
-
trans-gen-python
Generating Python trans code
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
treap_non_random
A non-randomized Treap implementation. Not very useful as a balanced tree, but useful when implementing CVM or similar algorithms.
-
deferred_vector
A deferred vector implementation
-
btree_graph
A generic graph data structure
-
object-chain
Ad-hoc structure builder
-
typeslice
type-level slices
-
collect-me
Additional collections not included in the Rust standard library
-
pinned-queue
Queue-like data structure whose elements can never move
-
kcr_volsync_backube
Kubernetes Custom Resource Bindings
-
flashtext
algorithm to search and replace keywords in given text
-
pq-bincode
A wrapper crate of queue-file for bincode serializable structs
-
linked_list_c
Safely work with c compatible linked lists
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
stonks
Sets that allow borrowing while inserting entries
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
latestmap
latest map
-
bitstr
contiguous sequence of bits in memory
-
bitsetium
One stop shop for all bitset needs
-
rs-collections
generic collections (no dependency on std)
-
distri-a2a
A2A protocol types for the Distri ecosystem
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
circularbuf
Rust fixed size circular (ring) buffer
-
tourney
A small package for generating and simulating tournaments of various structures
-
header-slice
Definitions for slices with headers, and a vec-like type with a header allocated inline
-
llkv-btree
Generic, paged B+Tree with batch-only pager I/O for the LLKV toolset
-
treesome
tree creation, manipulation, traversal and visualization
-
boost_date_time
Boost C++ library boost_date_time packaged using Zanbil
-
bndpresbufq
Bounds-preserving, optionally limited, buffer queue
-
bytesstr
An immutable reference-counted UTF8 String
-
collect-once-hashmap
A hashmap that can be collected only when there are unique keys in the iterator
-
mmap_json_file
parse, count, filter JSON files using memory mapped io library
-
ctxmap
A collection that can store references of different types and lifetimes
-
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. -
uvector
access two slices as a single continuous vector
-
embedrs-bytes
Types and traits for working with bytes
-
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
few
A generalization of
std::Optionallowing for up to two optional values -
rdf-query
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
grafite
Range Filter
-
mrslac
sparse matrix data structures
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
tuplities-debug
A trait for debug formatting of tuples
-
lanyard
UTF-8 C string types
-
rusted_list
A ever sorted list for rust that is operating on binary search
-
fp-collections
An alternate collections library for rust
-
tree-automata
Term Rewriting Systems
-
once-list
an append-only per-item list
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
shared-string
Split a string without another allocation
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
ransel
rank/select succinct data structures
-
kcr_quay_redhat_com
Kubernetes Custom Resource Bindings
-
ax_banyan
Persistent indexable tree data structure
-
cuml_map
A trait representing cumulative mappings, and several implemntations of this trait
-
priority-set
A no_std Priority Set
-
open-payments-iso20022-pacs
Open Payments - Message Parsing Library - ISO20022 PACS
-
smolbox
Like a Box, but small objects are stored on the stack
-
faultline_index
Spatial index abstractions for FaultLine
-
unsized-stack
Fast heterogeneous / unsized stack
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
doubly-linked-list
double link list
-
bytes-expand
Types and traits for working with bytes
-
bitmap4rust
creating and manipulating bitmaps
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
tc-state
TinyChain's general state enum
-
histree
A framework for disk-based historical indices
-
boost_variant
Boost C++ library boost_variant packaged using Zanbil
-
hashset_ext
Extension for HashSet with intuitive, chainable Python-like set operations
-
realhydroper-smodel
Semantic modeling for Rust
-
kalgan_string
A collection of functions for string manipulation used by Kalgan Framework
-
terms
Tree terms and patterns data structures
-
sliced
A segmented vector for iterating over slices
-
intid-core
Defines the IntegerId trait without a dependency on intid_derive
-
mumu-flow
Stream tranform tools plugin for the Lava language
-
rust-ds
Custom data structures crate for Rust
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
moonlight_collections
Collections for Rust
-
frozen-collections-core
logic for frozen collections
-
qmap
LinkedHashMap alternative using nested VecDeque as LinkedList replacement
-
static_merkel_tree
Static Merkel Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
base-traits
base traits (for Rust)
-
metacomplete_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
-
bloomfx
Bloom filter implementation backed by fxhash
-
id_cache
A cache data structure which generates sequentially-assigned ids for unique values
-
cloneless_cow
A greatly-reduced implementation of Cow that does not require T to be Clone but allows for storing either a reference or an owned instance for future needs of references to T
-
stack-stack
stack-allocated stack
-
tag-vec
A vector used for storing tags
-
stacked
Stack-allocated data structures. This was a good learning experience, and these container types work well, but in the end, I was not able to beat the performance of Vec
-
aabel-bloom-rs
implements the Bloom filter
-
small_vec2
Vector on the stack or heap need nightly rustc
-
mutcrab
written in rust that contains various classic data structures
-
trans-gen-csharp
Generating C# trans code
-
animgraph
Animation data flow library using hierarchical state machines
-
sorting-vec
Sorts a vector using a btreemap
-
split_slice
accessing (&[T], &[T]) as if it were a single slice
-
buf-list
A list of buffers that implements the bytes::Buf trait
-
subway
Fast, performant in-memory SkipList implemented in Rust
-
indexvec
Simplified copy of rustc's index crate
-
phago-runtime
Colony management, scheduling, and runtime for Phago biological computing
-
algae-rs
A collection of abstract algebraic structures implemented in Rust
-
cachingmap
A caching Hashmap accepting new entries through interior-mutability