-
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
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
phf
Runtime support for perfect hash function data structures
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
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
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
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.
-
slotmap
data structure
-
bit-set
A set of bits
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
enum-map
A map with C-like enum keys represented internally as an array
-
bimap
Bijective maps
-
zerovec
Zero-copy vector backed by a byte array
-
tinystr
A small ASCII-only bounded length string representation
-
rpds
Persistent data structures with structural sharing
-
bit-vec
A vector of bits
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
generic-array
Generic types implementing functionality of arrays
-
croaring
Rust wrapper for CRoaring
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
generator
Stackfull Generator Library in Rust
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
bio
A bioinformatics library for Rust. This library provides implementations of many algorithms and data structures that are useful for bioinformatics, but also in other fields.
-
wide
help you go wide
-
guppy
Track and query Cargo dependency graphs
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
trie-rs
Memory efficient trie (prefix tree) and map library based on LOUDS
-
rowan
generic lossless syntax trees
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
im
Immutable collection datatypes
-
histogram
A collection of histogram data structures
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
ego-tree
Vec-backed ID-tree
-
enumset
creating compact sets of enums
-
fixedbitset
bitset collection
-
radix_trie
Generic radix trie data-structure
-
range-set-blaze
Integer sets as fast, sorted, integer ranges with full set operations
-
smallbitvec
A bit vector optimized for size and inline storage
-
bloomfilter
Bloom filter implementation
-
yrs
High performance implementation of the Yjs CRDT
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
index_vec
Newtype-style helpers for
Vecandusize -
yada
double-array trie library aiming for fast search and compact data representation
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
imbl
Immutable collection datatypes
-
smartstring
Compact inlined strings
-
bitmaps
Fixed size boolean arrays
-
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
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
barcoders
A barcode-encoding library
-
multimap
A multimap implementation
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
dlv-list
Semi-doubly linked list implemented using a vector
-
bytes-utils
Additional utilities for working with the bytes crate
-
ecow
Compact, clone-on-write vector and string
-
cita_trie
Modified Patricia Tree (aka Trie)
-
array-init
Safe wrapper for initializing fixed-size arrays
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
spade
Delaunay triangulations for the rust ecosystem
-
narrow
Apache Arrow
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
orx-split-vec
An efficient constant access time vector with dynamic capacity and pinned elements
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
egg
egraphs
-
sn_registers
Safe Network Register Logic
-
ringbuffer
A fixed-size circular buffer
-
thin-vec
A vec that takes up less space on the stack
-
smallbox
Small Boxoptimization: store small item on stack and fallback to heap for large item -
linked_hash_set
HashSet with insertion ordering
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
hashbag
An unordered multiset implementation using a hash bag
-
av-data
Multimedia data structures
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
cordyceps
Mycelium intrusive data structures
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
csaf-walker
work with CSAF data
-
newtype-uuid
Newtype wrapper around UUIDs
-
arrow-array
Array abstractions for Apache Arrow
-
vortex-scalar
Vortex Scalars
-
louds-rs
High performance LOUDS (Level-Order Unary Degree Sequence) library
-
array-macro
Array multiple elements constructor syntax
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
bridgetree
A space-efficient Merkle tree designed for linear appends with witnessing of marked leaves, checkpointing & state restoration
-
string
A UTF-8 encoded string with configurable byte storage
-
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
-
bitfield-struct
Struct-like procedural macro for bitfields
-
crop
A pretty fast text rope
-
merkle-search-tree
A data structure for efficient state-based CRDT replication and anti-entropy
-
lib-sokoban
Sokoban: compact, efficient data structures packed into contiguous byte arrays
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
vortex-dtype
Vortex's core type system
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
cdg_api
interact with api.congress.gov
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
modql
Model Query Language support
-
qfilter
Efficient bloom filter like datastructure, based on the Rank Select Quotient Filter (RSQF)
-
iset
Map and set with interval keys (x..y)
-
nonempty-collections
Correct-by-construction non-empty collections
-
fastbloom
The fastest Bloom filter in Rust. No accuracy compromises. Compatible with any hasher.
-
range-set
Smallvec-backed containers of sorted integer ranges
-
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. -
portgraph
Data structure library for directed graphs with first-level ports
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
range-collections
Sets and maps of ranges, backed by smallvec
-
intervallum
Generic interval and interval set library
-
blart
adaptive radix tree packaged as a BTreeMap replacement
-
gix-pack
Implements git packs and related data structures
-
hibitset
Hierarchical bit set structure
-
queue-file
lightning-fast, transactional, file-based FIFO
-
dary_heap
A d-ary heap
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
zerofrom
trait for constructing
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
tree_iterators_rs
built to provide you with the iterators to easily work with tree data structures in Rust
-
phf_codegen
Codegen library for PHF types
-
bv
Bit-vectors and bit-slices
-
equivalent
Traits for key comparison in maps
-
lsm-tree
A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
tinyset
Size-optimized sets
-
vers-vecs
A collection of succinct data structures supported by fast implementations of rank and select queries
-
array2d
A fixed sized two-dimensional array
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
grid
Dynamic generic 2D data structure
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
deep_causality
Computational causality library. Provides causality graph, collections, context and causal reasoning.
-
v_frame
Video Frame data structures, originally part of rav1e
-
idlset
Fast u64 set operations library
-
keyvi
key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
xsd-types
XSD data types
-
caches
popular caches (support no_std)
-
vec_map
map based on a vector for small integer keys
-
typed_floats
Types for handling floats with type checking at compile time
-
diff-struct
A trait for diffing and applying diffs to types
-
differential-dogs3
Advanced join patterns in differential dataflow
-
vecmap-rs
A vector-based map and set implementation
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
trees
General purpose tree data structures
-
fqdn
FQDN (Fully Qualified Domain Name)
-
jaq-json
JSON values for jaq
-
flatcontainer
A flat container representation for Rust
-
bloom2
Fast, compressed, 2-level bloom filter and bitmap
-
btree-range-map
B-tree range map implementation
-
cow_hashbrown
port of Google's SwissTable hash map with copy-on-write support
-
xml-builder
Easy and highly-configurable XML builder/writer
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
rust_dynamic
Support for dynamically-typed values in run-time
-
bitfield-rle
A run-length-encoder that compresses bitfields
-
oxidd
A safe, concurrent, modular, and performant decision diagram framework
-
uguid
GUID (Globally Unique Identifier) no_std library
-
nodit
Discrete Interval Tree Data-Structures, which are based off BTreeMap
-
parsable
A trait to easily parse data structures
-
iptrie
IPv4/v6 prefixes lookup structures (based on tries)
-
metatensor
Self-describing sparse tensor data format for atomistic machine learning and beyond
-
map_vec
The Map and Set APIs backed by Vec
-
kempt
Ordered collection types with no unsafe code and no_std support
-
iso7816
Types for ISO 7816
-
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.
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
uluru
fast, LRU cache implementation
-
algorithm
about algorithm data structure, now has ttl with lru/lru-k/lfu/arc and slab/rbtree/roaring_bitmap/timer_wheelss, 关于算法常用的数据结构
-
baby_shark
Geometry processing library
-
gix-traverse
gitoxide project
-
spatialtree
A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)
-
array-concat
Macros for concatenating const arrays
-
validated
The cumulative sibling of
ResultandEither -
mhgl
Matts HyperGraph Library (MHGL). A straightforward library for hypergraph datastructures.
-
extindex
Persisted immutable index
-
id_tree
creating and modifying Tree structures
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
tracker
A macro to track changes on structs
-
slabmap
HashMap-like collection that automatically determines the key
-
xor_name
Xor Type
-
griddle
A HashMap variant that spreads resize load across inserts
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
phf_shared
Support code shared by PHF libraries
-
prio-graph
A lazily populated directed acyclic graph with top-level priority ordering
-
indexset
A two-level BTree with fast iteration and indexing operations
-
base-traits
base traits (for Rust)
-
rsdict
Fast static rank and select data structure
-
smallstr
String-like container based on smallvec
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
tuplez
Tuples represented in recursive form
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
min-max-heap
An efficient, double-ended priority queue
-
intervals-general
enabling general representation of and operations on intervals over generic types (e.g. supporting units of measure or arbitrary built-in types, or any type with PartialOrd implementation).
-
warg-transparency
transparency data structures
-
truc
Rust code generator for safe, fixed size, evolving records
-
scapegoat
Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
-
simple-grid
2d-grid structure
-
etc-os-release
Parse /etc/os-release file
-
chronologic
Time constraint reasoning (scheduling...)
-
chat-prompts
Chat prompt template
-
vortex-error
Vortex errors
-
broccoli
broadphase collision detection algorithms
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
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… -
cactus
Immutable parent pointer tree
-
xorf
implementing xor filters - faster and smaller than bloom and cuckoo filters
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
honeycomb-core
Core structure implementation for combinatorial maps
-
ordered-multimap
Insertion ordered multimap
-
bitm
bit and bitmap (bit vector) manipulation
-
ggapi
communicating with start.gg's API
-
delay_map
HashMap collections whose entries expire after a given time
-
rt_ref
Internal
Reftypes forrt_refandrt_vec -
postman2openapi
Convert a Postman collection to an OpenAPI definition
-
intmap
Specialized HashMap for u64 keys
-
short-uuid
generate and parse short uuids
-
valkyrie-ast
Strong typed abstract syntax tree of valkyrie language
-
json-number
JSON number parsing and storage
-
roadmap
model a project roadmap as a directed acyclic graph
-
pi_slotmap
Slotmap data structure
-
polars-ops
More operations on Polars data structures
-
manganis
Ergonomic, automatic, cross crate asset collection and optimization
-
walker-common
Common functionality for SBOM and CSAF walker
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
tskit
rust interface to tskit
-
more_collections
Additional collections not found in std::collections
-
trie-hard
Fast implementation of trie data structure
-
orx-fixed-vec
An efficient constant access time vector with fixed capacity and pinned elements
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
kbs-types
Rust (de)serializable types for KBS
-
enum-collections
Collections data structures optimized for Enum, initializable at runtime
-
trane
An automated system for learning complex skills
-
relend
A generalized reborrowing mechanism that extends beyond simple references. It also allows for implementing traits that work with reborrowing for custom types.
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
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…
-
pyinrs
type library that is as easy to use as Python built-in types
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
skiplist
in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
validit
Validate data structures internal state
-
c_vec
Structures to wrap C arrays
-
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…
-
basic_trie
Trie implementation in Rust
-
blas-array2
Parameter-optional BLAS wrapper by ndarray::Array (Ix1 or Ix2)
-
libwebnovel
enabling users to get chapters of a webnovel, with multiple available backends
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
differential-dataflow-master
An incremental data-parallel dataflow platform
-
adflib
handle amiga disk files
-
grovedbg-types
Common type definitions for data exchange over GroveDBG protocol
-
fastset
Fast set implementation for dense, bounded integer collections, optimized for quick updates and access
-
typemap_rev
A hashmap, but stores types as keys
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
tailcall-chunk
persistent data structure for efficient append and concatenation operations
-
pasture-core
A framework for working with point cloud data
-
supply-chain-trust-example-crate-000006
port of Google's SwissTable hash map
-
xmltv
electronic program guide (EPG) parser and generator using serde
-
oxidd-manager-index
Index-based manager implementation for OxiDD
-
among
The enum
Amongwith variantsLeft,MiddleandRightis a general purpose sum type with three cases -
optional
supplies a number of Option-like primitive types
-
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
-
canopydb
Transactional key-value storage engine
-
avl
A map and a set implemented with an AVL tree
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
demand
A CLI prompt library
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
reactive_stores
Stores for holding deeply-nested reactive state while maintaining fine-grained reactive tracking
-
timed-map
Lightweight map implementation that supports expiring entries and fully compatible with both std and no_std environments
-
cbsk_base
locked version cargo crates
-
authenticode
working with Authenticode (no-std)
-
snowflake_me
A distributed unique ID generator inspired by Twitter's Snowflake
-
podded
Zero-copy types for constraint environments
-
cantrip
Practical extension methods for standard Rust collections
-
form_builder
building forms with various fields and validation
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
every_variant
EveryVariant trait that provides the every_variant method on types. Allows you to easily generate every combination of variants in structures that contains Enums, or in nested enum trees…
-
slotmap-careful
Wrap the slotmap crate and prevent key reuse
-
hibit_tree
Hierarchical bitmap tree. Prefix tree without memory overhead that act as herarchical bitmap.
-
unordered-pair
A tuple struct representing an unordered pair
-
polytype
A Hindley-Milner polymorphic typing system
-
flatk
Flat layout abstraction toolkit
-
edtui-jagged
A jagged array data structure for the edtui editor
-
sucds
Succinct data structures in Rust
-
pfds
Purely Functional Data Structures
-
matrixable
Traits and structs extending capabilities of matrix-like structures
-
disjoint
Fast and safe implementation of the disjoint-set data structure
-
h3o-ice
Frozen{Map,Set} for H3 cells, based on finite state transducers
-
sized-chunks
Efficient sized chunk datatypes
-
sparsevec
Compress vectors using row displacement
-
ux-primitives
Graphics Primitives for Angular Rust
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
slice_ring_buf
A ring buffer implementation optimized for working with slices
-
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.
-
ordsearch
A data structure for efficient lower-bound lookups
-
bc-envelope
Gordian Envelope for Rust
-
raft-log
Raft log implementation
-
spacetimedb-data-structures
Assorted data structures used in spacetimedb
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
array-object
Self-describing binary format for arrays of integers, real numbers, complex numbers and strings, designed for object storage, database and single file
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
cc-traits
Common collection traits
-
rdf-types
Data-structures and traits definitions for RDF
-
list-fn
A generic lazy list
-
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
-
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. -
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
ultragraph
Hypergraph data structure
-
map-macro
Declarative macros for statically initializing collections
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
tmflib
Interface library for processing TMF payloads
-
hi_sparse_bitset
Hierarchical sparse bitset. Incredibly high performance. Compact memory usage.
-
sync42
synchronization tools
-
sync-ptr
Sync & Send wrappers for raw pointer's
-
named_colors
that provides named colors in RGB and Hexadecimal formats
-
tea-core
Core data structures and traits for tevec
-
suggest
A minimal library to provide similar name suggestions like "Did you mean?"
-
tetengo_trie
A trie library implemented with a double array
-
tree-ds
manipulate tree data structures
-
defer-drop
Defer dropping large types to a background thread
-
roussillon-type-system
A type system for a programming language
-
rbtree
the rbtree for Rust
-
jaggedarray
Multidimensional jagged array
-
btree-slab
A memory compact Slab-based B-tree implementation
-
gctree
cache-friendly, graph-like, arena-allocated datastructures
-
lctree
Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees
-
alot
A forbid-unsafe, generational slot map with usize-sized IDs
-
typeid_prefix
that implements a type-safe version of the TypePrefix section of the
TypeIDSpecification -
variadics
Variadic generics on stable Rust using tuple lists
-
entity_data
A container for entity component data
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
frunk_laws
contains laws for algebras declared in Frunk
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
hotel
Collection Data-structure to associate values with keys
-
horizon_data_types
The Horizon data types library for third-party integrations
-
arbutus
Trees
-
bitboard64
A 64-bit bitboard useful for chess programming
-
decomp
Components of a decompilation pipeline
-
snowflake-ng
Dead easy and high performance
snowflakeimplemented in Rust -
i_shape
iShape is a compact and efficient library specifically designed for representing 2D data structures using IntPoint
-
rust_multistack
Support for two-dimentional stacks for the Rust programming language
-
lsph
Learned Spatial HashMap
-
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…
-
datas
data structures and algorithms and data analisys
-
stacked_errors
high level error propogation with programmed backtraces
-
cmsketch
A count min sketch implementation in Rust
-
signalk
parse signalk maritime data
-
normalize_interval
Normalizing interval library
-
qutee
A quadtree implementation
-
stack-queue
Heapless auto-batching queue
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
do-notation
Monadic do syntactic sugar
-
av-codec
Multimedia format decoding and encoding
-
pdatastructs
probabilistic data structures
-
cve
Mappings for parsing the CVE JSON files
-
beach_map
slotmap
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
erased_set
A set of erased types
-
binary-util
A panic-free binary utility crate to read/write binary streams over the wire
-
bevy_spatial
tracking bevy entities in spatial indices
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
ball-tree
K-nearest neighbors
-
bittle
Zero-cost bitsets over native Rust types
-
edgefirst-schemas
Maivin EdgeFirst Services Schemas
-
fingertrees
Immutable persisten finger trees
-
mphf_benchmark
The program for benchmarking Minimal Perfect Hash Functions
-
slice-dst
Slice-based custom DSTs
-
nestac
access nested structures using path-like string format
-
rust_flightweather
Decodes METAR and TAF
-
ofdb-boundary
Serializable, anemic data structures for accessing the OpenFairDB API in a type-safe manner
-
pipebuf
Efficient byte-stream pipe buffer
-
enum2egui
derive macro that creates a set of egui ui databindings from arbitrary data structures. Supports egui v0.29.1
-
ocpp_rs
Protocol implementation for Open Charge Point Protocol (OCPP) in Rust
-
rchess
A Chess Library Written In Rust
-
golomb-coded-set
BIP158 Golomb-Coded Set data structure
-
doubloon
Money datatype that supports both statically and dynamically typed currencies
-
bitstring-trees
Trees based on bitstrings
-
radixmap
Rust-based Radix Tree for fast prefix lookup, supporting named param, glob, regex
-
stack-map
constant-size associative container for building higher-level data structures out of
-
fiftyonedegrees
A wrapper around the 51Degrees device detection C library
-
vart
An immutable versioned adaptive radix trie
-
svd-rs
A CMSIS-SVD base structures
-
epsg
EPSG Coordinate Reference System tools & data
-
undo
An undo-redo library
-
est
Extensions for the rust Standard library and Tokio
-
minimizer-iter
Iterate over minimizers of a DNA sequence
-
boomerang_tinymap
A tiny, fast, and simple Slotkey-type map implementation for Boomerang
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
gtfs-geojson
converter for GTFS to GeoJSON formats
-
ordinal-map
Ordinal trait to map values to integers and efficient maps and sets for such types
-
ladata
& modular data model
-
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
-
sk-store
SimKube trace store library
-
superintervals
Interval overlap library
-
sigmars
sigmahq rule collections
-
rust_redux
A Redux-like state management library for Rust
-
linearize
Types that are enumerable and an array-backed map
-
field_access
Dynamically access struct fields
-
mssmt
Merkle-Sum Sparse Merkle Tree (MS-SMT)
-
packed-uints
Array of uints that scales from u4 to u32 to minimize wasted space while still being fast
-
data_reader
A data loading library for data scientist
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
any-rope
A fast and robust arbitrary rope for Rust. Based on Ropey.
-
ordered
A wrapper for adding arbitrary partial/total order to a type
-
ninjabook
A lightweight and high performance orderbook
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
ndata
Thread-safe, self-owned JSON-like data with manual garbage collection
-
uid_store
Generate random uid strings containing letters, numbers, or base62 values
-
fvm_ipld_kamt
Sharded IPLD Map implementation with level skipping
-
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
awint
Arbitrary width integers
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
libreda-db
Layout and netlist datastructures for chip design
-
keyed-set
Keyed Set: a hashbrown-based HashSet that indexes based on projections of its elements
-
atelier
a Computational Workshop for Market Microstructure Modeling, Synthetic Simulation and Historical Replay
-
small-fixed-array
providing fixed length immutable collections with a low memory footprint
-
rust-box
odd set of tools for Rust programming
-
vortex-runend
Vortex run end encoded array
-
supply-chain-trust-example-crate-000039
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
scope-cell
temporary, scope-bound, and thread-safe mutation of data in Rust
-
adapton
programming abstractions for general-purpose incremental computations
-
compact-rc
Low-memory reference-counting pointers
-
value-ext
Serde Json Value Extension Trait (more Value type later)
-
easy-tree
efficient tree structure library for Rust with recursive traversal
-
phf_generator
PHF generation logic
-
ethbloom
Ethereum bloom filter
-
odht
hash tables that can be mapped from disk into memory without the need for up-front decoding
-
weak-table
Weak hash maps and sets
-
owning_ref
creating references that carry their owner with them
-
mmdb
A std-collection-like database
-
strict
collections with strict bounds
-
sharded
Safe, fast, and obvious concurrent collections
-
enumoid
Enum Indexed Containers
-
graphrs
package for the creation, manipulation and analysis of graphs
-
HArcMut
mutable arc
-
persian-rug
Framework for bringing together disparate objects with inconvenient relationships
-
ndarray-histogram
Histogram support for n-dimensional arrays
-
balanced-tree-index
constant-time manipulation of a complete binary tree with a flat in-memory representation
-
binary-greedy-meshing
A port of https://github.com/cgerikj/binary-greedy-meshing to Rust
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
statiki
Static friendly data structures
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
mapgraph
A directed graph that can also be used as an arbitrary map
-
datafrost
Data format and acceleration structure management
-
exhaustive-map
An exhaustive map for types with finite inhabitants
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
bondrewd
Bit-Level field packing with proc_macros
-
pstd
parts of Rust std library ( different implementations, features not yet stabilised etc )
-
settrie
Fast subset and superset queries
-
crdt-lite
CRDT library for Rust
-
hextree
Location to value mapping
-
mikufans-proto
gRPC APIs for Mikufans
-
prefix-sum-vec
Compressed storage for highly repeating elements, with
O(log n)lookups -
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
gix-diff
Calculate differences between various git objects
-
taskchain
A block-based, non-circular double-linked list implementation for Rust
-
hightorrent
High-level torrent library which supports Bittorrent v1, v2 and hybrid torrents
-
scribe
Text editor toolkit
-
trie-root
In-memory patricia trie operations
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
smooth-json
opinionated, customizable utility to flatten serde_json Value variants into serde_json Objects ready for use in columnar or table-like usages
-
one-dto-mapper
One DTO mapper
-
farmfe_core
Core types and data structures for farm
-
heavykeeper
finding the top-k elements of a stream of data
-
intrusive-lru-cache
An LRU cache implementation using intrusive data structures
-
atomicow
A
Cow-like data structure where owned data is stored inside anArc -
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.
-
token-parser
parsing texts into data structures
-
semver-eq
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
minivec
A version of Vec that's only the size of a single pointer
-
hello_egui
A collection of useful crates for egui
-
dia-i18n
-
lattices
Lattice data types for simplifying distributed state by providing associativity, commutativity, and idempotence
-
shortguid
Short URL-safe Base64 encoded UUIDs
-
pfx
A prefix tree (map and set), implemented without any unsafe
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
non_empty_continuous
Non-empty continuous collections
-
hifa-xml-schema
Structure generator from XSD source file
-
stavec
Stack-allocated vector with static capacity
-
triangle_matrix
Triangle matrix indexing operations
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
rotbl
Read Only Table
-
code_generator
A code generator (Currently only targets C)
-
im-pathtree
Immutable, path-addressable tree data structure
-
type-map
typemap container with FxHashMap
-
historian
a high performance zero-config histogram implementation
-
search_trail
manager of variables that can save and restore their values
-
seoul
trait Isomorphism
-
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.
-
gridly
managing fixed-size 2D spaces
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
tri-mesh
A triangle mesh data structure including basic operations
-
cistring
A string type that preserve case, but compares insensitiveley
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
ndstruct
Structures for N-dimensions
-
lambda-runtime-types
Common structures for lambda architecture
-
twovec
A data structure for storing 2 types of data in a packed, heap allocated array
-
standard_card
A Lightweight Library for Efficient Card Representation
-
blaze-common
Blaze common shared types
-
bin-it
efficient Rust library for binary serialization and deserialization
-
reqray
Log ‘request x-rays’ for rust programs instrumented with
tracing -
threshold
data structures
-
rstmt-neo
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
ttgraph
Typed/Transactional Graph container
-
smart_led_effects
A collection of effects for LED strips
-
kollect
Collections made ergonomic for gamedev usecases
-
sstable
Sorted String Tables, an on-disk format for storing immutable maps consisting of string,string pairs, and retrieving values by key efficiently. This crate also features bloom filters…
-
shardtree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
oxidd-rules-zbdd
Zero-suppressed decision diagrams (ZBDDs) for OxiDD
-
radicle-cob
Radicle Collaborative Objects library
-
vector
The package provides a vector database allowing for efficient search of nearest neighbors
-
identified_vec
Like HashSet but retaining INSERTION order and without
Hashrequirement on the Element type -
arrayset
An array-backed ordered set type
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
enum_meta
Add metadata to Enum Variants
-
indexical
indexed collections
-
rasn-smi
Data types for handling Structure for Management Information
-
alist
Association list offering fast lookups while preserving insertion order
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
aliasable
Basic aliasable (non unique pointer) types
-
chinese-rand
Random generation of data structures in Chinese, using Rust
-
grovedb-path
Path extension crate for GroveDB
-
whirlybird
generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
byte_converter
converting bytes to various units (KB, MB, GB, etc.)
-
compact_strings
A more compact but limited representation of a list of strings or bytestrings
-
trybox
stable,
no_std-compatible, fallible heap allocation -
orx-selfref-col
SelfRefColis a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees -
smodel
Symbol semantic modeling for Rust
-
i24
working with 24-bit integers
-
ordes
treating arrays and tuples a little bit more like vectors
-
chemrust-core
The core modules defining the flow and structs of data in computational chemistry routines
-
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.
-
boa_interner
String interner for the Boa JavaScript engine
-
surface-grid
providing data structures for square-tiled grids wrapped around the surface of certain objects
-
permafrost
Write. Macros. Everywhere.
-
plane-2d
Continuous 2D data structure representing infinite 2d plane
-
know
Framework for Rust
-
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…
-
linear_collections
Map and Set types backed by linear data structures
-
host-port-pair
Host-port pair type
-
ndim
N-dimensional array for numerals in Rust similar to NumPy
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
linker-set
Declarative programming via linker-constructed arrays
-
beat_saber_map
Read and write Beat Saber maps with Rust
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
cdll
A circular doubly linked list
-
slabigator
A linked list that doesn't do dynamic memory allocations
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
singletonThread
thread in a singleton
-
rtree_rs
R-tree for Rust
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
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
-
uintx
Unaligned unsigned integers with exact size in memory and arithmetic operations for them
-
ftree
A very fast fenwick tree implementation
-
re_string_interner
string interning library
-
bitstring
traits and implementations
-
committable
Keccak256-based structured commitments
-
awid
Small, simple, universally unique identifiers
-
microkelvin
tree traversal over annotated data structures
-
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
oca-presentation
Lib providing struct for OCA presentation
-
hashheap
data structures that combine a hashmap and a min/max priority heap, with main operations requiring O(1) or O(log n) time
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
unionfind
A union find library made for building type inference engines. Can be used as general purpose datastructure.
-
dot2
generating Graphviz DOT language files for graphs
-
iterlist
Linked list with a cursor based api
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
eventio
A collection of event I/O processors for event-processing applications
-
value_pool
implements a ValuePool struct that makes the creation of self-referential data structures easier and safer
-
delta-collections
Data structures with revertable operations called deltas
-
rive-models
Revolt API models for the Rive ecosystem
-
task-group
manage groups of tokio tasks
-
walker-extras
Additional functionality for SBOM and CSAF walker
-
value-log
Value log implementation for key-value separated LSM storage
-
itybity
An itty bitty crate providing bit iterators and bit iterator accessories
-
rb_tree
A Red Black Tree implementation in Rust
-
vec-btree-map
Basically just a sorted Vec that can be used as a HashMap
-
aircraft_icao_country
aircraft ICAO codes and their country of origin
-
tld
Top Level domain static hash map, tld list is obtained from of iana.org
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
lox
Fast polygon mesh library with different data structures and traits to abstract over those
-
nt-list
Compatible, type-safe, and idiomatic Rust implementations of Windows NT Linked Lists
-
messaging
two-way messaging crate
-
entity
that provides entity-like constructs
-
set_genome
A genetic data structure for neuroevolution algorithms
-
opt_struct
Optional collections
-
sampling-tree
sampling tree implementation for sampling discrete distributions with sparse dynamic updates. This allows us to sample efficiently from a distribution given the relative importance of each datapoint…
-
index-ext
Index slices with arbitrary ints and as arrays
-
digit-sequence
Sequence of u8 digits
-
ztimer
A block-based, non-circular double-linked list implementation for Rust
-
disjoint-sets
Three union-find implementations
-
python-packed-resources
Manage data structures containing Python resources
-
madeleine
Transparent object persistence with predefined operations and state containers
-
expiringdict
A dict / HashMap whose items expire over time
-
codas
Compact and streamable data format that works anywhere--from web apps to robots
-
sentry-contrib-breakpad
Unopinionated crash collection for Sentry reporting purposes
-
space
providing abstractions for spatial datastructures and search
-
spatialize
collection of spatial data structures used for efficent spatial partitioning
-
egui-multiwin
that allows for multiple windows with egui
-
kv6
Collection of structs to allow reading of Ken Silverman's voxel formats
-
cfpyo3_rs_core
a collection of performant utilities
-
grovedb-epoch-based-storage-flags
Epoch based storage flags for GroveDB
-
entoli
A functional programming library inspired by haskell
-
supply-chain-trust-example-crate-000019
A hash table with consistent order and fast iteration
-
lp-pack-scanner
scanner library
-
akita
Mini orm for rust
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
td-shim-interface
TD-shim metadata data structures and related functions. UEFI Platform Initializaiton data structures and accessors
-
quickselect
基于rust的选择算法
-
interavl
An optimised interval tree for efficient interval stabbing
-
dachshund
graph mining library written in Rust. It provides high performance data structures for multiple kinds of graphs, from simple undirected graphs to typed hypergraphs. Dachshund also provides…
-
artie_common
Common Library for Artie Rust Projects
-
gpt_disk_types
GPT (GUID Partition Table) disk data types no_std library
-
trk-io
TrackVis (*.trk) reader and writer
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
matreex
matrix implementation
-
graphplan
planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust
-
spenso
A tensor (n-dim array) network, iterating, and contraction (using automatic abstract index matching) library
-
cbsk_socket
socket callback tool
-
string_manipulation_utf8
String manipulation functions using character indexing (UTF-8) instead of bytes
-
splay-safe-rs
Splay implemented with safe rust
-
diffogus
calculate the difference between 2 instances of a type
-
tf-semver
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
circbuf
A growable circular buffer for working with bytes
-
sorted_vector_map
maps and sets backed by sorted vectors
-
smallbitset
series of allocation free sets capable of holding small integer values
-
clone_cell
A Cell that works with a restrictive form of Clone
-
timer_list
A list of timed events that will be triggered sequentially when the timer expires
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
rust-tls-duplex-stream
Full Duplex stream Wrapper around rust-tls
-
hit-data
Hierarchical Indexed Typed data structure
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
emap
A map with a fixed capacity and integers as keys
-
typerat
Type-level rational numbers based on
typenum -
iterable
collection like types
-
iter-tree
Convert between iterators and tree structures in both directions
-
rustc_data_structures
Reuse rustc_data_structures for compiler_base
-
etwin_dinoparc_store
Dinoparc store implementation
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
maelstrom-base
Fundamental data structures used by all Maelstrom code
-
token-lists
token list representation
-
type-set
A set of heterogeneous types
-
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… -
validiter
Iterator adapters for validating iterations
-
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…
-
aatree
in Rust
-
loaned
Safely move values with live inner borrows
-
quadtree_simple
quadtree implementation
-
lru-st
A package providing a Vec based doubly linked list implementation and related data structures
-
fm-index
FM index and its variant implementations for Rust
-
regroup
regrouping arrays
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
pi_spatial
sparial octtree quadtree
-
iowrap
Small helpers for using io::Read/io::Write
-
depends
Ergonomic, performant, incremental computation between arbitrary types
-
codas-flow
Low-latency, high-throughput bounded queues ("data flows") for (a)synchronous and event-driven systems
-
confiner
A config language for things that look like trees
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
zk-kit-smt
Sparse Merkle Tree
-
irange
A data structure to store and manipulate ranges of integers with set operations
-
honeycomb-render
Visualization tool for combinatorial maps
-
queues
Efficient FIFO Queue data structures
-
deinterleave
your datastructures
-
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 -
mc-oblivious-ram
Implementations of Oblivious RAM data structures
-
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
-
gw_signal
Package with signal processing tools for graviational waves studies
-
phf_mut
Perfectly hashed mutable containers
-
floating_bar
Representing rational numbers using the floating-bar number type
-
jupyter-serde
Serialization and Deserialization for Jupyter related data structures
-
std-ext
Extend the standard library functionality
-
to_markdown_table
An easy way to format any data structure into a Markdown table
-
grdf
Generalized RDF graphs and datasets
-
tdx-guest
The tdx-guest provides a Rust implementation of Intel® Trust Domain Extensions (Intel® TDX) Guest APIs, supporting for TDX Guest specific instructions, structures and functions
-
dusa_collection_utils
A common library with standardized functions that the ais_platform, dusa, recs and others will depend on
-
competitive-programming-rs
Competitive Programming Library in Rust
-
arraystring
Fixed capacity stack based generic string
-
mini-rx
bare-bones "reactive programming" (change propogation) using a central data dependency graph
-
school_library
structures to manage school-related data, including students, classes, and schools
-
indexedlinkedhashmap
An indexable LinkedHashMap. The user defines the data structure that controls order.
-
sequential_gen
sequential generator
-
expiremap
Key-Value map where each value has a custom expiry time
-
coalesced_intervals
Data structure for maintaining maximally-coalesced 1D intervals
-
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… -
slablit
Literal for slab creation
-
loro-rle
A internal library of loro for storing and manipulating run-length encoded data. Do not use it directly.
-
sapling-tree-pattern-match
Pattern match for tree structures
-
arr-rs
arrays library
-
color-operators
Color data structures, converters, and arithmetic operators
-
anymap2
A safe and convenient store for one value of each type
-
ux-dx
3D Graphics Primitives for Angular Rust
-
exact-covers
Knuth's algorithm for solving the exact cover problem with colors
-
riblt
Rateless Invertable Bloom Lookup Table (RIBLT) data structure
-
bittyset
A BitSet type for manipulating bit sets
-
magnetise
asses the similarity between SQL queries
-
mini_uuid
A small and URL-safe UUID crate for Rust
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
ibuilder
Interactive builder for Rust types
-
radix-heap
Fast monotone priority queues
-
tord
Data structure to store transitive relations
-
linux-audit-parser
Parser for Linxu Audit logs
-
idbag
A bag of integers
-
structures
collection data structures
-
libwebnovel-storage
A complement to libwebnovel: this package handles downloading and organizing collections of followed webnovels
-
pinocchio-token
Pinocchio helpers to invoke Token program instructions
-
no_std_collections
Auxiliary structures and traits for using dynamically resizable arrays (Vectors) in flexible environments, supporting both std and no_std contexts
-
pi_densevec
重定向映射表，一个使用usize作为key的映射表
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
retaker
ecs implementation
-
commitlog
Sequential, disk-backed commit log library
-
cmus-status
structure cmus status data
-
gdsl
graph data-structure library including graph containers, connected node strutures and efficient algorithms on those structures. Nodes are independent of a graph container and can be used as connected smart pointers
-
micro_autotile
LDTK autotiling
-
incrementalmerkletree-testing
Common types, interfaces, and utilities for testing Merkle tree data structures
-
mantra-rust-trace
Collects requirement traces from rust code for the
mantraframework -
lace_stats
Contains component model and hyperprior specifications
-
pi_slot
lock free Slotmap data structure
-
latestmap
latest map
-
super-struct
structofRustin the same way thatdictofPython -
supply-chain-trust-example-crate-000048
Types and traits for working with bytes
-
pimalaya-tui
Collection of crossterm widgets shared accross Pimalaya terminal-based projects
-
bit-int
An arbitrary fixed bit-width integer library
-
influxdb-dispatcher
Batch metrics collection using influxdb
-
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
flat_collections
Lightweight and memory-efficient associative data structures
-
ux-dataflow
Data Processing Library
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
smallvec-wrapper
Macro and common structs to play with
smallvec -
range_map_vec
range map data structure backed by a Vec
-
sbbf-rs
Split block bloom filter implementation
-
hrtb-lending-iterator
A lending iterator trait based on higher-rank trait bounds (HRTBs)
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
strumbra
Umbra-style strings (also known as German strings)
-
tangu-lints
A collection of lints for the Tangu language
-
anchors
async incremental computations
-
flat-tree
Series of functions to map a binary tree to a list
-
coca
Data structures with constant capacity
-
rust_twostack
Support for two-dimentional stacks for the Rust programming language
-
sparse_set_container
A container based on sparse set. Stable keys, O(1) lookup, cache-friendly iterations, and no hashing.
-
cbsk_mut_data
ref mut tool
-
dst-container
Containers for DST objects
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
medianheap
A median heap for keeping track of a running median
-
text-style
Types and conversions for styled text
-
flo_rope
An attributed and streaming implementation of the rope data structure
-
dcl_data_structures
Data structures for for deep_causality crate
-
vss-rs
Voxel storage system for rust ported from cpp
-
enso-data
A collection of useful data structures
-
structured
Data structures to handle large, structured data
-
forest-ds
secure tree structure
-
data_model
[highly unstable] data model for virtualization
-
comparer
track changes in a HashMap over several iterations
-
merkle-heapless
Statically-allocated Merkle Tree and Mountain Range
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
hashstash
It's like git but for your Rust data structures
-
crater
Very generic containers including KD trees, fibonacci heaps, minmax heaps,
-
rtdlib
TDLib for rust
-
parallel_vec
A generic contiguous collection of heterogenous values
-
spaghetto
making double-ended data structures, like an always-contigouous double-ended queue (deque) and double-ended string
-
chesspos
Basic structs for representing chess squares
-
ascent-byods-rels
data structures for Ascent relations, made possible by Ascent's BYODS feature
-
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…
-
safe_index
Type-safe indexes
-
supertrees
Supervision trees for Tokio-based services inspired by Erlang/OTP
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
uniquevec
A
Vec-like datastructure which only contains unique entries. It is no_std and has optional serde support. -
xot
Full-featured XML tree library for Rust
-
cmdtree
(Rust) commands tree
-
sliding_tree
A tree that grows from the leaves and recedes from the root
-
nlist
inline-allocated list with statically tracked length
-
fenwick
tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
sql-json-path
SQL/JSON Path implementation in Rust
-
loro-delta
Loro internal library. It's used as a delta between two versions of text or lists. It's also an efficient Rope.
-
swaybar-types
building swaybar status commands in rust
-
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
scored_set
A scored sorted set data structure for Rust
-
genmap
generational map data structure with no dependencies
-
safer_owning_ref
creating references that carry their owner with them
-
non-random-state
Deterministic HashMap and HashSets
-
vlcb-defs
VLCB protocol core library containing important value definitions and data structures
-
pi_append_vec
Only supports append vectors, lock free
-
dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
jsonmap
store values of multiple types value in one Map
-
gix-hashtable
that provides hashtable based data structures optimized to utilize ObjectId keys
-
higher
Functors, Applicatives, Monads and other bad ideas
-
uuidv7
UUIDv7 implementation
-
cow_hashmap
Hashmap with copy-on-write semantics that requires no locks
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
leetcode-trees-rs
Tree Node LeetCode problems
-
automerge-test
testing automerge libraries
-
wasmrs-frames
WasmRS RSocket frame decoding, encoding, and data structures
-
defaultmap
HashMap with an automatic default for missing keys
-
zond
standard rust collections but with collecting statistics
-
colibri
Rust data structures for Jitsi Meet Colibri messages
-
lru-mem
An LRU cache implementation bounded by memory
-
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
supply-chain-trust-example-crate-000058
Generic types implementing functionality of arrays
-
generic-btree
Generic BTree for versatile purposes
-
rexsgdata
Scatter-Gather Data Descriptors
-
meminterval
interval-tree in Rust made to store memory mappings
-
i_tree
Red-black tree implementation for rust. Only for uniq elements
-
spring-sms
基于spring-rs 0.2.1 版，简单实现了短信发送功能，未来将完善，目前只支持阿里云短信发送
-
lodtree
help create octrees and quadtrees for chunked level of detail
-
dayendar
advanced days calendar operations
-
mset
/ multiset / bag implementation
-
tensorism
Multidimensional arrays with bounds included in the type system
-
msgpack_simple
Simplified, easy to use, pure Rust MessagePack implementation focused on handling dynamic data structures
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
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
-
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
-
typeslice
type-level slices
-
gen_value
indexes and values with generations for vectors
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
villa01-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
rt_map
Runtime managed mutable borrowing from a map
-
sbwt
Indexing sets of DNA k-mers with the spectral Burrow-Wheeler transform
-
malwaredb-api
Common API endpoints and data types for MalwareDB components
-
thinset
A data structure for sparse sets of unsigned integers that sacrifices space for speed
-
fallback
A helper library to implement fallback mechaism
-
libkv
building data structures atop key-value stores
-
point-nd
flexible no-std struct to model points on axes of any dimensions
-
gecs
A generated entity component system
-
histogram-sampler
Sampling from a distribution given by a histogram
-
tuco
used to automatically generate tuple representations of your types. This can be helpful if you don't want to leak crate specific types of simple data through your API. Or if you want…
-
range_bounds_map
[
RangeBoundsMap] and [RangeBoundsSet], Data Structures for storing non-overlapping intervals based of [BTreeMap] -
pin_array
Tiny crate providing an array with structurally projected pinning
-
ord-collections
offering collections which are pre-sorted automatically
-
orn
A general implementation of the sum type. Meant to be a generic counterpart to tuples.
-
tuple_list
macro-free variadic tuple metaprogramming
-
supply-chain-trust-example-crate-000085
tinyvecprovides 100% safe vec-like data structures -
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
orchestrator
Orchestration sequences
-
dartlib
Disk backed concurrent Adaptive Radix Tree implementation, with optional generations
-
type-rules
easily constrain a struct
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections
-
shiftnanigans
contains different iteration data structures for either iterating or for shifting iteratively forward and backward
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16coordinates. -
product-os-openapi
Product OS : OpenAPI provides a set of structs for defining the structure of an OpenAPI / Swagger specification. This crate is intended to be used with Product OS : Connector.
-
oxidd-rules-tdd
Ternary decision diagrams (TDDs) for OxiDD
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
touch-selection
Selection data structure intended for touch and single button devices
-
arc-bytes
A reference-counted byte buffer
-
pax-properties-coproduct
Static container for program-variable data structures and polymorphic components
-
small_iter
A 3-pointer iterator that moves out of a
Vec<T>orBox<[T]> -
incrstruct
Build self-referencing structs using two-phase initialization
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
ldtk_map
reading ldtk maps for usage in games
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
open-coroutine-timer
The time utils
-
loaded_dice
sampler for loaded dices, implementing the alias method
-
lr_trie
Left-Right trie is trie capable of mapping any string to any string
-
tryingarraylist
arraylist implementation
-
rep
A small tool for representation/class invariants
-
sif-itree
immutable, flat interval tree
-
im-lists
Persistent unrolled linked lists and vlists
-
zhifeng_impl_barnes_hut_tree
implements Barns-Hut Tree for accelerated N-body force calculation
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
broomdog
A type-erased map with 'indefinite loanership'
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
steiner-tree
Fast construction of rectilinear steiner minimal trees (RSMT) in two dimensions
-
amalgamator
A set/map like data structure that allows you to combine members together
-
byteview
Thin, immutable zero-copy slice type
-
sortedvec
a sorted vector that enables quick lookups
-
ioc
An Inversion-of-Control library in Rust
-
bloomfilter-rust
A bloomfilter implementation in Rust
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
hashslab
A hash table with data accessible by index
-
rooting-forms
Generates HTML (rooting) forms from structures
-
netlist
generic netlist data structure for VLSI design
-
sum
General-purpose sum types
-
ttmap
Trivial implementation of type map
-
mist-lib
Juniper Mist Schema Definitions
-
rj
reactive json
-
onebuck
An efficient unordered dynamically-sized data structure
-
hashrevise
hashing data structures and then caching results and avoiding work
-
find-all-the-kitty-cats-in-charlotte
A collection of crates for working with cats
-
mut-rc
Temporarily mutable
Rc<T>that decays intoRc<T> -
alignment-exporter
Proc macro providing alignment info for a user-defined struct
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
hydroperfox-smodel
Semantic modeling for Rust
-
ast2str
pretty-printing ASTs and other recursive data structures
-
syzlang-parser
Parse Syzlang language
-
suff_collections
Fast realization of suffix array and suffix tree
-
mco-gen
Stackfull Generator Library in Rust
-
xbinser
binary structure transporation
-
minsize
Collections with a statically known minimum size (using const generics)
-
vortex-bytebool
Vortex byte-boolean array
-
bdaddr
Bluetooth Device Address
-
alt-std
Alternative Lightweight Std library for making small executables and shared objects
-
panoradix
A generic map and a set, both backed by a Radix tree
-
caffeine
Collection of data structures I'm writing for fun. Originally written for use with my crafting interpeters tutorial implementation.
-
filey
A collection of utilities to make file operations more convenient
-
superset_map
Map that stores distinct supersets based on the total order defined
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
bitvector
in Rust
-
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
orbweaver
designed for effortless construction and analysis of graph data structures
-
ssd-data
A service and data description format + a code generator based on rhai scripts and templates
-
rmat
minimal implementation of two-dimensional matrix algebra
-
nybbles
Efficient nibble-sized (4-bit) byte sequence data structure
-
voxtree
A sparse voxel octree for rust & rust-gpu
-
compare
Experimental comparators for collections to be generic over
-
vecdeque-stableix
Deque with stable index values
-
plexus
2D and 3D mesh processing
-
ofilter
fast thread-safe Bloom filter
-
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…
-
phylo
An extensible Phylogenetics library written in rust
-
croaring-sys
Raw bindings to CRoaring
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
text-document
Text document structure and management
-
grovedb-version
Versioning library for Platform
-
data_nostd
Structures and data types definitions for dinvoke_nostd
-
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
subranges
manage non-interssecting integer intervals
-
handlemap
A collection that produces handles that can be used as keys to retrieve the stored items
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
contack
easy contact library
-
flex-alloc
Data structures with extra flexible storage
-
prefix_array
A generic container for searching on prefixes of keys
-
intervaltree
generic implementation of an immutable interval tree
-
varlen
Ergonomic variable-length types
-
sbom-walker
work with SBOM data
-
aversion
Versioned data structures with auto-upgrading
-
csf
compressed static functions (maps) that use perfect hashing and value compression
-
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 -
logisheets_controller
the core of LogiSheets
-
index-from-end
Allow indexing arrays and Vecs from the end using expressions like array[Len-1]
-
binary-tree-view
A binary tree visualization application built in Rust
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
collect-rs
Special and custom Collections and Containers (for Rust)
-
baz-tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
write_x86_64
help you write x86_64 assembly code
-
seq-map
Sequential Map
-
vec-string
To print Vec<Display>
-
disk-ringbuffer
lock free on disk ringbuffer to be used in the implementation of Franz
-
undo_2
Undo and redo done the right-way
-
resizing-vec
An automatic resizing vector for data with linear increasing ids
-
deepmesa
fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
rblist
A block-based, non-circular double-linked list implementation for Rust
-
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
-
netcrab
creating and exporting Petri nets
-
llist
Lisp-style singly-linked list
-
rive
ecosystem crate
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
kvv-efa-api
Rust bindings for the KVV (Karlsruher Verkehrs Verbund) "EFA"-API
-
sparseset
A Sparse Set
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
bitlab
Extracting a range of bits from a binary data source
-
vec-x
structure
VecXto manage fixed-length arrays, supporting numeric operations and assignment operations betweenVecXand scalar values -
pulz-arena
A generational arena allocator with compact generational indices
-
periodic-rs
Bounded datastructures
-
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
-
boolvec
A vector of boolean stored contiguously in memory
-
lurk-elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
spaceindex
-
nslice
Structures for interpreting slices of variable length as arrays
-
grids
2D grid data structure for games
-
grid-tree
Pixel quadtrees and voxel octrees
-
gw2timers
Iterate and collect Guild Wars 2 map meta event times
-
bit-vec-omnitool
A vector of bits
-
ternary-tree
Ternary Search Trees, with no unsafe blocks
-
nimbusqueue
fifo collection
-
hicollections
C-liked Collections
-
overtone
An API for creation and management of rich (as in rich-text) musical-ish projects
-
scoped_stack
A scoped stack data structure
-
tracing-rc
Cycle-aware reference-counted pointers with a safe, simple api
-
pi_dirty
Record hierarchy dirty
-
bgp-models
Structs and other building blocks for BGP and MRT related Rust projects
-
crdt_tree
Tree Conflict-free Replicated Data Type (CRDT)
-
moka-cht
Lock-free resizeable concurrent hash table
-
piece_table_rs
piece table data structure
-
rust-3d
2D/3D library written in rust
-
try-lazy-init
Fallible lazy initialization
-
magiclist
List with O(log n) random access, insertion, splitting, and merging
-
union-fn
Proc. macro for creating efficient "inline closures".
-
tinyvecdeq
VecDeque-like data structures -
pi_sinfo
used to describe the 'structure', that is, the meta information of the structure
-
fixed_deque
A fixed size VecDeque to match Python Deque
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
nimble-steps
Nimble Steps Collections
-
div-int
Rational numbers with a compile-time denominator
-
fenwick-bit-tree
Slighly over-engineered FenwickTree implmentation
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
art-tree
The Adaptive Radix Tree
-
ordered_hash_map
HashMap which preserves insertion order
-
anyid
ambiguous identifier
-
compt
A complete binary tree visitor library
-
rs_filter
filter library for matching on complex data structures
-
mikel_binary_tree
search binary tree implementation
-
omango-util
Utililites
-
rpds-pathtree
Immutable, path-addressable tree data structure
-
rust_examples
rust 的学习中的一些例子
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
b-tree
A persistent B+ tree using freqfs
-
evento-store
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
xsparseset
sparse set
-
inplace-vec-builder
Build a vec from a vec, in place
-
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
segment-tree
Quickly perform interval queries or modifications
-
lim-bit-vec
Limited bit vectors
-
veho
a iterable toolset
-
bitvek
bit vector implementation
-
word-dictionary
data structure for word mapping. It can be used for language translation.
-
fn-map
Abstraction around HashMap. Uses closure to compute and store value.
-
pac_cell
Parent and child cell
-
bmap
A bitmap with an internal counter
-
extensions-rs
File extension types in Rust
-
redmaple
offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
rosary
About Rose Trees
-
stdng
An enhancement for Rust standard library
-
validbr
data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
twitter/rustcommon-time
getting current and recent timestamps
-
diamond-types
The world's fastest text CRDT
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
hj_ds
A data structure library for Rust
-
rotated-array-set
An ordered set supporting O(1) rank and O(√n) inserts and deletes
-
kampu
Generic byte array parser function where you can define the structure/tree of the bytes in JSON, send it a byte array and get the parsed output in JSON
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
ordmask
To check if a value is included efficiently
-
rk-utils
A collection of utility functions and data structures for rust
-
cseq
compact sequences
-
hashable-map
Wrappers for HashMap and HashSet that implement Hash
-
osmgraph
Convert OSM queries into graphs
-
moving_min_max
Tracking minimum or maximum of sliding windows
-
purse
Bag data structure implementation in Rust
-
darts-clone-rs
Rust binding of a clone of Darts (Double-ARray Trie System)
-
fst-map
succinct map
-
groupex
Syncronization primitive that allows acquire lock by index
-
vecset
A vector-based sorted map, set and keyed-set implementation
-
raw-btree
Generic B-Tree implementation
-
light-curve-interpol
Interpolations tools for time series
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
omnitool
A curated respository of algorithms and data structures. The libraries are included as forks of Rust codebases
-
filetrack
persistent logrotated reading and other useful io things
-
v9
A slim data engine for Data Oriented Design
-
total-maps
Maps where every possible key has an associated value
-
rstmt
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
holyhashmap
A hash map with stable indices
-
queued_rust
queue type for better privacy managment and data orginization
-
vicardi
JSON VCardArray Generator that uses Serde
-
mazer-data-structures
A minimal, simple math markup language that compiles to HTML, written in Rust
-
ergo_avltree_rust
cryptographically authenticated dictionary based on AVL tree
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
morton-index
Types and functions for efficiently and easily work with Morton indices
-
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:… -
froop
A functional reactive stream library for rust
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
implies
A parser for logical formulas
-
merkle
tree implementation with support for generation of inclusion proofs
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
eastl-rs
EASTL binary-compatible Rust implementations
-
list_tools
一个自己研发的Vec<T>
-
flatbuffers-retained
allows a user to validate a flatbuffer once and the move it around or store it in a data structure without keeping the buffer borrowed. Then later it can be used again without re-validation.
-
ord-uuid
Creates lexically sortable uuid values of size 16 bytes
-
memvec
Memory-backed vector, not buffer. Designed for for mmap. Not MemMap, but MemVec!
-
collect-me
Additional collections not included in the Rust standard library
-
literally
Macro literals for members of std::collections
-
index-map
A map with automatically generated usizes as keys
-
timer-queue
Pure, minimal, and scalable timers
-
expiringmap
a HashMap-backed TTL map
-
linear-hashtbl
Linear probing hash table
-
incremental-map
combinators for incremental immutable maps (see crate
incremental) -
vec-entries
Entry API for iterating over and removing elements from a
Vec -
gchemol
Graph-based CHEMical Objects Library
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
isx
Traits for checking certain conditions of values
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
serde_either
set to enums to deserialize and serialize data that can either be string, struct or vec
-
wccg-models
WCCG Data
-
median-heap
A median heap implementation in Rust, used to keep track of a running median of a sequence of numbers
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
relational_types
Manage relations between objects
-
symbolic-sets
Sets that are stored symbolically
-
thin-string
A String with a smaller stack footprint
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
structdb
Persistent data structures using RocksDB
-
zetacore
in-memory vector store library with Python bindings
-
beehive
collections for 3D hexagonal maps
-
brownstone
building fixed-size arrays
-
chainbuf
Fast chained buffers
-
merkle-root
calculating the Merkle root of either a file, or walked directory
-
succinct
data structures for Rust
-
rs-car
CAR v1 and v2 specifications
-
valord-map
A dictionary sorted by values
-
multiset
Multisets/bags
-
bit-parallelism
Small integer specialized, word level, parallel algorithms and data structures
-
intervals-rs
intervals
-
hst-tw-images
working with Twitter profile images
-
arctree
A 'DOM-like' tree implemented using atomic reference counting
-
btree_experiment
implements a BTreeMap similar to std::collections::BTreeMap
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
chainmap
mutability of intermediate maps
-
rangelist
A representation of sets as lists of inclusive ranges
-
sidex
A format- and language-agnostic data structure and API definition language
-
recursive_reference
way to walk on recursive structures easily and safely
-
cbsk_log
log tool
-
billios
A soil library
-
rdc
generating Java code from rust structs
-
stealth-lib
functions for ZKP
-
unsized-vec
Like Vec, but for unsized values
-
nanotweaks-proc
moved to https://crates.io/crates/spread_macros
-
identifier
Generate 128 bits id structs easily
-
poppy-filters
providing serializable Bloom filters implementations
-
range-mutex
A
Mutex<[T]>-like type, that allows locking different ranges separately -
rustz
functional programming in Rust
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
esl01-indexedlog
Append-only on-disk storage with integrity checks and indexing support
-
ndshape
fast linearization of N-dimensional array indices
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
teardown_tree
A binary search tree that supports fast clone and delete-range operations
-
egui_suspense
Automatically show loading and error uis for egui
-
header-vec
Vector with user-specified header, length, capacity, and array elements all stored on the heap together
-
prefix_dictionary
Data structure similar to a dictionary, but enabling search for prefixes
-
pvec
RRB-Tree based persistent vector implementation
-
wplot
Plot interface
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
append-only
Append only versions of std data structures
-
thot-core
Core functionality and types for Thot data management and analysis software
-
kushi
A queue built for the Dango Music Player and Oden Music Bot
-
associated_list
An associated list, for cases when the key implements neither Hash nor Ord
-
hdf5-hl
High level bindings to HDF5 High Level API
-
anndata-memory
Thread-safe AnnData-like structure for single-cell genomics data in Rust. Provides controlled mutability, efficient memory management, and flexible data manipulation. Ideal for concurrent bioinformatics applications.
-
qualia
Basic semi-schemaless document store
-
sesstype
Multiparty Session Types
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
epoch32
32-bit Epoch with specified starting year
-
array_map
Map backed array for fixed size keys with O(1) performance
-
nakadi-types
A connector for the Nakadi Event Broker
-
multi_containers
Ergonomically work with multiple values per key
-
limq
Queue with optional maximum number of elements constraint
-
datazoo
Bitset and jagged array data structures
-
pointcloud
An accessor layer for goko
-
bitval
For packing booleans in variables using bitwise operations
-
reactive-signals
dx-first scope-based fine-grained reactive system
-
cast-rs
A collection of types cast for Rust
-
aleo-agent
Agent library to communicate with the Aleo Blockchain, following the Public Specification
-
cubic-bezier
Create and modify cubic bezier curves
-
dsa_sport
revision material for undergrads
-
prototty_common
Definition of common ui elements and views for use with prototty
-
atlv
Algebraic Tag Length Value encoding
-
pas
strided slice
-
screech
A collection of helpers for handling audio data in real time
-
tinybitset
Generic implementation of small, fixed size, copyable bitsets
-
qualomat_schema
Rust bindings for the *Qual-O-Mat* open data format for the german voting advice tool *Wahl-O-Mat*
-
listfree
lockfree prepend-only list
-
constructivism
Simplify the construction of structured data
-
nanovec
Arrays and Vec-likes of small integers packed in an integer or two
-
membuffer
A very fast flat memory buffer used to deserialize at a fast speed
-
make-message-bus
Generate a pub-sub bus for use in async applications
-
dakv_skiplist
skiplist for dakv
-
bit-array-rs
Bit Array
-
yrs-kvstore
Generic persistence layer over Yrs documents
-
pl-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
fns
add common fn, eg: debounce, throttle
-
awint_ext
Externally allocating
awintfunctionality -
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 -
structo
Data structures made in Rust
-
statemachine-rs
A statemachine crate which have zero dependencies
-
clap_flags
Collection of reusable flags for Clap
-
extended-rational
implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
feature-set
User defined feature set
-
driftdb
A real-time data backend for browser-based applications (core library)
-
numas
multidimensional array for efficient computing
-
rust_list
Singly linked list in Rust, with macros for easy instantiation
-
luthor
A collection of lexers for various languages/formats, and the tools required to build them
-
chain-map
A chain of maps with a single view into the aggregated values
-
either_of
working with enumerated types that contain one of 2..n other types
-
tilecoding
Dr. Richard S. Sutton's tile coding software.
-
double-map
A HashMap with double key to single data/value
-
cbsk_timer
rayon thread runtime
-
crio
An easy to use persistent data storage library
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
st2-logformat
Adapter-agnostic definitions for data types used by ST2
-
mipmap-1d
A small data structure to perform 1d-mipmapping (downsampling)
-
typed_graph
Staticly typed graph library
-
seq_watcher
A pair of structures for monitoring a stream of data for one or more sequences
-
comprende
Python-style collection comprehensions in Rust
-
array2ds
Package for handling sized 2d arrays in rust, without the usage of the keyword unsafe cuz why not
-
dectree-rs
A decision tree implementation in Rust
-
lumberjack
Read and modify constituency trees
-
rustic_core
fast, encrypted, deduplicated backups that powers rustic-rs
-
vmcircbuf
A circular buffer that magically wraps around without any copying
-
markov-generator
Highly customizable crate for building Markov chains and generating data from them
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
rahashmap
Fork of standard library HashMap with additional functionality
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
pgdb_to_struct
CLI application to generate Rust struct files from PostgreSQL database tables
-
pciids
parse the pci.ids data file
-
modupipe
A modular and extensible ETL-like pipeline builder
-
mine_sweeperr
Minimalist interface to manage the backed of a mine sweeper game
-
variant-set
A set-like data structure for enum variants, allowing you to store at most one value for each variant of an enum
-
ref_kind
Different reference kinds
-
unicase_collections
Collection of UniCase datastructures
-
ads-rs
(Algorithms and Data Structures) is a set of useful generic production-ready algorithms and data structures
-
proptest-recurse
Helper for defining mutually recursive strategies with proptest
-
lignin
A virtual DOM structure, primarily for web use
-
ndcopy
Fast N-dimensional array memcpy
-
hashable_weak
A hashable weak pointer
-
quickphf_codegen
Code generator for creating static maps and sets for use with quickphf
-
landfill
Various types for dealing with on-disk data
-
skog
Adobe's stlab::forest data structure
-
shogiutil
A collection of tools to handle shogi data
-
win-variant
that aims to provide a more ergonomic way of working with variants in winapi based projects
-
gpt_disk_io
GPT (GUID Partition Table) disk IO no_std library
-
tinymap
A map structure that stores its data on the stack
-
ware
middleware chains
-
minimizer-queue
Fast computation of minimizers using a monotone queue
-
merkle-cbt-lean
Special implementation of Complete Merkle Binary Tree for minimal memory footprint
-
cycler
A simultainious write/read data structure
-
stonks
Sets that allow borrowing while inserting entries
-
libreda-splay
Splay map and splay set data structures
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
actions
Software without side-effects. Redo and Undo. Macro's.
-
slice-rbtree
A slice-based Red-black tree
-
generic_event_queue
generic event-queue API
-
optimistic_lock_coupling
A General Lock following paper 'Optimistic Lock Coupling: A Scalable and Efficient General-Purpose Synchronization Method'
-
path-value
Universal type and access property(s) by path
-
evicting_cache_map
An Evicting LRU cache supporting prune hooks
-
trying
Basic trie crate
-
large_int
An ease-of-use unbounded signed integer
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
data_tree
Hierarchical data tree with pathing and search support
-
mc-oblivious-map
Oblivious Hash Map data structures on top of Oblivious RAM
-
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!
-
range-map
Maps and sets implemented using ranges
-
canadensis_bit_length_set
A bit length set type used to calculate data type sizes when processing Cyphal data structure description language files
-
trie
An ordered map and set based on a trie
-
bit-set-omnitool
A set of bits
-
vec-with-gaps
A data structure that behaves like a vec of vecs, but where the subvecs are kept in one contiguous section of memory, which improves cache performance for some workloads
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
pathlink
A URL type whose path can also be used as a filesystem path, for Rust
-
insrcdata
Embed static data as source code
-
rs-tree-sitter-languages
Collection of Tree-Sitter parsers
-
learn_together
Curated collection of lists of useful resources to learn Rust together
-
transient_map
Hashmap with eviction of unused elements
-
bookfile
A container file format with chapters and an index
-
crfsuite-sys
Rust binding to crfsuite
-
rimu-value
A data structure template system
-
augurs-core
Core data structures and traits for the augurs time series library
-
liblet
learning about formal languages and grammars
-
mergle
A data structure with fast merging and comparison
-
multipath
split file path, like
/home/{user,admin}/file.txt -
unnamed_entity
Strongly-typed indexing for vectors and other structures
-
viral32111-xml
XML parser crate for my Rust projects
-
folketinget-api-models
Autogenerated Rust structures based on the Danish Parliament's OData metadatafile
-
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
-
simple-sds-sbwt
A fork of simple-sds used in the sbwt crate
-
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…
-
sweeper
A foundation for Minesweeper implementations in Rust
-
supply-chain-trust-example-crate-000044
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
gsgdt
Generic Stringly Typed Graph Datatype
-
mqfilters
Highly optimized approximate membership query filters (bloom, cuckoo, xor, quotient) with SIMD support
-
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
patricia_router
Radix Tree implementation for Rust
-
partial
Optional monad with fake variant
-
interval-map
A vector-based, non-duplicate range-keyed, sorted array
-
sparse_set
sparse set data structure
-
tan-lints
A collection of lints for the Tan Language
-
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
dinvoke_data
Structures and data types definitions for dinvoke
-
render_as_tree
visualizing tree data structures via text
-
distant-protocol
Protocol library for distant, providing data structures used between the client and server
-
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.
-
quadboard
Typed fixed-length buffers of chess pieces
-
oxidd-cache
Apply cache for OxiDD
-
cnctd_smart_home
A collection of Smart Home APIs
-
pi_ordmap
Ord Map
-
range_union_find
A union-find data structure for ranges
-
hamst
Hash Array Mapped Shareable Trie
-
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.
-
upair
Unordered pair data structure
-
dade
data definition for Rust structures
-
anylist
a list type for any type
-
wrapping
slices and arrays
-
zaplib_components
The widget toolkit for Zaplib
-
y-sync
Yrs synchronization protocol
-
simple-vec-collections
Collections implemented using Vec
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
twice-cell
Like
once-cell, except you set the value twice -
slas
Static Linear Algebra System
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
smolvec
A lightweight vector implementation with small-vector optimization for rust
-
voml-collection
Collections for VOML
-
strawberry_fields
Consume, read, and mutate struct fields with an iterator-like api
-
usage
A convenient alternative to the newtype pattern
-
gapbuf
Generic gap buffer
-
nvpair-rs
Safe and rustic wrapper around nvpair
-
RustyDSA
A libary for Rust data structure
-
vec-option
A space optimized version of
Vec<Option<T>>that stores the discriminant seperately -
leetcode-solutions
A collection of leetcode solution in rust
-
bktree
BK-tree datastructure
-
colours
Color types for different color models with conversions between it
-
restorable
An iterator adapter for saving and restoring iterator state
-
aabel-identifier-rs
defines identifier behavior, such comparing them, or generating sequences of identifiers
-
type-freak
Collection of typed data structures, trait operators and aliases
-
processing_chain
set up processing chains of large amounts of data
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
mkargs
Build command arguments
-
reql-types
Some useful types to use along with the reql crate
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
cvrdt-exposition
Understanding Convergent Replicated Data Types
-
lxc
Linux Containers API
-
tiny-test
tiny-testis collection of functions simplifying test assertions in rust -
nary_tree
A vec-backed tree structure with tree-specific generational indexes
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
lru-slab
Pre-allocated storage with constant-time LRU tracking
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
prototty
Wrapper crate for frontend-independent prototty crates
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
hash-rings
Implementations of various hash rings
-
deltastruct
Allows defining deltas for tagged structs for later application
-
simple-undo
Easy to use undo-redo library
-
read-copy-update
locking primitive
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
try-push
A trait for attempting potentially expensive actions
-
collect_result
collecting an iterator of results into a result of a collection
-
xdag
DAG(Directed Acyclic Graph) lib
-
arbtree
A small library for general purpose tree data structures
-
epoch-timestamp
Boilerplate collection for epoch timestamping
-
grapes
Persistent graph data structures: Tree, Graph, Arena & more
-
syntastic
Generic abstract syntax representation
-
l6t-file
A part of l6t library: reading, writing and deconding for L6T IFF data
-
rt-lists
Link lib
-
synthax
Synthesize syntax with quasiquoting plugins
-
bitworks
meant to provide easy to use bitsets with emphasis on safety
-
id_collections
Index-oriented programming in Rust
-
isomorphism
2 directional hashmaps
-
torro
A correct and easy-to-use BitTorrent library
-
collectable
Fallible, no_std-friendly collection traits
-
changed
change detection
-
bengbenge
inifity array for round-robin dns, beng, beng
-
tbytes
A tiny library for reading and writing typed data into buffers
-
cdragon-prop
Work with BIN files used by Riot
-
Xorfilter
No alloc membership approximation
-
tree_collections
A collection for tree data structures. It provides APIs that allows users to create memory efficient binary search trees, red-black trees and avl trees.
-
hdrhistogram
A port of HdrHistogram to Rust
-
reunion
A generic implementation of the Union-Find w/ Rank data structure
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
casbin-arangors-adapter
ArangoRs adapter for casbin-rs
-
windowed-futures
Helpers for windowed parallel execution of collections of futures
-
ittybitty
An itty bitty bitset to hold your itty bitty bits
-
astack
offers a Stack data structure with fixed capacity capable of fast LIFO operations
-
corresponding
Move corresponding fields between structs
-
mivim
-
indextreemap
A BTreeMap implementation that allows for key and or positional insertion and retreival
-
monitor-common
Basic data structure and algorithm of linux-monitor tool
-
ic-stable-memory
Internet Computer's stable memory collections and tools
-
libflow
grouping network flow data
-
lazy-seq
constructing lazily evaluated sequences
-
rust_fixed_width
that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
counted_map
a hashmap that automatically assigns keys to pushed values
-
applejack
Radix tree
-
b100m-filter
The fastest bloom filter in Rust. No accuracy compromises. Use any hasher.
-
loki-logger
A loki logger for the log facade
-
varset
an any type set of items
-
plain_trie
Classic trie implementation capable of mapping any T to string composed of English alphabet letters
-
eirproject/libeir_ir
Erlang ecosystem common IR
-
starbase-tools
A collection of tools created to help with ship building in the game Starbase by FrozenByte
-
another-option
option data type; useful when allocations are expensive
-
object-collection
A collection that can store multiple values of types
-
sti
STd Improved
-
typed_index_collection
Manage collection of objects
-
construe
Compile-Time Growable Array: Vec & String for const!
-
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.
-
fixed_heap
A fixed-size heap structure with manually provided stateful comparison function
-
terees
a collection of tree-like data structures
-
run-loop
Run loop for thread, provide message post, deadline timer and future executor
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
indexed-bitfield
An indexed bitfield, to track presence or absence of up to 128 elements
-
scopegraphs-lib
A port of scopegraphs to Rust
-
dyn_vec
A Vec<T: ?Sized>
-
ro
stuff read-only
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
shortlist
An efficient data structure to track the largest items pushed to it
-
armory
a fast pool for storing lots of objects of one type without fragmenting
-
segmentmap
A collection that maintains insertion order
-
disjoint-collections
Disjoint-set data structures
-
bit-index
A little-endian zero-indexed bitstring representation
-
short-lease-map
A map collection optimized for brief internship of values
-
boxing
cross-platform implementations for NaN and ptr boxes
-
plurals
singular/plural forms, mostly in English
-
designal
Procedural macro for use with futures-signals
-
inditech
A set of technical indicators for time series analysis
-
milvus-sdk-rust
The official Milvus Rust SDK
-
kubizone-common
Typed Rust structures for representing partially and fully qualified domain names
-
rocstr
An immutable fixed capacity stack based generic copy string
-
ransel
rank/select succinct data structures
-
funnel
data structure that makes it easy to read from multiple channels from a single source
-
opt_vec
A wrapper around Vec<Option<T> that makes deletion fast
-
cueue
High performance SPSC circular byte buffer with batch operations
-
sif-kdtree
immutable, flat k-d tree
-
whistlinoak
Annotated even-arity trees backed by mmaps
-
bitarr
A fast and efficient Rust implementation of a BitSet, supporting multiple backing stores
-
treemap
Squarified Treemap algorithm
-
recursive_array
arrays using recrusive data structures to avoid limitations of the rust compiler
-
hyperbitbit
data structure
-
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
puruda
Pure Rust DataFrame
-
dotwalk
Traits to traverse structures and generate DOT graphs
-
lanyard
UTF-8 C string types
-
empty_type
Tools to define and convert between types and their corresponding "maybe types"
-
win-idispatch
that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
yptoscr
writing yptoscr
-
field_accessor
A procedural macro to get and set a struct field by String dynamically
-
cds
Collection of Optimized Data Structures
-
petal-clustering
A collection of clustering algorithms
-
cranelift-entity
Data structures using entity references as mapping keys
-
mori_parallel
parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
terrain-graph
Graph Library for Rust
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
goodreads
deserializing a Goodreads library export
-
grovedb-visualize
Debug prints extension crate for GroveDB
-
fwdlist
A simply linked (forward) list
-
hilbert_curve_generator
A WIP Hilbert Space-Filling Curve Coordinate Generator
-
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).
-
goya
morphological analyzer for Rust and WebAssembly
-
supply-chain-trust-example-crate-000029
'Small vector' optimization: store up to a small number of items on the stack
-
cliquers
Manage filesequences with a common numeric component
-
rbtset
A set based on a RB-Tree for efficient operations
-
fufu
-
errling
A collection of intrinsically useful errors
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
once-list
an append-only per-item list
-
the_one
bst crate, created as a project for class
-
chemrust-scanner
The core modules defining the flow and structs of data in computational chemistry routines
-
bitvec_simd
bitvec with SIMD
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
temporary-annex
Helper for creating temporary annex on a collection
-
gfa-reader
Reading gfa format v1
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII's gridd)
-
exosphere-core
Core crate for Exosphere
-
protect
A protected data structure
-
evento-query
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
contextual
deal with data in context
-
smallobjectpool
A small object pool for Rust
-
openpgp-keylist
An OpenPGP Keylist data structure
-
ypwt
ypwang's personal toolbox
-
two_three
A two-three (2-3) tree implementation in Rust. Includes a map and set interface
-
aterm
Annotated Terms data structure
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
datastruct
A pure-data structure builder
-
implhm
Simplified library of collision-handling HashMaps
-
granite
Generic backing storage framework for building data structures
-
handy
providing handles and handlemaps
-
index_many
A proof of concept for indexing an slice at multiple locations at once
-
mutable
keep track of changes in structures
-
zotero
Communicate with Zotero API
-
bubbletree
Bubble-tree
-
foba
A test crate
-
combinations
give you all the combinations of values in a vec
-
hedge
An index based half-edge mesh implementation
-
expire
data structure for data maybe expired
-
prometheus-tokio
A collection of tokio runtime metrics for prometheus consumption
-
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
-
myopic
A possibly bad lens library for Rust
-
graph_process_manager_core
explore parts of a tree-like or graph-like structure that is not known in advance
-
generational_token_list
A doubly-linked list backed by generational-arena
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
semver-store
An HashMap structure that uses semver strings as keys
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
watermark
watermarking set for in-order insertions
-
motivations
a collection of motivating messages
-
cset
Fine-grained and reversible struct transactions
-
rand_map
A map that creates a random handle on insertion to use when retrieving
-
graphlib_rust
Dagre's Graphlib implementation in Rust
-
fast_id_map
fast map
-
awint_dag
DAG
awintfunctionality -
vivalaakam_seattle_collection
Collection provider
-
gumbel-top-bucket
A bucket data structure that is sampled using the Gambel-Top trick, which allows for O(1) sampling from a softmax-like distribution
-
ljprs_async_pool
async-friendly pool data structure using tokio
-
aoc-framework-utils
such as data types, algorithms and functions for aoc-framework-rs
-
fervid_core
The core structures and utilities of fervid
-
jec
My collection of general-purpose crates
-
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
cbsk_log_rayon
log tool, using tokio as the runtime
-
modular-bitfield-ordering
Provide u8be..u128be, u8le..u128le for modular-bitfield
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
zeen_filter
A fast and optimized Bloom Filter implementation in Rust
-
aspiesolutions_core
core types used by many crates
-
ts_lib
A collection of functions I find useful for my projects
-
foxy_types
Types for
foxy -
l6t-symbolic
A part of l6t library: symbolic data model for different known devices
-
evillatoro-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
kukoo
lockfree cuckoo hashmap
-
sss_fft
FFT and IFFT for arrays and iterateable collections with modular algorithm interface
-
atree
An arena based tree structure with removal support
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
rpos
Cursor Manager on Table
-
tf2-types
a collection of types for tf2
-
tcgeneric
Generic data types used internally by TinyChain
-
doublets-decorators
Decorators for doublets
-
vec-strings
Store any string efficiently in an immutable way
-
diskdata
A catalog of on-disk data structures
-
motivation
A collection of motivating messages
-
rolling-set
A first in first out set that never grows above a certain size
-
rs-arboretum
A study in trees
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
ndtensor
n-dimensional tensor library for Rust
-
treez
A collection of useful data structures
-
geogrid
Manipulate geographic data on a grid
-
kodiak-sets
manage generic sets supporting unique features
-
entry_put_ext
Map entry extension for put operations
-
skootrs-model
module contains the various data structures used by the other Skootrs modules. This is also setup to make it easy to generate schemas from this code for the purposes of easily implementing…
-
aph_disjoint_set
Disjoint set implementation with optimized memory usage and ability to detach elements
-
vec_key_value_pair
A drop-in replacement for std::HashMap and std::HashSet that use Vec on the backend
-
struct_mapping
Token StructMapping for testing StructMapping implementations
-
rust_release_artefact
Safely extract installable files from Rust release artefacts
-
rcbytes
Rc version bytes crate
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
visit_diff
Efficiently finding differences between data structures
-
type-info
Meta type information and type reflection at compile-time and runtime
-
uwheel
Embeddable Aggregate Management System for Streams and Queries
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
fxd
Fixed-point decimal implementation
-
icu-data
International Components for Unicode (ICU) data in Rust structures
-
dyn-slice
&dyn [Trait] implementation, inspired by a Reddit thread
-
stackbt
A small collection of crates for game AI
-
soa-vec
Vec-like API over a struct of arrays layout
-
libpaprika
read and generate Paprika recipe files and recipe collections
-
dd_statechart
A Data-Driven implementation of Harel Statecharts designed for high-reliability systems
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
Project2
Implementations of red black tree and AVL tree
-
extract_map
A HashMap for memory efficent storage of value types which contain their own keys
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
crdt
Conflict-free Replicated Data Types for Rust
-
cad_import
importing CAD data from different formats into a uniform in-memory structure
-
table
A specialized map for storing values of varying types
-
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
app_properties
reading application properties from a file
-
cosmic_undo_2
Undo and redo done the right-way
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
bigraph
Different representations with implemented operations on bigraphs
-
subset-map
A map where the keys are subsets of an initial set of elements
-
bit-vec_serde
A vector of bits
-
simid
Universally Unique IDentifier (UUID)
-
latticequeries
Allows for fast hierarchical queries on Vecs
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
fixedbitset-stack
A forked version of FixedBitSet that supports const generics
-
crdt-sample
containing samples of crdts
-
binary_sort_tree
二叉树的new,insert,del,search等方法
-
ensure
target state of an object
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
orx-imp-vec
ImpVecstands for immutable push vector 👿, it is a data structure which allows appending elements with a shared reference -
nereon
Riboseinc configuration library for Rust
-
kodiak-taxonomy
manage generic taxonomies supporting unique features
-
const-oid
Const-friendly implementation of the ISO/IEC Object Identifier (OID) standard as defined in ITU X.660, with support for BER/DER encoding/decoding as well as heapless no_std (i.e. embedded) support
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
simple-ref-fn
function wrappers that do not require virtual tables
-
kd_interval_tree
Implements a K-dimensional interval tree, for fast interval-overlap lookup. Binary-tree based implementation, i.e. O(log(n)) lookups.
-
rustupolis_server
using space tuples in fog computing
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
partial_const
way to handle constant and non-constant values in a unified way
-
bb-qol
Small collection of quality-of-life functions
-
fe_data
Data structures for FE
-
mashmap
A flat HashMap that supports multiple entries per key
-
linked-vector
A hybrid linked list and vector data structure
-
okasaki
A collection of peristent datastructures
-
cursed-collections
Collections that (seem to) break Rust safety
-
twitter/rustcommon-streamstats
Statistics calculated for a stream of samples
-
type-erased-table
A column-oriented based raw data storage
-
charcoal
Implements tree data structures and interfaces to work with them
-
arraylist
wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
dynprops
Creating and extending objects with typed dynamic properties
-
ds-bst
Binary search tree implementation
-
arrsingh-lists
A test crate to test publishing
-
assoc
Treat vectors like associative arrays
-
willowtree
Lazily evaluated trees
-
f1d2d2f924e986ac86fdf7b36c94bcdf32beec15
Test for XSS on docs.rs
-
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
disk-mpmc
on-disk mpmc
-
retworkx
A python graph library implemented in Rust
-
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…
-
transit_model_relations
Modeling the relations between objects
-
tree_by_path
A tree data structure featuring nodes addressable using a &Vec<usize> path and avoiding recursion and run-time borrow checking
-
rimu-parse
A data structure template system
-
bloomfx
Bloom filter implementation backed by fxhash
-
blocklist
The project is based on blocklistproject. It provides perfect hash map/set structures for fast lookup of blocklisted items.
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
restor
A dynamic resource storage system in rust
-
content-tree
An efficient data structure for compacted RLE data
-
list-any
Type erased slices and Vecs
-
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)
-
json_tables
A structure that eases operations with a local json storage of undetermined items
-
bin-tree
Building Binary Tree
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
enum-tag
Proc. macro for generating enum discriminant types.
-
fusebox
Mostly safe and sound append-only collection of trait objects
-
contiguous_collections
collections backed by flat contiguous arrays
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
type-pools
A data structure to store values of multiple types
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
competitive-programming-lib
Competitive Programming Library
-
merkletree
Light merkle tree implementation with SPV support and dependency agnostic
-
fenny
working with Fenwick trees
-
simple-observable
observable pointer for mutable and immutable data
-
hdf5-dst
DST extensions for HDF5
-
blobary
place for blobs
-
hexarr
working with hexagonal grids
-
system-config
storing application properties on disk
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
anat-rs
represent natural numbers as well-founded sets
-
rs-bush
Bush data structure
-
char_index
efficient charwise indexing into a string
-
ditto
CRDTs for common data structures like maps, sets, vecs, strings, and JSON
-
hgg
Approximate nearest neighbor search collection
-
byte_set
Efficient sets of bytes
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
embedded-async-helpers
staticfriendly helpers for async on embedded -
graus-db
A high-performance, thread-safe key-value embedded data store
-
moc
made to create and manipulate HEALPix Multi-Order Coverages maps (MOCs), see https://ivoa.net/documents/MOC/
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
anystruct
that provides traits for converting between JSON and Protocol Buffers (Proto) data structures
-
map-to-const
Easily convert HashMap<K, V> to constant [(K, V); N] values
-
persistence
A resizable, mutable array type implemented on top of mmap, providing persistence for arrays of data in memory
-
data_structure_traits
data structure collection traits
-
hkalbasi-rustc-ap-rustc_serialize
Automatically published version of the package
rustc_serializein the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
tongrams
Tons of N-grams
-
codas-macros
Macros for Codas
-
stable_node_set
An ordered set with handles to values
-
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) -
vector-map
VecMap<K, V>: a Linear Search with Map API
-
dsalgo
A package for Datastructures and Algorithms
-
dlist
List data structure based on AVL tree. It can store elements which have dimension and quickly search for elements by distance from 0.
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
scratchbuffer
A Vec<u8> like data-structure, that can be used as slices of different types
-
sbbf-rs-safe
Split block bloom filter implementation
-
batbox-approx
Approximate comparison
-
arenas
Arena data structure for efficiently adding & removing items with stable IDs
-
id_sys
data structures which can be marked such that they only work with similarly marked integer data types
-
zngur-def
Data types that define the structure of a zng file
-
static_merkel_tree
Static Merkel Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
zang
A test crate which is also a collection of some libraries which I tend to use for hobby projects
-
rust-fp-pfds
A Functional Programming Library in Rust, Purely Functional Data Structure
-
unicode_extension
Extension of the Unicode Segmentation crate allowing you to use a list of clusters as if they were a String
-
geomprim2d
2D geometric primitive types
-
fenwick-tree
binary indexed tree (Fenwick tree) data structure in Rust
-
naq_domain
Domain library for nordic air quality (naq) that defines shared domain data structures
-
standards
A collection of standards for international trade facilitation
-
flats
flattens nested structures into a flat single dimension map
-
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 -
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
context-mapper
Single rust macro for generating different maps
-
binary-search
General binary search implementation
-
rustupolis
tuple space data structure in Rust
-
num-bigint
Big integer implementation for Rust
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
nolan
Commitlog/WAL Implmentation and Powerful Abstractions
-
hashcons
Hash cons'ing for compact representations of shared, immutable data structures
-
cell-grid
fixed-size 2d grid container suitable for
no_stdgame development -
chtholly
Tree, a data structure originated from CF896C
-
priq
Array implementation of the min/max heap
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
twie
fast and compact prefix tries
-
datastreams-rs
DataStreams container
-
rustifact_extra
Extra features for Rustifact
-
advanced_collections
advanced data structures (collections). Includes counter (hash-bag, multiset), disjoint set (union-find, merge-find), circular buffer (cyclic buffer) and interval (range)
-
foxy_utils
Common types and utilities for
foxysubmodules -
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
-
ranno
Annotations over recursive data structures
-
ctxmap
A collection that can store references of different types and lifetimes
-
dequemap
A no_std compatible implementation of the dequemap crate
-
laizy
stable and thread-safe implementation of a lazy value
-
discrete_range_map
DiscreteRangeMap and DiscreteRangeSet, Data Structures for storing non-overlapping discrete intervals based off BTreeMap
-
byte-sequence
A little marco that creates structs to be used as byte sequences (for ApiKeys, SessionIds and so on)
-
break_array
For breaking array indexing
-
adts
Common abstract data type traits and implementations
-
hash_ring
Consistent Hashing library for Rust
-
utf8char
that supplies a utf8 encoded char
-
ahtable
Array Hash Table implementation
-
mtgjson
Unofficially provided lightweight models of the data provided by MTGJSON
-
courgette
Colour manipulation/conversion library
-
handler_map
Map from types to functions that receive them
-
graphstack
Graph-structured stack
-
rudac
common data structures and algorithms
-
cess-sp-core
CESS Storage Proofs - Core parts for proofs of storage
-
parse_tree
A non-abstract syntax tree type
-
big_enum_set
creating sets of enums with a large number of variants
-
abbrev-tree
highly inefficient data structure for text completion
-
eytzinger
implements the "eytzinger" (aka BFS) array layout
-
mismatch
abstract mismatching. Useful for error propagation.
-
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
hashbrown_tstd
port of Google's SwissTable hash map
-
collidea
Collision-prone memory-efficient collections
-
treeflection
that provides reflection for tree structures
-
eztd
Quick start Rust
-
board
creating a single vector with coordinate based access, and a few nice functions for easy use
-
keylist
Elixir keyword list in Rust
-
equivalence
Trait and derive macro for comparing and hashing types modulo an equivalence relation
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
vbox
type erased Box of trait object
-
ord-by-set
providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
object-chain
Ad-hoc structure builder
-
lending-library
A key-value store that loans full ownership of items
-
elaru
Memory safe implementation of LRU cache
-
portdiff
Data structure for fast local graph rewriting
-
halfling
A collection of basic utilities for working with nibbles
-
pinned_vec
Vec-like data structure whose elements never move
-
predicates
boolean-valued predicate functions
-
lockfree-cuckoohash
lockfree cuckoo hashmap
-
map_split
providing simultaneous mutable access to disjoint portions values stored in a hash map
-
tracker-macros
Macros for the tracker crate
-
spectacle
Opt-in runtime introspection
-
linked_lists
Different types of linked lists
-
char-list
A persistent string type with the same API as a linked-list of characters
-
oxidd-test-utils
Test utilities for OxiDD
-
sdsl
interface for the Succinct Data Structure Library
-
scopegraphs-prust-lib
fork of prust for scopegraphs
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
forged-in-lost-lands
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
rtlp-lib
This create provide structures to parse PCI TLPs
-
paged
Read and create read-only paged database files
-
vfs-tools
A collection ofttools to work with VFS
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
samplify-rs
A procedural macro to generate sample data for Rust structs
-
old_norse_alphabet
Old Norse alphabet constants & sort for Rust
-
dpc-simplemap
map with default value and compacting
-
map_err
map error values
-
bitf
procedural macro to easily create a bitfield out of a struct
-
tc-state
TinyChain's general state enum
-
const_std_vec
const std vec
-
ABtree
AVL and Btree for rust
-
ultrametric_matrix_tools
Toolbox that provides functions and data structures to generate and handle ultrametric matrices
-
cycle_cursor
Cyclic cursor implementation over generic iterators
-
debounce
Data structures and helpers for debouncing a stream of events: removing duplicate events occurring closely in time
-
sbf-blake3
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
exegraph
no_std execution graph library
-
jirachi
A collision resistant runtime agnostic key-generator
-
hv-alchemy
Heavy Alchemy - the black arts of transmutation, wrapped for your safe usage and enjoyment
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
treers
Sedgewick's tree maps
-
packed_array
Packed Array aka sparse set structure with compile-time known size
-
linked-syntax-tree
A doubly-linked syntax tree
-
slotmap-map
Slotmap data structure
-
anycollections
Rust Vec and HashMap which can contain arbitrary types
-
benchmark-counters
Light-weight data structures to help with monitoring and benchmarking
-
lockerroom
Readers-writer access to individual cells of your collection!
-
intsplit
splitting numeric types into their binary component arrays
-
mexset
Implementing a set with MEX support
-
cbsk_log_tokio
log tool, using tokio as the runtime
-
bndpresbufq
Bounds-preserving, optionally limited, buffer queue
-
advancedresearch-max_tree
maximizer library based on a maximum tree structure
-
art
adaptive radix trie
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
array_stump
A data structure mixing dynamic array and sorted set semantics
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
model
model-based testing for data structures, with linearizability checking
-
std_collection_traits
Abstraction of operations in std collection types
-
pin-list
A safe
Pin-based intrusive doubly linked list -
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
-
data-query
Query library that allows for Querying Serializable data using string queries
-
aoc-framework-parsers
Compilation of input parsers for aoc-framework-rs
-
grit-bitvec
BitVec, a vector type that can store fixed-width data with irregular bit widths
-
fill_canvas
FillCanvas is a wrapper around a matrix with special methods to fill the cells
-
dendron
Generic tree data structure
-
simple-canvas
generic 2 dimensional canvas struct
-
bigvec
A really big vec
-
lookups
Improve the data retrieval operations for collections
-
uset
set and a map designed for speed, with unsigned integers as keys
-
typed_id
Make your IDs strongly typed!!
-
pati
Image data structure and format for the Patica editor
-
threshold-dict
A data structure to find smallest key that is larger than the query
-
espalier
Very simple flattened tree structure
-
fixedvec
A heapless version of the Rust vector type
-
twodarray
A 2D array library
-
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
rust-datastructures
some datastructures in rust
-
simple-collection-macros
configurable macros for maps and sets
-
setting
The styles of all graphics elements
-
stringvec
macro for creating Vec<String> from various types
-
id-pool
Create and recycle integer ids using a ranged pool
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
las
Reads and writes point clouds stored in the ASPRS las file format
-
trie-standardmap
Standard test map for profiling tries
-
deno-bindgen2-utils
Contains utilities for interacting with rust data structures through FFI. Conditionally-compiled and embedded into the final shared library by the CLI tool
-
db_meta_derive
db-meta-derive is a wrapper around PostgresSOL using tokio-postgres
-
tinysearch-cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
sorbus
A tree manipulation library
-
blend-bindgen-rs
generated Blender's data structures
-
grid_trait
2D and 3D grids with combinators
-
bfield
B-field datastructure implementation in Rust
-
re_types_core
The core traits and types that power Rerun's data model
-
dot_tree
Create, query and store binary trees
-
batbox-collection
Collection of identifiable objects
-
ringbahn
an experimental safe API for io-uring
-
qt-json
JSON library for QT
-
take-some
that provides a way to obtain *some* value from various collections
-
hylo-fix
Fixed-point number types with Solana Anchor support
-
cmp_wrap
Let you compare structes by context
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
hdf5-hl-sys
Bindings to HDF5 High Level API
-
nibble_vec
Vector data-structure for half-byte values
-
swimmer
Thread-safe object pool type
-
disjoint_set_forest
A disjoint set data structure implemented using a disjoint set forest
-
extensions
typemap container with FxHashMap
-
slotgraph
Graph implementation built with slotmap and petgraph
-
raphy
A graph data structure library
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
bstree
A Binary Search Tree written in Rust
-
circular-queue
A circular buffer-like queue
-
sharedvec
A fast but limited collection for storing values of a single type
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
wrapped_slab
WrappedSlab: Auto-generate newtype idiom based on a Slab
-
hlist2
Compile-time heterogeneous list implementation
-
streamhist
streaming histogram
-
arenavec
An arena backed implementation of vectors and related types
-
kaola
A Persistent Delayed Queue in Rust
-
rstructure
A thread-safe data structure library
-
judy-wrap
Judy arrays FFI mid-level binding
-
tree-index
Index a flat-tree
-
kserd
Kurt's Self-Explanatory Rust Data
-
asdl
Parser for ASDL format. Describes the abstract syntax of compiler intermediate representations and other tree-like data structures
-
uuid-timestamp
UUID timestamp
-
schemes
cache-aware recursion schemes in rust
-
eclectic
Experimental collection traits
-
indexed_vec
IndexVecfromlibrustc_data_structures -
flat-veb
Fast implementation of vEB trees without internal allocation
-
ramp_table
RampTable, a data structure useful for certain specialized situations
-
m6coll
Small Smart Collections using prefix m6
-
grafite
Range Filter
-
range-traits
Ranges related traits
-
cognitive-frames
Managing windows for
cognitive -
collectivity
Generic collection traits
-
mycelium-bitfield
Structured bitfields, courtesy of Mycelium
-
chtholly_tree
Rust bindings for Chtholly Tree
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
graff
manipulating graphs
-
arc-atomic
atomic pointer to an
Arc -
backtracking_iterator
generic iterator with an item history, capable of backtracking and forgetting
-
jui_file
file tool
-
u64_array_bigints
biginteger library based on u64 arrays
-
bsp-pathfinding
Runtime path finding using Binary Spatial Partitioning
-
pds
Probabilistic Data Structures efficiently implemented in Rust
-
id-map
Data structure of values indexed by IDs
-
better_peekable
Create a Peekable structure like Rust's Peekable except allowing for peeking n items ahead
-
ccl_owning_ref
creating references that carry their owner with them
-
luka
working with graphs
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
artsy
ART Tree data structure library
-
intersection
Find the intersection over a collection of sets; when you need more than the intersection between two sets
-
rt_vec
Runtime managed mutable borrowing from a vec
-
bittree
O(1) find functions in a special data structure called a bit tree
-
bugu
Cuckoo Filter: Practically Better Than Bloom
-
hedel-rs
A Hierarchical Doubly Linked List
-
multi-stash
Vector-based arena data structure that reuses vacant slots
-
no_vec
modifying sized arrays
-
radixt
A fast, memory-efficient radix tree implementation in Rust
-
traitgraph
Abstracting over different graph representations
-
jsonnlp
JSON-NLP data structure
-
sequencetree
a new type of collection to store keys and their corresponding values
-
pinned-bucket
Mutable container for pinned and immutable items
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
linked-list
An alternative implementation of std::collections::LinkedList
-
holium-rs-sdk
Holium Rust SDK
-
tierkreis-core
Core implementation for the tierkreis quantum-classical hybrid workflow orchestration tool
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
front-vec
Efficiently-prependable Vec and String types
-
mycelial-crdt
mycelial crdt
-
causal-length
CRDT's based on causal length sets
-
passive
A trio of marker traits to classify passive data structures
-
empty-collections
Correct-by-construction empty collections
-
truncate-integer
Truncate integers
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
simple_event_bus
A basic, simple event bus in Rust
-
delete_if_not
unsafely in-place delete function
-
map1
@ErichDonGubler's fancy template for new Rust projects
-
key_set
KeySet representing concepts of All, None, Some(list), and AllExceptSome(list), with basic set calculations (intersection, difference, inverse)
-
hirpdag
procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
bstree-file-readonly
Query read-only binary-search tree file, supporting billions of entries in files of tens of GB
-
disjoint-set
Tarjan's Union-Find Data Structure
-
higher_order_point
An experimental higher order data structure for 3D points
-
data_registry
An unordered data structure with immediate insertion, removal and access
-
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… -
hecs
A fast, minimal, and ergonomic entity-component-system library
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
algae-rs
A collection of abstract algebraic structures implemented in Rust
-
dastral
Reduce boilerplate code, learn data structures & algorithms with Dastral
-
bitsvec
A bit vector with the Rust standard library's portable SIMD API
-
apint
Arbitrary precision integers library
-
btree-vec
A growable array (vector) implemented using a B-tree
-
largeint
that supports large integer arithmetic
-
polystore
Polymorphic data store
-
kdt
k-dimensional tree implemented with const generics
-
fast-list
A doubly linked list using SlotMap for improved cache locality, and to solve the ABA problem
-
catalan
binary tree of n variables where the parent node represents a function and the child node represents a value
-
soak
Transform a struct into arrays of its fields
-
my-stack
stack implementation in Rust
-
cartesian-tree
Construct a Cartesian Tree from a Slice in Linear Time
-
strchunk
Data types for working with UTF-8 text in I/O
-
collect-once-hashmap
A hashmap that can be collected only when there are unique keys in the iterator
-
simple-matrix
generic matrix library
-
flatbuffers-owned
that enables a more flexible usage of FlatBuffers
-
dyn_trie
Dynamic trie is trie capable of mapping any T to any string
-
offset
Glorified offsets for arbitrary structures
-
packbytes
Convert structures to and from packed representavises - byte arrays of fixed size that live on stack
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
lineartree
tree data structure for rust
-
slots
Fixed size data structure with constant-time operations
-
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits-sized unsigned integer elements -
loro-preload
Loro internal lib for loading data
-
precedence-net
Create and analyse precedence networks
-
aabel-bloom-rs
implements the Bloom filter
-
ulid-generator-rs
generating ULIDs
-
vlsm-tree
Versioned Log Stream Merkle Tree
-
version-rs
A struct for Versions, with the methods you expect
-
valet
Stores your objects and gives you a tag to retrieve them later
-
multi_key_map
a hash table that shares one value across multiple keys
-
banyan
Persistent indexable tree data structure
-
unsized_enum
Unsized enum implementation
-
automap
pattern to implement key-value maps where the value type contains the key type
-
go-heap-rs
Golang's heap written in Rust
-
bytes-expand
Types and traits for working with bytes
-
bitmac
Structure for accessing to single bits
-
composite_types
Compose type definitions in the style of typescript
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
secured_linked_list
A cryptographically secured and provable linked list
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
rstmt-core
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
tournament-kway
k-way merge using a tournament tree
-
sexpr_parser
Generic S-Expression parser
-
p8n-types
Basic types for representing binary programs
-
triskell
A tri-partite ring buffer
-
building_blocks_mesh
Fast meshing algorithms for voxel data structures
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
gap_query_interval_tree
that provides a gap-query optimized interval-tree data-structure
-
moretypes
Named tuples, records, and more!
-
fsort
sort files in a fast, OS-independent and 'rusty' way
-
iron_rose
Invertable Bloom Filters & Strata Estimators as found in https://www.ics.uci.edu/~eppstein/pubs/EppGooUye-SIGCOMM-11.pdf
-
weakheap
Weak Heap data structure implementation in Rust
-
insert_multiple
insert multiple items into a stream in reasonable runtime
-
packedvec
Store vectors of integers efficiently
-
lazy-cogs
Lazy Cogs is a implementation of lazy clonable data structures
-
bloom_filter_plus
rust_bloom_filter
-
rudy
Judy array implementation in pure Rust
-
genindex
Generational index library
-
suffix_trie
Suffix trie for searching
-
cola
A text CRDT for real-time collaborative editing
-
typemap_core
A no_std typemap with trait-based value-presence guarantees (on nightly)
-
rimu-eval
A data structure template system
-
apid
Collection of type definitions from several APIs
-
forgetful
Track and forget values within a specific scope, enabling detection of repeated values
-
tree-graphviz
Generate GraphViz DOT directed trees, based on an arbitrary tree structure
-
colony
A fast associative data-structure that chooses its own keys
-
hashtree
A Merkle Tree implementation in Rust
-
fixed-slice-deque
A fixed size deque implementation
-
treena
Tree stored in an arena
-
decoded-char
wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
taskforge
Task management shared functions and structures for the taskforge family of tools
-
more_ranges
Range types not provided in the standard library
-
range-split
splitting sequences with range parameters
-
one_way_slot_map
SlotMap with minimal restrictions on Keys and Values
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
aligned-utils
Common utilities to work with aligned values and allocation
-
hyper-tree-router
Routing middleware for Hyper http library using Prefix tree (trie) for path finding
-
bitint
Integer types that have a logical size measured in bits
-
graphia
graph data structure
-
reusable-vec
A Vec wrapper that allows reusing contained values
-
fplist
An immutable, persistent, singly-linked list
-
sets_multisets
API for working with sets and multisets of elements of type usize
-
binary-data-schema
Meta language for raw binary serialization
-
atlas-rb-tree
A textbook implementation of a Red-Black Tree
-
push-while-ref
push while having a reference
-
rust-bloomfilter
bloom filter implementation in Rust programming language
-
fp-collections
An alternate collections library for rust
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
automatic-relations
Tree automatic relations
-
aggregate-map
Collect key-values pairs into a mapping from keys to collections of values
-
arrsingh
A top level crate in the workspace
-
biheap
A heap group that supports efficient removal of extreme elements
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
cbor-tag-index
Tag index
-
supply-chain-trust-example-crate-000097
generate and parse UUIDs
-
url-hash
types that provide secure and stable hash values for Urls
-
batbox-android
Helper crate for android
-
dynamic-matrix
work with matrices
-
flatten_objects
A container that stores numbered objects. Each object can be assigned with a unique ID.
-
cbsk_unique
unique value generator
-
tinyvec_string
tinyvec based string types
-
mapro
A tiny macro library for creating std::collections
-
projected-hash-map
projected HashMap over HashSet
-
ux
Implement the following non standard integers: u2, u3, u4, u5, u6, u7, u9, u10, u11, u12, u13, u14, u15, u17, u18, u19, u20, u21, u22, u23, u24, u25, u26, u27, u28, u29, u30, u31, u33…
-
densevec
Map like collection with usize indices that stores values contiguosly
-
common-tree
common tree lib
-
binartree
Binary Tree realisation
-
onigiri
handling chars
-
heapless_topo
no-std topological sort using
heapless -
to-offset
developer-friendly methods to manipulate strings with character indices
-
truetree
Trees in Rust
-
owned_chunks
a collection of traits and iterators to get owned chunks from collections
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
xio_base_datatypes
XIO base data structures
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
wasmflow-interface
Types used by the Wasmflow tool chain
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
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"
-
mind-tree
Organize your thoughts in a tree-like structure
-
circular_vec
A fixed length vector that provides a next function that loops infinitely
-
cons-rs
containing a Cons data structure
-
solana_libra_canonical_serialization
Libra canonical serialization
-
know_yaml
The Know Framework for Rust
-
prefix_tree_map
generic prefix tree (trie) map with wildcard capture support
-
enum-ref
Proc. macro for generating enum discriminant types.
-
offset-views
Create and index offset views of arrays, slices, strings, etc
-
memcell
providing a MemoryCell struct, which stores a current and previous value
-
nimrodshn-btree
A persistent copy-on-write B+Tree implementation, designed as an index for a key-value store, inspired by SQLite
-
data-buffer
low-level data buffer type useful for IO and in homogeneous collections
-
fera
An aggregation of algorithms, data structures and supporting crates
-
librualg
Collection of basic algorithms for everyday development
-
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. -
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
miny
Box<T> with small value optimization
-
leetcode_for_rust
leetcode for rust
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
prust_core
encoding/decoding PUS-C packet data structures with ease
-
solomondb
An embedded and distributed Gremlin-compatible graph database
-
prototty_storage
Interface to persistent storage
-
siraph
A node-based digital signal processing crate
-
frbf
robust, and efficient implementation of the Bloom Filter data structure in Rust
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
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…
-
comprehend
Python like list, set and hashmap comprehensions via macros
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
history-buffer
A fixed capacity, write-only, ring buffer
-
cdl-list-rs
A circular doubly linked list implementation using Rc<T> and RefCell<T>
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
negatable-set
Wrapper for sets that allows full boolean operations including negation
-
seg-tree
segment tree library
-
c_linked_list
handling NULL-terminated C linked lists
-
dsu-tree
A non-invasive disjoint-set-like data structure implementation
-
bidirectional-map
A two-way map data structure for small keys and values
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
triemap
Triemaps for Rust
-
compressed_map
'Static functions': compressed maps with the keys removed
-
pretree
package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
ov
a collection of traits that allow you to chain off of anything
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
same_elements
Function to test if two collections contain the same values
-
vector2
2D vector library
-
collection
Deterministic, copy-on-write balanced search trees
-
kermit-ds
Kermit, the Leapfrog Triejoin algorithm with associated data structures
-
ppar
Persistent immutable array
-
vortex-alp
Vortex ALP array
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
dynamic-list
A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
-
fusefilter
No alloc membership approximation
-
lhlist
Labeled heterogeneous lists
-
gridd
A generic, dirt-simple, two-dimensional grid
-
fast_collections
noheap zero copy collections
-
trailer
Store a type with an associated buffer in contiguous memory
-
dense_bitset
A variably sized, heap allocated, dense bitset implemented using no
unsafecode -
crdt_rs
work with Conflict-free replicated data types (CRDT) in Rust
-
tree-cursor
non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
set-trie
A trie for fast subset and superset queries
-
dag-cbor-references
Extract blake3 ipld links from dag-cbor blocks
-
pui-arena
Generalized Arenas that can be used on
no_std -
simple_ringbuf
Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
map_ext
Extensions to std::collections::HashMap and std::collections::BTreeMap
-
disjoint-hash-set
A disjoint set / union-find data structure suitable for incremental tracking of connected component identified by their hash
-
intervalsets
bounded and unbounded intervals implemented as sets with all the associated set operations
-
queue-rs
queue
-
head
Common types with inline headers, such as HeaderVec for Vec
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
fricgan
performing basic input and output on bytes
-
u64_array_bigints_core
Core library for
u64_array_bigints -
flat-zip
An iterator adaptor to help traverse two-level collections
-
partial-array
potentially partially-filled arrays
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
trait-map
Rust map for dynamic trait storage and references
-
box-collections
A no_std compatible implementation of the collection crate
-
plain-map
map that uses small_vec as backing storage, which is useful for having many tiny maps. For storing non-Copy types please use v1.x which is also supported.
-
compact-map
'Small map' optimization: store up to a small number of key-value pairs on the stack
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
bitsetium
One stop shop for all bitset needs
-
qt-json-rs
JSON library for QT
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
sortedcontainers
An experimental sorted data structure
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
repc
APIs to calculate the layout of C types
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
treelike
A trait to abstract over trees, and simplify implementing them, all in one handy crate
-
domain-lookup-tree
A tree structure in Rust optimized for looking up domain names, with wildcard support
-
graphlib
powerful rust library for the graph data-structure
-
nave
Thinking about the construction of distributed systems starting from the *consistent hash* algorithm
-
sized-vec
Type level sized vectors
-
header-slice
Definitions for slices with headers, and a vec-like type with a header allocated inline
-
dmfr-dataset-reader
Reads transitland folder and outputs graph of valid feeds and operators
-
tdb-succinct
succinct data structures used by terminusdb
-
hashmap_ext
Extensions to std::collections::HashMap
-
miniconf
Serialize/deserialize/access reflection for trees
-
ckb_multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
tranche
Tranches are an alternative to slices
-
prioq
Priority Queue implemented using std::collections::BinaryHeap
-
copy-range
core::ops::Range et al, but Copy and IntoIterator
-
enum_from_variant
macro to generate From<T> trait implementations for enum variants, simplifying error conversions and enum mapping
-
dot_json
Tools for dot map representations of serde_json Maps
-
fremkit
broadcast log
-
tapestry
Generic 2D grid data structure and utilities
-
dyn_array
easy to use N-dimensional dynamic array
-
spigal
fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
lobby-queue
Const-size queue-like data structure
-
autocomplete
Auto-complete feature using Trie data structure
-
gavl
A fast implementation for a map and a set using an AVL tree
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
rc-slice2
Reference-counted slices with easy subdivision
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
arrav
Sentinel-based heapless vector
-
fast_trie_tree
A fast
TrieTreefor multiple data types -
udgraph
Universal dependency graphs
-
containerof
Macros and traits facilitating the use of intrusive structures in Rust
-
any_handle
A thread-safe, type-safe smart pointer that can share, store and downcast a
dyn Any -
bet
parsing and evaluating binary expression trees
-
xtree
general purpose tree data structure
-
dst
Data structures for DSTs
-
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.
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
collect
An experimental extension of std::collections
-
hayami
general use symbol table
-
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
vector-trees
Vector backed B and AVL trees
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
btree-map
A data structure for storing and manipulating fixed number of elements of a specific type
-
variant-map
defines maps to store variants of enums
-
len-trait
Len trait for collectons
-
asyncapi
aims to provide data structures that represent the AsyncAPI specification easily deserializable with serde
-
densemap
A collection data structure that is permanently accessible by unique keys and fast iterable
-
bfilters
bloom filter implementation in Rust
-
fast_forward
Quering collections blazing fast
-
workit
single-threaded work queueing utility
-
treesome
tree creation, manipulation, traversal and visualization
-
dashmap-shard
port of Google's SwissTable hash map
-
upto
Fixed-capacity and variable length stack allocated arrays
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
serde-ordered-collections
Ordered serialization/deserialization serde functionality
-
hodgepodge
enums
-
unrolled-linked-list
unrolled linked list in rust
-
ethers-impl-rlp
RLP serialization support for uint and fixed hash
-
key-node-list
Doubly-linked list that stores key-node pairs
-
skew-forest
Skew-binary random access lists
-
bloom_filter_plush
rust_bloom_filter
-
btreelist
A list data structure that has efficient insertion and removal in the middle
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
vector_mapp
A Vec based map
-
rope_rd
A Read/Seek rope implementation
-
pathtrie
A specialised trie for paths in the style of a Patricia or radix trie
-
shelves
Storing values referenced by a unique typed index
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
stride
A strided slice type
-
gsrs
Generic Self Referencing Struct
-
batbox-range
Helpers for working with ranges
-
bytes-quilt
data structure for tracking random-access writes to a buffer
-
include-lua
that allows the embedding of a lua source tree into a Rust application binary
-
mvbitfield
Generates types to work with bit-aligned fields
-
nexum
collection of commonly used data structures
-
priority-set
A no_std Priority Set
-
arraylike
trait for using arrays without needing const expressions
-
rbtree-arena
A cache friendly red black tree where nodes live on sequential memory
-
get-many-mut
Stable polyfill for slice::get_many_mut
-
deferred_vector
A deferred vector implementation
-
smallbytes
= SmallVec + impl BufMut (from the bytes crate)
-
pi_phf_map
phf_map
-
b_trees
Implementations for various binary trees including AVL tree
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
avl-cont
A contiguous AVL Tree
-
cursieve
that makes it easy to deserialize byte arrays into annotated Rust structures
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
runtime-sized-array
A variable-length array, also called runtime-sized
-
jmt-blake3
Jellyfish Merkle Tree based on BLAKE3 hash function
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
sorting-vec
Sorts a vector using a btreemap
-
prefix_sum
prefix sum data structure
-
unsized-stack
Fast heterogeneous / unsized stack
-
hprtree
A Hilbert-Packed-R-Tree implementation for rust
-
seq
The module 'seq' provides the lightweight, generic sequence container 'Seq' for unmovable data and is embedded into the program during compile time
-
rs-bucket-filter
Skips slow scans using cache, bloom filter,
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
neighborgrid
A 2-D grid datastructure with easy to use iterators and adjacent cell methods
-
transit_model_collection
Manage collection of objects
-
btree_monstousity
a code port of BTreeMap but with comparator functions
-
bytes_to_type
facilitate byte conversion to specified types using macro generation
-
blfilter
Bloom filter implementation using farmhash
-
erased-type-arena
A type-erased allocation arena with proper dropping
-
tsil_cev
LinkedList on Vec
-
extended-collections
An extension to the collections in the standard library with various data structures
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
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…
-
collection_macros
Collection of macros for collections
-
tagged-tree
A tree-like data structure where the values are tagged
-
dyobj
improved version of the ECS pattern
-
enum-set
A structure for holding a set of enum variants
-
fibheap
but actually useful Fibonacci Heaps
-
flowerbloom
fast bloom filter implementation with thorough documentation and tests
-
lightning-containers
A set of lock-free data structures
-
rimu-ast
A data structure template system
-
shared-string
Split a string without another allocation
-
pokeapi-model
Data structures for PokéAPI v2
-
graphster
High-performance DataGraph Library
-
simple-octree
octree implementation written in Rust
-
prefix-tree
A map and set interfaces using trie data structure
-
slotmapd
orlp/slotmap fork where serialization cycle doesn't change observable behavior
-
retrace
Safe, generic rollback log with predictable latency
-
stacking
using a stack datastructure in rust
-
explicit-discriminant
Macro for enforcing enum discriminants
-
power_map
A map with finite key and fixed size
-
inspector
General purpose inspection for popular data structures
-
pi_slotmap_tree
A tree structure implemented by dense memory linked list
-
enumap
A HashMap and HashSet like interface for enums backed by an array
-
reservoir-buf
Dead simple interning
-
json-node
A way to work with JSON as a node tree
-
structurray
Easy psuedo-array generation for database optimization
-
atom_table
Assign easy-to-handle typed IDs to large, hard to handle things like strings
-
mmap_json_file
parse, count, filter JSON files using memory mapped io library
-
dynamization
Fast insertion for static containers
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
street_index
small utility crate for working with road name / street indexing for cartographic purposes
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
clampf
Clamped floating-point types
-
data_structures_SD
collection of data structures. In other words a collection of ways to handle your data in your code and/or program.
-
yagraphc
working with Graph data structures and common algorithms on top of it
-
tadm
A collection of algorithms and data structures wrote out while reading The Algorithm Design Manual book
-
hamt
Purely functional hash array mapped tries
-
last-git-commit
wrapper arround git2-rs to get info about the last commit. Useful for when you want to show the git hash in a program.
-
bytes
Types and traits for working with bytes
-
quickphf
Runtime code for static data structures based on the PTHash perfect hash function
-
lilbits
Super fast u8 set (ie bitmap) relying on the assumption that elements are <= 63
-
murmurhash64
MurmurHash2 (64bit version)
-
map-trait
Generic Map trait
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
bytesstr
An immutable reference-counted UTF8 String
-
linked_list_c
Safely work with c compatible linked lists
-
contigious-tree
Write and read tree graphs to and from contigious blocks of memory
-
terms
Tree terms and patterns data structures
-
wheelbuf
wheelbuffer crate offers a ringbuffer-like structure without a read pointer, making multiple reads of a buffer possible. The store behind the buffer is flexible and can be a static array…
-
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.
-
bufferring
Ring buffers for Rust
-
bloomy
Bloom filter using only two hash functions
-
rustgym
solutions
-
kermit-algos
Kermit, the Leapfrog Triejoin algorithm with associated data structures
-
hitree
Indexable containers for Rust: HiSet and HiMap
-
hashable_rc
Hashable wrappers for reference countings
-
stl-rs
STL like features in idiomatic rust
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
hashed
type you can convert any hashable type into and still do equality checks on
-
simple-bitrange
manipulating bit ranges which is common when working with IC registers
-
fallacy-hash
fallible hash collections
-
deqmap
A double-ended queue with optional keys
-
sliced
A segmented vector for iterating over slices
-
flat_enum
Expand nested enum into flattened enum
-
sortedlist-rs
A fast sorted list data structure in rust
-
pq-bincode
A wrapper crate of queue-file for bincode serializable structs
-
pegitan
A bunch of random algorithms library
-
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… -
local_vec
fixed-capacity vector allocated on the stack
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
an-rope
an rope for large text documents
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
stack-stack
stack-allocated stack
-
ommui_data
OMMUI data structures
-
sixarm_collections
Collections for HashMapToSet and BTreeMapToSet as trait extensions. By SixArm.com.
-
immer-rs
A wrapper around the C++ library immer for persistent datastructures
-
parity-hash
A collection of fixed-size byte array representations
-
btree_dag
A generic DAG (undirected graph) data structure
-
btree_network
A generic network (undirected graph) data structure
-
to_any
Auto derive ToAny trait for any structure
-
tyght-map
A static type map implementation
-
nom-midi
Parse a simple midi file into data structures using nom
-
cacaos
Core library for CACAO traits and data structures
-
simple-tree
Create, edit and iterate over tree structures
-
final
Wrap a value in a type that does not give out mutable references
-
congruence
closure
-
closures
Abstraction for seperating code and state in closures
-
fcsd
Front-coding string dictionary
-
bucket
Offers a very simple container for any value without mutation
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
prust-lib
Persistent & Immutable Data Structures in Rust
-
altdeque
An alternative deque implementation
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
ego-binary-tree
Binary tree API built by wrapping ego-tree
-
single_byte_hashmap
HashMap for storing singular bytes as keys
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/History -
simple_trie
array backed trie
-
tampon
Contains SAFE Rust functions, macro and trait to serialize / deserialize data structure and/or object and generate buffer
-
indexed_json
Index json files like a database
-
plum
Probabilistic data structures for rust
-
guzzle
A derivable trait for consuming key value pairs into structs
-
tree-experiments
Experiments with tree-like data structures
-
queueue
Queue-like data structures used in rCore
-
rimu-meta
A data structure template system
-
alo
ALO means At Least One. It could contain any number of item like
Vecbut it does not heap allocation if it contains only one item -
provenance
Container structures that generate key upon insertion that only works with the map that generated it
-
const-vec
Vec-like data structure with immutable push method
-
sortbuf
Data structure for sorting large numbers of items
-
recasting
traits for one-to-one recasting of values in data structures
-
tapa-trait-serde
A collection of Tapalogi's reusable crates
-
hashmap_union
Allows the union and intersection of hashmaps
-
sac
A macro for constructing collections
-
another_radix_trie
Rust built radix tree library
-
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…
-
arith
containers with arithmetics
-
gentrix
that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
bitstr
contiguous sequence of bits in memory
-
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. -
routee-compass-core
The core routing algorithms and data structures of the RouteE-Compass energy-aware routing engine
-
doubly-linked-list
double link list
-
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
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
banyan-utils
work with banyan trees
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
svec
Dart-style list in Rust
-
ngds
Rust bindings for AVFounation
-
pinned-queue
Queue-like data structure whose elements can never move
-
ra-ap-rustc_graphviz
Automatically published version of the package
rustc_graphvizin the rust-lang/rust repository from commit 5113ed28ea1451a13eae3a05dca0dbabfd56f587 The publishing script for this crate lives at:… -
map-of-indexes
A compact key-value map for unique but not dense indexes
-
golomb-set
A Golomb Coded Set implementation
-
default-vec
A specialized vector that has a default value
-
unempty
Non-empty data structures for Rust
-
string-err
String error type
-
safer-bytes
safe, non-panicking wrappers around the 'bytes' crate
-
compressed-sparse-fiber
Compressed sparse fiber implementation for Rust
-
bigsi_rs
A in-memory implementation of a BIGSI-like data structure
-
dependency-graph
building and resolving dependency graphs
-
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.
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
dirty
Holds a value with a dirty flag which is set on writes and cleared on clear()
-
array_trait
A generic trait for any array, with item as type and length as const parameter
-
ttl-queue
A queue that drops its content after a given amount of time
-
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
-
hubs
The horribly unsafe buffer structure
-
moonlight_collections
Collections for Rust
-
ninja-files-data
Core data structures for ninja files
-
bipbuffer
Simon Cooke's Bip-Buffer
-
butils
shared by software included in BSuccinct
-
persistent_rope
An immutable persistent rope data structure
-
dynamic_graph
graph processing
-
serde_fs
[De]serializing data structures as files
-
gtrie
Generic trie implementation with a support of different key and value types
-
lupine
A bloom filter using FX Hash with Kirsch and Mitzenmacher optimization
-
grafana-dashboard
grafana import/export data serializable structures
-
compactmap
Compact Vec-based map that choses assigns IDs for your values on it's own. Very similar to Slab.
-
unrecurse
Helper crate for rewriting your recursive code in iterative way
-
lazy-array
An array where entries are lazily initialized in any order
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
anymap3
A safe and convenient store for one value of each type
-
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)…
-
pulz-bitset
bitset implementation
-
tag-vec
A vector used for storing tags
-
cli_tree
A CLI tool to generate a tree of user defined nodes
-
digger
A trait for extracting data from recursive data structures
-
phf_macros
Macros to generate types in the phf crate
-
dogma
Dogma.rs
-
simple-stack
linked list-based implementation of the Stack data type
-
trips
generic triple store written in Rust
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
tree_multiset
A tree-based multiset for Rust
-
algo
Algorithms & Data Structure implementations
-
small_vec2
Vector on the stack or heap need nightly rustc
-
staticbitset
A container like std::collections::BitSet but static storage + Copy trait
-
crdt-list
Abstract CRDTs for lists
-
compacts
compact data structures
-
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
locale-decoder
Parser and data structure for dealing with locale strings
-
miniqueue
A minimalistic single-thread job queue based on fold/reduce
-
flex-algo
Rust commonly used data structure and algorithms
-
kvptree
a lightweight library for sending data around
-
trie-generic
A trie with generic content
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
const-arrayvec
A vec-like type backed by an array on the stack
-
branchless
Algorithms and data structures designed to maximize performance on superscalar processors
-
batching-queue
An Israeli Queue implementation
-
ropey
A fast and robust text rope for Rust
-
mini-linked-list
A package containing a minimal i32 LinkedList implementation
-
external_set
A set with externally-owned items, designed for managing subscribers, clients, listeners, or observers across threads. Inserting an item returns an ItemOwner that removes the item when dropped.
-
trie_map
A trie with good iterator support backed by a hashmap
-
static-bytes
Bytes for embedded devices
-
winvec
Windowed Vector (TTL) Collection for Rust
-
algotrees
VERY early stage project to implement a library of algorithms and data structures in Rust. It has very little features and only supports one data structure (binary trees) at the moment…
-
pathtree
An immutable tree data structure for fast path operations
-
simple-binary-tree
binary tree view representation
-
querable
Quer(y)able data structure implementation
-
init_trait
A small helper trait to simplify the initialisation of 'indexable' data structures
-
pointer-value-pair
A pair of a pointer and a small integer packed into a pointer-sized object
-
vsf
Versatile Storage Format
-
flashtext
algorithm to search and replace keywords in given text
-
xsl-rs
A simple library
-
sorted-list
SortedList data structure which allows mapping an Ord key to multiple distinct PartialEq values
-
nanobox
NanoBoxoptimization: store small item on stack and fallback to heap for large item -
qlrumap
A HashMap with an LRU feature
-
inexor-rgf-model-binary
Inexor - Reactive Graph Flow - Model - Binary
-
stacked_type_map
Compile time map of any type
-
flexible-string
A stack heap flexible string designed to improve performance
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
linked_lista
LinkedList data structure
-
indexvec
Simplified copy of rustc's index crate
-
littlechestnutgames-trie
A generalized trie implementation for quick prefix searching
-
vortex-dict
Vortex dictionary array
-
binary_tree_zy
binary tree
-
ax_banyan
Persistent indexable tree data structure
-
option_vec
Vec<Option<T>>-like container
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
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 -
dogged
Persistent vector, similar to Clojure
-
sn-trie-proofs
Starknet Transaction Trie Proofs
-
faex
A fast and efficient Compact Data Structures Library
-
event-queue
crates.io için bir paket nasıl hazırlanırın ele alındığı öğrenme amaçlı modüldür
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
priority-matrix
A matrix that supports per-row, per-column and whole-matrix maximum key queries
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
rankmap
rust hash table supporting key ranking
-
static-box
A stack-allocated box that stores trait objects
-
stringz
A way to use strings in generic paramters
-
lineup_rust
queue implementation in Rust. This is a learning and a hobby project and is not intended for production use.
-
any_key
Dynamically typed keys for associative arrays
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
phf_mac
Compiler plugin for perfect hash function data structures
-
smol_str
small-string optimized string type with O(1) clone
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
indexed-vector
that implements vector container that can be indexed with specified function
-
graphrepresentations
providing efficient abstract implementations of different graph representations
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
tibitset
bitset replacement for HashSet
-
blocked-vec
A vector of byte blocks behaving like files
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
kermit-iters
Kermit, the Leapfrog Triejoin algorithm with associated data structures
-
generic-json
Generic JSON traits
-
opt_arrayvec
Vector-like container with fixed capacity, using options instead of stored length
-
dynvec
DynVectype that acts like a vector to store any datatype -
intrusive-containers
intrusive data structures
-
sequence_buffer
Sequence buffer data structure implementation
-
kvstructs
General basic key-value structs for Key-Value based storages
-
freezable
immutable data
-
pq-tree
consecutive ones property (C1P) and graph planarity testing
-
twilio-data
Twilio API data structures
-
justly
justified containers
-
clouseau
A query language for inspecting Rust data structures at runtime
-
mrslac
sparse matrix data structures
-
valued
Describe your data in terms of basic data structures. Get serialization and other facilities for free
-
dimsum
multi-dimensional array library
-
gtfs-translations
Reads GTFS translations.txt into structures
-
shared_bytes
Owned string and byte slices
-
html-types
HTML Data structures
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
packed_str
Store immutable strings in a single packed allocation
-
tree-rizzen-yazston
Tree Library using the Any trait for data
-
raw-vec
A Raw utility for managing contiguous heap allocations
-
stable-bloom-filter
A Rust-implementation of a stable Bloom filter for filtering duplicates out of data streams
-
array-ops
Automatic method implementations for array data types
-
containers-rs
'Collections' interfaces for describing objects that contain other objects
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
loaf
Why have a slice when you can have a loaf?
-
vortex-datetime-dtype
Vortex datetime extension dtype
-
sif-rtree
immutable, flat R-tree
-
functional_vec
Owning versions of mutable Vec methods
-
dsll
Fast Thread Safe Doubly Sorted Linked List
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
uvector
access two slices as a single continuous vector
-
velect
A Vec with item / index selection
-
wl-tools
Wordlist tools – algorithms and data structures for working with lists of words
-
flat-multimap
A multimap and multiset implementation using a flattened hash table
-
id_cache
A cache data structure which generates sequentially-assigned ids for unique values
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
mutuple
Replace items in Python's immutable tuples
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
immutable-seq
Immutable sequence data structure
-
aximate
core data structures and utilities
-
lfbs
Lock-free stack with batched pop
-
toboggan-kv
abstraction layer over multiple KV stores
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
slice-deque
A double-ended queue that Deref's into a slice
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
capillary
HashMap-like storage of key-value pairs, but allowing for step-by-step (partial) search of value
-
flattree
A series of functions to map a binary tree to a list
-
string32
A string that is indexed by u32 instead of usize
-
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
array-linked-list
A data structure, which combines the advantages of dynamic arrays and linked lists
-
hff-core
Hierarchical File Format: core structure
-
hashmap_vec
A HashMap with lists a values
-
flit
Bloom filter backed by xxHash
-
pi_async_graph
async graph
-
intset
Various integer set data structures, each efficient for different operations
-
dynstr
A string implementation optimized for manipulations
-
sqa-bounded-spsc-queue
A bounded SPSC queue (temporary version so I can publish sqa-engine)
-
alloc-checked
Collections that don't panic on alloc failures
-
hashindexed
A cache. A set which compares elements in a customisable way without overriding the eq() and hash() functions on the type itself.
-
tuco-core
Contains the Tuco trait, used by the Tuco crate
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
unstorable
An interface for requiring that a type is only used on the current stack frame
-
fera-graph
Graph data structures and algorithms
-
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…
-
lighter
Macro for rewriting string matches as tries
-
eitherq
Queue which support two different types
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
binary_search_tree
Binary search tree implementation
-
slice-cell
A
Cell<[T]>-like mutable slice, that allows slice-like APIs -
smallvec-stableunion
Fork of the crate smallvec. Uses unions in stable rust. Please note that it can only store Copy types. No functional differences apart from that.
-
maybe-string
newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
index-set
An ordered set that stores indices in a sparse bit field
-
elastic-array-plus
Elastic vector backed by fixed size array
-
datastructures
A variety of data structures for learning purpose
-
xio_instructionset
XIO instructionset data structures
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
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. -
low-map
A convenient wrapper around a vector of options
-
vortex-zigzag
Vortex zig zag array
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
gardiz
integer geometry on 2D planes, focused on games
-
graphed
implement graph-based functionality
-
prio-queue
priority queue implemented as a heap stored in a Vec
-
csgo-gsi-payload
Data structures for CSGO Game State Integration
-
rbloom
efficient and minimalistic bloom filter
-
vortex-fastlanes
Vortex fastlanes arrays
-
graphiti
macro dsl and builder for creating and describing arbitrary sets of related data using a serializable description type
-
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
-
quarkrs
A collection of small life improvements for rust
-
vortex-schema
Vortex file schema abstraction
-
randsort
A sorting library with an optimal complexity of O(n) (!!) by randomly sorting Vectors until they are sorted
-
tdf_utils
such as tree
-
tuco-derive
Derive macro for the Tuco crate
-
atlist-rs
LinkedList which is allowed to insert/remove element by immutable iterator.Adding, removing and moving the elements within the list or across several lists does not invalidate the iterators or references…
-
slicedvec
A segmented vector for iterating over slices
-
immutable-avl
An Immutable map and set implement for rust based on an AVL tree
-
embedrs-bytes
Types and traits for working with bytes
-
neurarbor
manipulating tree graphs, for the analysis of neuronal arbors
-
keyed
Implement comparison traits by specifying a key
-
quetta
Immutable, reference-counted strings for rust
-
fast-btree
A fast B-tree implementation ported from tlx library
-
internode
Smart references to your graph nodes
-
ethercat-types
Common EtherCAT data structures
-
immutable_string
Immutable Single Instance Strings for Rust
-
ringvec
ring buffer implementation based on a vector
-
arae
Cursed data structures
-
regex-map
Associative container where the keys are regular expressions
-
doubly
linked lists in rust
-
bloomy-rs
Fast bloom filter implementation
-
rustgym-util
handy macros, data types and traits for rustgym
-
const_queue
A stack-only, no_std queue using const generics
-
tournament_tree
A tournament tree library
-
oxidd-rules-bdd
Binary decision diagrams (BDDs) for OxiDD
-
poison
writing poisoned types
-
sliding_window
A fixed size, heapless sliding window
-
rs-collections
generic collections (no dependency on std)
-
kudzu
concurrent, grow-only data structures
-
labelgraph
graph implementation, allowing random access to nodes via labels
-
cursorvec
Cursored vector container
-
triple_arena
Regular, Chain, Surjection, and Ordered Arenas supporting non-Clone types, deletion, and more
-
algods
A collection of data structures and algorithms
-
vortex-sampling-compressor
Vortex compressor that uses statistical sampling
-
castle_api
Castle API, graph api
-
geen
Hashed based Accumulators
-
radixdb
a radix tree data structure for in memory or zero copy on disk storage
-
texcraft-stdext
Rust data structures and algorithms used in the Texcraft project
-
im-rope
Unicode strings backed by RRB vectors
-
handlebox
A map-like collection that reuses unused keys
-
algostru
Algorithms (algo) and Data Structures (stru)
-
lifetimed-bytes
Bytes, but with attached lifetime