-
hashbrown
port of Google's SwissTable hash map
-
indexmap
A hash table with consistent order and fast iteration
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
predicates
boolean-valued predicate functions
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
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
-
roaring
A better compressed bitset - pure Rust implementation
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
bimap
Bijective maps
-
bit-vec
A vector of bits
-
tinystr
A small ASCII-only bounded length string representation
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
croaring
Rust wrapper for CRoaring
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
smartstring
Compact inlined strings
-
generator
Stackfull Generator Library in Rust
-
trie-rs
Memory efficient trie (prefix tree) and map library based on LOUDS
-
zerofrom
trait for constructing
-
linked_hash_set
HashSet with insertion ordering
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
rowan
generic lossless syntax trees
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
ego-tree
Vec-backed ID-tree
-
im
Immutable collection datatypes
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
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.
-
fixedbitset
bitset collection
-
faststr
string library that reduces the cost of clone
-
enumset
creating compact sets of enums
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
gix-pack
Implements git packs and related data structures
-
bloomfilter
Bloom filter implementation
-
radix_trie
Generic radix trie data-structure
-
yrs
High performance implementation of the Yjs CRDT
-
index_vec
Newtype-style helpers for
Vecandusize -
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
imbl
Immutable collection datatypes
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
bitmaps
Fixed size boolean arrays
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
ecow
Compact, clone-on-write vector and string
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
rpds
Persistent data structures with structural sharing
-
smallbitvec
A bit vector optimized for size and inline storage
-
array-init
Safe wrapper for initializing fixed-size arrays
-
nonempty-collections
Correct-by-construction non-empty collections
-
spade
Delaunay triangulations for the rust ecosystem
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
multimap
A multimap implementation
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
egg
egraphs
-
range-set-blaze
Integer sets as fast, sorted, integer ranges with full set operations
-
thin-vec
A vec that takes up less space on the stack
-
smallbox
Small Boxoptimization: store small item on stack and fallback to heap for large item -
intmap
Specialized HashMap for integer keys
-
uluru
fast, LRU cache implementation
-
guppy
Track and query Cargo dependency graphs
-
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.
-
dlv-list
Semi-doubly linked list implemented using a vector
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
orx-split-vec
An efficient dynamic capacity vector with pinned element guarantees
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
comparable
comparing data structures in Rust, oriented toward testing
-
fastbloom
The fastest Bloom filter in Rust. No accuracy compromises. Compatible with any hasher.
-
narrow
Apache Arrow
-
str-buf
Static string buffer
-
cordyceps
Mycelium intrusive data structures
-
array-macro
Array multiple elements constructor syntax
-
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
-
hashbag
An unordered multiset implementation using a hash bag
-
micromap
The fastest alternative to HashMap, for maps smaller than 20 keys
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
equivalent
Traits for key comparison in maps
-
grid
Dynamic generic 2D data structure
-
jaq-json
JSON values for jaq
-
tree_iterators_rs
built to provide you with the iterators to easily work with tree data structures in Rust
-
modql
Model Query Language support
-
dary_heap
A d-ary heap
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
slice-dst
Slice-based custom DSTs
-
mycelium-bitfield
Structured bitfields, courtesy of Mycelium
-
qfilter
Efficient bloom filter like datastructure, based on the Rank Select Quotient Filter (RSQF)
-
bitfield-struct
Struct-like procedural macro for bitfields
-
lsm-tree
A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)
-
csaf-walker
work with CSAF data
-
boa_interner
String interner for the Boa JavaScript engine
-
orx-priority-queue
Priority queue traits and high performance d-ary heap implementations
-
oci-spec
Open Container Initiative Specifications in Rust
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
cranelift-entity
Data structures using entity references as mapping keys
-
string
A UTF-8 encoded string with configurable byte storage
-
rustic_core
fast, encrypted, deduplicated backups that powers rustic-rs
-
range-collections
Sets and maps of ranges, backed by smallvec
-
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
-
newtype-uuid
Newtype wrapper around UUIDs
-
indexset
A two-level BTree with fast iteration and indexing operations
-
vers-vecs
A collection of succinct data structures supported by fast implementations of rank and select queries
-
las
Reads and writes point clouds stored in the ASPRS las file format
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
iset
Map and set with interval keys (x..y)
-
phf_shared
Support code shared by PHF libraries
-
vecmap-rs
A vector-based map and set implementation
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
blobby
Iterator over simple binary blob storage
-
fqdn
FQDN (Fully Qualified Domain Name)
-
cita_trie
Modified Patricia Tree (aka Trie)
-
circular-queue
A circular buffer-like queue
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
ringbuffer
A fixed-size circular buffer
-
oxc_index
Newtype-style helpers for
Vecandusize -
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
portgraph
Data structure library for directed graphs with first-level ports
-
fm-index
FM index and its variant implementations for Rust
-
i256
Optimized implementations of 256-bit signed and unsigned integers
-
timed-map
Lightweight map implementation that supports expiring entries and fully compatible with both std and no_std environments
-
vec_map
map based on a vector for small integer keys
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
tinyset
Size-optimized sets
-
setsum
order-agnostic checksum
-
lib-sokoban
Sokoban: compact, efficient data structures packed into contiguous byte arrays
-
submap
B-Tree map for pub/sub services
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
open-payments-iso20022-acmt
Open Payments - Message Parsing Library - ISO20022 ACMT
-
vart
An immutable versioned adaptive radix trie
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
bloom2
Fast, compressed, 2-level bloom filter and bitmap
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
qwt
Quad Wavelet Tree
-
keyvi
key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
xsd-types
XSD data types
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
array-concat
Macros for concatenating const arrays
-
xot
Full-featured XML tree library for Rust
-
xml-builder
Easy and highly-configurable XML builder/writer
-
vise
Typesafe metrics client
-
crop
A pretty fast text rope
-
btree-range-map
B-tree range map implementation
-
iptrie
IPv4/v6 prefixes lookup structures (based on tries)
-
trees
General purpose tree data structures
-
rustica
functional programming library for the Rust language
-
loro-delta
Loro internal library. It's used as a delta between two versions of text or lists. It's also an efficient Rope.
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
collection_tools
General purpose tools to manipulate collections( containers like Vec/HashMap/HashSet )
-
intervallum
Generic interval and interval set library
-
bytes-utils
Additional utilities for working with the bytes crate
-
short-uuid
generate and parse short uuids
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
rust_dynamic
Support for dynamically-typed values in run-time
-
cow_hashbrown
port of Google's SwissTable hash map with copy-on-write support
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
rsdict
Fast static rank and select data structure
-
chat-prompts
Chat prompt template
-
undo
An undo-redo library
-
bitflag-attr
A macro to generate bitflags structures from C-like enums
-
idlset
Fast u64 set operations library
-
cueue
High performance SPSC circular byte buffer with batch operations
-
cactus
Immutable parent pointer tree
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
pin-list
A safe
Pin-based intrusive doubly linked list -
tree-ds
manipulate tree data structures
-
uuid-rng-internal
Private implementation details of the uuid crate
-
ordinal-map
Ordinal trait to map values to integers and efficient maps and sets for such types
-
base-traits
base traits (for Rust)
-
cc-traits
Common collection traits
-
spatialtree
A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)
-
hibitset
Hierarchical bit set structure
-
im-lists
Persistent unrolled linked lists and vlists
-
pg_filters
helper to generate postgres sql for pagination, sorting and filtering
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
tracker
A macro to track changes on structs
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
ftree
A very fast fenwick tree implementation
-
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…
-
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… -
interavl
An optimised interval tree for efficient interval stabbing
-
itybity
An itty bitty crate providing bit iterators and bit iterator accessories
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
slotmap-careful
Wrap the slotmap crate and prevent key reuse
-
delay_map
HashMap collections whose entries expire after a given time
-
cdg_api
interact with api.congress.gov
-
ordered-multimap
Insertion ordered multimap
-
ordered
A wrapper for adding arbitrary partial/total order to a type
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
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. -
blart
adaptive radix tree packaged as a BTreeMap replacement
-
mzpeaks
representing peaks in mass spectrometry data
-
phf_generator
PHF generation logic
-
wildbird
Rust Framework 🐦
-
xorf
implementing xor filters - faster and smaller than bloom and cuckoo filters
-
sparsevec
Compress vectors using row displacement
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
flex_array
A
#[no_std]flexible array much like std::Vec but with custom indices and length and capacity types -
queue-file
lightning-fast, transactional, file-based FIFO
-
array2d
A fixed sized two-dimensional array
-
prio-graph
A lazily populated directed acyclic graph with top-level priority ordering
-
louds-rs
High performance LOUDS (Level-Order Unary Degree Sequence) library
-
dogear
merging bookmark trees
-
block-grid
A quick, cache-conscious, tiled 2D array
-
merkletree
Light merkle tree implementation with SPV support and dependency agnostic
-
faststr-fork
Faststr is a string library that reduces the cost of clone
-
value-log
Value log implementation for key-value separated LSM storage
-
rpds-pathtree
Immutable, path-addressable tree data structure
-
smallstr
String-like container based on smallvec
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
linearize
Types that are enumerable and an array-backed map
-
csf
compressed static functions (maps) that use perfect hashing and value compression
-
normalize_interval
Normalizing interval library
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
range-set
Smallvec-backed containers of sorted integer ranges
-
arrow-row
Arrow row format
-
rt_ref
Internal
Reftypes forrt_refandrt_vec -
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
bittle
Zero-cost bitsets over native Rust types
-
slice_ring_buf
A ring buffer implementation optimized for working with slices
-
diff-struct
A trait for diffing and applying diffs to types
-
is-tree
Everything is a tree
-
raft-log
Raft log implementation
-
libwebnovel
enabling users to get chapters of a webnovel, with multiple available backends
-
matreex
matrix implementation
-
stac-server
SpatioTemporal Asset Catalog (STAC) API server
-
sync-ptr
Sync & Send wrappers for raw pointer's
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
adflib
handle amiga disk files
-
map_vec
The Map and Set APIs backed by Vec
-
vec-strings
Store any string efficiently in an immutable way
-
kempt
Ordered collection types with no unsafe code and no_std support
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
byteview
Thin, immutable zero-copy slice type
-
walker-common
Common functionality for SBOM and CSAF walker
-
id_tree
creating and modifying Tree structures
-
sized-chunks
Efficient sized chunk datatypes
-
more_collections
Additional collections not found in std::collections
-
xor_name
Xor Type
-
truc
Rust code generator for safe, fixed size, evolving records
-
shardtree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
hashslab
A hash table with data accessible by index
-
funcmap
Derivable functorial mappings for Rust
-
roadmap
model a project roadmap as a directed acyclic graph
-
dot2
generating Graphviz DOT language files for graphs
-
valkyrie-ast
Strong typed abstract syntax tree of valkyrie language
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
stacked_errors
high level error propogation with software controlled backtraces
-
unsized-vec
Like Vec, but for unsized values
-
ocpp_rs
Protocol implementation for Open Charge Point Protocol (OCPP) in Rust
-
f3l_search_tree
3D Point Cloud Library
-
uuid-rs
Universally Unique IDentifier (UUID)
-
mule-map
A hybrid between a HashMap and a lookup table
-
rdf-types
Data-structures and traits definitions for RDF
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
bumparaw-collections
A small set of bumpalo-backed collections for low-level operations
-
ergo_avltree_rust
cryptographically authenticated dictionary based on AVL tree
-
snowid
generating SnowID - a Snowflake-like timestamp-based distributed unique identifier
-
variadics
Variadic generics on stable Rust using tuple lists
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
xmltv
electronic program guide (EPG) parser and generator using serde
-
polytype
A Hindley-Milner polymorphic typing system
-
snowflake_me
A distributed unique ID generator inspired by Twitter's Snowflake
-
json-number
JSON number parsing and storage
-
cheap-clone
A trait which indicates that such type can be cloned cheaply
-
heavykeeper
finding Top-K elephant flows with high precision and low memory footprint
-
packedvec
Store vectors of integers efficiently
-
pi_map
Define a Triat: map for the mapped schema, and provide two built-in implementations of HashMap and vecmap
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
edtui-jagged
A jagged array data structure for the edtui editor
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
wavltree
An intrusive Weak AVL Tree
-
flatk
Flat layout abstraction toolkit
-
case_insensitive_hashmap
A HashMap that uses case-insensitive strings as keys
-
euui
An Extended Universal Unique Identifier
-
scopegraphs
A well-documented port of scopegraphs to Rust
-
overlay-map
A two-layered map data structure for Rust that tracks current and previous values for each key — with zero-clone, in-place state transitions
-
ordsearch
A data structure for efficient lower-bound lookups
-
seoul
trait Isomorphism
-
compact-rc
Low-memory reference-counting pointers
-
lean_string
Compact, clone-on-write string
-
min-max-heap
An efficient, double-ended priority queue
-
swamp-code-gen
generates swamp-vm opcodes
-
signalk
parse signalk maritime data
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
form_builder
building forms with various fields and validation
-
tetengo_trie
A trie library implemented with a double array
-
beap
Bi-parental heap data structure implementation in Rust
-
madeleine
Transparent object persistence with predefined operations and state containers
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
scapegoat
Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
-
rs-ecs
reasonably simple entity component system
-
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
-
flatten_objects
A container that stores numbered objects. Each object can be assigned with a unique ID.
-
dup-indexer
Create a non-duplicated index from Strings, static str, Vec, or Box values
-
slabmap
HashMap-like collection that automatically determines the key
-
enum-collections
Collections data structures optimized for Enum, initializable at runtime
-
hyperloglogplus
HyperLogLog implementations
-
mikufans-proto
gRPC APIs for Mikufans
-
ux-primitives
Graphics Primitives for Angular Rust
-
stavec
Stack-allocated vector with static capacity
-
indexical
indexed collections
-
i_tree
Expiration key tree. Usable in algorithms like swipe line. Only for uniq elements
-
tailcall-chunk
persistent data structure for efficient append and concatenation operations
-
span-map
A data structure for efficiently managing sets of values over spans/ranges
-
orx-fixed-vec
An efficient fixed capacity vector with pinned element guarantees
-
nodit
Discrete Interval Tree Data-Structures, which are based off BTreeMap
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
vectree
Vector-buffered tree collection with post-order, depth-first, mutable/immutable iterator
-
simple-grid
2d-grid structure
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
random-access-disk
Continuously read and write to disk, using random offsets and lengths
-
vortex-array
Vortex in memory columnar data format
-
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…
-
slabigator
A linked list that doesn't do dynamic memory allocations
-
typemap_rev
A hashmap, but stores types as keys
-
ttgraph
Typed/Transactional Graph container
-
field_access
Dynamically access struct fields
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
easy-tree
efficient tree structure library for Rust with recursive traversal
-
bitvec_helpers
BitVec based bitstream reader and writer
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
ball-tree
K-nearest neighbors
-
codas-flow
Low-latency, high-throughput bounded queues ("data flows") for (a)synchronous and event-driven systems
-
intervaltree
generic implementation of an immutable interval tree
-
fingertrees
Immutable persisten finger trees
-
superset_map
Map that stores distinct supersets based on the total order defined
-
among
The enum
Amongwith variantsLeft,MiddleandRightis a general purpose sum type with three cases -
sector
A stateful vector implementation that provides different memory management behaviors through Rust traits and state machines
-
small-fixed-array
providing fixed length immutable collections with a low memory footprint
-
optional
supplies a number of Option-like primitive types
-
lru-slab
Pre-allocated storage with constant-time LRU tracking
-
iter-tree
Convert between iterators and tree structures in both directions
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
treeclocks
Various Tree Clock data-structures and utilities
-
typeid_prefix
that implements a type-safe version of the TypePrefix section of the
TypeIDSpecification -
pi_slot
lock free Slotmap data structure
-
jaggedarray
Multidimensional jagged array
-
srdf
RDF data shapes implementation in Rust
-
jsonbb
A binary representation of json value, optimized for parsing and querying
-
rt-pods-client
Official Client for RtPods
-
avl
A map and a set implemented with an AVL tree
-
tuplez
Tuples represented in recursive form
-
pasture-core
A framework for working with point cloud data
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
h3o-ice
Frozen{Map,Set} for H3 cells, based on finite state transducers
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
cpx-coords
power the rust-quantum project, this library provides a robust
Cpxtype, specifically optimized for the intensive complex number multiplications required for quantum gate applications and tensor product operations… -
do-notation
Monadic do syntactic sugar
-
mapgraph
A directed graph that can also be used as an arbitrary map
-
hextree
Location to value mapping
-
anyrust
any rust
-
persistent-kv
Persistent key-value store
-
atelier
a Computational Workshop for Market Microstructure Modeling, Synthetic Simulation and Historical Replay
-
open-payments-iso20022-camt
Open Payments - Message Parsing Library - ISO20022 CAMT
-
griddle
A HashMap variant that spreads resize load across inserts
-
rdf-model
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
ranges
generic alternative to core/std ranges, set-operations to work with them and a range set that can efficiently store them with the least amount of memory possible
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
cantrip
Practical extension methods for standard Rust collections
-
radixmap
Rust-based Radix Tree for fast prefix lookup, supporting named param, glob, regex
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
lctree
Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees
-
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. -
graph-api-petgraph
Integration between graph-api and petgraph - use graph-api's traversal system with petgraph structures
-
livestock-rs
comprehensive library and CLI tool for managing, identifying, and working with livestock breeds, growth rates, and health. Designed to support farming and ranching applications, breed registries…
-
uid_store
Generate random uid strings containing letters, numbers, or base62 values
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
mphf_benchmark
The program for benchmarking Minimal Perfect Hash Functions
-
bye_nanoflann_rs
KD-Tree, implemented based on nanoflann, primarily optimized for 2D or 3D point clouds
-
vortex-sparse
Vortex Sparse array
-
attribute-search-engine
Generic search engine for rows with attributes using different matchers
-
validit
Validate data structures internal state
-
bitboard64
A 64-bit bitboard useful for chess programming
-
array-linked-list
A data structure, which combines the advantages of dynamic arrays and linked lists
-
agb_hashmap
no_std hashmap implementation intended for use in the
agblibrary -
forest-ds
secure tree structure
-
unsure
handling unsure (optional) values that might fail, with an additional rejection variant
-
entid
generating and validating type-safe, prefixed entity identifiers based on UUIDs and ULIDs
-
hotel
Collection Data-structure to associate values with keys
-
flatcontainer
A flat container representation for Rust
-
cell-grid
2d grid container
-
json_deref
JSON internal field links resolver
-
cpx-mat2by2
power the rust-quantum project, this library provides a robust AltMat type for a single qubit, specifically optimized for the intensive complex number multiplications required for quantum…
-
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…
-
plain_trie
Classic trie implementation capable of mapping any T to char iterator
-
hashify
Fast perfect hashing without dependencies
-
slice_map
A generic container to store a single type of data into unevenly sized slices
-
intrusive-lru-cache
An LRU cache implementation using intrusive data structures
-
incrementalmerkletree-testing
Common types, interfaces, and utilities for testing Merkle tree data structures
-
kn0sys-ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
minimizer-iter
Iterate over minimizers of a DNA sequence
-
sif-itree
immutable, flat interval tree
-
data_reader
A data loading library for data scientist
-
bloomcalc
calculator for bloom filters
-
rust-mcp-transport
Transport implementations for the MCP (Model Context Protocol) within the rust-mcp-sdk ecosystem, enabling asynchronous data exchange and efficient message handling between MCP clients and servers
-
flashlight_tensor
tensor library focused around matrix operations
-
sucds
Succinct data structures in Rust
-
strumbra
Umbra-style strings (also known as German strings)
-
suffixarrayview
Creates a view of a suffix array
-
rbtree
the rbtree for Rust
-
hash-iter
Iterator producing sequence of hash values for a given input (using double hashing technique)
-
dia-i18n
-
any-rope
A fast and robust arbitrary rope for Rust. Based on Ropey.
-
disjoint
Fast and safe implementation of the disjoint-set data structure
-
typeables
type aliases. By SixArm.com.
-
unordered-pair
A tuple struct representing an unordered pair
-
cdll
A circular doubly linked list
-
weak-table
Weak hash maps and sets
-
digit-sequence
Sequence of u8 digits
-
hicollections
C-liked Collections
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
bitstring
traits and implementations
-
stack-queue
Heapless auto-batching queue
-
linear-hashtbl
Linear probing hash table
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
paginate
framework agnostic pagination crate, that is especially suited for databases, slices and collections. Paginate calculates the range of pages indexes, making it ideal for accessing slices…
-
exhaustive-map
An exhaustive map for types with finite inhabitants
-
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
-
smallvec-wrapper
Macro and common structs to play with
smallvec -
windows-collections
Windows collection types
-
tree-sitter-traversal2
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
tournament-kway
k-way merge using a tournament tree
-
ligature
Ligature's data model in Rust
-
re_string_interner
string interning library
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
wrapped_slab
WrappedSlab: Auto-generate newtype idiom based on a Slab
-
keyed-set
Keyed Set: a hashbrown-based HashSet that indexes based on projections of its elements
-
indexed_arena
index-based arena without deletion
-
space
providing abstractions for spatial datastructures and search
-
sif-kdtree
immutable, flat k-d tree
-
halfling
A collection of basic utilities for working with nibbles
-
ninjabook
A lightweight and high performance orderbook
-
oxidd-rules-bdd
Binary decision diagrams (BDDs) for OxiDD
-
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…
-
tagid
Defines a newtype labeled tagging for different types of ids
-
ofilter
fast thread-safe Bloom filter
-
range-map
Maps and sets implemented using ranges
-
cseq
compact sequences
-
hashheap
data structures that combine a hashmap and a min/max priority heap, with main operations requiring O(1) or O(log n) time
-
lsph
Learned Spatial HashMap
-
heapless_graphs
composable graphs for no_alloc environments
-
ringmap
A hash table with consistent deque-like order and fast iteration
-
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
windowed-infinity
data structure representing an infinite sequentially writable u8 vector of which a small view has writes to it preserved. This is primarily useful when implementing CoAP block-wise transfers…
-
pdatastructs
probabilistic data structures
-
hi_sparse_bitset
Hierarchical sparse bitset. Incredibly high performance. Compact memory usage.
-
orn
A general implementation of the sum type. Meant to be a generic counterpart to tuples.
-
shared_vector
Reference counted vector data structure
-
elusion
modern DataFrame / Data Engineering / Data Analysis library that combines the familiarity of DataFrame operations (like those in PySpark, Pandas, and Polars) with the power of SQL query building…
-
nestac
access nested structures using path-like string format
-
gesha-collections
Collection utilities for the Gesha project
-
btree-slab
A memory compact Slab-based B-tree implementation
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
seq-map
Sequential Map
-
lru-st
A package providing a Vec based doubly linked list implementation and related data structures
-
roussillon-type-system
A type system for a programming language
-
pfds
Purely Functional Data Structures
-
doubloon
Money datatype that supports both statically and dynamically typed currencies
-
rust_flightweather
Decodes METAR and TAF
-
ipld-dagpb
IPLD DAG-PB codec
-
psrutils
few utilities to facilitate pulsar science projects in rust
-
segtri
Segment tree with customizable data type and update operations
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
ndarray-histogram
Histogram support for n-dimensional arrays
-
stac
SpatioTemporal Asset Catalog (STAC) specification
-
bose_einstein
A data structure that efficiently partitions elements into two sets
-
parallel_frontier
Queue-like frontier for breath-first visits on graphs that supports constant-time concurrent pushes and parallel iteration
-
rust_multistack
Support for two-dimentional stacks for the Rust programming language
-
general_stable_vec
A Vec implementation with stable indices
-
implies
A parser for logical formulas
-
sets_multisets
API for working with sets and multisets of elements of type usize
-
engcon
macros to define (eng)ineering (con)tracts on data-structure level
-
rand-select
a tiny choice selector
-
basic_trie
Trie implementation in Rust
-
bv
Bit-vectors and bit-slices
-
mmdb
A std-collection-like database
-
data_registry
An unordered data structure with immediate insertion, removal and access
-
pipebuf
Efficient byte-stream pipe buffer
-
strict
collections with strict bounds
-
anymap2
A safe and convenient store for one value of each type
-
chinese-rand
Random generation of data structures in Chinese, using Rust
-
leetcode-trees-rs
Tree Node LeetCode problems
-
vortex-bytebool
Vortex byte-boolean array
-
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.
-
fit-rust
designed for reading, writing, and merging FIT protocol files
-
taskchain
A block-based, non-circular double-linked list implementation for Rust
-
threshold
data structures
-
idbag
A bag of integers
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
yrs_tree
implementing a CRDT-based tree data structure powered by Yrs
-
try_reserve
Stable implementation of the TryReserveError from std for custom collections
-
swamp-script-source-map-lookup
Source map lookup for Swamp
-
arraystring
Fixed capacity stack based generic string
-
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
merkle_light
Light merkle tree implementation with SPV support and dependency agnostic
-
identified_vec
Like HashSet but retaining INSERTION order and without
Hashrequirement on the Element type -
walker-extras
Additional functionality for SBOM and CSAF walker
-
dynarg
mechanism for dynamic robust argument handling
-
smooth-json
opinionated, customizable utility to flatten serde_json Value variants into serde_json Objects ready for use in columnar or table-like usages
-
sharded
Safe, fast, and obvious concurrent collections
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
solvent
Dependency Resolver library
-
deepmesa
fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
mco-gen
Stackfull Generator Library in Rust
-
identity_map
Identity-based maps
-
freyr
A UI component library for Dioxus web
-
qutee
A quadtree implementation
-
scope-cell
temporary, scope-bound, and thread-safe mutation of data in Rust
-
cacheline-ef
Per-cacheline encoding of sorted integer sequences
-
astrie
High-performance hybrid data structure that combines the benefits of tries and B+ trees to provide efficient key-value storage with adaptive behavior based on data patterns
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
snowflake-ng
Dead easy and high performance
snowflakeimplemented in Rust -
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…
-
plane-2d
Continuous 2D data structure representing infinite 2d plane
-
lox
Fast polygon mesh library with different data structures and traits to abstract over those
-
skiplist
in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
float16
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
samling-clorinde
Database queries etc for the
samlingcrate -
gridly
managing fixed-size 2D spaces
-
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
closed-interval-set
Unions of closed intervals as containers of pairs
-
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
-
ascent-byods-rels
data structures for Ascent relations, made possible by Ascent's BYODS feature
-
atree
An arena based tree structure with removal support
-
the-zipper
zipper is a data structure that allows you to traverse and modify a tree-like structure efficiently. It provides a way to navigate through the tree while keeping track of the context…
-
nb-tree
Very simple tree structure with generic node and branch data
-
mutcursor
Safely stores mutable references to parent nodes, for backtracking during traversal of tree & graph structures
-
aliasable
Basic aliasable (non unique pointer) types
-
lru-mem
An LRU cache implementation bounded by memory
-
smodel
Symbol semantic modeling for Rust
-
disjoint-sets
Three union-find implementations
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
rb_tree
A Red Black Tree implementation in Rust
-
cow_hashmap
Hashmap with copy-on-write semantics that requires no locks
-
once-list2
A single linked list which is backed by
OnceCell. You can append the value to the non-mutableOnceList. -
dequemap
A no_std compatible implementation of the dequemap crate
-
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.
-
usize-set
Set data structures optimized to store sparsely distributed usize values
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
map-macro
Declarative macros for statically initializing collections
-
extindex
Persisted immutable index
-
pi_sinfo
used to describe the 'structure', that is, the meta information of the structure
-
blf_lib-derivable
Shared traits used by blf_lib and blf_lib-derive
-
irange
A data structure to store and manipulate ranges of integers with set operations
-
delta-collections
Data structures with revertable operations called deltas
-
spart
A collection of space partitioning tree data structures for Rust
-
hora-id
A 64-bit time-based sorted unique ID generator that includes the current time in the ID
-
pinned-deque
A high-performance double-ended queue, inspired by BOOST deque. Every element in this deque is pinned until its popping
-
linkedin-csv
Structs defined to hold the data as exported from LinkedIn
-
clubcard
exact membership query filter for static sets
-
lesbar
String types that must encode legible text
-
c_vec
Structures to wrap C arrays
-
nlist
inline-allocated list with statically tracked length
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
gapbuf
Generic gap buffer
-
rand_pool
Create a pool of random numbers pre generated thread safe
-
retaker
ecs implementation
-
lookupvec
Container with Vec-like properties that also offers O(1) lookup of items based on an id field
-
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… -
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
stable-map
A hash map with temporarily stable indices
-
snix-castore
Modular functional package manager
-
hydroperfox-smodel
Semantic modeling for Rust
-
lignin
A virtual DOM structure, primarily for web use
-
cbsk_socket
socket callback tool
-
a-tree
A dynamic data structure for efficiently indexing arbitrary boolean expressions
-
sigmars
sigmahq rule collections
-
host-port-pair
Host-port pair type
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
mset
/ multiset / bag implementation
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
bitvector
in Rust
-
iterable
collection like types
-
retworkx
A python graph library implemented in Rust
-
differential-dataflow-master
An incremental data-parallel dataflow platform
-
whale
A lock-free, dependency-tracking primitive for incremental computation
-
bit-int
An arbitrary fixed bit-width integer library
-
untis
accessing the Untis API
-
micromap-rawl
Fork of Micromap https://github.com/yegor256/micromap, the fastest alternative to HashMap, for maps smaller than 20 keys
-
iterlist
Linked list with a cursor based api
-
bin-it
efficient Rust library for binary serialization and deserialization
-
akita
Mini orm for rust
-
dsa_abc
basic data structure and algorithms. Usability and performance is priority
-
sortedlist-rs
A fast sorted list data structure in rust
-
orx-tree
A beautiful tree 🌳 with convenient and efficient growth, mutation and traversal features
-
microkelvin
tree traversal over annotated data structures
-
ksq
k-2 tree
-
splay-safe-rs
Splay implemented with safe rust
-
frozen-collections
Fast partially-immutable collections
-
beat_saber_map
Read and write Beat Saber maps with Rust
-
reusing-vec
Wrapper over Vec that allows elements to be reused without dropping them
-
beach_map
slotmap
-
fixed_deque
A fixed size VecDeque to match Python Deque
-
atomic_ptr_cell
Safe no_std repr(transparent) wrapper for AtomicPtr and &AtomicPtr with an api similar to a cell
-
onebuck
An efficient unordered dynamically-sized data structure
-
gtfs-geojson
converter for GTFS to GeoJSON formats
-
named_colors
that provides named colors in RGB and Hexadecimal formats
-
openligadb
API
-
loc_api
interact with the loc.gov API
-
blas-array2
Parameter-optional BLAS wrapper by ndarray::Array (Ix1 or Ix2)
-
libwebnovel-storage
A complement to libwebnovel: this package handles downloading and organizing collections of followed webnovels
-
fastset
Fast set implementation for dense, bounded integer collections, optimized for quick updates and access
-
nid
Generate and parse Nano IDs
-
foyer-intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
regroup
regrouping arrays
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
data-source
that fetches data from different sources
-
array_list
A dynamic container that combines the characteristics of a Vec and a LinkedList
-
sweetrpg-kv-objects
Objects for Key-value store
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
mikel_binary_tree
search binary tree implementation
-
collections-futures
working with futures through collections types
-
arraysetcell
A fixed-capacity, vector-like array with interior mutability and no ordering guarantees
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
kn0sys_ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
sequential
A configurable sequential number generator
-
enid
parse Encrypted Numeric Identifiers
-
enum-table
creating tables with enums as key
-
pineappl
not an extension of APPLgrid
-
expiremap
Key-Value map where each value has a custom expiry time
-
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.
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
osmgraph
Convert OSM queries into graphs
-
floating_bar
Representing rational numbers using the floating-bar number type
-
id_collections
Index-oriented programming in Rust
-
opt_struct
Optional collections
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
cve
Mappings for parsing the CVE JSON files
-
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
-
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
-
string_manipulation_utf8
String manipulation functions using character indexing (UTF-8) instead of bytes
-
disk-ringbuffer
lock free on disk ringbuffer to be used in the implementation of Franz
-
nimbusqueue
fifo collection
-
bytering
A ring buffer specialized for vectored reading and writing in blocking and async I/O
-
orx-selfref-col
SelfRefCol is a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees
-
trie-root
In-memory patricia trie operations
-
suff_collections
Fast realization of suffix array and suffix tree
-
libnv
Safe and rustic wrapper around libnv-sys
-
tagged-vec
A Vec which can be indexed by one specific type
-
trk-io
TrackVis (*.trk) reader and writer
-
merkle-log
"Merkle Tree-Structured Log" defined in the paper "Transparent Logs for Skeptical Clients." https://research.swtch.com/tlog
-
thin-string
A String with a smaller stack footprint
-
fast-ordered-buffer
A faster buffering implementation for asynchronous streams, trading off memory usage for speed
-
rangetools
Extending the Rust Range structs found in std::ops
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
cbsk_base
locked version cargo crates
-
open-payments-fednow
Open Payments - Message Parsing Library - FedNow
-
skiplist-rust
A lockless skiplist implementation in Rust
-
merkle-heapless
Statically-allocated Merkle Tree and Mountain Range
-
contexts
Implements a type for treating several hashmaps as one
-
rdf-format
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
bitvek
bit vector implementation
-
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.
-
phf_macros
Macros to generate types in the phf crate
-
bool_vec
A crates that exposes a vector called BoolVec which allows you to store a boolean in a single bit
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
eastl-rs
EASTL binary-compatible Rust implementations
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
fibonacci_heap
A Fibonacci Heap implementation in Rust
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
linum
An open-source 2D-, and 3D-Vector Library
-
rust-tls-duplex-stream
Full Duplex stream Wrapper around rust-tls
-
indexed_json
Index json files like a database
-
text-style
Types and conversions for styled text
-
entity_data
A container for entity component data
-
gcollections
Generic traits over Rust collections library
-
extract_map
A HashMap for memory efficent storage of value types which contain their own keys
-
rsor
Reusable slice of references
-
hprtree
A Hilbert-Packed-R-Tree implementation for rust
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
rust_redux
A Redux-like state management library for Rust
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
data_tree
Hierarchical data tree with pathing and search support
-
firims
fixed range integer maps and sets
-
rocstr
An immutable fixed capacity stack based generic copy string
-
trie-hard
Fast implementation of trie data structure
-
hybridmap
Hybrid map using smallvec and the std hashmap
-
flammkuchen
Some data structures for fun and flammkuchen (e.g. a 2d grid which permits negative indices)
-
minivec
A version of Vec that's only the size of a single pointer
-
ztimer
A block-based, non-circular double-linked list implementation for Rust
-
sum
General-purpose sum types
-
vector
The package provides a vector database allowing for efficient search of nearest neighbors
-
ux-dataflow
Data Processing Library
-
rs-bush
Bush data structure
-
expiringdict
A dict / HashMap whose items expire over time
-
compt
A complete binary tree visitor library
-
commitlog
Sequential, disk-backed commit log library
-
geosite-rs
that parses geosite.dat file format
-
circbuf
A growable circular buffer for working with bytes
-
bytes_deque
A growable bytes deque in Rust, providing access to the raw pointer
-
tiled_parse_tree
Tree data structure
-
foreign_vec
Unofficial implementation of Apache Arrow spec in safe Rust
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
tree-iter
iterating over tree structures
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
sapling-dag
DAG used for source control
-
flat-tree
Series of functions to map a binary tree to a list
-
packed-uints
Array of uints that scales from u4 to u32 to minimize wasted space while still being fast
-
access
that helps creating diverse accessors
-
sortedvec
a sorted vector that enables quick lookups
-
tensorism
Multidimensional arrays with bounds included in the type system
-
cfpyo3_rs_core
a collection of performant utilities
-
HArcMut
mutable arc
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
ordered_hash_map
HashMap which preserves insertion order
-
dcl_data_structures
Data structures for for deep_causality crate
-
ware
middleware chains
-
div-int
Rational numbers with a compile-time denominator
-
horizon_data_types
The Horizon data types library for third-party integrations
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
rangeset
Integer collection backed by ranges with set operation support
-
flat_enum
Expand nested enum into flattened enum
-
ostr
Owned str
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
omango-util
Utililites
-
bloom-filter-yss
bloom filter for me or you
-
pas
strided slice
-
arrayset
An array-backed ordered set type
-
equivalent-flipped
Similar to
equivalentcrate, but flipsKandQ -
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
vecdeque-stableix
Deque with stable index values
-
rtdlib
TDLib for rust
-
safe_index
Type-safe indexes
-
cses-rs
A CSES spec impl in Rust
-
binn-ir
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
akshually
Smart Boys
-
unnamed_entity
Strongly-typed indexing for vectors and other structures
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
point-nd
flexible no-std struct to model points on axes of any dimensions
-
grangers
working with genomic ranges and annotations
-
luka
working with graphs
-
pbloom
A portable bloom filter implementation in Rust
-
modern-multiset
A hash multiset implementation
-
simple-file-manifest
Interact with lists of files through a storage-agnostic interface
-
bk-tree
A Rust BK-tree implementation
-
concurrent-bloom-rs
thread-safe bloom filter
-
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
radyx
A basic radix tree implementation
-
slablit
Literal for slab creation
-
aircraft_icao_country
aircraft ICAO codes and their country of origin
-
hyper-tree
Quadtrees and Octrees generalized to any dimension and type
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
lodtree
help create octrees and quadtrees for chunked level of detail
-
median-accumulator
fast, space-efficient, generic accumulator for computing median
-
cistring
A string type that preserve case, but compares insensitiveley
-
arraylist
wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
lsmtree
Implements a Sparse Merkle tree for a key-value store. The tree implements the same optimisations specified in the libra whitepaper, to reduce the number of hash operations required per tree operation to O(k)…
-
ux-dx
3D Graphics Primitives for Angular Rust
-
qmc
Quantum Monte Carlo simulations in Rust
-
set_genome
A genetic data structure for neuroevolution algorithms
-
espalier
Very simple flattened tree structure
-
radix-heap
Fast monotone priority queues
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
value-ext
Serde Json Value Extension Trait (more Value type later)
-
qust-ds
a part of crate qust
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
parallel_vec
A generic contiguous collection of heterogenous values
-
markov-generator
Highly customizable library for building Markov chains and generating random data
-
ref_kind
Different reference kinds
-
gamma
Graph primitives and traversals for Rust
-
fenwick
tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
nary_tree
A vec-backed tree structure with tree-specific generational indexes
-
malwaredb-api
Common API endpoints and data types for MalwareDB components
-
panoradix
A generic map and a set, both backed by a Radix tree
-
pvec
RRB-Tree based persistent vector implementation
-
prepona
A graph crate with simplicity in mind
-
vise-exporter
Prometheus exporter for metrics defined using
vise -
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
ultragraph
Hypergraph data structure
-
contack
easy contact library
-
compressed-intvec
A compressed integer vector with fast random access that stores values with instantaneous codes in a bitstream
-
py_env
A wrapper for Python commands to easily install dependencies and run Python scripts in an optionally impersistent environment
-
rexsgdata
Scatter-Gather Data Descriptors
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
pi_slotmap_tree
A tree structure implemented by dense memory linked list
-
box-collections
A no_std compatible implementation of the collection crate
-
moka-cht
Lock-free resizeable concurrent hash table
-
rubbl_visdata
Preliminary work on generic data structures for radio interferometric visibility data
-
validiter
Iterator adapters for validating iterations
-
contigious-tree
Write and read tree graphs to and from contigious blocks of memory
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
chunked_vec
A vector-like data structure that stores elements in fixed-size chunks for better memory management
-
segment-tree
Quickly perform interval queries or modifications
-
higher
Functors, Applicatives, Monads and other bad ideas
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
constructivism
Simplify the construction of structured data
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
queue-queue
A priority queue implementation based on Rust's BinaryHeap
-
xskiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
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!
-
vec_extract_if_polyfill
Polyfill for Vec::extract_if
-
redmaple
offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
rspack_collections
rspack collections
-
iowrap
Small helpers for using io::Read/io::Write
-
bitpack-vec
A vector for arbitrary bitwidth integers, densely packed
-
advancedresearch-tree_mem_sort
An in-memory topological sort algorithm for trees based on Group Theory
-
string-hash-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
coca
Data structures with constant capacity
-
easy-xml
An XML library
-
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
-
enum_meta
Add metadata to Enum Variants
-
im-pathtree
Immutable, path-addressable tree data structure
-
shortguid
Short URL-safe Base64 encoded UUIDs
-
jsonmap
store values of multiple types value in one Map
-
merkle-tree-bulletin-board
A public bulletin board based upon Merkle trees
-
precedence-net
Create and analyse precedence networks
-
linked-list
An alternative implementation of std::collections::LinkedList
-
netcrab
creating and exporting Petri nets
-
sweetrpg-model-core
Core model definitions for SweetRPG
-
ntree-rs
A mutable n-tree with async support
-
indexedlinkedhashmap
An indexable LinkedHashMap. The user defines the data structure that controls order.
-
gen_value
indexes and values with generations for vectors
-
rive
ecosystem crate
-
structured
Data structures to handle large, structured data
-
serde_map
Mapbased onVecfor serialization purposes -
ladata
& modular data model
-
rtree_rs
R-tree for Rust
-
res
build-script dependency for managing your project's resources
-
aph_disjoint_set
Disjoint set implementation with optimized memory usage and ability to detach elements
-
hashbrown_tstd
port of Google's SwissTable hash map
-
ndstruct
Structures for N-dimensions
-
stacked-set
Set interface, allowing stack-only implementations
-
rust_airport_supplier
Rust-AirportSupplier downloads airport data from OurAirports and decodes the information
-
lockerroom
Readers-writer access to individual cells of your collection!
-
handlemap
A collection that produces handles that can be used as keys to retrieve the stored items
-
sparse_set_container
A container based on sparse set. Stable keys, O(1) lookup, cache-friendly iterations, and no hashing.
-
cola-crdt
A text CRDT for real-time collaborative editing
-
char_index
efficient charwise indexing into a string
-
index-ext
Index slices with arbitrary ints and as arrays
-
entity
that provides entity-like constructs
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
fwdlist
A simply linked (forward) list
-
roers
prepare augmented annotations for single-cell RNA-seq analysis
-
idmap
Efficient maps of integer id keys to values, backed by an underlying
Vec -
boolvec
A vector of boolean stored contiguously in memory
-
grid-tree
Pixel quadtrees and voxel octrees
-
broomdog
A type-erased map with 'indefinite loanership'
-
range_bounds_map
[
RangeBoundsMap] and [RangeBoundsSet], Data Structures for storing non-overlapping intervals based of [BTreeMap] -
hinted
small crate for providing a size hint and exact size on an iterator
-
dashmap-shard
port of Google's SwissTable hash map
-
fenwick-bit-tree
Slighly over-engineered FenwickTree implmentation
-
charcoal
Implements tree data structures and interfaces to work with them
-
mapack
mapbox vector tiles
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
segvec
data structure for rust. Similar to Vec, but allocates memory in chunks of increasing size
-
char-list
A persistent string type with the same API as a linked-list of characters
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
interval-rbtree
An interval tree implementation using Red-Black Tree as its underlying data structure
-
range_map_vec
range map data structure backed by a Vec
-
semver-eq
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
gsgdt
Generic Stringly Typed Graph Datatype
-
query-flow
A macro-free, data-oriented, general-purpose library for incremental, on-demand, self-adjusting computation using query-based dataflow
-
union-fn
Proc. macro for creating efficient "inline closures".
-
merkle
tree implementation with support for generation of inclusion proofs
-
bnr-xfs
Pure Rust implementation of the BNR XFS USB
-
cbsk_log
log tool
-
rj
reactive json
-
zngur-def
Data types that define the structure of a zng file
-
write_x86_64
help you write x86_64 assembly code
-
total-maps
Maps where every possible key has an associated value
-
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…
-
indexlist1
A doubly linked list, backed by a vector
-
chainbuf
Fast chained buffers
-
ndshape
fast linearization of N-dimensional array indices
-
content-tree
An efficient data structure for compacted RLE data
-
vec-btree-map
Basically just a sorted Vec that can be used as a HashMap
-
membuffer
A very fast flat memory buffer used to deserialize at a fast speed
-
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 -
messaging
two-way messaging crate
-
objectionable
storage of unsized types inline inside allocated objects
-
onigiri
handling chars
-
lanyard
UTF-8 C string types
-
art-tree
The Adaptive Radix Tree
-
zhifeng_impl_barnes_hut_tree
implements Barns-Hut Tree for accelerated N-body force calculation
-
uintx
Unaligned unsigned integers with exact size in memory and arithmetic operations for them
-
proptest-recurse
Helper for defining mutually recursive strategies with proptest
-
ttmap
Trivial implementation of type map
-
indexed_vec
IndexVecfromlibrustc_data_structures -
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
btreemultimap
A multimap implementation with range support
-
small-world-rs
The easiest HNSW vector index you'll ever use
-
wolf-derivation-graph
Adds support for memoizing data flow graphs to wolf-graph
-
range_union_find
A union-find data structure for ranges
-
emap
A map with a fixed capacity and integers as keys
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
appendlist
An append-only list that preserves references to its elements
-
object-collection
A collection that can store multiple values of types
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
type-rules
easily constrain a struct
-
reactive-signals
dx-first scope-based fine-grained reactive system
-
lazy-cow
Copy-on-write pointers with lazy modification support to minimise clones with a cost counter to limit work duplication
-
smallbitset
series of allocation free sets capable of holding small integer values
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
heapix
providing heap data structures
-
vp-avl
A combined Vantage-Point AVL tree, to make VP trees updateable
-
cphf
Compile-time perfect hash function data structures
-
tord
Data structure to store transitive relations
-
recursion-visualize
visualized cache-aware stack safe recursion
-
limq
Queue with a controller for monitoring queue elements
-
enumoid
Enum Indexed Containers
-
singletonThread
thread in a singleton
-
bdaddr
Bluetooth Device Address
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
varlen
Ergonomic variable-length types
-
large_int
An ease-of-use unbounded signed integer
-
ndim
N-dimensional array for numerals in Rust similar to NumPy
-
lr_trie
Left-Right trie is trie capable of mapping any string to any string
-
pi_vec_remain
vec remain range
-
word-dictionary
data structure for word mapping. It can be used for language translation.
-
magnetise
asses the similarity between SQL queries
-
fixed-collections
Dynamically allocated ungrowable collections
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
surface-grid
providing data structures for square-tiled grids wrapped around the surface of certain objects
-
alist
Association list offering fast lookups while preserving insertion order
-
automap
pattern to implement key-value maps where the value type contains the key type
-
heapq
Priority Queue with scoring function
-
value_pool
implements a ValuePool struct that makes the creation of self-referential data structures easier and safer
-
rdf-writer
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
inplace-vec-builder
Build a vec from a vec, in place
-
froop
A functional reactive stream library for rust
-
holyhashmap
A hash map with stable indices
-
groupex
Syncronization primitive that allows acquire lock by index
-
fenny
working with Fenwick trees
-
slas
Static Linear Algebra System
-
hash-rings
Implementations of various hash rings
-
intervals-rs
intervals
-
llist
Lisp-style singly-linked list
-
alignment-exporter
Proc macro providing alignment info for a user-defined struct
-
mori
orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
histogram-sampler
Sampling from a distribution given by a histogram
-
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
seadawg
that implements the online algorithm for Direct Acyclic Word Graph (DAWG) and Compact Direct Acyclic Word Graph (CDAWG)
-
artie_common
Common Library for Artie Rust Projects
-
memvec
Memory-backed vector, not buffer. Designed for for mmap. Not MemMap, but MemVec!
-
vecset
A vector-based sorted map, set and keyed-set implementation
-
two-sided-vec
Double ended vectors for rust, which can grow in both the front and back
-
indexmap-rmw
hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
designal
Procedural macro for use with futures-signals
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
wolf-graph
Data structures and algorithms for working with graphs with reference or value semantics
-
vicardi
JSON VCardArray Generator that uses Serde
-
b-tree
A persistent B+ tree using freqfs
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
fallback
A helper library to implement fallback mechaism
-
solomondb
An embedded and distributed Gremlin-compatible graph database
-
linear_collections
Map and Set types backed by linear data structures
-
minsize
Collections with a statically known minimum size (using const generics)
-
oxidd-test-utils
Test utilities for OxiDD
-
dsalgo
A package for Datastructures and Algorithms
-
generic-btree
Generic BTree for versatile purposes
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
raw-btree
Generic B-Tree implementation
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
graphlib
powerful rust library for the graph data-structure
-
vecshard
Split Vecs in constant time
-
xsparseset
sparse set
-
sliding_tree
A tree that grows from the leaves and recedes from the root
-
aligned-utils
Common utilities to work with aligned values and allocation
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
numas
multidimensional array for efficient computing
-
utf8char
that supplies a utf8 encoded char
-
prefix-tree-rs
A Trie (prefix tree) implementation
-
rust_twostack
Support for two-dimentional stacks for the Rust programming language
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
tree_by_path
A tree data structure featuring nodes addressable using a &Vec<usize> path and avoiding recursion and run-time borrow checking
-
async-func
providing macros to simplify the creation of asynchronous closures with external state captured by move. Useful for structuring asynchronous code with ease and clarity.
-
text-document
Text document structure and management
-
expiringmap
a HashMap-backed TTL map
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
fast_collections
noheap zero copy collections
-
sql-json-path
SQL/JSON Path implementation in Rust
-
fibis
fixed range bitset
-
idata
Small tools to reduce mutability
-
bitvec_simd
bitvec with SIMD
-
btree-ondisk
BTree structure on persistent storage in userspace
-
valord-map
A dictionary sorted by values
-
eventree
creating lossless syntax trees
-
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.
-
rustz
functional programming in Rust
-
grdf
Generalized RDF graphs and datasets
-
bitlab
Extracting a range of bits from a binary data source
-
granite
Generic backing storage framework for building data structures
-
sbom-walker
work with SBOM data
-
timely_container
Container abstractions for Timely
-
fluentbit
build output plugins for Fluent-bit
-
croaring-sys
Raw bindings to CRoaring
-
wolf-graph-mermaid
Adds support for generating Mermaid diagrams from wolf-graph graphs
-
loaned
Safely move values with live inner borrows
-
dirbuf
reusable directory bufferes
-
ahtable
Array Hash Table implementation
-
willowtree
Lazily evaluated trees
-
construe
Compile-Time Growable Array: Vec & String for const!
-
bubbletree
Bubble-tree
-
schema2struct
Convert a JSON schema into Rust structs for efficient and type-safe data management
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections
-
win-variant
that aims to provide a more ergonomic way of working with variants in winapi based projects
-
lurk-elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
simple-triplestore
graph database for storing triples with support for custom node and edge properties
-
dynp
Dynamic property system that emphasizes the use of the Newtype pattern
-
brownstone
building fixed-size arrays
-
astack
offers a Stack data structure with fixed capacity capable of fast LIFO operations
-
enso-data
A collection of useful data structures
-
lumberjack
Read and modify constituency trees
-
rb-interval-map
rb-interval-mapis a map based on interval tree -
get-full-year
An unofficial Rust client for getfullyear.com that helps you get the full year
-
mzdata-spectra
A subset of
mzdata’s traits and spectrum data model -
tree-rizzen-yazston
Tree Library using the Any trait for data
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
pna
PNA(Portable-Network-Archive) decoding and encoding library
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
rose_tree
An indexable tree data structure with a variable and unbounded number of branches per node. It is Implemented on top of petgraph's Graph data structure and attempts to follow similar conventions where suitable.
-
wccg-models
WCCG Data
-
traiter
Traits collection
-
detach
helper type for being able to detach/reatach a member item
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
indextreemap
A BTreeMap implementation that allows for key and or positional insertion and retreival
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
swaybar-types
building swaybar status commands in rust
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
double-map
A HashMap with double key to single data/value
-
bravery_router
Radix Tree implementation
-
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
siraph
A node-based digital signal processing crate
-
tinyvec_string
tinyvec based string types
-
awid
Small, simple, universally unique identifiers
-
overtone
An API for creation and management of rich (as in rich-text) musical-ish projects
-
flatarray
Fast implementation of SeqEval, a sequence evaluation framework
-
nutype
The newtype with guarantees
-
noindexmap
hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
rosary
About Rose Trees
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
patricia_router
Radix Tree implementation for Rust
-
ahtml
An HTML templating and manipulation library
-
collectable
Fallible, no_std-friendly collection traits
-
slice-rbtree
A slice-based Red-black tree
-
twovec
A data structure for storing 2 types of data in a packed, heap allocated array
-
fixed-index-vec
A vector-like data structure whose indices do not change when elements are removed
-
truncate-integer
Truncate integers
-
v9
A slim data engine for Data Oriented Design
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
wildfly_container_versions
WildFly container versions
-
twounordered
two vec-like vecs backed by a single vec and provides retain_mut_unordered()
-
stringid
Lightweight system to manage identifier as human readable string and unique number
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
bstree-file-readonly
Query read-only binary-search tree file, supporting billions of entries in files of tens of GB
-
chainmap
mutability of intermediate maps
-
uniquevec
A
Vec-like datastructure which only contains unique entries. It is no_std and has optional serde support. -
wacky_traits
Defines some traits
-
tinybuf
Container for many types of immutable bytes, with optimisations for small arrays
-
ecstatic
Statically-typed ECS library
-
latestmap
latest map
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
genindex
Generational index library
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
chesspos
Basic structs for representing chess squares
-
to-offset
developer-friendly methods to manipulate strings with character indices
-
implhm
Simplified library of collision-handling HashMaps
-
dayendar
advanced days calendar operations
-
dendron
Generic tree data structure
-
fixedvec
A heapless version of the Rust vector type
-
ldpc
A toolbox for classical and quantum LDPC codes
-
Sparse-Voxel-64Tree
A lib for handling Sparse Voxel Contrees
-
boxing
cross-platform implementations for NaN and ptr boxes
-
chain-map
A chain of maps with a single view into the aggregated values
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
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
-
modifier
Fluid chaining APIs for both mutable ownership types
-
partial-array
potentially partially-filled arrays
-
timer_list
A list of timed events that will be triggered sequentially when the timer expires
-
indexland
Rust Collections with Newtype Indices
-
sorbus
A tree manipulation library
-
swamp-analyzer
analyzer for swamp
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
lluvia
A stripped down Entity Component System that allows for no-nonsense data storage in finite time
-
open-payments-iso20022-reda
Open Payments - Message Parsing Library - ISO20022 REDA
-
civs
Controllably Increasing/Inflating VectorS
-
make-message-bus
Generate a pub-sub bus for use in async applications
-
limited-queue
a limited queue that overrides the oldest data if trying to push a data when the queue is full
-
sycamore-state-core
sycamore-state core types and trait definitions
-
corresponding
Move corresponding fields between structs
-
compare
Experimental comparators for collections to be generic over
-
applejack
Radix tree
-
many-to-many
creating many-to-many data structures with the ability to query either side, useful for applications such as pubsub. Like a fusion between
bimapandmultimap. -
mashmap
A flat HashMap that supports multiple entries per key
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
serde_either
set to enums to deserialize and serialize data that can either be string, struct or vec
-
enum-tag
Proc. macro for generating enum discriminant types.
-
seg-tree
segment tree library
-
bufferring
Ring buffers for Rust
-
traitgraph
Abstracting over different graph representations
-
bktree
BK-tree datastructure
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
bufferbuffer
Double Buffer design pattern from 'Game Programming Patterns' by Robert Nystrom
-
spaceindex
-
klingt
audio graph library?
-
granular-id
ID numbers with arbitrary precision
-
task-collection
Types for managing and waiting on groups of tasks
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
sid_vec
Tiny library providing id types and an id-based vector
-
isomorphism
2 directional hashmaps
-
smallobjectpool
A small object pool for Rust
-
purse
Bag data structure implementation in Rust
-
myopic
A possibly bad lens library for Rust
-
periodic-rs
Bounded datastructures
-
pi_densevec
重定向映射表，一个使用usize作为key的映射表
-
baz-tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
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
-
const_array_map
A const-capable Map type backed by a static array
-
pointcloud
An accessor layer for goko
-
tree-graphviz
Generate GraphViz DOT directed trees, based on an arbitrary tree structure
-
flat_collections
Lightweight and memory-efficient associative data structures
-
keylist
Elixir keyword list in Rust
-
minimizer-queue
Fast computation of minimizers using a monotone queue
-
front-vec
Efficiently-prependable Vec and String types
-
singletonset
SingletonSetdata structure, which makes it easy to store a single instance each of various types within a single set -
collection_literals
macros for initializing std::collections
-
auto_vec
Vec that automatically remove the child when the child is being dropped
-
cdl-list-rs
A circular doubly linked list implementation using Rc<T> and RefCell<T>
-
iter-set
Set operations on sorted, deduplicated iterators
-
dot_tree
Create, query and store binary trees
-
merkle-lite
fast, and composable binary Merkle tree and proof for Rust Crypto hash functions
-
fns
add common fn, eg: debounce, throttle
-
statemachine-rs
A statemachine crate which have zero dependencies
-
workit
single-threaded work queueing utility
-
segmap
Map and set data structures whose keys are stored as ranges. Contiguous and overlapping ranges that map to the same value are coalesced into a single range. Originated as a fork of Jeff Parsons' "rangemap"
-
vecbool
bit vector built on top of Vec<u8>
-
dynamic_dict
A lightweight basic crate to create dynamically typed dictionaries
-
extended-rational
implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
sbox
Tiny Linux containers implementation
-
vec_arith
Powerful vector/matrix arithmetic library written in Rust
-
cbloom
Concurrent implementation of Bloom filters
-
pokeapi-model
Data structures for PokéAPI v2
-
rcbytes
Rc version bytes crate
-
treeflection
that provides reflection for tree structures
-
vec_key_value_pair
A drop-in replacement for std::HashMap and std::HashSet that use Vec on the backend
-
luthor
A collection of lexers for various languages/formats, and the tools required to build them
-
lending-library
A key-value store that loans full ownership of items
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
tilecoding
Dr. Richard S. Sutton's tile coding software.
-
graphannis-core
supports graph representation and generic query-functionality
-
erased_set
A set of erased types
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
slotgraph
Graph implementation built with slotmap and petgraph
-
polystore
Polymorphic data store
-
tyght-map
A static type map implementation
-
hgg
Approximate nearest neighbor search collection
-
clash_rules
a clash yaml rule parser and matching algorithms provider
-
output_iter
An iterator that performs calculation during iteration
-
upair
Unordered pair data structure
-
whirlybird
generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
ipld-core
IPLD core types
-
dyn-slice
&dyn [Trait] implementation, inspired by a Reddit thread
-
open-coroutine-timer
The time utils
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
core_collections
copy of libstd::collections with all the parts that don't work in core removed. Most importantly, it provides HashMap and HashSet. This crate is (mostly) automatically generated from the rust git source…
-
stac-extensions
Manage STAC extensions (https://stac-extensions.github.io/)
-
fenwick-tree
binary indexed tree (Fenwick tree) data structure in Rust
-
fxd
Fixed-point decimal implementation
-
eki
solver for steady and transient flow in fluid networks
-
linear-map
A map implemented by searching linearly in a vector
-
tcgeneric
Generic data types used internally by TinyChain
-
pciids
parse the pci.ids data file
-
modupipe
A modular and extensible ETL-like pipeline builder
-
lockfree-cuckoohash
lockfree cuckoo hashmap
-
rahashmap
Fork of standard library HashMap with additional functionality
-
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.
-
analytic
has been renamed to be the math crate https://crates.io/crates/math
-
cds
Collection of Optimized Data Structures
-
weak-map
BTreeMap with weak references
-
retrace
Safe, generic rollback log with predictable latency
-
genmap
generational map data structure with no dependencies
-
treers
Sedgewick's tree maps
-
hedge
An index based half-edge mesh implementation
-
dynamic-list
A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
-
spatialize
collection of spatial data structures used for efficent spatial partitioning
-
fast-list
A doubly linked list using SlotMap for improved cache locality, and to solve the ABA problem
-
default-vec2
Vec-like data structure with default elements and a bitset built using it -
cpp_map
C++ std::map emulator
-
sweeper
A foundation for Minesweeper implementations in Rust
-
elastic_hash_rs
Elastic Hashing from Optimal Bounds for Open Addressing without Reordering
-
mqfilters
Highly optimized approximate membership query filters (bloom, cuckoo, xor, quotient) with SIMD support
-
graphrepresentations
providing efficient abstract implementations of different graph representations
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
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…
-
know
Framework for Rust
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
non_empty_continuous
Non-empty continuous collections
-
actions
Software without side-effects. Redo and Undo. Macro's.
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
distant-protocol
Protocol library for distant, providing data structures used between the client and server
-
rs-collections
generic collections (no dependency on std)
-
hayami
general use symbol table
-
zsling
Rust Wrapper around a Sequentially lockign (SeqLock) Ring Buffer written in Zig
-
wildland-catlib
Wildland Catalog Library client
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
trey
Writing V3000 CTfiles
-
web-glitz-buffer-vec
Implements growing WebGlitz memory buffers for slices of data
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
light-id
Generate and manipulate incremental IDs effortlessly
-
partial_const
way to handle constant and non-constant values in a unified way
-
seq-set
A Set collection that maintains insertion order
-
generic_event_queue
generic event-queue API
-
syntastic
Generic abstract syntax representation
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
simple-vec-collections
Collections implemented using Vec
-
pq-tree
consecutive ones property (C1P) and graph planarity testing
-
ndcopy
Fast N-dimensional array memcpy
-
arc-atomic
atomic pointer to an
Arc -
splay
native implementation of a Splay Tree for Rust. Splay Trees are self-balancing binary search trees which adapt dynamically to lookups over time to allow common access patterns to frequently have better than log(n)…
-
treentern
An interning library that makes it easy to intern tree like types
-
btreec
Rust bindings for btree.c
-
nonempty-containers
Fast, zero-cost conversion, and fully inter-operable nonempty container types
-
no-order
A transparent wrapper to ignore ordering and hashing of any value
-
mergle
A data structure with fast merging and comparison
-
treelike
A trait to abstract over trees, and simplify implementing them, all in one handy crate
-
entoli
A functional programming library inspired by haskell
-
swamp-std
standard library for swamp
-
medianheap
A median heap for keeping track of a running median
-
zot
Option-like enums for working with ordered collections of zero, one, or two items (
Zot), or ordered collections of one or two items (Ot) -
diskmap
disk based HashMap-like for shared concurrent memory usage
-
rds-tensors
Rust Data Science Tensors crate
-
advanced_collections
advanced data structures (collections). Includes counter (hash-bag, multiset), disjoint set (union-find, merge-find), circular buffer (cyclic buffer) and interval (range)
-
redox_simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
cast-rs
A collection of types cast for Rust
-
multiset
Multisets/bags
-
rust_black_tree
Please don't use this in something serious lol
-
graphia
graph data structure
-
crio
An easy to use persistent data storage library
-
das-grid
2D grid library which serves as fundamental building block for any 2D game built on the concept of grid
-
dynstr
A string implementation optimized for manipulations
-
pfx
A prefix tree (map and set), implemented without any unsafe
-
simple-ref-fn
function wrappers that do not require virtual tables
-
igraph
A graph representation data structure with a built in index on keys
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
hashable_weak
A hashable weak pointer
-
statiki
Static friendly data structures
-
simple-undo
Easy to use undo-redo library
-
rpos
Cursor Manager on Table
-
processing_chain
set up processing chains of large amounts of data
-
object-chain
Ad-hoc structure builder
-
atomic_lifo
Lock free thread-safe lifo for rust
-
app_properties
reading application properties from a file
-
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII's gridd)
-
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits-sized unsigned integer elements -
mutcrab
written in rust that contains various classic data structures
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
unflatter
unflatteris a Rust library providing extension traits for flattening and unwrapping nested structures, including nestedOptionandResulttypes. It simplifies working with deeply… -
tinyid
A tiny ID type that's like UUID except shorter and easier for a user to type in
-
u64_array_bigints
biginteger library based on u64 arrays
-
circularbuf
Rust fixed size circular (ring) buffer
-
multi_containers
Ergonomically work with multiple values per key
-
persistent_hashmap
Persistent hashmap is a library for working with memory mapped hashmaps
-
hash_ring
Consistent Hashing library for Rust
-
optionee
The macro to create option struct easily
-
sparse-bitfield
Bitfield that allocates a series of small buffers
-
multipath
split file path, like
/home/{user,admin}/file.txt -
bengbenge
inifity array for round-robin dns, beng, beng
-
goodreads
deserializing a Goodreads library export
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
untyped_vec
A type-erased vector type for Rust
-
pinned_vec
Vec-like data structure whose elements never move
-
typed_graph
Staticly typed graph library
-
pareto_front
Builds a Pareto front incrementaly
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
index_many
A proof of concept for indexing an slice at multiple locations at once
-
parst
declarative parsing
-
nave
Thinking about the construction of distributed systems starting from the *consistent hash* algorithm
-
resizing-vec
An automatic resizing vector for data with linear increasing ids
-
queues
Efficient FIFO Queue data structures
-
ds-bst
Binary search tree implementation
-
shared-string
Split a string without another allocation
-
sequencetree
a new type of collection to store keys and their corresponding values
-
partial
Optional monad with fake variant
-
hyperbitbit
data structure
-
read-copy-update
locking primitive
-
inline-css
Embed CSS directly in your Rust code
-
collect-rs
Special and custom Collections and Containers (for Rust)
-
datastructures
A variety of data structures for learning purpose
-
kodiak-taxonomy
manage generic taxonomies supporting unique features
-
jirachi
A collision resistant runtime agnostic key-generator
-
list-any
Type erased slices and Vecs
-
mkargs
Build command arguments
-
ospf-rust-multiarray
A multi-array utils for ospf-rust
-
hdf5-hl
High level bindings to HDF5 High Level API
-
index-map
A map with automatically generated usizes as keys
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
libarena
Arena allocated graph implementation
-
recursive_array
arrays using recrusive data structures to avoid limitations of the rust compiler
-
leetcode-solutions
A collection of leetcode solution in rust
-
path-value
Universal type and access property(s) by path
-
valet
Stores your objects and gives you a tag to retrieve them later
-
aatree
in Rust
-
mind-tree
Organize your thoughts in a tree-like structure
-
collect_result
collecting an iterator of results into a result of a collection
-
smap
Simple-Map: HashMap for easy to use
-
tinymap
A map structure that stores its data on the stack
-
octree
algorithm for nearest neighbor search in 3D space
-
bitstring-trees
Trees based on bitstrings
-
ashscript-types
Types for Ashcript Game game and action states
-
search_trail
manager of variables that can save and restore their values
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
vec-option
A space optimized version of
Vec<Option<T>>that stores the discriminant seperately -
const_std_vec
const std vec
-
chrom
representing colours
-
wolf-graph-dot
Adds support for generating Graphviz DOT files from wolf-graph graphs
-
deviz
access to a VS Code extension for displaying structured program output
-
moonlight_collections
Collections for Rust
-
codemap2
maintained fork of the codemap crate that contains a data structure for efficiently storing source code position and span information (e.g. in a compiler AST), and mapping it back to file/line/column locations for error…
-
changed
change detection
-
anylist
a list type for any type
-
cbsk_log_tokio
log tool, using tokio as the runtime
-
opt_vec
A wrapper around Vec<Option<T> that makes deletion fast
-
multi_key_map
a hash table that shares one value across multiple keys
-
iunorm
Map normalized floating-point numbers to/from (un)signed integers
-
pac_cell
Parent and child cell
-
arc-bytes
A reference-counted byte buffer
-
bloom-filters
Rust port of https://github.com/tylertreat/BoomFilters
-
conlife
Backend-only implementation of Game of Life with minimal dependencies
-
tag-vec
A vector used for storing tags
-
slice-cell
A
Cell<[T]>-like mutable slice, that allows slice-like APIs -
cursed-collections
Collections that (seem to) break Rust safety
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
mrkl
Generic, minimalist, parallelizable Merkle tree
-
dyn_list
A linked list that can hold dynamically sized values in its nodes
-
treap_non_random
A non-randomized Treap implementation. Not very useful as a balanced tree, but useful when implementing CVM or similar algorithms.
-
spooles_ffi
Spooles C library FFI
-
rust_fixed_width
that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
realhydroper-smodel
Semantic modeling 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…
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
rive-models
Revolt API models for the Rive ecosystem
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
flats
flattens nested structures into a flat single dimension map
-
sliding_extrema
Queue data structure with support for an O(1) extrema function over contents (for example, to obtain min and max over a sliding window of samples)
-
ctxmap
A collection that can store references of different types and lifetimes
-
memorable
Lock-free, ordered and multiple version memory table for key-value databases
-
tea-core
Core data structures and traits for tevec
-
one_way_slot_map
SlotMap with minimal restrictions on Keys and Values
-
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 -
benchmark-counters
Light-weight data structures to help with monitoring and benchmarking
-
arith
containers with arithmetics
-
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
collectivity
Generic collection traits
-
evicting_cache_map
An Evicting LRU cache supporting prune hooks
-
flow-graph
A representation of a graph data structure for flow-based programming
-
composite_types
Compose type definitions in the style of typescript
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
nvpair-rs
Safe and rustic wrapper around nvpair
-
xdag
DAG(Directed Acyclic Graph) lib
-
comprehend
Python like list, set and hashmap comprehensions via macros
-
colmac
Macros to work with
std::collections -
case_insensitive_string
A case insensitive string struct
-
inditech
A set of technical indicators for time series analysis
-
cons-rs
containing a Cons data structure
-
typed_index_collection
Manage collection of objects
-
hashable-map
Wrappers for HashMap and HashSet that implement Hash
-
fqdn-trie
FQDN (Fully Qualified Domain Name) lookup structures (based on tries)
-
lexpr
A representation for Lisp data
-
simple-matrix
generic matrix library
-
nimble-steps
Nimble Steps Collections
-
fixed-slice-deque
A fixed size deque implementation
-
uvector
access two slices as a single continuous vector
-
equivalence
Trait and derive macro for comparing and hashing types modulo an equivalence relation
-
linked-vector
A hybrid linked list and vector data structure
-
owned_chunks
a collection of traits and iterators to get owned chunks from collections
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
generational_token_list
A doubly-linked list backed by generational-arena
-
dd_statechart
A Data-Driven implementation of Harel Statecharts designed for high-reliability systems
-
weak-lists
Lists with weak references and concurrent iteration and modification
-
viral32111-xml
XML parser crate for my Rust projects
-
sot
Object Tree
-
cbsk_timer
rayon thread runtime
-
colours
Color types for different color models with conversions between it
-
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
capillary
HashMap-like storage of key-value pairs, but allowing for step-by-step (partial) search of value
-
rdf-reader
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
hpo
Human Phenotype Ontology Similarity
-
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
-
binary-tree-view
A binary tree visualization application built in Rust
-
tc-state
TinyChain's general state enum
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
swimmer
Thread-safe object pool type
-
priq
Array implementation of the min/max heap
-
lesbar-text
String extensions and queries for legible text
-
plurals
singular/plural forms, mostly in English
-
sdsl
interface for the Succinct Data Structure Library
-
btree-vec
A growable array (vector) implemented using a B-tree
-
take-some
that provides a way to obtain *some* value from various collections
-
subset-map
A map where the keys are subsets of an initial set of elements
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
parse_tree
A non-abstract syntax tree type
-
froggy
prototype for the Component Graph System programming model. It aims to combine the convenience of composition-style Object-Oriented Programming with the performance close to Entity-Component Systems
-
liblet
learning about formal languages and grammars
-
actionidmap-updater
A HashMap that can be updated from a URL. Intended to be used to keep reverse-engineered API's in use even as private referenced ID's get updated.
-
nslice
Structures for interpreting slices of variable length as arrays
-
half-2
Fork of starkat99/half-rs. Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types.
-
quarkrs
A collection of small life improvements for rust
-
bitvec-rs
Bit vector with guaranteed
[u8]representation and the ability to get safe immutable and mutable views into its internal vector for easy I/O -
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
kvv-efa-api
Rust bindings for the KVV (Karlsruher Verkehrs Verbund) "EFA"-API
-
version-rs
A struct for Versions, with the methods you expect
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
restorable
An iterator adapter for saving and restoring iterator state
-
trying
Basic trie crate
-
kn0sys_ndarray_rand
Constructors for randomized arrays.
randintegration forndarray. -
mini_uuid
A small and URL-safe UUID crate for Rust
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
ypwt
ypwang's personal toolbox
-
magiclist
List with O(log n) random access, insertion, splitting, and merging
-
nostd-bv
Bit-vectors and bit-slices
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
oats-rs
Short, unique ids without the hassle of random uuids
-
bibliographix
A bibliography management crate
-
simplecountry
Country Library
-
fplist
An immutable, persistent, singly-linked list
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
dependency-graph
building and resolving dependency graphs
-
usage
A convenient alternative to the newtype pattern
-
temporary-annex
Helper for creating temporary annex on a collection
-
batbox-cmp
Traits & functions related to Ord
-
petr-stdlib
the petr language's standard library
-
kmmp-generator
allows one to automate the setup of Kotlin Multiplatform Mobile (KMM) projects. Simplify the creation of KMM projects by generating project structures, managing configurations, handling dependencies…
-
vec-entries
Entry API for iterating over and removing elements from a
Vec -
cset
Fine-grained and reversible struct transactions
-
handler_map
Map from types to functions that receive them
-
data_structure_traits
data structure collection traits
-
simple_event_bus
A basic, simple event bus in Rust
-
prefix_array
A generic container for searching on prefixes of keys
-
pl-hlist
support for heterogeneous lists (known as
HLists), which are functional, tuple-like, strongly-typed data structures that can contain elements of differing types -
anas
Anas's Meta-data crate
-
qualomat_schema
Rust bindings for the *Qual-O-Mat* open data format for the german voting advice tool *Wahl-O-Mat*
-
hibit_tree
Hierarchical bitmap tree. Integer-key map that can intersect FAST.
-
hi-doc-jumprope
fast rope (fancy string) library built on top of Skiplists - hi-doc fork
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
run-loop
Run loop for thread, provide message post, deadline timer and future executor
-
dependy
Dependency resolution with variable dependency types
-
dyobj
improved version of the ECS pattern
-
sws-tree
Slotmap-backed ID-tree
-
meminterval
interval-tree in Rust made to store memory mappings
-
dyn_vec
A Vec<T: ?Sized>
-
okasaki
A collection of peristent datastructures
-
dynprops
Creating and extending objects with typed dynamic properties
-
epoch32
32-bit Epoch with specified starting year
-
const-vec
Vec-like data structure with immutable push method
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
vector-trees
Vector backed B and AVL trees
-
decomp
Components of a decompilation pipeline
-
rt-lists
Link lib
-
quadboard
Typed fixed-length buffers of chess pieces
-
dawgdic
Port of DAFSA in safe Rust (original implementation courtesy to Susumu Yata)
-
bit-array-rs
Bit Array
-
shortlist
An efficient data structure to track the largest items pushed to it
-
cad_import
importing CAD data from different formats into a uniform in-memory structure
-
graff
manipulating graphs
-
bytesstr
An immutable reference-counted UTF8 String
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
range-mutex
A
Mutex<[T]>-like type, that allows locking different ranges separately -
circular_vec
A fixed length vector that provides a next function that loops infinitely
-
eytzinger-map
array/vec based map using eytzinger search algorithm
-
graph-rs
graph library
-
gpt_disk_types
GPT (GUID Partition Table) disk data types no_std library
-
fusefilter
No alloc membership approximation
-
wide
help you go wide
-
soapy-shared
Custom types used by soapy macros
-
trips
generic triple store written in Rust
-
tantivy
Search engine library
-
canopydb
Transactional key-value storage engine
-
rustupolis
tuple space data structure in Rust
-
nfe
NF-e - Manipulação da nota fiscal eletrônica
-
lim-bit-vec
Limited bit vectors
-
tree-cursor
non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
bitf
procedural macro to easily create a bitfield out of a struct
-
bittyset
A BitSet type for manipulating bit sets
-
simple-graph
Graph library with ability to serialize/deserialize Trivial Graph Format
-
elastic-array-plus
Elastic vector backed by fixed size array
-
Project2
Implementations of red black tree and AVL tree
-
bitstr
contiguous sequence of bits in memory
-
embedded-async-helpers
staticfriendly helpers for async on embedded -
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
oas3
Structures and tools to parse, navigate, and validate OpenAPI v3.1 specifications
-
zetacore
in-memory vector store library with Python bindings
-
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…
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
p8n-types
Basic types for representing binary programs
-
stupid-add
If you want to add stuff this lib is the way to go
-
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.
-
colony
A fast associative data-structure that chooses its own keys
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
spectacle
Opt-in runtime introspection
-
fast_forward
Quering collections blazing fast
-
bidrag
input-binding system (API-Agnostic)
-
last-git-commit
wrapper arround git2-rs to get info about the last commit. Useful for when you want to show the git hash in a program.
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
ternary-tree
Ternary Search Trees, with no unsafe blocks
-
aoc-framework-utils
such as data types, algorithms and functions for aoc-framework-rs
-
adjacency-list
Adjacency List and Adjacency Graph
-
safe-graph
Graph implementation (refactored version of GraphMap from popular crate petgraph)
-
kd_interval_tree
Implements a K-dimensional interval tree, for fast interval-overlap lookup. Binary-tree based implementation, i.e. O(log(n)) lookups.
-
immer-rs
A wrapper around the C++ library immer for persistent datastructures
-
datazoo
Bitset and jagged array data structures
-
protocoll
clojure inspired protocols for rust collections
-
eternaltwin_dinoparc_store
Dinoparc store implementation
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
collect-me
Additional collections not included in the Rust standard library
-
win-idispatch
that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
array2ds
Package for handling sized 2d arrays in rust, without the usage of the keyword unsafe cuz why not
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
rand_map
A map that creates a random handle on insertion to use when retrieving
-
ih-muse-record
Record Muse Api usage for testing purposes
-
inline-str
Efficent and immutable string type, backed by inline-array
-
clonelicious
macro library that simplifies cloning and closure execution. The
clone!macro automatically clones variables and immediately executes the closure with the cloned values, streamlining… -
kukoo
lockfree cuckoo hashmap
-
cliquers
Manage filesequences with a common numeric component
-
dyn_trie
Dynamic trie is trie capable of mapping any T to any char iterator
-
quetta
Immutable, reference-counted strings for rust
-
bytes32
Used to create a custom type for 32-bit-wide byte arrays. Used for Drops of Diamond (more information about DoD is available at https://github.com/Drops-of-Diamond/Diamond-drops).
-
construct
A macro for building container literals
-
puruda
Pure Rust DataFrame
-
rust_release_artefact
Safely extract installable files from Rust release artefacts
-
system-config
storing application properties on disk
-
eth2_ssz_types
types with unique properties required for SSZ serialization and Merklization
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
simple-collections
Collection of simple collections
-
farmap
working with Farcaster label datasets
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
ensure
target state of an object
-
undo_2
Undo and redo done the right-way
-
triangle_matrix
Triangle matrix indexing operations
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
adts
Common abstract data type traits and implementations
-
rudy
Judy array implementation in pure Rust
-
alo
ALO means At Least One. It could contain any number of item like
Vecbut it does not heap allocation if it contains only one item -
stringmap
An immutable string map with pointers into frozen memory that can be shared between C, Ruby, Python and Rust
-
gap_vec
GapVec data structure in rust
-
threshold-dict
A data structure to find smallest key that is larger than the query
-
poset
posets
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
sesstype
Multiparty Session Types
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
const-oid
Const-friendly implementation of the ISO/IEC Object Identifier (OID) standard as defined in ITU X.660, with support for BER/DER encoding/decoding as well as heapless no_std (i.e. embedded) support
-
tree-collection
Name reservation – Project will feature a collection of dependency-free pure rust implementations of tree varaints, such as AVL Tree, TTree and B+ Tree
-
cosmic_undo_2
Undo and redo done the right-way
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
linked_array
Arbitrarilly long fixed-size arrays
-
my_crate_new
function collection
-
bytes-quilt
data structure for tracking random-access writes to a buffer
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
collections-rs
Generic collection types for rust
-
zond
standard rust collections but with collecting statistics
-
another-option
option data type; useful when allocations are expensive
-
vax-floating
VAX floating-point types
-
collectioner
collection helper
-
text_utils_s
edit array. Example delete duplicate in array. Clear string
-
defaultmap
HashMap with an automatic default for missing keys
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
push-while-ref
push while having a reference
-
ads-rs
(Algorithms and Data Structures) is a set of useful generic production-ready algorithms and data structures
-
fdm-toolkit
reading and writing 4D Miner (0.2.1.4 Alpha) game-data
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
fusebox
Mostly safe and sound append-only collection of trait objects
-
string-err
String error type
-
binary_sort_tree
二叉树的new,insert,del,search等方法
-
tinyvecdeq
VecDeque-like data structures -
polars-ad-hoc
Polars
-
gamozolabs/rangeset
Pure Rust x86_64 bootloader and kernel
-
dltree
Doubly linked tree with leaf-considering typing
-
gardiz
integer geometry on 2D planes, focused on games
-
proc-concat-bytes
Like std::concat but for byte strings
-
ndtensor
n-dimensional tensor library for Rust
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
identifier
Generate 128 bits id structs easily
-
hannibal
A small actor library
-
open-payments-common
Open Payments - Message Parsing Library - ISO20022
-
indexmap-amortized
hash table with consistent order and fast iteration. The indexmap is a hash table where the iteration order of the key-value pairs is independent of the hash values of the keys. It has the usual…
-
strawberry_fields
Consume, read, and mutate struct fields with an iterator-like api
-
bet
parsing and evaluating binary expression trees
-
tiltflake
distributed database that uses the flake algorithm to generate unique IDs
-
sparseset
A Sparse Set
-
rbx_tree
Weakly-typed Roblox DOM implementation for Rust
-
eziter
Wrapper around Iterator
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
competitive-programming-rs
Competitive Programming Library in Rust
-
sorted_vector_map
maps and sets backed by sorted vectors
-
kserd
Kurt's Self-Explanatory Rust Data
-
bloom_filter_plus
rust_bloom_filter
-
thin_str
A string type that’s smaller than
Box<str>or String -
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
tinysearch-cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
lumberjack-utils
Read and modify constituency trees
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
tudelft-dsmr-output-generator
Companion library for the TU Delft Software Fundamentals individual assignment
-
fixed_str
Fixed-size, null-padded UTF-8 string type with const-safe construction and binary serialization support
-
triskell
A tri-partite ring buffer
-
kill_tree
🌳 Kill Tree is a library designed to terminate a specified process and all its child processes recursively, operating independently of other commands like kill or taskkill
-
bounded
numeric types
-
map_in_place
Reuse the memory of a Vec<T>, Box<[T]> or Box<T> when mapping the elements if possible
-
byte_set
Efficient sets of bytes
-
simple-bitrange
manipulating bit ranges which is common when working with IC registers
-
packed_str
Store immutable strings in a single packed allocation
-
memcell
providing a MemoryCell struct, which stores a current and previous value
-
incrstruct
Build self-referencing structs using two-phase initialization
-
ziptree
Tarjan's zip tree implemented in Rust
-
bin_file
Mangling of various file formats that conveys binary information (Motorola S-Record, Intel HEX, TI-TXT and binary files)
-
geo-index
Fast, immutable, ABI-stable spatial indexes
-
guzzle
A derivable trait for consuming key value pairs into structs
-
foxy_types
Types for
foxy -
elaru
Memory safe implementation of LRU cache
-
ute2
(U)biquitous (T)ile (E)ngine (2) - lib for parsing and manipulating abstract polygons with tagged sides
-
abbrev-tree
highly inefficient data structure for text completion
-
flex-algo
Rust commonly used data structure and algorithms
-
lambda-apigateway-response
Response object for AWS Lambda with API Gateway
-
simple-collection-macros
configurable macros for maps and sets
-
alloc-wg
Attempt of collection several proposals of the allocators-wg
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
smallgraph
A small graph based on smallvec
-
ra_ap_rustc-dependencies
TBD
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
hostname
Cross-platform system's host name functions
-
ecoord-core
Core primitives and operations for transforming between 3D coordinate frames
-
ketsugou
merges two arrays
-
courgette
Colour manipulation/conversion library
-
rustupolis_server
using space tuples in fog computing
-
tsil_cev
LinkedList on Vec
-
automerge-persistent-sled
A sled adapter for persisting Automerge documents
-
btree-plus-store
B-trees backed by a slab/arena to reduce allocations and increase locality + copyable, immutable B-trees which must be manually dropped
-
nats-types
Enumerations and types for representing NATS protocol messages
-
rustfsm
Define state machines that can accept events and produce commands
-
terminal-linked-hash-map
A fork of linked-hash-map that builds on stable in exchange for not allowing custom hashers
-
graph_process_manager_core
explore parts of a tree-like or graph-like structure that is not known in advance
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16coordinates. -
unempty
Non-empty data structures for Rust
-
sharedvec
A fast but limited collection for storing values of a single type
-
simple_ringbuf
Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
hex-string
a data structure for managing hex strings in both string and byte vector representation
-
serde-ordered-collections
Ordered serialization/deserialization serde functionality
-
vec_2d
2d vector for Rust
-
nonoverlapping_interval_tree
Map data structure keyed on (non-overlapping) ranges that allows lookup of a point within a range. Can be no_std (with use of alloc crate).
-
google-contacts-csv
Struct defined to hold the contact information from the Google contact file
-
graph-api-simplegraph
efficient graph implementation for the graph-api ecosystem with support for indexing
-
dataflow-rs
A lightweight, rule-driven workflow engine for building powerful data processing pipelines and nanoservices in Rust. Extend it with your custom tasks to create robust, maintainable services.
-
hexarr
working with hexagonal grids
-
containers
Containers
-
default-vec
A specialized vector that has a default value
-
quantity
Representation of quantites, i.e. of unit valued scalars and arrays.
-
bfield
B-field datastructure implementation in Rust
-
largeint
that supports large integer arithmetic
-
bit-vec-omnitool
A vector of bits
-
arrow-message
implements a way to define messages according to the Arrow format in both Rust and Python
-
string-offsets
Converts string offsets between UTF-8 bytes, UTF-16 code units, Unicode code points, and lines
-
cbsk_log_rayon
log tool, using tokio as the runtime
-
nibble_vec
Vector data-structure for half-byte values
-
scratchbuffer
A Vec<u8> like data-structure, that can be used as slices of different types
-
ppar
Persistent immutable array
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
cmp_wrap
Let you compare structes by context
-
medea-reactive
Reactive mutable data containers
-
arenas
Arena data structure for efficiently adding & removing items with stable IDs
-
art
adaptive radix trie
-
median-heap
A median heap implementation in Rust, used to keep track of a running median of a sequence of numbers
-
keymaps
standardized encoding for key codes
-
typeslice
type-level slices
-
thinset
A data structure for sparse sets of unsigned integers that sacrifices space for speed
-
tupley
Extension for primitive tuple (Hlist based on recursive structure)
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
futures-bounded
bounding futures in size and time
-
quantized-density-fields
Quantized Density Fields data structure
-
jcm
Pure Rust implementation of the JCM USB communication protocol
-
bonsai
Index arithmetic functions for perfect binary trees
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
apint
Arbitrary precision integers library
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
orx-imp-vec
ImpVecstands for immutable push vector 👿, it is a data structure which allows appending elements with a shared reference -
aabel-identifier-rs
defines identifier behavior, such comparing them, or generating sequences of identifiers
-
binary_tree_zy
binary tree
-
fpq
Priority Queue with scoring Function
-
simd-r-drive-extensions
Storage extensions for SIMD R Drive
-
extensions
typemap container with FxHashMap
-
geomprim2d
2D geometric primitive types
-
sigma-rust
parsing and evaluating Sigma rules to create custom detection pipelines
-
bpf-ins
working with eBPF instructions
-
kushi
A queue built for the Dango Music Player and Oden Music Bot
-
blocked-vec
A vector of byte blocks behaving like files
-
composable-indexes
In-memory collections with composable indexes
-
restor
A dynamic resource storage system in rust
-
graphrox
A graph library for graph compression and fast processing of graph approximations
-
kathy
Const-evaluated swift-style keypaths
-
typed_floats
Types for handling floats with type checking at compile time
-
internode
Smart references to your graph nodes
-
timeless
storing in-memory timeseries data
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
unicase_collections
Collection of UniCase datastructures
-
gvdb
glib gvdb file format
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
grit-bitvec
BitVec, a vector type that can store fixed-width data with irregular bit widths
-
anycollections
Rust Vec and HashMap which can contain arbitrary types
-
disjoint-hash-set
A disjoint set / union-find data structure suitable for incremental tracking of connected component identified by their hash
-
kodiak-sets
manage generic sets supporting unique features
-
bitint
Integer types that have a logical size measured in bits
-
deltastruct
Allows defining deltas for tagged structs for later application
-
destiny-pkg
Destiny 1/2 Tiger package library and tools (unpacker, verification)
-
esl01-dag
DAG used for source control
-
macaddr
MAC address types
-
wagon-utils
Various utilities for WAGon
-
single_byte_hashmap
HashMap for storing singular bytes as keys
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
tiled-json-rs
parse and interact with Tiled editor JSON files
-
crdt
Conflict-free Replicated Data Types for Rust
-
data-structures-algorithms
Data Structures and Algorithms in Rust!
-
ro
stuff read-only
-
judy-wrap
Judy arrays FFI mid-level binding
-
smol_str
small-string optimized string type with O(1) clone
-
extended-collections
An extension to the collections in the standard library with various data structures
-
final
Wrap a value in a type that does not give out mutable references
-
ascii_num
digit to ascii numbers
-
depends
Ergonomic, performant, incremental computation between arbitrary types
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
json_to_struct
Convert JSON into Rust structs for efficient and type-safe data management
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
lancelot
binary analysis framework for x32/x64 PE files
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
priority-expiry-cache
A cache that evicts items based on their priority and expiry time (LRU + TTL) Add (O(1)), Get (O(1)), Evict (O(1)) in both time and space
-
field_accessor
A procedural macro to get and set a struct field by String dynamically
-
squall_dot_io_resp
A RESP parser implementation, written with edge performance in mind
-
ioc
An Inversion-of-Control library in Rust
-
arrayvec-const
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
chtholly_tree
Rust bindings for Chtholly Tree
-
shopless-types
API types of shopless
-
mismatch
abstract mismatching. Useful for error propagation.
-
json_tables
A structure that eases operations with a local json storage of undetermined items
-
bitsvec
A bit vector with the Rust standard library's portable SIMD API
-
into_enum
Rust macro to generate trivial From impls
-
structures
collection data structures
-
bipbuffer
Simon Cooke's Bip-Buffer
-
to-binary
Converts From Hex, UTF-8, Vector of Bytes, or a Byte Slice to a Binary String And Implements Many Useful Functions For Binary Strings
-
ploc-bvh
A Bounding Volume Hierarchy based on PLOC
-
forgetful
Track and forget values within a specific scope, enabling detection of repeated values
-
collidea
Collision-prone memory-efficient collections
-
scoped_stack
A scoped stack data structure
-
twie
fast and compact prefix tries
-
pluck
Extract values conveniently
-
better_peekable
Create a Peekable structure like Rust's Peekable except allowing for peeking n items ahead
-
brarchive
Bedrock Archives in Rust
-
backtracking_iterator
generic iterator with an item history, capable of backtracking and forgetting
-
quotient-filter
A quotient filter implementation
-
graphific
graph data structure library
-
alpha-micrograd-rust
Expression tree, automatic gradients, neural networks, layers and perceptrons
-
cock-tier
Measure the power level of a peen
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
prcn_lib
private library for atcoder
-
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 -
qlrumap
A HashMap with an LRU feature
-
interval-map
A vector-based, non-duplicate range-keyed, sorted array
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
flo_scene_guest
no_std implementation of the guest protocol for flo_scene for smaller wasm guests
-
sequence-map
Implements a map of unsigned 64-bit keys into strings. The map is optimized for creating it once, and then reading many times. The struct
Builderis used to build the map, and the structMapis used for lookups… -
map1
@ErichDonGubler's fancy template for new Rust projects
-
progress-streams
Progress callbacks for types which implement Read/Write
-
hv-alchemy
Heavy Alchemy - the black arts of transmutation, wrapped for your safe usage and enjoyment
-
rmat
minimal implementation of two-dimensional matrix algebra
-
clone_cell
A Cell that works with a restrictive form of Clone
-
iodyn
An incremental collections library making use of Adapton
-
vectune
A lightweight VectorDB with Incremental Indexing, based on FreshVamana
-
file_graph-rs
A tiny crate to generate a tree like structure starting from a folder and branching inwards
-
ropey
A fast and robust text rope for Rust
-
rt_vec
Runtime managed mutable borrowing from a vec
-
ABtree
AVL and Btree for rust
-
json-node
A way to work with JSON as a node tree
-
gridd
A generic, dirt-simple, two-dimensional grid
-
streamhist
streaming histogram
-
yagraphc
working with Graph data structures and common algorithms on top of it
-
keyed_vec
Vector type where the key is a custom object to avoid mixing indices between vectors
-
os_error
Struct
OsErrorrepresents only the OS error part ofstd::io::Error.OsErrorimplementsClone,Copy,PartialEq,PartialOrd,Eq,Ord,Display,Debug,Hash,TryFrom<std::io::Error>… -
honeycomb-core
Core structure implementation for combinatorial maps
-
fill_canvas
FillCanvas is a wrapper around a matrix with special methods to fill the cells
-
csgo-gsi-payload
Data structures for CSGO Game State Integration
-
cloneless_cow
A greatly-reduced implementation of Cow that does not require T to be Clone but allows for storing either a reference or an owned instance for future needs of references to T
-
twodarray
A 2D array library
-
fast-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
miny
Box<T> with small value optimization
-
discrete_range_map
DiscreteRangeMap and DiscreteRangeSet, Data Structures for storing non-overlapping discrete intervals based off BTreeMap
-
rust-mcp-schema
Type-safe implementation of the Model Context Protocol in Rust, designed to reduce errors and accelerate development with powerful utilities
-
tiny-interner
Easy to use string interner with fast access to underlying strings and minimal memory footprint
-
id-map
Data structure of values indexed by IDs
-
arr-rs
arrays library
-
kvstructs
General basic key-value structs for Key-Value based storages
-
compact_path_tree
A data structure providing a compact in-memory representation of a tree of paths
-
leaderboard
functions for Vec such as ranking with ex aequos
-
range-split
splitting sequences with range parameters
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
eztd
Quick start Rust
-
vox_writer
writer module for MagicaVoxel file format
-
csv2struct
Generate Rust struct definitions from CSV
-
an-rope
an rope for large text documents
-
rbtset
A set based on a RB-Tree for efficient operations
-
cbsk_unique
unique value generator
-
cbor-tag-index
Tag index
-
insrcdata
Embed static data as source code
-
typed_id
Make your IDs strongly typed!!
-
hashmap_union
Allows the union and intersection of hashmaps
-
rust-ds
Custom data structures crate for Rust
-
cuml_map
A trait representing cumulative mappings, and several implemntations of this trait
-
char-buf
A writable, fixed-length
charbuffer usable inno_stdenvironments -
gaps
Functionality for working with gaps/holes in ordered sequences of values
-
graphs
Graph data-structure implementations based off graph-traits
-
wordlist-generator
A handy wordlist generator
-
grafferous
graph library with a focus on generic data in nodes
-
tinybitset
Generic implementation of small, fixed size, copyable bitsets
-
libreda-splay
Splay map and splay set data structures
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
easy_linked_list
easy linked list is easy to work
-
deterministic-bloom
A deterministic Bloom filter with support for saturation. Suitable for distributed use cases and as a cryptographic primitive.
-
moretypes
Named tuples, records, and more!
-
hdf5-dst
DST extensions for HDF5
-
pretree
package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
nanovec
Arrays and Vec-likes of small integers packed in an integer or two
-
mikufans-proto-intl
gRPC APIs for Mikufans (Intl)
-
mc-oblivious-ram
Implementations of Oblivious RAM data structures
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
onevec
One-based indexed Vec wrapper
-
fr-trie
Fuzzy Radix Trie
-
pui-arena
Generalized Arenas that can be used on
no_std -
flowerbloom
fast bloom filter implementation with thorough documentation and tests
-
p-chan
Multimedia (Audio, Raster) Channel Newtypes and Conversions
-
pathio
Data type for storing generic data on a virtual path tree hierarchy. The data is stored in memory, this is not OS file system abstraction, but immitation
-
simple-binary-tree
binary tree view representation
-
oxidd
A safe, concurrent, modular, and performant decision diagram framework
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
offset
Glorified offsets for arbitrary structures
-
enum-ref
Proc. macro for generating enum discriminant types.
-
xsd
XSD.rs
-
tracker-macros
Macros for the tracker crate
-
idcontain
Generational (or tagged) ID-based containers
-
fricgan
performing basic input and output on bytes
-
stac-duckdb
Client for querying stac-geoparquet using DuckDB
-
hexing
A basic Rust library to manipulate hexagonal grids
-
const-size-flatten
Flatten and FlatMap with constant inner iterator size
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
serde_view
Serialize views of data
-
more_collection_macros
Adds new macros to rust for creating collections
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
arenavec
An arena backed implementation of vectors and related types
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
range-traits
Ranges related traits
-
qris
QRIS Parser & Editor
-
light_merkle
A light-weight merkle tree implementation that allows to use any hashing algorithms from the packages sha2 and sha3
-
big-tuple
providing trait implementations for tuples of up to 128 elements
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
batbox-collection
Collection of identifiable objects
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
vortex-sampling-compressor
Vortex compressor that uses statistical sampling
-
theban_interval_tree
Interval Tree implementation
-
sylvan-sys
Bindings for the Sylvan parallel decision diagrams library
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
jp_multimap
A barebones multimap (part of the jp project)
-
ttgraph_macros
Proc-macros for TTGraph
-
merged_range
rangeset that can merge overlap
-
string32
A string that is indexed by u32 instead of usize
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
ankurah-core
Core state management functionality for Ankurah
-
tensr
A high-performance, cross-platform, multi-backend tensor/array library for Rust
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
jpostcode_rs
Japanese postal code lookup library in Rust, powered by jpostcode-data
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
trybox
stable,
no_std-compatible, fallible heap allocation -
insert_multiple
insert multiple items into a stream in reasonable runtime
-
tree-index
Index a flat-tree
-
package-json
package.json manager for Rust
-
bndpresbufq
Bounds-preserving, optionally limited, buffer queue
-
ast2str-lib
pretty-printing ASTs and other recursive data structures
-
mutable
keep track of changes in structures
-
uuid-timestamp
UUID timestamp
-
fsort
sort files in a fast, OS-independent and 'rusty' way
-
event-store-adapter-rs
DynamoDB an Event Store
-
hashcons
Hash cons'ing for compact representations of shared, immutable data structures
-
contiguous_collections
collections backed by flat contiguous arrays
-
uwheel
Embeddable Aggregate Management System for Streams and Queries
-
crdt_rs
work with Conflict-free replicated data types (CRDT) in Rust
-
append-only
Append only versions of std data structures
-
elinor
Evaluation Library in Information Retrieval
-
ts-builder
Timestamp builder
-
rdf-vocab
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
vec-vp-tree
A vantage-point tree implementation backed by vectors for good performance with no unsafe code
-
bmap
A bitmap with an internal counter
-
decoded-char
wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
gsrs
Generic Self Referencing Struct
-
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
dag_compute
construction of arbitrary computation DAGs and the expression of dataflow graphs
-
tree-sitter-generate
generating C source code from a tree-sitter grammar
-
stochastic-data-structures
Various stochastic datastructures implemented
-
varstack
A call-stack based singly-linked list
-
wec
Useful vec!-like macros
-
hashtree
A Merkle Tree implementation in Rust
-
flat-multimap
A multimap and multiset implementation using a flattened hash table
-
big_enum_set
creating sets of enums with a large number of variants
-
jui_file
file tool
-
banyan
Persistent indexable tree data structure
-
tiny-sparse-merkle-tree
Sparse Merkle Tree
-
bugu
Cuckoo Filter: Practically Better Than Bloom
-
msiz_rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
hdrhistogram
A port of HdrHistogram to Rust
-
labelgraph
graph implementation, allowing random access to nodes via labels
-
mori_parallel
parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
kdt
k-dimensional tree implemented with const generics
-
skiplist-rs
Skip list is a kind of ordered map and can store any value inside. See skip list wikipedia page to learn more about this data structure.
-
mmdb_core
A std-collection-like database
-
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
histogram
A collection of histogram data structures
-
validbr
data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
dgunther2001-linked_list
A generic singly linked list
-
goya
morphological analyzer for Rust and WebAssembly
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
more_ranges
Range types not provided in the standard library
-
sized-vec
Type level sized vectors
-
ego-binary-tree
Binary tree API built by wrapping ego-tree
-
xtree
general purpose tree data structure
-
trait-union
Stack-allocated trait objects
-
elu
Traits and implementations for EVAL-LINK-UPDATE data structures
-
sliding_window
A fixed size, heapless sliding window
-
shelves
Storing values referenced by a unique typed index
-
generic_singleton
allowing for generic singleton patterns
-
cow-rewrite
Rewrite copy-on-write types copying only when it's neccessary
-
tapestry
Generic 2D grid data structure and utilities
-
bitworks
meant to provide easy to use bitsets with emphasis on safety
-
forged-in-lost-lands
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
smolvec
A lightweight vector implementation with small-vector optimization for rust
-
rust_list
Singly linked list in Rust, with macros for easy instantiation
-
river-ring-buffer
ring buffer implementation
-
grapes
Persistent graph data structures: Tree, Graph, Arena & more
-
bit-index
A little-endian zero-indexed bitstring representation
-
geogrid
Manipulate geographic data on a grid
-
b100m-filter
The fastest bloom filter in Rust. No accuracy compromises. Use any hasher.
-
collect-once-hashmap
A hashmap that can be collected only when there are unique keys in the iterator
-
hexga_generational
GenVec, ideal for MAS (Multi-Agent System), where each agent can be removed at any time and has references to other agents
-
open-payments-iso20022-pain
Open Payments - Message Parsing Library - ISO20022 PAIN
-
rs-bucket-filter
Skips slow scans using cache, bloom filter,
-
fcsd
Front-coding string dictionary
-
rblist
A block-based, non-circular double-linked list implementation for Rust
-
stringvec
macro for creating Vec<String> from various types
-
datastreams-rs
DataStreams container
-
spigal
fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
sodg
Surging Object DiGraph (SODG)
-
key-node-list
Doubly-linked list that stores key-node pairs
-
option_set
Bitflags on steroids
-
mvbitfield
Generates types to work with bit-aligned fields
-
bitmac
Structure for accessing to single bits
-
tbytes
A tiny library for reading and writing typed data into buffers
-
pthash
Rust bindings for PTHash
-
collection_macros
Collection of macros for collections
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
aoc-framework-rs
A framework for AdventOfCode coding competition, that handles input, output and provides some core utilities
-
multi-stash
Vector-based arena data structure that reuses vacant slots
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
bidir-map
Bidirectional map implementation for Rust
-
mathio
A lightweight, simple and straight-forward opinionated library for math used in other projects
-
try-lazy-init
Fallible lazy initialization
-
ahash
A non-cryptographic hash function using AES-NI for high performance
-
simple-canvas
generic 2 dimensional canvas struct
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
arrav
Sentinel-based heapless vector
-
ciborium
serde implementation of CBOR using ciborium-basic
-
exhaustive-map-macros
Proc macros for the exhaustive-map crate
-
num-rational
Rational numbers implementation for Rust
-
matrixcompare-core
Core traits for matrixcompare
-
stuff
Stuffing things into pointers
-
smt_map
A uint-to-uint map backed by Sparse Merkle Tree (SMT), which supports generating Merkle Proofs of key-values
-
sortedcontainers
An experimental sorted data structure
-
hedel-rs
A Hierarchical Doubly Linked List
-
oomfi
A minimal Bloom Filter implementation in Rust
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
sparse_set
sparse set data structure
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
arrsingh
A top level crate in the workspace
-
lookups
Improve the data retrieval operations for collections
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
dot_json
Tools for dot map representations of serde_json Maps
-
arrow-digest
Stable hashes for Apache Arrow
-
bloom_filter_plush
rust_bloom_filter
-
ttl-queue
A queue that drops its content after a given amount of time
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
idr-ebr
An efficient concurrent ID to object resolver
-
unsized_enum
Unsized enum implementation
-
pointer-value-pair
A pair of a pointer and a small integer packed into a pointer-sized object
-
probly-search
A lightweight full-text search engine with a fully customizable scoring function
-
flexstr
A flexible, simple to use, immutable, clone-efficient
Stringreplacement for Rust -
kvtree
Heterogenous in memory key value tree storage
-
immutable_string
Immutable Single Instance Strings for Rust
-
reusable-vec
A Vec wrapper that allows reusing contained values
-
hdf5-hl-sys
Bindings to HDF5 High Level API
-
keyed
Implement comparison traits by specifying a key
-
qt-json
JSON library for QT
-
mapro
A tiny macro library for creating std::collections
-
i24
working with 24-bit integers
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
projected-hash-map
projected HashMap over HashSet
-
gur
A undo-redo framework
-
linear-deque
A double-ended queue that can be sliced at any time without preparation
-
modql-macros
Macros for modql. Not intended to be used directly.
-
tongrams
Tons of N-grams
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
fastbuf
single-thread-oriented very fast byte buffer
-
safer-bytes
safe, non-panicking wrappers around the 'bytes' crate
-
ibuilder
Interactive builder for Rust types
-
aversion
Versioned data structures with auto-upgrading
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
rdf-query
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
stringz
A way to use strings in generic paramters
-
sorted-collections
providing useful extension traits and convenience methods for ordered collections in Rust. NOTE: This library is not currently in active development, and much of the functionality…
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
ct-tilemap
help parse ClickTeam Tilemap files
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
break_array
For breaking array indexing
-
weighted_random_list
A Vec<T> that allows you to define the weight of each entry and randomly get entries
-
array-ops
Automatic method implementations for array data types
-
boxed_array_ringbuffer
A ring buffer of fixed size, that uses a boxed array as storage, therefore avoiding re-allocations when converting from Vec or to VecDeque
-
varset
an any type set of items
-
byte-sequence
A little marco that creates structs to be used as byte sequences (for ApiKeys, SessionIds and so on)
-
fairqueue
Spatially distancing fair queue. A kind of queue for sequential round-robin processing.
-
pui-vec
An append only vector, with guaranteed elided bounds checks
-
ax_banyan
Persistent indexable tree data structure
-
graphsearch
graph search and representation library
-
typemap_core
A no_std typemap with trait-based value-presence guarantees (on nightly)
-
scopegraphs-prust-lib
fork of prust for scopegraphs
-
healm
**He**ap **al**located **me**rkle tree
-
sparse_vec
Datastructure that stores separate but contiguous ranges of values efficiently
-
rustgym
solutions
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
avl-cont
A contiguous AVL Tree
-
velarixdb
An LSM Storage Engine focused on reduced IO amplification
-
ptr_hash
A high-throughput minimal perfect hash function
-
algods
A collection of data structures and algorithms
-
nimrodshn-btree
A persistent copy-on-write B+Tree implementation, designed as an index for a key-value store, inspired by SQLite
-
fibonacii-heap
Priority queue implemeted using a Fibonacii Heap
-
ulid-generator-rs
generating ULIDs
-
dst-container
Containers for DST objects
-
smart_access
A minimalistic "lazy bidirectional pointer" framework
-
no_vec
modifying sized arrays
-
cycler
A simultainious write/read data structure
-
priority-queue-rs
Priority Queue is more specialized data structure than Queue. Like ordinary queue, priority queue has same method but with a major difference. In Priority queue items are ordered by…
-
db_meta_derive
db-meta-derive is a wrapper around PostgresSOL using tokio-postgres
-
ckb_multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
simple-observable
observable pointer for mutable and immutable data
-
wildbird_macro_derive
Rust Framework 🐦 | Macro System
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
persistent_array
Persistent array is a library for working with memory mapped arrays
-
slots
Fixed size data structure with constant-time operations
-
object-merge
Traits useful for recursively merging document-like objects
-
hexgridspiral
Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
go-heap-rs
Golang's heap written in Rust
-
pgdb_to_struct
CLI application to generate Rust struct files from PostgreSQL database tables
-
priority-set
A no_std Priority Set
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
butils
shared by software included in BSuccinct
-
jsonnlp
JSON-NLP data structure
-
watermark
watermarking set for in-order insertions
-
crudite
A JSON CRDT
-
neighborgrid
A 2-D grid datastructure with easy to use iterators and adjacent cell methods
-
static-bytes
Bytes for embedded devices
-
range_vec
Fast indexed access to a range of mostly-default values
-
bytes
Types and traits for working with bytes
-
mutuple
Replace items in Python's immutable tuples
-
fid-rs
High performance FID (Fully Indexable Dictionary) library
-
clampf
Clamped floating-point types
-
topset
Top N selector
-
u64_array_bigints_core
Core library for
u64_array_bigints -
rs-merkletree
create Merkle Trees
-
anon-vec
An Anonymous Vector that emulates dynamic typing
-
type-info
Meta type information and type reflection at compile-time and runtime
-
docchi
A diff-based data management language to implement unlimited undo, auto-save for games, and cloud-apps which needs to retain every change
-
cargo-index-transit
A package for common types for Cargo index interactions, and conversion between them
-
const-assoc
A const-capable Map type backed by a static array
-
short-lease-map
A map collection optimized for brief internship of values
-
weakheap
Weak Heap data structure implementation in Rust
-
trait-map
Rust map for dynamic trait storage and references
-
compacts-bits
succinct bit vector
-
loaf
Why have a slice when you can have a loaf?
-
structz
Anonymous struct implementation in rust
-
associated_list
An associated list, for cases when the key implements neither Hash nor Ord
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
unique-id-collection
Collection with unique Id
-
gen-vec
Vector indexed with generational indices
-
rbtree-arena
A cache friendly red black tree where nodes live on sequential memory
-
dag-cbor-references
Extract blake3 ipld links from dag-cbor blocks
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
keysymdefs
A collection of key symbol definitions
-
artsy
ART Tree data structure library
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
mstr
2-word, immutable Cow<str>
-
ransel
rank/select succinct data structures
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
slotmap
data structure
-
vbox
type erased Box of trait object
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
tiger-pkg
Tiger engine package reading library for Destiny 1/2 and Marathon
-
variant-map
defines maps to store variants of enums
-
intsplit
splitting numeric types into their binary component arrays
-
atom_table
Assign easy-to-handle typed IDs to large, hard to handle things like strings
-
const_queue
A stack-only, no_std queue using const generics
-
uuid-macro-internal
Private implementation details of the uuid! macro
-
f256
Octuple-precision floating-point arithmetic
-
rez
A convention for libraries to bundle resource files alongside binaries
-
bitops
Miscellaneous bit operations for any Integer
-
rope_rd
A Read/Seek rope implementation
-
randsort
A sorting library with an optimal complexity of O(n) (!!) by randomly sorting Vectors until they are sorted
-
altdeque
An alternative deque implementation
-
discrimination-tree
discrimination tree term indexing
-
collect-mac
collect!macro, which can be used to easily construct arbitrary collections, includingVec,String, andHashMap. It also endeavours to construct the collection with a single allocation, where possible. -
mmap_json_file
parse, count, filter JSON files using memory mapped io library
-
once-list
an append-only per-item list
-
type-pools
A data structure to store values of multiple types
-
spatial-neighbors
certain Spatial-Partitioning Algorithms | DataStructures
-
indexed-vector
that implements vector container that can be indexed with specified function
-
treesome
tree creation, manipulation, traversal and visualization
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
matrixgraph
A graph implementation based on dense adjacency matrices
-
borrow-framework
More flexible borrowing
-
bookfile
A container file format with chapters and an index
-
hashable_rc
Hashable wrappers for reference countings
-
isx
Traits for checking certain conditions of values
-
prefix_tree_map
generic prefix tree (trie) map with wildcard capture support
-
automatic-relations
Tree automatic relations
-
hit-data
Hierarchical Indexed Typed data structure
-
libflow
grouping network flow data
-
tapa-trait-serde
A collection of Tapalogi's reusable crates
-
shine-graph
SHINE. Graph and sparse matrix module for the shine engine.
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
dynamic-matrix
work with matrices
-
compacts-dict
succinct dictionary
-
mtgjson
Unofficially provided lightweight models of the data provided by MTGJSON
-
linked_list_c
Safely work with c compatible linked lists
-
rust_cards
Simulates playing cards
-
fallacy-hash
fallible hash collections
-
ati
Introduces the
Attrait, which allows collections to be indexed byu|i{8,16,32,64,128}andisize. Supports Python-like negative index, where -1 is last element. -
indexvec
Simplified copy of rustc's index crate
-
inspector
General purpose inspection for popular data structures
-
fuid
A UUID-compatible identifier in a friendly base-62 format
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
hashed
type you can convert any hashable type into and still do equality checks on
-
graph-api-lib
Core library for the graph-api ecosystem - a flexible, type-safe API for working with in-memory graphs in Rust
-
num-bigint-dig
Big integer implementation for Rust
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
la-arena
index-based arena without deletion
-
any_key
Dynamically typed keys for associative arrays
-
null-vec
A specialized vector that stores nullable values
-
webgraph-algo
Algorithms for the Rust port of the WebGraph framework (http://webgraph.di.unimi.it/)
-
gecs
A generated entity component system
-
option-block
A minimal utility Rust crate for small, fixed-size blocks of optional types
-
stride
A strided slice type
-
wrapping
slices and arrays
-
tiny-solver
Factor graph solver
-
triemap
Triemaps for Rust
-
vector-growing
The growing vector with free indexes
-
transit_model_relations
Modeling the relations between objects
-
whistlinoak
Annotated even-arity trees backed by mmaps
-
lazy_list
Lazily-populated lists, finite or infinite
-
copy-range
core::ops::Range et al, but Copy and IntoIterator
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
lightning-containers
A set of lock-free data structures
-
flex-alloc
Data structures with extra flexible storage
-
binary-data-schema
Meta language for raw binary serialization
-
muds
Minimalistic Data Structures and Entity-Component-System Library
-
toboggan-kv
abstraction layer over multiple KV stores
-
piece_table_rs
piece table data structure
-
converge
Layered configuration, can be expressed in a single line of code. The
Convergetrait merges instances of structures into a new instance of a structure. TheConvergetrait can be derived… -
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
priority-matrix
A matrix that supports per-row, per-column and whole-matrix maximum key queries
-
l6t-file
A part of l6t library: reading, writing and deconding for L6T IFF data
-
dastral
Reduce boilerplate code, learn data structures & algorithms with Dastral
-
btree_network
A generic network (undirected graph) data structure
-
type-set
A set of heterogeneous types
-
tranche
Tranches are an alternative to slices
-
zvariant
D-Bus & GVariant encoding & decoding
-
nuid
A highly performant unique identifier generator
-
cola
A text CRDT for real-time collaborative editing
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
stac-async
Asynchronous I/O for stac-rs
-
init_trait
A small helper trait to simplify the initialisation of 'indexable' data structures
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
open-payments-iso20022-pacs
Open Payments - Message Parsing Library - ISO20022 PACS
-
weighted_trie
Weighted prefix trie for autosuggestions
-
flexible-string
A stack heap flexible string designed to improve performance
-
pi_link_list
linklist
-
vector2
2D vector library
-
flax
An ergonomic archetypical ECS
-
jsonpath-rust
basic functionality to find the set of the data according to the filtering query
-
closures
Abstraction for seperating code and state in closures
-
static-box
A stack-allocated box that stores trait objects
-
arc-swap
Atomically swappable Arc
-
head
Common types with inline headers, such as HeaderVec for Vec
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
sled
Lightweight high-performance pure-rust transactional embedded database
-
aterm
Annotated Terms data structure
-
tensorism-gen
Multidimensional arrays with bounds included in the type system
-
synchronized-writer
A tiny implement for synchronously writing data
-
array-object
Self-describing binary format for arrays of integers, real numbers, complex numbers and strings, designed for object storage, database and single file
-
data-buffer
low-level data buffer type useful for IO and in homogeneous collections
-
fibheap
but actually useful Fibonacci Heaps
-
moogle
data structures for relational code
-
graph-api-test
Test utilities and property-based testing for the graph-api ecosystem
-
pi_phf_map
phf_map
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
csvenum
Generate code for enums with associated constants from a .csv in your command line
-
enum-set
A structure for holding a set of enum variants
-
mti
that implements type-safe, prefix-enhanced identifiers based on the TypeID Specification
-
setting
The styles of all graphics elements
-
street_index
small utility crate for working with road name / street indexing for cartographic purposes
-
trailer
Store a type with an associated buffer in contiguous memory
-
const_enum_map
Get const value from enum handle
-
char-circle
A circular buffer for strings and traits for in-place string transforms
-
orx-self-or
Defines SoR (self-or-ref) and SoM (self-or-mut) traits that are useful in reducing code duplication and pushing forward the ownership transfer decision from the type designer to the consumer
-
local_vec
fixed-capacity vector allocated on the stack
-
strck
Checked owned and borrowed strings
-
succinct
data structures for Rust
-
uf_rush
A lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure
-
map-trait
Generic Map trait
-
bs
bitset with small-set (single-word) optimization
-
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
gtrie
Generic trie implementation with a support of different key and value types
-
len-trait
Len trait for collectons
-
lhlist
Labeled heterogeneous lists
-
tindex
Vec, slice and bitset with custom index types -
achan
& convenient representation for any value
-
nanobox
NanoBoxoptimization: store small item on stack and fallback to heap for large item -
datastruct
A pure-data structure builder
-
delete_if_not
unsafely in-place delete function
-
bytes_to_type
facilitate byte conversion to specified types using macro generation
-
hj_ds
A data structure library for Rust
-
yuuang_dominators
null
-
nstree
construct branched 'namespace strings' for nested subcomponents, often for logging
-
tdf_utils
such as tree
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
bloomy
Bloom filter using only two hash functions
-
framering
Queue-of-queues container
-
validated
The cumulative sibling of
ResultandEither -
immutable-avl
An Immutable map and set implement for rust based on an AVL tree
-
qt-json-rs
JSON library for QT
-
rc-box
Known unique versions of Rc and Arc
-
typescript-definitions-ufo-patch
serde support for exporting Typescript definitions
-
subway
Fast, performant in-memory SkipList implemented in Rust
-
vec-2-10-10-10
A 32-bit vector, where 2 bits are dedicated for alpha, and 30 bits are dedicated for color. Compatible with GL_UNSIGNED_INT_2_10_10_10_REV vertex attribute format.
-
rust-fp-pfds
A Functional Programming Library in Rust, Purely Functional Data Structure
-
probabilistic_data_structures
Probabilistic data structures in Rust Lang
-
deqmap
A double-ended queue with optional keys
-
predicates-core
An API for boolean-valued predicate functions
-
pegitan
A bunch of random algorithms library
-
another_radix_trie
Rust built radix tree library
-
sorting-vec
Sorts a vector using a btreemap
-
nnn
Generate your newtypes from a single macro
-
dsll
Fast Thread Safe Doubly Sorted Linked List
-
btree_graph
A generic graph data structure
-
sif-rtree
immutable, flat R-tree
-
btree_monstousity
a code port of BTreeMap but with comparator functions
-
sixarm_collections
Collections for HashMapToSet and BTreeMapToSet as trait extensions. By SixArm.com.
-
open-payments-iso20022-admi
Open Payments - Message Parsing Library - ISO20022 ADMI
-
secured_linked_list
A cryptographically secured and provable linked list
-
compact_bitset
A type for storing fixed-size arrays of booleans densely to optimize space
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
bitsetium
One stop shop for all bitset needs
-
pointer_vec
The PointerVec works same as the std Vec structure except the Vec has a size of 3 usize (pointer, length, capacity). This crate provides a replacement that has a size of 1 pointer.
-
banyan-utils
work with banyan trees
-
hashindexed
A cache. A set which compares elements in a customisable way without overriding the eq() and hash() functions on the type itself.
-
judy-sys
Low-level Judy array FFI binding
-
bondrewd
Bit-Level field packing with proc_macros
-
aces
Algebra of Cause-Effect Structures
-
ensf594-project-mmap
Final project for the ENSF 594 course of the University of Calgary, summer 2022
-
hashmap_vec
A HashMap with lists a values
-
contextual
deal with data in context
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
roaring-graphs
Graph data structure backed by roaring bitmaps
-
header-slice
Definitions for slices with headers, and a vec-like type with a header allocated inline
-
immutable-seq
Immutable sequence data structure
-
maybe-string
newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
zeen_filter
A fast and optimized Bloom Filter implementation in Rust
-
eimage
processing image collections in 3D space
-
collect
An experimental extension of std::collections
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
paged
Read and create read-only paged database files
-
bstree
A Binary Search Tree written in Rust
-
queue-rs
queue
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
compressed_map
'Static functions': compressed maps with the keys removed
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
bigraph
Different representations with implemented operations on bigraphs
-
append-only-bytes
Shareable append-only bytes
-
flashtext
algorithm to search and replace keywords in given text
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
libcanopy
Canopy is a lightweight tree-based data structure for Rust, optimized for reference management using Rc and Weak pointers
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
bits128
A struct to iterate over 128 bits by taking only 128 bits
-
random-access-storage
Abstract interface to implement random-access instances
-
fpdec
Decimal fixed-point arithmetic
-
aora
Append-only random-accessed data persistence
-
gentrix
that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
fixed-bigint
Fixed-size big integer implementation for Rust
-
bytey
convenient and easy to use byte storage
-
portable-network-archive
cli
-
graphstack
Graph-structured stack
-
exclusion-set
a lock-free concurrent set
-
mmap_bytey_byte_buffer
Mmap Bytey MByteBuffer code, use Mmap Bytey instead
-
voxel_chunk
A voxel object module which allows you to have private Chunk objects with methods to modify their data
-
deferred_vector
A deferred vector implementation
-
miniconf
Serialize/deserialize/access reflection for trees
-
collection
Deterministic, copy-on-write balanced search trees
-
loglevel
way to set your log level
-
no_proto
Flexible, Fast & Compact Serialization with RPC
-
const-arrayvec
A vec-like type backed by an array on the stack
-
vhr_datatypes
data/file structures used in the computer game Valheim
-
vortex-fastlanes
Vortex fastlanes arrays
-
btreelist
A list data structure that has efficient insertion and removal in the middle
-
tree-automata
Term Rewriting Systems
-
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
crdt-list
Abstract CRDTs for lists
-
event-queue
crates.io için bir paket nasıl hazırlanırın ele alındığı öğrenme amaçlı modüldür
-
map-of-indexes
A compact key-value map for unique but not dense indexes
-
stable_node_set
An ordered set with handles to values
-
enum_set2
A bit-set indexed by enum variants
-
xml2arrow
Efficiently convert XML data to Apache Arrow format for high-performance data processing
-
grafana-dashboard
grafana import/export data serializable structures
-
history-buffer
A fixed capacity, write-only, ring buffer
-
vpb
key-value proto buffer for veladb
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
fixedbitset-stack
A forked version of FixedBitSet that supports const generics
-
bit-set-omnitool
A set of bits
-
raw-vec
A Raw utility for managing contiguous heap allocations
-
tuple_list
macro-free variadic tuple metaprogramming
-
villa01-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
-
crossbeam-skiplist-mvcc
Support MVCC (Multiple Version Concurrent Control) for
crossbeam-skiplist -
persistent_rope
An immutable persistent rope data structure
-
vortex
file format with all builtin codecs and a sampling compressor
-
native_model
A thin wrapper around serialized data which add information of identity and version
-
tampon
Contains SAFE Rust functions, macro and trait to serialize / deserialize data structure and/or object and generate buffer
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
uberbyte
Bit manipulation for dummies
-
doubly-linked-list
double link list
-
lighter
Macro for rewriting string matches as tries
-
taganak-core
RDF types and interfaces from Taganak (Transactional, Aggregating Graph Architecture for Networking and Access to Knowledge)
-
slotmapd
orlp/slotmap fork where serialization cycle doesn't change observable behavior
-
hamst
Hash Array Mapped Shareable Trie
-
one-of
Macro to represent a type that can be converted either
FromorTryIntothe given types -
crossbeam-skiplist
A concurrent skip list
-
graph-arena
Collection type to store immutable graph structures efficiently
-
uid
creation of unique IDs
-
downstream
efficient, constant-space implementations of stream curation algorithms
-
aabel-bloom-rs
implements the Bloom filter
-
m6coll
Small Smart Collections using prefix m6
-
nonempty_range
Range representing nonempty ranges
-
eitherq
Queue which support two different types
-
index_graph
Graph library that only stores indexes from a base array
-
arbitrary-int
Modern and lightweight implementation of u2, u3, u4, ..., u127
-
generic
Higher level serialization of rust values to rust values
-
ldtk_map
reading ldtk maps for usage in games
-
empty-collections
Correct-by-construction empty collections
-
rdf_rs
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
token-string
Short (up to 65,535 bytes) immutable strings to e.g. parse tokens, implemented in Rust. These are sometimes called 'German Strings', because Germans have written the paper mentioning them.
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
uniplate
boilerplate-free operations on tree-shaped data types
-
oneoff
one-off types
-
modular-bitfield-ordering
Provide u8be..u128be, u8le..u128le for modular-bitfield
-
mytrie
Trie implmentation
-
vortex-mask
Vortex Mask - sorted, unique, non-negative integers
-
small_vec2
Vector on the stack or heap need nightly rustc
-
feature-set
User defined feature set
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
tany
Type-erased container with inline storage for small values
-
sliced
A segmented vector for iterating over slices
-
jinpyok_input
My comfortable user input methods
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
know_yaml
The Know Framework for Rust
-
hashcow
HashMap implementation with copy-on-write keys and values
-
pi_world
ecs world
-
roopes
Object Oriented Pattern Element System. This crate provides generic traits and implementations for typical object-oriented patterns. It is intended to be used as a cluster of utility…
-
bit-array
A compile time sized array of bits
-
zerovec
Zero-copy vector backed by a byte array
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
anymap3
A safe and convenient store for one value of each type
-
skew-forest
Skew-binary random access lists
-
ranno
Annotations over recursive data structures
-
stack-stack
stack-allocated stack
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
unsized-stack
Fast heterogeneous / unsized stack
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
arrsingh-lists
A test crate to test publishing
-
stac-validate
Validate STAC objects with jsonschema
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
rc-borrow
Borrowed forms of Rc and Arc
-
bytebufrs
A ring buffer for bytes implementing io::Read and io::Write
-
explicit-discriminant
Macro for enforcing enum discriminants
-
graph-api-benches
Benchmarking utilities and performance tests for the graph-api ecosystem
-
nybbles
Efficient nibble-sized (4-bit) byte sequence data structure
-
vizz
creating GraphViz/DOT visualizations of Rust data structures
-
stof
unified data interface and interchange format for creating, sharing, and manipulating data. Stof removes the fragile and cumbersome parts of combining and using data in applications.
-
awint_macros
Accompanying procedural macros to
awint -
ctb
ctb unifies borrowed and owned values into a smart pointer that is internally borrowed to retain ownership
-
flit
Bloom filter backed by xxHash
-
kurve
Adjacency list graph data structure
-
collection_traits
Collection traits & utilities; work in progress
-
pathlink
A URL type whose path can also be used as a filesystem path, for Rust
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
svec
Dart-style list in Rust
-
stapifaction
allowing to easily generate static APIs
-
compact-map
'Small map' optimization: store up to a small number of key-value pairs on the stack
-
trie
An ordered map and set based on a trie
-
stacking
using a stack datastructure in rust
-
gavl
A fast implementation for a map and a set using an AVL tree
-
bloom_filter_simple
generic bloom filter implementation
-
arc-vector-rust
Rust client for Arc Vector Search Engine
-
arbtree
A small library for general purpose tree data structures
-
linked_lists
Different types of linked lists
-
hff-core
Hierarchical File Format: core structure
-
erasable
Type-erased thin pointers
-
rusty_list
A no_std compatible, intrusive doubly linked list implementation
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
velect
A Vec with item / index selection
-
enumap
A HashMap and HashSet like interface for enums backed by an array
-
append-only-vec
Append-only, concurrent vector
-
grid_trait
2D and 3D grids with combinators
-
plum
Probabilistic data structures for rust
-
stable_queue
Queues with stable indices
-
maybe-multiple
An extension of
Optionwhich can hold none, one or multiple elements -
bit_range
A small library for getting bits and ranges of bits from byte collections
-
cursorvec
Cursored vector container
-
eclectic
Experimental collection traits
-
dimsum
multi-dimensional array library
-
bset
Fast and compact sets of bytes or ASCII characters
-
terms
Tree terms and patterns data structures
-
flat_bit_set
有序、稀疏、节省空间的 bitset，适用于小数据量
-
slotmap-fork-otter
Slotmap data structure - temporary fork for Otter
-
rb
A thread-safe ring buffer with blocking IO
-
power_map
A map with finite key and fixed size
-
my-stack
stack implementation in Rust
-
fill
trait, an alternative to Extend for finite containers
-
picocadrs
working with picoCAD saves
-
stonks
Sets that allow borrowing while inserting entries
-
open-payments-iso20022
Open Payments - Message Parsing Library - ISO20022
-
r-collections
Created some collection example LinkedList, Stack and Queue
-
trie-generic
A trie with generic content
-
perm-vec
Datatype representing permutations of indices
-
louds
LOUDS implementation for Rust
-
vortex-proto
Protocol buffer definitions for Vortex types
-
smolbox
Like a Box, but small objects are stored on the stack
-
key_set
KeySet representing concepts of All, None, Some(list), and AllExceptSome(list), with basic set calculations (intersection, difference, inverse)
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
glace
A type-safe, user-friendly proc macro for embedding a file tree into your code
-
unrecurse
Helper crate for rewriting your recursive code in iterative way
-
double-buffer
double buffer generic implementation
-
littlechestnutgames-trie
A generalized trie implementation for quick prefix searching
-
timed_set
timed set in Rust to store elements for a given time period
-
immutable
persistent data structures for Rust
-
option_vec
Vec<Option<T>>-like container
-
mdarray
Multidimensional array for Rust
-
fral
Functional random-access lists
-
loro-preload
Loro internal lib for loading data
-
btree_dag
A generic DAG (undirected graph) data structure
-
get-many-mut
Stable polyfill for slice::get_many_mut
-
lesbar-macros
Procedural macros for string types that encode legible text
-
generic-json
Generic JSON traits
-
tennis
data structures
-
enum_from_variant
macro to generate From<T> trait implementations for enum variants, simplifying error conversions and enum mapping
-
nbits_vec
Small bits value (e.g. 1,2.. bits) vector implementation.
-
causal-length
CRDT's based on causal length sets
-
rdf-borsh
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
nexum
collection of commonly used data structures
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
fixed_free_list
A fixed-size free-list with optional key lifetime safety and macroless unique typing
-
baffa
Generic buffer for bytes
-
pulz-bitset
bitset implementation
-
orx-concurrent-iter
A thread-safe and ergonomic concurrent iterator trait and efficient lock-free implementations
-
v-trie
Just a generic compressed prefix tree
-
bagofholding
collection types. Efficient data structures that look bigger on the inside.
-
querable
Quer(y)able data structure implementation
-
kudzu
concurrent, grow-only data structures
-
typescript-definitions
serde support for exporting Typescript definitions
-
ringvec
ring buffer implementation based on a vector
-
bit_collection
A trait for iterating over the individual bits of a collection
-
bstorage
A lightweight library for working with application configuration files
-
out-reference
out references
-
ziku-pds
probabilist data structures
-
simple_trie
array backed trie
-
dynvec
DynVectype that acts like a vector to store any datatype -
taganak-orm
ORM (object-relational mapper) for Rust dataypes onto Taganak graphs
-
passive
A trio of marker traits to classify passive data structures
-
orx-concurrent-vec
A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations
-
fp-collections
An alternate collections library for rust
-
iregex-automata
Finite automata definitions for the
iregexcrate -
lupine
A bloom filter using FX Hash with Kirsch and Mitzenmacher optimization
-
im-rope
Unicode strings backed by RRB vectors
-
transit_model_collection
Manage collection of objects
-
tuco-core
Contains the Tuco trait, used by the Tuco crate
-
compacts
compact data structures
-
slice-deque
A double-ended queue that Deref's into a slice
-
stack-trait
Stack trait with entry API for the LIFO element
-
vec-x
structure
VecXto manage fixed-length arrays, supporting numeric operations and assignment operations betweenVecXand scalar values -
merkle-search-tree
A data structure for efficient state-based CRDT replication and anti-entropy
-
bounded-vector
Vec wrapper that guarantees upper and lower bounds on type level
-
atlist-rs
LinkedList which is allowed to insert/remove element by immutable iterator.Adding, removing and moving the elements within the list or across several lists does not invalidate the iterators or references…
-
umili
Mutate and observe Rust data structures
-
derive-visitor
Derive visitor pattern for arbitrary data structures
-
by_address
Wrapper for comparing and hashing pointers by address
-
skl
A lock-free thread-safe concurrent ARENA based (heap backend or memory map backend) skiplist implementation which helps develop MVCC memtable for LSM-Tree
-
suffix_trie
Suffix trie for searching
-
sbf-blake3
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
bitty
Extract bits from, and put back into integer types
-
persistent-list
A singly-linked persistent thread safe list
-
to-display
A trait that is Display or can be converted to Display
-
collectables
collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
line-index
Maps flat
TextSizeoffsets to/from(line, column)representation -
evillatoro-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
one-stack-vec
OneStackVec could contain any number of item like
Vec, and it does heap allocation only when it contains more than one item -
smallvec-stableunion
Fork of the crate smallvec. Uses unions in stable rust. Please note that it can only store Copy types. No functional differences apart from that.
-
vortex-ipc
IPC message format to exchange Vortex arrays across processes
-
graph-traits
Traits for graph data structures
-
indextree-ng
Arena based tree structure by using indices instead of reference counted pointers. Fork of indextree by Sascha Grunert which allows to remove nodes
-
corosensei
A fast and safe implementation of stackful coroutines
-
ax_banyan_utils
work with banyan trees
-
rbloom
efficient and minimalistic bloom filter
-
hlist2
Compile-time heterogeneous list implementation
-
reference-interval
reference interval helpers a.k.a. reference range helpers.
-
hyper-tree-router
Routing middleware for Hyper http library using Prefix tree (trie) for path finding
-
dogma
Dogma.rs
-
functional_list
A functional, immutable list for Rust
-
open-payments-iso20022-remt
Open Payments - Message Parsing Library - ISO20022 REMT
-
do_util
Discrete Optimization utilitary library (data-structures)
-
terees
a collection of tree-like data structures
-
serde-ndim
Serde support for n-dimensional arrays from self-describing formats
-
intersection
Find the intersection over a collection of sets; when you need more than the intersection between two sets
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
handlebox
A map-like collection that reuses unused keys
-
dade
data definition for Rust structures
-
array_map
Map backed array for fixed size keys with O(1) performance
-
prio-queue
priority queue implemented as a heap stored in a Vec
-
nth-cons-list
The nth cons list implementation
-
matrixable
Traits and structs extending capabilities of matrix-like structures
-
frozen-collections-core
logic for frozen collections
-
buf-list
A list of buffers that implements the bytes::Buf trait
-
disjoint-collections
Disjoint-set data structures
-
bloomy-rs
Fast bloom filter implementation
-
opt_arrayvec
Vector-like container with fixed capacity, using options instead of stored length
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
yoke
Abstraction allowing borrowed data to be carried along with the backing data it borrows from
-
trs
Term Rewriting Systems