-
hashbrown
port of Google's SwissTable hash map
-
indexmap
A hash table with consistent order and fast iteration
-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
phf
Runtime support for perfect hash function data structures
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
rangemap
Map and set data structures whose keys are stored as ranges. Contiguous and overlapping ranges that map to the same value are coalesced into a single range
-
bit-set
A set of bits
-
slotmap
data structure
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
roaring
A better compressed bitset - pure Rust implementation
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
enum-map
A map with C-like enum keys represented internally as an array
-
bimap
Bijective maps
-
rpds
Persistent data structures with structural sharing
-
zerovec
Zero-copy vector backed by a byte array
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
tinystr
A small ASCII-only bounded length string representation
-
bit-vec
A vector of bits
-
generic-array
Generic types implementing functionality of arrays
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
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.
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
croaring
Rust wrapper for CRoaring
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
wide
help you go wide
-
generator
Stackfull Generator Library in Rust
-
im
Immutable collection datatypes
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
guppy
Track and query Cargo dependency graphs
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
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
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
ego-tree
Vec-backed ID-tree
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
histogram
A collection of histogram data structures
-
fixedbitset
bitset collection
-
radix_trie
Generic radix trie data-structure
-
enumset
creating compact sets of enums
-
bloomfilter
Bloom filter implementation
-
smallbitvec
A bit vector optimized for size and inline storage
-
range-set-blaze
Integer sets as fast, sorted, integer ranges with full set operations
-
bitmaps
Fixed size boolean arrays
-
smartstring
Compact inlined strings
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
yrs
High performance implementation of the Yjs CRDT
-
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
-
index_vec
Newtype-style helpers for
Vecandusize -
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
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
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
ecow
Compact, clone-on-write vector and string
-
barcoders
A barcode-encoding library
-
dlv-list
Semi-doubly linked list implemented using a vector
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
thin-vec
A vec that takes up less space on the stack
-
bytes-utils
Additional utilities for working with the bytes crate
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
multimap
A multimap implementation
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
intmap
Specialized HashMap for integer keys
-
spade
Delaunay triangulations for the rust ecosystem
-
cita_trie
Modified Patricia Tree (aka Trie)
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
narrow
Apache Arrow
-
egg
egraphs
-
hashbag
An unordered multiset implementation using a hash bag
-
sn_registers
Safe Network Register Logic
-
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
array-init
Safe wrapper for initializing fixed-size arrays
-
gix-pack
Implements git packs and related data structures
-
ringbuffer
A fixed-size circular buffer
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
av-data
Multimedia data structures
-
smallbox
Small Boxoptimization: store small item on stack and fallback to heap for large item -
cordyceps
Mycelium intrusive data structures
-
csaf-walker
work with CSAF data
-
newtype-uuid
Newtype wrapper around UUIDs
-
arrow-array
Array abstractions for Apache Arrow
-
linked_hash_set
HashSet with insertion ordering
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
louds-rs
High performance LOUDS (Level-Order Unary Degree Sequence) library
-
vortex-scalar
Vortex Scalars
-
array-macro
Array multiple elements constructor syntax
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
bridgetree
A space-efficient Merkle tree designed for linear appends with witnessing of marked leaves, checkpointing & state restoration
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
string
A UTF-8 encoded string with configurable byte storage
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
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
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
vortex-dtype
Vortex's core type system
-
lib-sokoban
Sokoban: compact, efficient data structures packed into contiguous byte arrays
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
bitfield-struct
Struct-like procedural macro for bitfields
-
merkle-search-tree
A data structure for efficient state-based CRDT replication and anti-entropy
-
qfilter
Efficient bloom filter like datastructure, based on the Rank Select Quotient Filter (RSQF)
-
crop
A pretty fast text rope
-
tree_iterators_rs
built to provide you with the iterators to easily work with tree data structures in Rust
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
deep_causality
Computational causality library. Provides causality graph, collections, context and causal reasoning.
-
hibitset
Hierarchical bit set structure
-
nonempty-collections
Correct-by-construction non-empty collections
-
fastbloom
The fastest Bloom filter in Rust. No accuracy compromises. Compatible with any hasher.
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
portgraph
Data structure library for directed graphs with first-level ports
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
modql
Model Query Language support
-
blart
adaptive radix tree packaged as a BTreeMap replacement
-
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. -
range-collections
Sets and maps of ranges, backed by smallvec
-
dary_heap
A d-ary heap
-
fqdn
FQDN (Fully Qualified Domain Name)
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
equivalent
Traits for key comparison in maps
-
queue-file
lightning-fast, transactional, file-based FIFO
-
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!
-
iset
Map and set with interval keys (x..y)
-
tinyset
Size-optimized sets
-
vers-vecs
A collection of succinct data structures supported by fast implementations of rank and select queries
-
intervallum
Generic interval and interval set library
-
array2d
A fixed sized two-dimensional array
-
range-set
Smallvec-backed containers of sorted integer ranges
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
grid
Dynamic generic 2D data structure
-
bv
Bit-vectors and bit-slices
-
phf_codegen
Codegen library for PHF types
-
v_frame
Video Frame data structures, originally part of rav1e
-
keyvi
key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
lsm-tree
A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)
-
arrow-ord
Ordering kernels for arrow arrays
-
idlset
Fast u64 set operations library
-
xsd-types
XSD data types
-
vecmap-rs
A vector-based map and set implementation
-
typed_floats
Types for handling floats with type checking at compile time
-
reactive_stores
Stores for holding deeply-nested reactive state while maintaining fine-grained reactive tracking
-
cdg_api
interact with api.congress.gov
-
zerofrom
trait for constructing
-
xor_name
Xor Type
-
caches
popular caches (support no_std)
-
btree-range-map
B-tree range map implementation
-
xml-builder
Easy and highly-configurable XML builder/writer
-
trees
General purpose tree data structures
-
diff-struct
A trait for diffing and applying diffs to types
-
bloom2
Fast, compressed, 2-level bloom filter and bitmap
-
algorithm
about algorithm data structure, now has ttl with lru/lru-k/lfu/arc and slab/rbtree/roaring_bitmap/timer_wheelss, 关于算法常用的数据结构
-
jaq-json
JSON values for jaq
-
cow_hashbrown
port of Google's SwissTable hash map with copy-on-write support
-
metatensor
Self-describing sparse tensor data format for atomistic machine learning and beyond
-
graphrs
package for the creation, manipulation and analysis of graphs
-
bitfield-rle
A run-length-encoder that compresses bitfields
-
rust_dynamic
Support for dynamically-typed values in run-time
-
oxidd
A safe, concurrent, modular, and performant decision diagram framework
-
kempt
Ordered collection types with no unsafe code and no_std support
-
uguid
GUID (Globally Unique Identifier) no_std library
-
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.
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
array-concat
Macros for concatenating const arrays
-
vec_map
map based on a vector for small integer keys
-
rsdict
Fast static rank and select data structure
-
map_vec
The Map and Set APIs backed by Vec
-
iso7816
Types for ISO 7816
-
uluru
fast, LRU cache implementation
-
hi_sparse_bitset
Hierarchical sparse bitset. Incredibly high performance. Compact memory usage.
-
nodit
Discrete Interval Tree Data-Structures, which are based off BTreeMap
-
baby_shark
Geometry processing library
-
iptrie
IPv4/v6 prefixes lookup structures (based on tries)
-
id_tree
creating and modifying Tree structures
-
spatialtree
A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
mhgl
Matts HyperGraph Library (MHGL). A straightforward library for hypergraph datastructures.
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
validated
The cumulative sibling of
ResultandEither -
parsable
A trait to easily parse data structures
-
ssd-data
A service and data description format + a code generator based on rhai scripts and templates
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
tracker
A macro to track changes on structs
-
griddle
A HashMap variant that spreads resize load across inserts
-
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.
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
phf_shared
Support code shared by PHF libraries
-
scapegoat
Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
-
indexset
A two-level BTree with fast iteration and indexing operations
-
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).
-
chat-prompts
Chat prompt template
-
warg-transparency
transparency data structures
-
truc
Rust code generator for safe, fixed size, evolving records
-
gix-traverse
gitoxide project
-
etc-os-release
Parse /etc/os-release file
-
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… -
ordered-multimap
Insertion ordered multimap
-
slabmap
HashMap-like collection that automatically determines the key
-
cactus
Immutable parent pointer tree
-
honeycomb-core
Core structure implementation for combinatorial maps
-
matrixable
Traits and structs extending capabilities of matrix-like structures
-
prio-graph
A lazily populated directed acyclic graph with top-level priority ordering
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
broccoli
broadphase collision detection algorithms
-
slotmap-careful
Wrap the slotmap crate and prevent key reuse
-
ggapi
communicating with start.gg's API
-
delay_map
HashMap collections whose entries expire after a given time
-
flatcontainer
A flat container representation for Rust
-
base-traits
base traits (for Rust)
-
extindex
Persisted immutable index
-
chronologic
Time constraint reasoning (scheduling...)
-
simple-grid
2d-grid structure
-
short-uuid
generate and parse short uuids
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
xorf
implementing xor filters - faster and smaller than bloom and cuckoo filters
-
polars-ops
More operations on Polars data structures
-
smallstr
String-like container based on smallvec
-
vortex-runend
Vortex run end encoded array
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
rt_ref
Internal
Reftypes forrt_refandrt_vec -
roadmap
model a project roadmap as a directed acyclic graph
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
tskit
rust interface to tskit
-
tailcall-chunk
persistent data structure for efficient append and concatenation operations
-
more_collections
Additional collections not found in std::collections
-
walker-common
Common functionality for SBOM and CSAF walker
-
postman2openapi
Convert a Postman collection to an OpenAPI definition
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
ergo_avltree_rust
cryptographically authenticated dictionary based on AVL tree
-
bitm
bit and bitmap (bit vector) manipulation
-
enum-collections
Collections data structures optimized for Enum, initializable at runtime
-
demand
A CLI prompt library
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
boa_interner
String interner for the Boa JavaScript engine
-
trane
An automated system for learning complex skills
-
grovedbg-types
Common type definitions for data exchange over GroveDBG protocol
-
pasture-algorithms
Point cloud algorithms for pasture
-
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…
-
beap
Bi-parental heap data structure implementation in Rust
-
trie-hard
Fast implementation of trie data structure
-
validit
Validate data structures internal state
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
libwebnovel
enabling users to get chapters of a webnovel, with multiple available backends
-
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…
-
c_vec
Structures to wrap C arrays
-
h3o-ice
Frozen{Map,Set} for H3 cells, based on finite state transducers
-
valkyrie-ast
Strong typed abstract syntax tree of valkyrie language
-
rdf-types
Data-structures and traits definitions for RDF
-
differential-dogs3
Advanced join patterns in differential dataflow
-
differential-dataflow-master
An incremental data-parallel dataflow platform
-
cc-traits
Common collection traits
-
adflib
handle amiga disk files
-
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…
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
structured
Data structures to handle large, structured data
-
pyinrs
type library that is as easy to use as Python built-in types
-
btree-slab
A memory compact Slab-based B-tree implementation
-
fastset
Fast set implementation for dense, bounded integer collections, optimized for quick updates and access
-
xmltv
electronic program guide (EPG) parser and generator using serde
-
optional
supplies a number of Option-like primitive types
-
kbs-types
Rust (de)serializable types for KBS
-
canopydb
Transactional key-value storage engine
-
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
-
blas-array2
Parameter-optional BLAS wrapper by ndarray::Array (Ix1 or Ix2)
-
pfds
Purely Functional Data Structures
-
typemap_rev
A hashmap, but stores types as keys
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
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
-
oxidd-manager-index
Index-based manager implementation for OxiDD
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
intrusive-lru-cache
An LRU cache implementation using intrusive data structures
-
skiplist
in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
sparsevec
Compress vectors using row displacement
-
disjoint
Fast and safe implementation of the disjoint-set data structure
-
sized-chunks
Efficient sized chunk datatypes
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
ux-primitives
Graphics Primitives for Angular Rust
-
ordsearch
A data structure for efficient lower-bound lookups
-
normalize_interval
Normalizing interval library
-
raft-log
Raft log implementation
-
sync-ptr
Sync & Send wrappers for raw pointer's
-
vart
An immutable versioned adaptive radix trie
-
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. -
supply-chain-trust-example-crate-000006
port of Google's SwissTable hash map
-
avl
A map and a set implemented with an AVL tree
-
cbsk_socket
socket callback tool
-
spacetimedb-data-structures
Assorted data structures used in spacetimedb
-
array-object
Self-describing binary format for arrays of integers, real numbers, complex numbers and strings, designed for object storage, database and single file
-
sucds
Succinct data structures in Rust
-
cantrip
Practical extension methods for standard Rust collections
-
ffi-convert
A collection of utilities to ease conversion between Rust and C-compatible data structures
-
bevy_spatial
tracking bevy entities in spatial indices
-
golomb-coded-set
BIP158 Golomb-Coded Set data structure
-
odht
hash tables that can be mapped from disk into memory without the need for up-front decoding
-
basic_trie
Trie implementation in Rust
-
tree-ds
manipulate tree data structures
-
orx-imp-vec
ImpVecstands for immutable push vector 👿, it is a data structure which allows appending elements with a shared reference -
pi_slotmap
Slotmap data structure
-
form_builder
building forms with various fields and validation
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
tmflib
Interface library for processing TMF payloads
-
mikufans-proto
gRPC APIs for Mikufans
-
doubloon
Money datatype that supports both statically and dynamically typed currencies
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
superintervals
Interval overlap library
-
signalk
parse signalk maritime data
-
stack-queue
Heapless auto-batching queue
-
mapgraph
A directed graph that can also be used as an arbitrary map
-
suggest
A minimal library to provide similar name suggestions like "Did you mean?"
-
orx-fixed-vec
An efficient constant access time vector with fixed capacity and pinned elements
-
bittle
Zero-cost bitsets over native Rust types
-
i_shape
iShape is a compact and efficient library specifically designed for representing 2D data structures using IntPoint
-
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 -
jaggedarray
Multidimensional jagged array
-
small-fixed-array
providing fixed length immutable collections with a low memory footprint
-
bc-envelope
Gordian Envelope for Rust
-
frunk_laws
contains laws for algebras declared in Frunk
-
hotel
Collection Data-structure to associate values with keys
-
rust-tls-duplex-stream
Full Duplex stream Wrapper around rust-tls
-
horizon_data_types
The Horizon data types library for third-party integrations
-
bitboard64
A 64-bit bitboard useful for chess programming
-
av-codec
Multimedia format decoding and encoding
-
qutee
A quadtree implementation
-
pipebuf
Efficient byte-stream pipe buffer
-
ball-tree
K-nearest neighbors
-
stacked_errors
high level error propogation with programmed backtraces
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
rust_multistack
Support for two-dimentional stacks for the Rust programming language
-
tuplez
Tuples represented in recursive form
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
datas
data structures and algorithms and data analisys
-
entity_data
A container for entity component data
-
cmsketch
A count min sketch implementation in Rust
-
stack-map
constant-size associative container for building higher-level data structures out of
-
slice_ring_buf
A ring buffer implementation optimized for working with slices
-
cve
Mappings for parsing the CVE JSON files
-
sync42
synchronization tools
-
minimizer-iter
Iterate over minimizers of a DNA sequence
-
std-ext
Extend the standard library functionality
-
pdatastructs
probabilistic data structures
-
hashslab
A hash table with data accessible by index
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
list-fn
A generic lazy list
-
beach_map
slotmap
-
defer-drop
Defer dropping large types to a background thread
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
timed-map
Lightweight map implementation that supports expiring entries and fully compatible with both std and no_std environments
-
either_of
working with enumerated types that contain one of 2..n other types
-
ordinal-map
Ordinal trait to map values to integers and efficient maps and sets for such types
-
nestac
access nested structures using path-like string format
-
undo
An undo-redo library
-
orx-split-vec
An efficient constant access time vector with dynamic capacity and pinned elements
-
slice-dst
Slice-based custom DSTs
-
fingertrees
Immutable persisten finger trees
-
mphf_benchmark
The program for benchmarking Minimal Perfect Hash Functions
-
edgefirst-schemas
Maivin EdgeFirst Services Schemas
-
rust_flightweather
Decodes METAR and TAF
-
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
-
singletonset
SingletonSetdata structure, which makes it easy to store a single instance each of various types within a single set -
map-macro
Declarative macros for statically initializing collections
-
gctree
cache-friendly, graph-like, arena-allocated datastructures
-
lsph
Learned Spatial HashMap
-
jomy-ap-rustc_index
Automatically published version of the package
rustc_indexin the rust-lang/rust repository from version 1.83.0 The publishing script for this crate lives at: https://github.com/rust-analyzer/rustc-auto-publish -
bitstring-trees
Trees based on bitstrings
-
among
The enum
Amongwith variantsLeft,MiddleandRightis a general purpose sum type with three cases -
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
fiftyonedegrees
A wrapper around the 51Degrees device detection C library
-
min-max-heap
An efficient, double-ended priority queue
-
epsg
EPSG Coordinate Reference System tools & data
-
radixmap
Rust-based Radix Tree for fast prefix lookup, supporting named param, glob, regex
-
erased_set
A set of erased types
-
binary-util
A panic-free binary utility crate to read/write binary streams over the wire
-
boomerang_tinymap
A tiny, fast, and simple Slotkey-type map implementation for Boomerang
-
pi_spatial
sparial octtree quadtree
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
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
-
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
-
fvm_ipld_kamt
Sharded IPLD Map implementation with level skipping
-
sk-store
SimKube trace store library
-
hibit_tree
Hierarchical bitmap tree. Prefix tree without memory overhead that act as herarchical bitmap.
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
ofdb-boundary
Serializable, anemic data structures for accessing the OpenFairDB API in a type-safe manner
-
kollect
Collections made ergonomic for gamedev usecases
-
rust_redux
A Redux-like state management library for Rust
-
packed-uints
Array of uints that scales from u4 to u32 to minimize wasted space while still being fast
-
any-rope
A fast and robust arbitrary rope for Rust. Based on Ropey.
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
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
-
ladata
& modular data model
-
mago-ast
Supplies the data structures and types for representing PHP code as an Abstract Syntax Tree (AST)
-
rdf-model
RDF.rs
-
vortex-error
Vortex errors
-
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
-
data_reader
A data loading library for data scientist
-
rbtree
the rbtree for Rust
-
gix-diff
Calculate differences between various git objects
-
field_access
Dynamically access struct fields
-
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
-
gtfs-geojson
converter for GTFS to GeoJSON formats
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
rchess
A Chess Library Written In Rust
-
snowflake-ng
Dead easy and high performance
snowflakeimplemented in Rust -
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
array_list
A dynamic container that combines the characteristics of a Vec and a LinkedList
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
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
-
ordered
A wrapper for adding arbitrary partial/total order to a type
-
flatten_objects
A container that stores numbered objects. Each object can be assigned with a unique ID.
-
do-notation
Monadic do syntactic sugar
-
nlist
inline-allocated list with statically tracked length
-
HArcMut
mutable arc
-
gridava
2D coordinate systems
-
ninjabook
A lightweight and high performance orderbook
-
bumparaw-collections
A small set of bumpalo-backed collections for low-level operations
-
rust-box
odd set of tools for Rust programming
-
mmdb
A std-collection-like database
-
strict
collections with strict bounds
-
loro-rle
A internal library of loro for storing and manipulating run-length encoded data. Do not use it directly.
-
enumoid
Enum Indexed Containers
-
relend
A generalized reborrowing mechanism that extends beyond simple references. It also allows for implementing traits that work with reborrowing for custom types.
-
hylo-fix
Fixed-point number types with Solana Anchor support
-
sharded
Safe, fast, and obvious concurrent collections
-
dot2
generating Graphviz DOT language files for graphs
-
persian-rug
Framework for bringing together disparate objects with inconvenient relationships
-
ndarray-histogram
Histogram support for n-dimensional arrays
-
atomicow
A
Cow-like data structure where owned data is stored inside anArc -
pfx
A prefix tree (map and set), implemented without any unsafe
-
binary-greedy-meshing
A port of https://github.com/cgerikj/binary-greedy-meshing to Rust
-
named_colors
that provides named colors in RGB and Hexadecimal formats
-
balanced-tree-index
constant-time manipulation of a complete binary tree with a flat in-memory representation
-
statiki
Static friendly data structures
-
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.
-
lattices
Lattice data types for simplifying distributed state by providing associativity, commutativity, and idempotence
-
linearize
Types that are enumerable and an array-backed map
-
heavykeeper
finding the top-k elements of a stream of data
-
exhaustive-map
An exhaustive map for types with finite inhabitants
-
leetcode-trees-rs
Tree Node LeetCode problems
-
pstd
parts of Rust std library ( different implementations, features not yet stabilised etc )
-
settrie
Fast subset and superset queries
-
decomp
Components of a decompilation pipeline
-
json-number
JSON number parsing and storage
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
standard_card
A Lightweight Library for Efficient Card Representation
-
prefix-sum-vec
Compressed storage for highly repeating elements, with
O(log n)lookups -
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
evento
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
farmfe_core
Core types and data structures for farm
-
sigmars
sigmahq rule collections
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
type-map
typemap container with FxHashMap
-
adapton
programming abstractions for general-purpose incremental computations
-
awint
Arbitrary width integers
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
taskchain
A block-based, non-circular double-linked list implementation for Rust
-
damped-springs
damped springs for smooth and springy motion
-
hello_egui
A collection of useful crates for egui
-
scope-cell
temporary, scope-bound, and thread-safe mutation of data in Rust
-
dia-i18n
-
orx-selfref-col
SelfRefColis a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees -
bondrewd
Bit-Level field packing with proc_macros
-
token-parser
parsing texts into data structures
-
shortguid
Short URL-safe Base64 encoded UUIDs
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
surface-grid
providing data structures for square-tiled grids wrapped around the surface of certain objects
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
non_empty_continuous
Non-empty continuous collections
-
hifa-xml-schema
Structure generator from XSD source file
-
value-log
Value log implementation for key-value separated LSM storage
-
grovedb-path
Path extension crate for GroveDB
-
hightorrent
High-level torrent library which supports Bittorrent v1, v2 and hybrid torrents
-
scribe
Text editor toolkit
-
historian
a high performance zero-config histogram implementation
-
radicle-cob
Radicle Collaborative Objects library
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
aliasable
Basic aliasable (non unique pointer) types
-
seoul
trait Isomorphism
-
smooth-json
opinionated, customizable utility to flatten serde_json Value variants into serde_json Objects ready for use in columnar or table-like usages
-
search_trail
manager of variables that can save and restore their values
-
ligature
Ligature's data model in Rust
-
hextree
Location to value mapping
-
shardtree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
bin-it
efficient Rust library for binary serialization and deserialization
-
plain_trie
Classic trie implementation capable of mapping any T to char iterator
-
ndstruct
Structures for N-dimensions
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
threshold
data structures
-
plane-2d
Continuous 2D data structure representing infinite 2d plane
-
rstmt-neo
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
tri-mesh
A triangle mesh data structure including basic operations
-
crdt-lite
CRDT library for Rust
-
blaze-common
Blaze common shared types
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
re_string_interner
string interning library
-
nybbles
Efficient nibble-sized (4-bit) byte sequence data structure
-
oxidd-rules-zbdd
Zero-suppressed decision diagrams (ZBDDs) for OxiDD
-
vector
The package provides a vector database allowing for efficient search of nearest neighbors
-
madeleine
Transparent object persistence with predefined operations and state containers
-
seq-map
Sequential Map
-
reqray
Log ‘request x-rays’ for rust programs instrumented with
tracing -
trie-root
In-memory patricia trie operations
-
rasn-smi
Data types for handling Structure for Management Information
-
es-entity
Event Sourcing Entity Framework
-
tetengo_trie
A trie library implemented with a double array
-
code_generator
A code generator (Currently only targets C)
-
markov-generator
Highly customizable crate for building Markov chains and generating data from them
-
chinese-rand
Random generation of data structures in Chinese, using Rust
-
jupyter-serde
Serialization and Deserialization for Jupyter related data structures
-
byte_converter
converting bytes to various units (KB, MB, GB, etc.)
-
hashheap
data structures that combine a hashmap and a min/max priority heap, with main operations requiring O(1) or O(log n) time
-
span-map
A data structure for efficiently managing sets of values over spans/ranges
-
semver-eq
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
identified_vec
Like HashSet but retaining INSERTION order and without
Hashrequirement on the Element type -
smodel
Symbol semantic modeling for Rust
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
permafrost
Write. Macros. Everywhere.
-
atomic_lifo
Lock free thread-safe lifo for rust
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
validiter
Iterator adapters for validating iterations
-
beat_saber_map
Read and write Beat Saber maps with Rust
-
cistring
A string type that preserve case, but compares insensitiveley
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
rtree_rs
R-tree for Rust
-
chemrust-core
The core modules defining the flow and structs of data in computational chemistry routines
-
im-pathtree
Immutable, path-addressable tree data structure
-
linker-set
Declarative programming via linker-constructed arrays
-
mssmt
Merkle-Sum Sparse Merkle Tree (MS-SMT)
-
ndim
N-dimensional array for numerals in Rust similar to NumPy
-
arrayset
An array-backed ordered set type
-
singletonThread
thread in a singleton
-
vizia_storage
The storage data structures of vizia
-
bit-int
An arbitrary fixed bit-width integer library
-
ztimer
A block-based, non-circular double-linked list implementation for Rust
-
digit-sequence
Sequence of u8 digits
-
bitstring
traits and implementations
-
triangle_matrix
Triangle matrix indexing operations
-
roussillon-type-system
A type system for a programming language
-
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
-
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…
-
awid
Small, simple, universally unique identifiers
-
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
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…
-
smart_led_effects
A collection of effects for LED strips
-
microkelvin
tree traversal over annotated data structures
-
oca-presentation
Lib providing struct for OCA presentation
-
compact_strings
A more compact but limited representation of a list of strings or bytestrings
-
stavec
Stack-allocated vector with static capacity
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
unionfind
A union find library made for building type inference engines. Can be used as general purpose datastructure.
-
minivec
A version of Vec that's only the size of a single pointer
-
cell-grid
fixed-size 2d grid container suitable for
no_stdgame development -
task-group
manage groups of tokio tasks
-
itybity
An itty bitty crate providing bit iterators and bit iterator accessories
-
rb_tree
A Red Black Tree implementation in Rust
-
delta-collections
Data structures with revertable operations called deltas
-
tld
Top Level domain static hash map, tld list is obtained from of iana.org
-
whirlybird
generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
queues
Efficient FIFO Queue data structures
-
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
-
walker-extras
Additional functionality for SBOM and CSAF walker
-
host-port-pair
Host-port pair type
-
gridly
managing fixed-size 2D spaces
-
index-ext
Index slices with arbitrary ints and as arrays
-
indexical
indexed collections
-
expiringdict
A dict / HashMap whose items expire over time
-
pasture-core
A framework for working with point cloud data
-
spenso
A tensor (n-dim array) network, iterating, and contraction (using automatic abstract index matching) library
-
arbutus
Trees
-
i24
working with 24-bit integers
-
merkle-heapless
Statically-allocated Merkle Tree and Mountain Range
-
slabigator
A linked list that doesn't do dynamic memory allocations
-
codas
Compact and streamable data format that works anywhere--from web apps to robots
-
opt_struct
Optional collections
-
python-packed-resources
Manage data structures containing Python resources
-
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…
-
cdll
A circular doubly linked list
-
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…
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
spatialize
collection of spatial data structures used for efficent spatial partitioning
-
iter-tree
Convert between iterators and tree structures in both directions
-
graphplan
planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust
-
egui-multiwin
that allows for multiple windows with egui
-
linear_collections
Map and Set types backed by linear data structures
-
ic-verifiable-credentials
Verifiable credentials issuing and verification for IC canisters
-
supply-chain-trust-example-crate-000058
Generic types implementing functionality of arrays
-
enum_meta
Add metadata to Enum Variants
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
messaging
two-way messaging crate
-
aircraft_icao_country
aircraft ICAO codes and their country of origin
-
akita
Mini orm for rust
-
ttgraph
Typed/Transactional Graph container
-
cfpyo3_rs_core
a collection of performant utilities
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
splay-safe-rs
Splay implemented with safe rust
-
td-shim-interface
TD-shim metadata data structures and related functions. UEFI Platform Initializaiton data structures and accessors
-
datafrost
Data format and acceleration structure management
-
stable-map
A hash map with temporarily stable indices
-
set_genome
A genetic data structure for neuroevolution algorithms
-
disjoint-sets
Three union-find implementations
-
know
Framework for Rust
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
lambda-runtime-types
Common structures for lambda architecture
-
coalesced_intervals
Data structure for maintaining maximally-coalesced 1D intervals
-
entoli
A functional programming library inspired by haskell
-
value_pool
implements a ValuePool struct that makes the creation of self-referential data structures easier and safer
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
trk-io
TrackVis (*.trk) reader and writer
-
artie_common
Common Library for Artie Rust Projects
-
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.
-
cueue
High performance SPSC circular byte buffer with batch operations
-
block-grid
A quick, cache-conscious, tiled 2D array
-
tf-semver
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
trybox
stable,
no_std-compatible, fallible heap allocation -
smallbitset
series of allocation free sets capable of holding small integer values
-
clone_cell
A Cell that works with a restrictive form of Clone
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
to_markdown_table
An easy way to format any data structure into a Markdown table
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
twovec
A data structure for storing 2 types of data in a packed, heap allocated array
-
no_std_collections
Auxiliary structures and traits for using dynamically resizable arrays (Vectors) in flexible environments, supporting both std and no_std contexts
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
rustc_data_structures
Reuse rustc_data_structures for compiler_base
-
maelstrom-base
Fundamental data structures used by all Maelstrom code
-
influxdb-dispatcher
Batch metrics collection using influxdb
-
weak-table
Weak hash maps and sets
-
quickselect
基于rust的选择算法
-
iterlist
Linked list with a cursor based api
-
iterable
collection like types
-
etwin_dinoparc_store
Dinoparc store implementation
-
rive-models
Revolt API models for the Rive ecosystem
-
loaned
Safely move values with live inner borrows
-
quadtree_simple
quadtree implementation
-
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.
-
gpt_disk_types
GPT (GUID Partition Table) disk data types no_std library
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
regroup
regrouping arrays
-
space
providing abstractions for spatial datastructures and search
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
committable
Keccak256-based structured commitments
-
idbag
A bag of integers
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
circbuf
A growable circular buffer for working with bytes
-
honeycomb-render
Visualization tool for combinatorial maps
-
aatree
in Rust
-
lp-pack-scanner
scanner library
-
type-set
A set of heterogeneous types
-
gw_signal
Package with signal processing tools for graviational waves studies
-
floating_bar
Representing rational numbers using the floating-bar number type
-
fm-index
FM index and its variant implementations for Rust
-
hit-data
Hierarchical Indexed Typed data structure
-
magnetise
asses the similarity between SQL queries
-
half-2
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types. Fork of half by Kathryn Long
-
sentry-contrib-breakpad
Unopinionated crash collection for Sentry reporting purposes
-
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
-
iowrap
Small helpers for using io::Read/io::Write
-
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
-
vortex-bytebool
Vortex byte-boolean array
-
irange
A data structure to store and manipulate ranges of integers with set operations
-
indexedlinkedhashmap
An indexable LinkedHashMap. The user defines the data structure that controls order.
-
owning_ref
creating references that carry their owner with them
-
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
-
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… -
interavl
An optimised interval tree for efficient interval stabbing
-
color-operators
Color data structures, converters, and arithmetic operators
-
mini_uuid
A small and URL-safe UUID crate for Rust
-
ftree
A very fast fenwick tree implementation
-
ibuilder
Interactive builder for Rust types
-
strumbra
Umbra-style strings (also known as German strings)
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
ux-dx
3D Graphics Primitives for Angular Rust
-
eventio
A collection of event I/O processors for event-processing applications
-
string_manipulation_utf8
String manipulation functions using character indexing (UTF-8) instead of bytes
-
tord
Data structure to store transitive relations
-
linux-audit-parser
Parser for Linxu Audit logs
-
supply-chain-trust-example-crate-000039
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
sbbf-rs
Split block bloom filter implementation
-
structures
collection data structures
-
libwebnovel-storage
A complement to libwebnovel: this package handles downloading and organizing collections of followed webnovels
-
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
-
tangu-lints
A collection of lints for the Tangu language
-
sorted_vector_map
maps and sets backed by sorted vectors
-
depends
Ergonomic, performant, incremental computation between arbitrary types
-
coca
Data structures with constant capacity
-
matreex
matrix implementation
-
pi_densevec
重定向映射表，一个使用usize作为key的映射表
-
grovedb-epoch-based-storage-flags
Epoch based storage flags for GroveDB
-
slablit
Literal for slab creation
-
vec-btree-map
Basically just a sorted Vec that can be used as a HashMap
-
phf_mut
Perfectly hashed mutable containers
-
sequential_gen
sequential generator
-
micro_autotile
LDTK autotiling
-
retaker
ecs implementation
-
incrementalmerkletree-testing
Common types, interfaces, and utilities for testing Merkle tree data structures
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
deinterleave
your datastructures
-
kv6
Collection of structs to allow reading of Ken Silverman's voxel formats
-
commitlog
Sequential, disk-backed commit log library
-
super-struct
structofRustin the same way thatdictofPython -
exact-covers
Knuth's algorithm for solving the exact cover problem with colors
-
bittyset
A BitSet type for manipulating bit sets
-
emap
A map with a fixed capacity and integers as keys
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
cmus-status
structure cmus status data
-
starlark_map
Map implementation with starlark-rust specific optimizations
-
forest-ds
secure tree structure
-
pinocchio-token
Pinocchio helpers to invoke Token program instructions
-
ux-dataflow
Data Processing Library
-
sparse_set_container
A container based on sparse set. Stable keys, O(1) lookup, cache-friendly iterations, and no hashing.
-
mago-reflection
Offers data structures and APIs to represent and inspect PHP code elements—like classes, functions, and interfaces—enabling introspection and analysis
-
hrtb-lending-iterator
A lending iterator trait based on higher-rank trait bounds (HRTBs)
-
const_sized_bit_set
A bitset with a const generic size parameter indicating the number of 64 bit words to use
-
confiner
A config language for things that look like trees
-
i_tree
Red-black tree implementation for rust. Only for uniq elements
-
entity
that provides entity-like constructs
-
flat_collections
Lightweight and memory-efficient associative data structures
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
arr-rs
arrays library
-
mc-oblivious-ram
Implementations of Oblivious RAM data structures
-
rust_twostack
Support for two-dimentional stacks for the Rust programming language
-
lace_stats
Contains component model and hyperprior specifications
-
alist
Association list offering fast lookups while preserving insertion order
-
cbsk_mut_data
ref mut tool
-
token-lists
token list representation
-
mantra-rust-trace
Collects requirement traces from rust code for the
mantraframework -
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
-
arraystring
Fixed capacity stack based generic string
-
codas-flow
Low-latency, high-throughput bounded queues ("data flows") for (a)synchronous and event-driven systems
-
ordes
treating arrays and tuples a little bit more like vectors
-
onebuck
An efficient unordered dynamically-sized data structure
-
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
-
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…
-
flo_rope
An attributed and streaming implementation of the rope data structure
-
enso-data
A collection of useful data structures
-
variadics
Variadic generics on stable Rust using tuple lists
-
comparer
track changes in a HashMap over several iterations
-
grdf
Generalized RDF graphs and datasets
-
typerat
Type-level rational numbers based on
typenum -
vec-collections
Rust collections that are newtype wrappers around smallvec
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
radix-heap
Fast monotone priority queues
-
flat-tree
Series of functions to map a binary tree to a list
-
parallel_vec
A generic contiguous collection of heterogenous values
-
rtdlib
TDLib for rust
-
ascent-byods-rels
data structures for Ascent relations, made possible by Ascent's BYODS feature
-
riddance
retiring, recyclable, reservable IDs
-
supply-chain-trust-example-crate-000085
tinyvecprovides 100% safe vec-like data structures -
chesspos
Basic structs for representing chess squares
-
anchors
async incremental computations
-
dcl_data_structures
Data structures for for deep_causality crate
-
expiremap
Key-Value map where each value has a custom expiry time
-
safe_index
Type-safe indexes
-
data_model
[highly unstable] data model for virtualization
-
cmdtree
(Rust) commands tree
-
sliding_tree
A tree that grows from the leaves and recedes from the root
-
lru-mem
An LRU cache implementation bounded by memory
-
linked-list
An alternative implementation of std::collections::LinkedList
-
villa01-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
swaybar-types
building swaybar status commands in rust
-
text-style
Types and conversions for styled text
-
mset
/ multiset / bag implementation
-
arraysetcell
A fixed-capacity, vector-like array with interior mutability and no ordering guarantees
-
phylo
An extensible Phylogenetics library written in rust
-
canadensis_dsdl_frontend
Compiler front-end for the Cyphal Data Structure Description Language
-
genmap
generational map data structure with no dependencies
-
hicollections
C-liked Collections
-
non-random-state
Deterministic HashMap and HashSets
-
vlcb-defs
VLCB protocol core library containing important value definitions and data structures
-
riblt
Rateless Invertable Bloom Lookup Table (RIBLT) data structure
-
crater
Very generic containers including KD trees, fibonacci heaps, minmax heaps,
-
dipa
dipa makes it easy to efficiently delta encode large Rust data structures
-
spaghetto
making double-ended data structures, like an always-contigouous double-ended queue (deque) and double-ended string
-
ofilter
fast thread-safe Bloom filter
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
higher
Functors, Applicatives, Monads and other bad ideas
-
hashstash
It's like git but for your Rust data structures
-
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…
-
sbwt
Indexing sets of DNA k-mers with the spectral Burrow-Wheeler transform
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
rt_map
Runtime managed mutable borrowing from a map
-
automerge-test
testing automerge libraries
-
wasmrs-frames
WasmRS RSocket frame decoding, encoding, and data structures
-
jsonmap
store values of multiple types value in one Map
-
defaultmap
HashMap with an automatic default for missing keys
-
xot
Full-featured XML tree library for Rust
-
safer_owning_ref
creating references that carry their owner with them
-
loro-delta
Loro internal library. It's used as a delta between two versions of text or lists. It's also an efficient Rope.
-
uuidv7
UUIDv7 implementation
-
mago-token
Defines the data structures and enumerations representing PHP tokens
-
rexsgdata
Scatter-Gather Data Descriptors
-
fixstr
fixing strings
-
foyer-intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
uintx
Unaligned unsigned integers with exact size in memory and arithmetic operations for them
-
fenwick
tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
lodtree
help create octrees and quadtrees for chunked level of detail
-
smallvec-wrapper
Macro and common structs to play with
smallvec -
dayendar
advanced days calendar operations
-
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
-
tea-core
Core data structures and traits for tevec
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
tuple_list
macro-free variadic tuple metaprogramming
-
malwaredb-api
Common API endpoints and data types for MalwareDB components
-
pi_slot
lock free Slotmap data structure
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
typeslice
type-level slices
-
lru-st
A package providing a Vec based doubly linked list implementation and related data structures
-
uniquevec
A
Vec-like datastructure which only contains unique entries. It is no_std and has optional serde support. -
gen_value
indexes and values with generations for vectors
-
gecs
A generated entity component system
-
zond
standard rust collections but with collecting statistics
-
sql-json-path
SQL/JSON Path implementation in Rust
-
rotbl
Read Only Table
-
point-nd
flexible no-std struct to model points on axes of any dimensions
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
alignment-exporter
Proc macro providing alignment info for a user-defined struct
-
scored_set
A scored sorted set data structure for Rust
-
pi_append_vec
Only supports append vectors, lock free
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
histogram-sampler
Sampling from a distribution given by a histogram
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
orchestrator
Orchestration sequences
-
steiner-tree
Fast construction of rectilinear steiner minimal trees (RSMT) in two dimensions
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
dartlib
Disk backed concurrent Adaptive Radix Tree implementation, with optional generations
-
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
type-rules
easily constrain a struct
-
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.
-
gix-hashtable
that provides hashtable based data structures optimized to utilize ObjectId keys
-
touch-selection
Selection data structure intended for touch and single button devices
-
pax-properties-coproduct
Static container for program-variable data structures and polymorphic components
-
incrstruct
Build self-referencing structs using two-phase initialization
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
diffogus
calculate the difference between 2 instances of a type
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
tuco
Tuco can automatically generate tuple representations of simple types. This is helpful if you want to create an API using plain types. Or if you want to provide an easy way to convert between types.
-
loaded_dice
sampler for loaded dices, implementing the alias method
-
suff_collections
Fast realization of suffix array and suffix tree
-
open-coroutine-timer
The time utils
-
broomdog
A type-erased map with 'indefinite loanership'
-
shiftnanigans
contains different iteration data structures for either iterating or for shifting iteratively forward and backward
-
tryingarraylist
arraylist implementation
-
rep
A small tool for representation/class invariants
-
range_map_vec
range map data structure backed by a Vec
-
rdf-reader
RDF.rs
-
anymap2
A safe and convenient store for one value of each type
-
arc-bytes
A reference-counted byte buffer
-
alt-std
Alternative Lightweight Std library for making small executables and shared objects
-
byteview
Thin, immutable zero-copy slice type
-
cow_hashmap
Hashmap with copy-on-write semantics that requires no locks
-
bitvector
in Rust
-
range_bounds_map
[
RangeBoundsMap] and [RangeBoundsSet], Data Structures for storing non-overlapping intervals based of [BTreeMap] -
ioc
An Inversion-of-Control library in Rust
-
ttmap
Trivial implementation of type map
-
mist-lib
Juniper Mist Schema Definitions
-
rj
reactive json
-
medianheap
A median heap for keeping track of a running median
-
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…
-
latestmap
latest map
-
generic-btree
Generic BTree for versatile purposes
-
mut-rc
Temporarily mutable
Rc<T>that decays intoRc<T> -
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
sortedvec
a sorted vector that enables quick lookups
-
small_iter
A 3-pointer iterator that moves out of a
Vec<T>orBox<[T]> -
vecdeque-stableix
Deque with stable index values
-
zk-kit-smt
Sparse Merkle Tree
-
syzlang-parser
Parse Syzlang language
-
big-tuple
providing trait implementations for tuples of up to 128 elements
-
meminterval
interval-tree in Rust made to store memory mappings
-
mco-gen
Stackfull Generator Library in Rust
-
sif-itree
immutable, flat interval tree
-
xbinser
binary structure transporation
-
pimalaya-tui
Collection of crossterm widgets shared accross Pimalaya projects
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
text-document
Text document structure and management
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
netlist
generic netlist data structure for VLSI design
-
bdaddr
Bluetooth Device Address
-
amalgamator
A set/map like data structure that allows you to combine members together
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
colibri
Rust data structures for Jitsi Meet Colibri messages
-
sum
General-purpose sum types
-
panoradix
A generic map and a set, both backed by a Radix tree
-
mqfilters
Highly optimized approximate membership query filters (bloom, cuckoo, xor, quotient) with SIMD support
-
write_x86_64
help you write x86_64 assembly code
-
plexus
2D and 3D mesh processing
-
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…
-
im-lists
Persistent unrolled linked lists and vlists
-
ast2str
pretty-printing ASTs and other recursive data structures
-
disk-ringbuffer
lock free on disk ringbuffer to be used in the implementation of Franz
-
sbom-walker
work with SBOM data
-
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
omango-util
Utililites
-
timer_list
A list of timed events that will be triggered sequentially when the timer expires
-
contack
easy contact library
-
minsize
Collections with a statically known minimum size (using const generics)
-
superset_map
Map that stores distinct supersets based on the total order defined
-
filey
A collection of utilities to make file operations more convenient
-
zhifeng_impl_barnes_hut_tree
implements Barns-Hut Tree for accelerated N-body force calculation
-
logisheets_controller
the core of LogiSheets
-
index-from-end
Allow indexing arrays and Vecs from the end using expressions like array[Len-1]
-
rmat
minimal implementation of two-dimensional matrix algebra
-
flex-alloc
Data structures with extra flexible storage
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections
-
voxtree
A sparse voxel octree for rust & rust-gpu
-
croaring-sys
Raw bindings to CRoaring
-
vec-string
To print Vec<Display>
-
undo_2
Undo and redo done the right-way
-
resizing-vec
An automatic resizing vector for data with linear increasing ids
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
bitvek
bit vector implementation
-
valser
Structure schema library for Rust
-
subranges
manage non-interssecting integer intervals
-
try-lazy-init
Fallible lazy initialization
-
netcrab
creating and exporting Petri nets
-
supply-chain-trust-example-crate-000019
A hash table with consistent order and fast iteration
-
supertrees
Supervision trees for Tokio-based services inspired by Erlang/OTP
-
timer-queue
Pure, minimal, and scalable timers
-
rive
ecosystem crate
-
compare
Experimental comparators for collections to be generic over
-
varlen
Ergonomic variable-length types
-
csf
compressed static functions (maps) that use perfect hashing and value compression
-
kvv-efa-api
Rust bindings for the KVV (Karlsruher Verkehrs Verbund) "EFA"-API
-
supply-chain-trust-example-crate-000048
Types and traits for working with bytes
-
ldtk_map
reading ldtk maps for usage in games
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
mikel_binary_tree
search binary tree implementation
-
vec-x
structure
VecXto manage fixed-length arrays, supporting numeric operations and assignment operations betweenVecXand scalar values -
bitlab
Extracting a range of bits from a binary data source
-
collect-rs
Special and custom Collections and Containers (for Rust)
-
fenwick-bit-tree
Slighly over-engineered FenwickTree implmentation
-
frunk-enum-core
Implemenation of genericized enums for use with frunk
-
pulz-arena
A generational arena allocator with compact generational indices
-
compt
A complete binary tree visitor library
-
boolvec
A vector of boolean stored contiguously in memory
-
spaceindex
-
ord-collections
offering collections which are pre-sorted automatically
-
ternary-tree
Ternary Search Trees, with no unsafe blocks
-
hydroperfox-smodel
Semantic modeling for Rust
-
overtone
An API for creation and management of rich (as in rich-text) musical-ish projects
-
tracing-rc
Cycle-aware reference-counted pointers with a safe, simple api
-
pi_dirty
Record hierarchy dirty
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
handlemap
A collection that produces handles that can be used as keys to retrieve the stored items
-
crdt_tree
Tree Conflict-free Replicated Data Type (CRDT)
-
magiclist
List with O(log n) random access, insertion, splitting, and merging
-
b-tree
A persistent B+ tree using freqfs
-
intervaltree
generic implementation of an immutable interval tree
-
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 -
oxidd-cache
Apply cache for OxiDD
-
pi_sinfo
used to describe the 'structure', that is, the meta information of the structure
-
sparseset
A Sparse Set
-
aversion
Versioned data structures with auto-upgrading
-
bevy_tiles
Bevy library for working with entities in grids
-
prefix_array
A generic container for searching on prefixes of keys
-
orn
A general implementation of the sum type. Meant to be a generic counterpart to tuples.
-
segment-tree
Quickly perform interval queries or modifications
-
fixed_deque
A fixed size VecDeque to match Python Deque
-
art-tree
The Adaptive Radix Tree
-
validbr
data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
bgp-models
Structs and other building blocks for BGP and MRT related Rust projects
-
grids
2D grid data structure for games
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
gw2timers
Iterate and collect Guild Wars 2 map meta event times
-
purse
Bag data structure implementation in Rust
-
rs_filter
filter library for matching on complex data structures
-
scoped_stack
A scoped stack data structure
-
rust-3d
2D/3D library written in rust
-
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
valord-map
A dictionary sorted by values
-
llist
Lisp-style singly-linked list
-
deepmesa
fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
osmgraph
Convert OSM queries into graphs
-
lim-bit-vec
Limited bit vectors
-
thinset
A data structure for sparse sets of unsigned integers that sacrifices space for speed
-
nslice
Structures for interpreting slices of variable length as arrays
-
sapling-tree-pattern-match
Pattern match for tree structures
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
word-dictionary
data structure for word mapping. It can be used for language translation.
-
pac_cell
Parent and child cell
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
holyhashmap
A hash map with stable indices
-
div-int
Rational numbers with a compile-time denominator
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
rosary
About Rose Trees
-
twitter/rustcommon-time
getting current and recent timestamps
-
bit-vec-omnitool
A vector of bits
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
kushi
A queue built for the Dango Music Player and Oden Music Bot
-
diamond-types
The world's fastest text CRDT
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
weak-lists
Lists with weak references and concurrent iteration and modification
-
ordmask
To check if a value is included efficiently
-
inplace-vec-builder
Build a vec from a vec, in place
-
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
-
grid-tree
Pixel quadtrees and voxel octrees
-
structdb
Persistent data structures using RocksDB
-
limq
Queue with optional maximum number of elements constraint
-
unsized-vec
Like Vec, but for unsized values
-
xsparseset
sparse set
-
cseq
compact sequences
-
fst-map
succinct map
-
expiringmap
a HashMap-backed TTL map
-
libkv
building data structures atop key-value stores
-
raw-btree
Generic B-Tree implementation
-
caffeine
Collection of data structures I'm writing for fun. Originally written for use with my crafting interpeters tutorial implementation.
-
light-curve-interpol
Interpolations tools for time series
-
moving_min_max
Tracking minimum or maximum of sliding windows
-
veho
a iterable toolset
-
filetrack
persistent logrotated reading and other useful io things
-
v9
A slim data engine for Data Oriented Design
-
rstmt
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
median-heap
A median heap implementation in Rust, used to keep track of a running median of a sequence of numbers
-
piece_table_rs
piece table data structure
-
rpds-pathtree
Immutable, path-addressable tree data structure
-
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
-
tinybitset
Generic implementation of small, fixed size, copyable bitsets
-
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
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
eastl-rs
EASTL binary-compatible Rust implementations
-
anyid
ambiguous identifier
-
ord-uuid
Creates lexically sortable uuid values of size 16 bytes
-
brownstone
building fixed-size arrays
-
merkle
tree implementation with support for generation of inclusion proofs
-
hst-tw-images
working with Twitter profile images
-
collect-me
Additional collections not included in the Rust standard library
-
rk-utils
A collection of utility functions and data structures for rust
-
memvec
Memory-backed vector, not buffer. Designed for for mmap. Not MemMap, but MemVec!
-
redmaple
offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
index-map
A map with automatically generated usizes as keys
-
stealth-lib
functions for ZKP
-
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.
-
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 -
incremental-map
combinators for incremental immutable maps (see crate
incremental) -
btree_experiment
implements a BTreeMap similar to std::collections::BTreeMap
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
grovedb-version
Versioning library for Platform
-
rdc
generating Java code from rust structs
-
id_collections
Index-oriented programming in Rust
-
serde_either
set to enums to deserialize and serialize data that can either be string, struct or vec
-
groupex
Syncronization primitive that allows acquire lock by index
-
wccg-models
WCCG Data
-
typed_graph
Staticly typed graph library
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
relational_types
Manage relations between objects
-
nimble-steps
Nimble Steps Collections
-
symbolic-sets
Sets that are stored symbolically
-
fn-map
Abstraction around HashMap. Uses closure to compute and store value.
-
omnitool
A curated respository of algorithms and data structures. The libraries are included as forks of Rust codebases
-
queued_rust
queue type for better privacy managment and data orginization
-
implies
A parser for logical formulas
-
aabel-multihash-rs
extends Hasher trait. The added functionality allows users to get sequeces of hash values. It can be used inside of implementations of probabilistic data structures such bloom filter or count-min.
-
header-vec
Vector with user-specified header, length, capacity, and array elements all stored on the heap together
-
hdf5-hl
High level bindings to HDF5 High Level API
-
chainbuf
Fast chained buffers
-
literally
Macro literals for members of std::collections
-
listfree
lockfree prepend-only list
-
rs-car
CAR v1 and v2 specifications
-
bmap
A bitmap with an internal counter
-
multiset
Multisets/bags
-
extensions-rs
File extension types in Rust
-
sidex
A format- and language-agnostic data structure and API definition language
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
lurk-elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
nimbusqueue
fifo collection
-
cbsk_log
log tool
-
ordered_hash_map
HashMap which preserves insertion order
-
spring-sms
基于spring-rs 0.2.1 版，简单实现了短信发送功能，未来将完善，目前只支持阿里云短信发送
-
wplot
Plot interface
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
poppy-filters
providing serializable Bloom filters implementations
-
bit-parallelism
Small integer specialized, word level, parallel algorithms and data structures
-
morton-index
Types and functions for efficiently and easily work with Morton indices
-
find-all-the-kitty-cats-in-charlotte
A collection of crates for working with cats
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
rustz
functional programming in Rust
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
teardown_tree
A binary search tree that supports fast clone and delete-range operations
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
egui_suspense
Automatically show loading and error uis for egui
-
succinct
data structures for Rust
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
beehive
collections for 3D hexagonal maps
-
oxidd-rules-tdd
Ternary decision diagrams (TDDs) for OxiDD
-
ultragraph
Hypergraph data structure
-
vicardi
JSON VCardArray Generator that uses Serde
-
zetacore
in-memory vector store library with Python bindings
-
append-only
Append only versions of std data structures
-
thot-core
Core functionality and types for Thot data management and analysis software
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
billios
A soil library
-
isx
Traits for checking certain conditions of values
-
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.
-
recursive_reference
way to walk on recursive structures easily and safely
-
nanotweaks-proc
moved to https://crates.io/crates/spread_macros
-
pl-lens
support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
chainmap
mutability of intermediate maps
-
ndshape
fast linearization of N-dimensional array indices
-
total-maps
Maps where every possible key has an associated value
-
range-mutex
A
Mutex<[T]>-like type, that allows locking different ranges separately -
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
-
array_map
Map backed array for fixed size keys with O(1) performance
-
esl01-indexedlog
Append-only on-disk storage with integrity checks and indexing support
-
orbweaver
designed for effortless construction and analysis of graph data structures
-
stdng
An enhancement for Rust standard library
-
kd-tree-rs
k-d tree
-
pointcloud
An accessor layer for goko
-
bitval
For packing booleans in variables using bitwise operations
-
ads-rs
(Algorithms and Data Structures) is a set of useful generic production-ready algorithms and data structures
-
rust_examples
rust 的学习中的一些例子
-
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
-
pvec
RRB-Tree based persistent vector implementation
-
prototty_common
Definition of common ui elements and views for use with prototty
-
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
-
alloc-checked
Collections that don't panic on alloc failures
-
union-fn
Proc. macro for creating efficient "inline closures".
-
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
-
screech
A collection of helpers for handling audio data in real time
-
hashable-map
Wrappers for HashMap and HashSet that implement Hash
-
yrs-kvstore
Generic persistence layer over Yrs documents
-
pas
strided slice
-
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 -
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
-
driftdb
A real-time data backend for browser-based applications (core library)
-
multi_containers
Ergonomically work with multiple values per key
-
nakadi-types
A connector for the Nakadi Event Broker
-
numas
multidimensional array for efficient computing
-
luthor
A collection of lexers for various languages/formats, and the tools required to build them
-
rustic_core
fast, encrypted, deduplicated backups that powers rustic-rs
-
chain-map
A chain of maps with a single view into the aggregated values
-
merkle-root
calculating the Merkle root of either a file, or walked directory
-
tilecoding
Dr. Richard S. Sutton's tile coding software.
-
intervals-rs
intervals
-
st2-logformat
Adapter-agnostic definitions for data types used by ST2
-
small-world-rs
The easiest HNSW vector index you'll ever use
-
double-map
A HashMap with double key to single data/value
-
thin-string
A String with a smaller stack footprint
-
periodic-rs
Bounded datastructures
-
cbsk_timer
rayon thread runtime
-
epoch32
32-bit Epoch with specified starting year
-
linear-hashtbl
Linear probing hash table
-
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
seq_watcher
A pair of structures for monitoring a stream of data for one or more sequences
-
comprende
Python-style collection comprehensions in Rust
-
dectree-rs
A decision tree implementation in Rust
-
atlv
Algebraic Tag Length Value encoding
-
lumberjack
Read and modify constituency trees
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
rahashmap
Fork of standard library HashMap with additional functionality
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
constructivism
Simplify the construction of structured data
-
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
-
nanovec
Arrays and Vec-likes of small integers packed in an integer or two
-
modupipe
A modular and extensible ETL-like pipeline builder
-
bloomfilter-rust
A bloomfilter implementation in Rust
-
mine_sweeperr
Minimalist interface to manage the backed of a mine sweeper game
-
tudelft-dsmr-output-generator
Companion library for the TU Delft Software Fundamentals individual assignment
-
vec-entries
Entry API for iterating over and removing elements from a
Vec -
bit-array-rs
Bit Array
-
unicase_collections
Collection of UniCase datastructures
-
crio
An easy to use persistent data storage library
-
ndcopy
Fast N-dimensional array memcpy
-
list_tools
一个自己研发的Vec<T>
-
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
-
structo
Data structures made in Rust
-
win-variant
that aims to provide a more ergonomic way of working with variants in winapi based projects
-
evicting_cache_map
An Evicting LRU cache supporting prune hooks
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
lignin
A virtual DOM structure, primarily for web use
-
equivalent-flipped
Similar to
equivalentcrate, but flipsKandQ -
variant-set
A set-like data structure for enum variants, allowing you to store at most one value for each variant of an enum
-
ostr
Owned str
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
gpt_disk_io
GPT (GUID Partition Table) disk IO no_std library
-
stonks
Sets that allow borrowing while inserting entries
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
actions
Software without side-effects. Redo and Undo. Macro's.
-
shogiutil
A collection of tools to handle shogi data
-
generic_event_queue
generic event-queue API
-
qualia
Basic semi-schemaless document store
-
large_int
An ease-of-use unbounded signed integer
-
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!
-
mipmap-1d
A small data structure to perform 1d-mipmapping (downsampling)
-
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
-
simple-vec-collections
Collections implemented using Vec
-
associated_list
An associated list, for cases when the key implements neither Hash nor Ord
-
rs-tree-sitter-languages
Collection of Tree-Sitter parsers
-
learn_together
Curated collection of lists of useful resources to learn Rust together
-
insrcdata
Embed static data as source code
-
prototty
Wrapper crate for frontend-independent prototty crates
-
crfsuite-sys
Rust binding to crfsuite
-
proptest-recurse
Helper for defining mutually recursive strategies with proptest
-
rimu-value
A data structure template system
-
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
liblet
learning about formal languages and grammars
-
mergle
A data structure with fast merging and comparison
-
feature-set
User defined feature set
-
reactive-signals
dx-first scope-based fine-grained reactive system
-
multipath
split file path, like
/home/{user,admin}/file.txt -
folketinget-api-models
Autogenerated Rust structures based on the Danish Parliament's OData metadatafile
-
libreda-splay
Splay map and splay set data structures
-
anylist
a list type for any type
-
qualomat_schema
Rust bindings for the *Qual-O-Mat* open data format for the german voting advice tool *Wahl-O-Mat*
-
gsgdt
Generic Stringly Typed Graph Datatype
-
slice-rbtree
A slice-based Red-black tree
-
cycler
A simultainious write/read data structure
-
vec-option
A space optimized version of
Vec<Option<T>>that stores the discriminant seperately -
patricia_router
Radix Tree implementation for Rust
-
partial
Optional monad with fake variant
-
range_union_find
A union-find data structure for ranges
-
mazer-data-structures
A minimal, simple math markup language that compiles to HTML, written in Rust
-
gapbuf
Generic gap buffer
-
optimistic_lock_coupling
A General Lock following paper 'Optimistic Lock Coupling: A Scalable and Efficient General-Purpose Synchronization Method'
-
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
path-value
Universal type and access property(s) by path
-
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
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
quadboard
Typed fixed-length buffers of chess pieces
-
cnctd_smart_home
A collection of Smart Home APIs
-
canadensis_bit_length_set
A bit length set type used to calculate data type sizes when processing Cyphal data structure description language files
-
pi_ordmap
Ord Map
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
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
-
ware
middleware chains
-
minimizer-queue
Fast computation of minimizers using a monotone queue
-
dade
data definition for Rust structures
-
wrapping
slices and arrays
-
zaplib_components
The widget toolkit for Zaplib
-
y-sync
Yrs synchronization protocol
-
moka-cht
Lock-free resizeable concurrent hash table
-
data_tree
Hierarchical data tree with pathing and search support
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
rblist
A block-based, non-circular double-linked list implementation for Rust
-
bisetmap
fast and thread-safe two-way hash map of sets. It is best suited where you need to associate two collumns uniquely. Each key is associated to one or more other unique values. The structure…
-
range-map
Maps and sets implemented using ranges
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
usage
A convenient alternative to the newtype pattern
-
RustyDSA
A libary for Rust data structure
-
torro
A correct and easy-to-use BitTorrent library
-
leetcode-solutions
A collection of leetcode solution in rust
-
bktree
BK-tree datastructure
-
colours
Color types for different color models with conversions between it
-
voml-collection
Collections for VOML
-
restorable
An iterator adapter for saving and restoring iterator state
-
sweeper
A foundation for Minesweeper implementations in Rust
-
sparse_set
sparse set data structure
-
rangelist
A representation of sets as lists of inclusive ranges
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
reql-types
Some useful types to use along with the reql crate
-
tbytes
A tiny library for reading and writing typed data into buffers
-
processing_chain
set up processing chains of large amounts of data
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
rust_list
Singly linked list in Rust, with macros for easy instantiation
-
mkargs
Build command arguments
-
trying
Basic trie crate
-
tiny-test
tiny-testis collection of functions simplifying test assertions in rust -
nvpair-rs
Safe and rustic wrapper around nvpair
-
rdf-format
RDF.rs
-
merkle-cbt-lean
Special implementation of Complete Merkle Binary Tree for minimal memory footprint
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
lazy-seq
constructing lazily evaluated sequences
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
transient_map
Hashmap with eviction of unused elements
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
simple-sds-sbwt
A fork of simple-sds used in the sbwt crate
-
deltastruct
Allows defining deltas for tagged structs for later application
-
simple-undo
Easy to use undo-redo library
-
read-copy-update
locking primitive
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
smolvec
A lightweight vector implementation with small-vector optimization for rust
-
mc-oblivious-map
Oblivious Hash Map data structures on top of Oblivious RAM
-
datazoo
Bitset and jagged array data structures
-
collect_result
collecting an iterator of results into a result of a collection
-
lr_trie
Left-Right trie is trie capable of mapping any string to any string
-
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
-
bit-set-omnitool
A set of bits
-
tan-lints
A collection of lints for the Tan Language
-
type-freak
Collection of typed data structures, trait operators and aliases
-
isomorphism
2 directional hashmaps
-
boxing
cross-platform implementations for NaN and ptr boxes
-
l6t-file
A part of l6t library: reading, writing and deconding for L6T IFF data
-
changed
change detection
-
collectable
Fallible, no_std-friendly collection traits
-
bengbenge
inifity array for round-robin dns, beng, beng
-
tinyvecdeq
VecDeque-like data structures -
cdragon-prop
Work with BIN files used by Riot
-
Xorfilter
No alloc membership approximation
-
hdrhistogram
A port of HdrHistogram to Rust
-
binary-tree-view
A binary tree visualization application built in Rust
-
lxc
Linux Containers API
-
casbin-arangors-adapter
ArangoRs adapter for casbin-rs
-
windowed-futures
Helpers for windowed parallel execution of collections of futures
-
nary_tree
A vec-backed tree structure with tree-specific generational indexes
-
mivim
-
corresponding
Move corresponding fields between structs
-
ic-stable-memory
Internet Computer's stable memory collections and tools
-
libflow
grouping network flow data
-
plurals
singular/plural forms, mostly in English
-
trie
An ordered map and set based on a trie
-
rust_fixed_width
that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
recursive_array
arrays using recrusive data structures to avoid limitations of the rust compiler
-
fallback
A helper library to implement fallback mechaism
-
applejack
Radix tree
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
augurs-core
Core data structures and traits for the augurs time series library
-
loki-logger
A loki logger for the log facade
-
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.
-
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
-
construe
Compile-Time Growable Array: Vec & String for const!
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
empty_type
Tools to define and convert between types and their corresponding "maybe types"
-
run-loop
Run loop for thread, provide message post, deadline timer and future executor
-
field_accessor
A procedural macro to get and set a struct field by String dynamically
-
synthax
Synthesize syntax with quasiquoting plugins
-
indexed-bitfield
An indexed bitfield, to track presence or absence of up to 128 elements
-
dyn_vec
A Vec<T: ?Sized>
-
tinymap
A map structure that stores its data on the stack
-
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.
-
syntastic
Generic abstract syntax representation
-
reunion
A generic implementation of the Union-Find w/ Rank data structure
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
subset-map
A map where the keys are subsets of an initial set of elements
-
treez
A collection of useful data structures
-
okasaki
A collection of peristent datastructures
-
flats
flattens nested structures into a flat single dimension map
-
pati
Image data structure and format for the Patica editor
-
circular-queue
A circular buffer-like queue