-
indexmap
A hash table with consistent order and fast iteration
-
hashbrown
port of Google's SwissTable hash map
-
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.
-
phf
Runtime support for perfect hash function data structures
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
arc-swap
Atomically swappable Arc
-
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
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
roaring
A better compressed bitset - pure Rust implementation
-
slotmap
data structure
-
bit-vec
A vector of bits
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
enum-map
A map with C-like enum keys represented internally as an array
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
bimap
Bijective maps
-
tinystr
A small ASCII-only bounded length string representation
-
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
-
yoke
Abstraction allowing borrowed data to be carried along with the backing data it borrows from
-
croaring
Rust wrapper for CRoaring
-
wide
help you go wide
-
fixedbitset
bitset collection
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
im
Immutable collection datatypes
-
smartstring
Compact inlined strings
-
generator
Stackfull Generator Library in Rust
-
histogram
A collection of histogram data structures
-
linked_hash_set
HashSet with insertion ordering
-
ego-tree
Vec-backed ID-tree
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
rowan
generic lossless syntax trees
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
dlopen2
opening and operating on dynamic link libraries (also known as shared objects or shared libraries)
-
enumset
creating compact sets of enums
-
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.
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
intaglio
UTF-8 string and byte string interner and symbol table
-
smallbitvec
A bit vector optimized for size and inline storage
-
yrs
High performance implementation of the Yjs CRDT
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
bloomfilter
Bloom filter implementation
-
ringbuffer
A fixed-size circular buffer
-
radix_trie
Generic radix trie data-structure
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
bitmaps
Fixed size boolean arrays
-
index_vec
Newtype-style helpers for
Vecandusize -
array-init
Safe wrapper for initializing fixed-size arrays
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
ecow
Compact, clone-on-write vector and string
-
las
Reads and writes point clouds stored in the ASPRS las file format
-
spade
Delaunay triangulations for the rust ecosystem
-
rpds
Persistent data structures with structural sharing
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
intmap
Specialized HashMap for integer keys
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
thin-vec
A vec that takes up less space on the stack
-
egg
egraphs
-
enumflags2
Enum-based bit flags
-
multimap
A multimap implementation
-
smallbox
Small Boxoptimization: store small item on stack and fallback to heap for large item -
nonempty-collections
Correct-by-construction non-empty collections
-
orx-split-vec
An efficient dynamic capacity vector with pinned element guarantees
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
narrow
Apache Arrow
-
imbl
Immutable collection datatypes
-
fastbloom
The fastest Bloom filter in Rust. No accuracy compromises. Compatible with any hasher.
-
hashbag
An unordered multiset implementation using a hash bag
-
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
-
sequential-storage
storing data in flash with minimal erase cycles
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
gxhash
non-cryptographic algorithm
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
array-macro
Array multiple elements constructor syntax
-
jaq-json
JSON values for jaq
-
gix-hashtable
that provides hashtable based data structures optimized to utilize ObjectId keys
-
yada
double-array trie library aiming for fast search and compact data representation
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
ph
data structures based on perfect hashing
-
cordyceps
Mycelium intrusive data structures
-
modql
Model Query Language support
-
equivalent
Traits for key comparison in maps
-
arrow-array
Array abstractions for Apache Arrow
-
dary_heap
A d-ary heap
-
uluru
fast, LRU cache implementation
-
qfilter
Efficient bloom filter like datastructure, based on the Rank Select Quotient Filter (RSQF)
-
boa_interner
String interner for the Boa JavaScript engine
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
typed_floats
Types for handling floats with type checking at compile time
-
zerofrom
trait for constructing
-
vec_map
map based on a vector for small integer keys
-
grid
Dynamic generic 2D data structure
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
walker-common
Common functionality for SBOM and CSAF walker
-
string
A UTF-8 encoded string with configurable byte storage
-
immutable-chunkmap
A fast immutable map and set with batch insert and update methods, COW operations, and big O efficient implementations of set and merge operations
-
loro-rle
A internal library of loro for storing and manipulating run-length encoded data. Do not use it directly.
-
range-collections
Sets and maps of ranges, backed by smallvec
-
cita_trie
Modified Patricia Tree (aka Trie)
-
vers-vecs
A collection of succinct data structures supported by fast implementations of rank and select queries
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
bloom2
Fast, compressed, 2-level bloom filter and bitmap
-
indexset
A two-level BTree with fast iteration and indexing operations
-
bittle
Zero-cost bitsets over native Rust types
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
fqdn
FQDN (Fully Qualified Domain Name)
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
iset
Map and set with interval keys (x..y)
-
newtype-uuid
Newtype wrapper around UUIDs
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
lsm-tree
A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)
-
portgraph
Data structure library for directed graphs with first-level ports
-
open-payments-fednow
Open Payments - Message Parsing Library - FedNow
-
fm-index
FM index and its variant implementations for Rust
-
crop
A pretty fast text rope
-
dlv-list
Semi-doubly linked list implemented using a vector
-
pi_slotmap
Slotmap data structure
-
phf_codegen
Codegen library for PHF types
-
deep_causality
Computational causality library. Provides causality graph, collections, context and causal reasoning.
-
iptrie
IPv4/v6 prefixes lookup structures (based on tries)
-
circular-queue
A circular buffer-like queue
-
caches
popular caches (support no_std)
-
vecmap-rs
A vector-based map and set implementation
-
sbat
UEFI Secure Boot Advanced Targeting (SBAT) no_std library
-
intervallum
Generic interval and interval set library
-
bitm
bit and bitmap (bit vector) manipulation
-
timed-map
Lightweight map implementation that supports expiring entries and fully compatible with both std and no_std environments
-
bitfield-struct
Struct-like procedural macro for bitfields
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
hibitset
Hierarchical bit set structure
-
vart
An immutable versioned adaptive radix trie
-
hpo
Human Phenotype Ontology Similarity
-
arrow-select
Selection kernels for arrow arrays
-
idlset
Fast u64 set operations library
-
keyvi
key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
bytes-utils
Additional utilities for working with the bytes crate
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
rsdict
Fast static rank and select data structure
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
bitflag-attr
A macro to generate bitflags structures from C-like enums
-
xsd-types
XSD data types
-
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. -
phf_shared
Support code shared by PHF libraries
-
array-concat
Macros for concatenating const arrays
-
xml-builder
Easy and highly-configurable XML builder/writer
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
tinyset
Size-optimized sets
-
undo
An undo-redo library
-
btree-range-map
B-tree range map implementation
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
cactus
Immutable parent pointer tree
-
rust_dynamic
Support for dynamically-typed values in run-time
-
trees
General purpose tree data structures
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
cow_hashbrown
port of Google's SwissTable hash map with copy-on-write support
-
bridgetree
A space-efficient Merkle tree designed for linear appends with witnessing of marked leaves, checkpointing & state restoration
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
queue-file
lightning-fast, transactional, file-based FIFO
-
short-uuid
generate and parse short uuids
-
tree-ds
manipulate tree data structures
-
i256
Optimized implementations of 256-bit signed and unsigned integers
-
xorf
implementing xor filters - faster and smaller than bloom and cuckoo filters
-
toodee
A lightweight 2D wrapper around a Vec
-
chat-prompts
Chat prompt template
-
sparsevec
Compress vectors using row displacement
-
interavl
An optimised interval tree for efficient interval stabbing
-
spatialtree
A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
rdf-types
Data-structures and traits definitions for RDF
-
value-log
Value log implementation for key-value separated LSM storage
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
uuid-rng-internal
Private implementation details of the uuid crate
-
tracker
A macro to track changes on structs
-
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… -
baby_shark
Geometry processing library
-
slotmap-careful
Wrap the slotmap crate and prevent key reuse
-
array2d
A fixed sized two-dimensional array
-
cdg_api
interact with api.congress.gov
-
griddle
A HashMap variant that spreads resize load across inserts
-
alot
A forbid-unsafe, generational slot map with usize-sized IDs
-
dup-indexer
Create a non-duplicated index from Strings, static str, Vec, or Box values
-
blart
adaptive radix tree packaged as a BTreeMap replacement
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
wildbird
Rust Framework 🐦
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
ergo_avltree_rust
cryptographically authenticated dictionary based on AVL tree
-
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…
-
ringmap
A hash table with consistent deque-like order and fast iteration
-
map_vec
The Map and Set APIs backed by Vec
-
merkletree
Light merkle tree implementation with SPV support and dependency agnostic
-
xor_name
Xor Type
-
istio-api-rs
A collection of CRDs for api used in Istio
-
delay_map
HashMap collections whose entries expire after a given time
-
block-grid
A quick, cache-conscious, tiled 2D array
-
diff-struct
A trait for diffing and applying diffs to types
-
ordered
A wrapper for adding arbitrary partial/total order to a type
-
dh
Data handling in Rust, made easy
-
yffi
Bindings for the Yrs native C foreign function interface
-
broccoli
broadphase collision detection algorithms
-
ftree
A very fast fenwick tree implementation
-
hashslab
A hash table with data accessible by index
-
hi_sparse_bitset
Hierarchical sparse bitset. Incredibly high performance. Compact memory usage.
-
cc-traits
Common collection traits
-
stack-graphs
Name binding for arbitrary programming languages
-
sync-ptr
Sync & Send wrappers for raw pointer's
-
smallvec-wrapper
Macro and common structs to play with
smallvec -
orx-fixed-vec
An efficient fixed capacity vector with pinned element guarantees
-
raft-log
Raft log implementation
-
slice_ring_buf
A ring buffer implementation optimized for working with slices
-
rt_ref
Internal
Reftypes forrt_refandrt_vec -
stac-server
SpatioTemporal Asset Catalog (STAC) API server
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
grovedbg-types
Common type definitions for data exchange over GroveDBG protocol
-
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…
-
more_collections
Additional collections not found in std::collections
-
linearize
Types that are enumerable and an array-backed map
-
unsized-vec
Like Vec, but for unsized values
-
tskit
rust interface to tskit
-
stack-queue
Heapless auto-batching queue
-
beap
Bi-parental heap data structure implementation in Rust
-
adflib
handle amiga disk files
-
id_tree
creating and modifying Tree structures
-
bose_einstein
A data structure that efficiently partitions elements into two sets
-
traitgraph
Abstracting over different graph representations
-
canopydb
Transactional key-value storage engine
-
nodit
Discrete Interval Tree Data-Structures, which are based off BTreeMap
-
nnn
Generate your newtypes from a single macro
-
kempt
Ordered collection types with no unsafe code and no_std support
-
scapegoat
Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
byteview
Thin, immutable zero-copy slice type
-
min-max-heap
An efficient, double-ended priority queue
-
atomicow
A
Cow-like data structure where owned data is stored inside anArc -
entid
generating and validating type-safe, prefixed entity identifiers based on UUIDs and ULIDs
-
roadmap
model a project roadmap as a directed acyclic graph
-
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
-
csaf-walker
work with CSAF data
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
xmltv
electronic program guide (EPG) parser and generator using serde
-
linear-hashtbl
Linear probing hash table
-
valkyrie-ast
Strong typed abstract syntax tree of valkyrie language
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
bumparaw-collections
A small set of bumpalo-backed collections for low-level operations
-
c_vec
Structures to wrap C arrays
-
persistent-kv
Persistent key-value store
-
differential-dataflow-master
An incremental data-parallel dataflow platform
-
stacked_errors
high level error propogation with software controlled backtraces
-
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.
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
json-number
JSON number parsing and storage
-
pin-list
A safe
Pin-based intrusive doubly linked list -
dot2
generating Graphviz DOT language files for graphs
-
dequemap
A no_std compatible implementation of the dequemap crate
-
snowid
generating SnowID - a Snowflake-like timestamp-based distributed unique identifier
-
loro-delta
Loro internal library. It's used as a delta between two versions of text or lists. It's also an efficient Rope.
-
smallstr
String-like container based on smallvec
-
st-map
Runtime for a stack-alocated map
-
dlx-rs
dancing links in Rust
-
slabmap
HashMap-like collection that automatically determines the key
-
snowflake_me
A distributed unique ID generator inspired by Twitter's Snowflake
-
libwebnovel
enabling users to get chapters of a webnovel, with multiple available backends
-
ordered-multimap
Insertion ordered multimap
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
ball-tree
K-nearest neighbors
-
garnish_lang_traits
Shared traits for garnish core libraries
-
libcanopy
Canopy is a lightweight tree-based data structure for Rust, optimized for reference management using Rc and Weak pointers
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
edtui-jagged
A jagged array data structure for the edtui editor
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
oxidd-test-utils
Test utilities for OxiDD
-
tailcall-chunk
persistent data structure for efficient append and concatenation operations
-
packedvec
Store vectors of integers efficiently
-
flatk
Flat layout abstraction toolkit
-
heavykeeper
finding the top-k elements of a stream of data
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
matreex
matrix implementation
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
spacetimedb-data-structures
Assorted data structures used in spacetimedb
-
field_access
Dynamically access struct fields
-
scopegraphs
A well-documented port of scopegraphs to Rust
-
superset_map
Map that stores distinct supersets based on the total order defined
-
pipebuf
Efficient byte-stream pipe buffer
-
validated
The cumulative sibling of
ResultandEither -
simple-grid
2d-grid structure
-
tetengo_trie
A trie library implemented with a double array
-
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. -
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
lsph
Learned Spatial HashMap
-
xml2arrow
Efficiently convert XML data to Apache Arrow format for high-performance data processing
-
ordsearch
A data structure for efficient lower-bound lookups
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
ux-primitives
Graphics Primitives for Angular Rust
-
minivec
A version of Vec that's only the size of a single pointer
-
flat_spatial
Flat spatial partitionning algorithms and data structures
-
typeid_prefix
that implements a type-safe version of the TypePrefix section of the
TypeIDSpecification -
jcm
Pure Rust implementation of the JCM USB communication protocol
-
matrixable
Traits and structs extending capabilities of matrix-like structures
-
normalize_interval
Normalizing interval library
-
extindex
Persisted immutable index
-
blazemap
Implements a vector-based slab-like map with an interface similar to that of HashMap, and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
treeclocks
Various Tree Clock data-structures and utilities
-
bevy_spatial
tracking bevy entities in spatial indices
-
i_shape
iShape is a compact and efficient library specifically designed for representing 2D data structures using IntPoint
-
rs-ecs
reasonably simple entity component system
-
hlist2
Compile-time heterogeneous list implementation
-
pdatastructs
probabilistic data structures
-
ttgraph
Typed/Transactional Graph container
-
among
The enum
Amongwith variantsLeft,MiddleandRightis a general purpose sum type with three cases -
stac
SpatioTemporal Asset Catalog (STAC) specification
-
pasture-core
A framework for working with point cloud data
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
cola
A text CRDT for real-time collaborative editing
-
type-map
typemap container with FxHashMap
-
graph_process_manager_core
explore parts of a tree-like or graph-like structure that is not known in advance
-
bv
Bit-vectors and bit-slices
-
sucds
Succinct data structures in Rust
-
clone_cell
A Cell that works with a restrictive form of Clone
-
form_builder
building forms with various fields and validation
-
polytype
A Hindley-Milner polymorphic typing system
-
product-os-http-body
Product OS : Http Body is a derivative of the http-body and http-body-util crates restructured for both std and no_std environments
-
mapgraph
A directed graph that can also be used as an arbitrary map
-
h3o-ice
Frozen{Map,Set} for H3 cells, based on finite state transducers
-
typemap_rev
A hashmap, but stores types as keys
-
avl
A map and a set implemented with an AVL tree
-
differential-dogs3
Advanced join patterns in differential dataflow
-
lean_string
Compact, clone-on-write string
-
arrayset
An array-backed ordered set type
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
bitfield-rle
A run-length-encoder that compresses bitfields
-
foyer-intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
span-map
A data structure for efficiently managing sets of values over spans/ranges
-
varuint
Variable length signed and unsigned integer types
-
jaggedarray
Multidimensional jagged array
-
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…
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
unordered-pair
A tuple struct representing an unordered pair
-
pi_slot
lock free Slotmap data structure
-
json_deref
JSON internal field links resolver
-
sized-chunks
Efficient sized chunk datatypes
-
mikufans-proto
gRPC APIs for Mikufans
-
eventio
A collection of event I/O processors for event-processing applications
-
optional
supplies a number of Option-like primitive types
-
fixed-slice-vec
FixedSliceVecis a dynamic length Vec with runtime-determined maximum capacity backed by a slice -
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…
-
seoul
trait Isomorphism
-
tuplez
Tuples represented in recursive form
-
fvm_ipld_kamt
Sharded IPLD Map implementation with level skipping
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
nlist
inline-allocated list with statically tracked length
-
fvm_ipld_hamt
Sharded IPLD HashMap implementation
-
intervals-general
enabling general representation of and operations on intervals over generic types (e.g. supporting units of measure or arbitrary built-in types, or any type with PartialOrd implementation).
-
dachshund
graph mining library written in Rust. It provides high performance data structures for multiple kinds of graphs, from simple undirected graphs to typed hypergraphs. Dachshund also provides…
-
do-notation
Monadic do syntactic sugar
-
hextree
Location to value mapping
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
heapless_graphs
composable graphs for no_alloc environments
-
pineappl
not an extension of APPLgrid
-
stavec
Stack-allocated vector with static capacity
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
attribute-search-engine
Generic search engine for rows with attributes using different matchers
-
swamp-script-source-map-lookup
Source map lookup for Swamp
-
bitboard64
A 64-bit bitboard useful for chess programming
-
flatcontainer
A flat container representation for Rust
-
rdf-model
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
enum-collections
Collections data structures optimized for Enum, initializable at runtime
-
minimizer-iter
Iterate over minimizers of a DNA sequence
-
keyed-set
Keyed Set: a hashbrown-based HashSet that indexes based on projections of its elements
-
array-init-cursor
help keep track of arrays of MaybeUninit
-
dlopen
opening and operating on dynamic link libraries (also known as shared objects or shared libraries). This is a modern and more flexible alternative to the already existing libraries like libloading or sharedlib
-
plain_trie
Classic trie implementation capable of mapping any T to char iterator
-
fastset
Fast set implementation for dense, bounded integer collections, optimized for quick updates and access
-
odht
hash tables that can be mapped from disk into memory without the need for up-front decoding
-
shardtree
A space-efficient Merkle tree with witnessing of marked leaves, checkpointing & state restoration
-
open-payments-iso20022-acmt
Open Payments - Message Parsing Library - ISO20022 ACMT
-
slabigator
A linked list that doesn't do dynamic memory allocations
-
rust_multistack
Support for two-dimentional stacks for the Rust programming language
-
supply-chain-trust-example-crate-000013
A hash table with consistent order and fast iteration
-
disjoint
Fast and safe implementation of the disjoint-set data structure
-
phf_generator
PHF generation logic
-
libpt
Personal multitool
-
compressed-intvec
A compressed integer vector with fast random access that stores values with instantaneous codes in a bitstream
-
csf
compressed static functions (maps) that use perfect hashing and value compression
-
agb_hashmap
no_std hashmap implementation intended for use in the
agblibrary -
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
-
tagid
Defines a newtype labeled tagging for different types of ids
-
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…
-
vec-strings
Store any string efficiently in an immutable way
-
easy-tree
efficient tree structure library for Rust with recursive traversal
-
roussillon-type-system
A type system for a programming language
-
try_reserve
Stable implementation of the TryReserveError from std for custom collections
-
madeleine
Transparent object persistence with predefined operations and state containers
-
kn0sys-ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
velarixdb
An LSM Storage Engine focused on reduced IO amplification
-
packed-uints
Array of uints that scales from u4 to u32 to minimize wasted space while still being fast
-
bitpack-vec
A vector for arbitrary bitwidth integers, densely packed
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
im-lists
Persistent unrolled linked lists and vlists
-
any-rope
A fast and robust arbitrary rope for Rust. Based on Ropey.
-
data_reader
A data loading library for data scientist
-
graphbench
A sparse graph analysis library
-
yrs_tree
implementing a CRDT-based tree data structure powered by Yrs
-
anchors
async incremental computations
-
farmap
working with Farcaster label datasets
-
arraystring
Fixed capacity stack based generic string
-
ptx-ir
Parallel Thread Execution (PTX) IR structure and parser
-
defaultmap
HashMap with an automatic default for missing keys
-
awint_ext
Externally allocating
awintfunctionality -
shrink-to-fit
Recursively calls
shrink_to_fiton all elements of the container -
windows-collections
Windows collection types
-
list-fn
A generic lazy list
-
decomp
Components of a decompilation pipeline
-
mule-map
A hybrid between a HashMap and a lookup table
-
pas
strided slice
-
gpt_disk_types
GPT (GUID Partition Table) disk data types no_std library
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
ordinal-map
Ordinal trait to map values to integers and efficient maps and sets for such types
-
hotel
Collection Data-structure to associate values with keys
-
bondrewd
Bit-Level field packing with proc_macros
-
sigma-types
Types checked for an invariant
-
rust_flightweather
Decodes METAR and TAF
-
hprtree
A Hilbert-Packed-R-Tree implementation for rust
-
radixmap
Rust-based Radix Tree for fast prefix lookup, supporting named param, glob, regex
-
collect-rs
Special and custom Collections and Containers (for Rust)
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
cphf
Compile-time perfect hash function data structures
-
orbweaver
designed for effortless construction and analysis of graph data structures
-
value-ext
Serde Json Value Extension Trait (more Value type later)
-
flatbuffers-owned
that enables a more flexible usage of FlatBuffers
-
engcon
macros to define (eng)ineering (con)tracts on data-structure level
-
strict
collections with strict bounds
-
entity_data
A container for entity component data
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
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…
-
structz
Anonymous struct implementation in rust
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
strumbra
Umbra-style strings (also known as German strings)
-
skiplist
in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
flatten_objects
A container that stores numbered objects. Each object can be assigned with a unique ID.
-
char_index
efficient charwise indexing into a string
-
ninjabook
A lightweight and high performance orderbook
-
fingertrees
Immutable persisten finger trees
-
qutee
A quadtree implementation
-
sortedlist-rs
A fast sorted list data structure in rust
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
validit
Validate data structures internal state
-
vecdeque-stableix
Deque with stable index values
-
mmdb
A std-collection-like database
-
dogma
Dogma.rs
-
trie-hard
Fast implementation of trie data structure
-
line-straddler
Determine how lines through text (underlines, strikethroughs, etc) should be rendered
-
voxtree
sparse voxel 64-tree implementation in rust
-
stable-map
A hash map with temporarily stable indices
-
trie-root
In-memory patricia trie operations
-
exhaustive-map
An exhaustive map for types with finite inhabitants
-
mangadex-api-input-types
A collection input types for mangadex-api
-
rust-tls-duplex-stream
Full Duplex stream Wrapper around rust-tls
-
ocpp_rs
Protocol implementation for Open Charge Point Protocol (OCPP) in Rust
-
uid_store
Generate random uid strings containing letters, numbers, or base62 values
-
cell-grid
2d grid container
-
rustdf
interacting with Bruker TDF formatted Raw Data
-
linker-set
Declarative programming via linker-constructed arrays
-
psrutils
few utilities to facilitate pulsar science projects in rust
-
dia-i18n
-
gen_value
indexes and values with generations for vectors
-
indexed_arena
index-based arena without deletion
-
map-macro
Declarative macros for statically initializing collections
-
scope-cell
temporary, scope-bound, and thread-safe mutation of data in Rust
-
re_string_interner
string interning library
-
kollect
Collections made ergonomic for gamedev usecases
-
deepmesa
fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
bitstring-trees
Trees based on bitstrings
-
singletonset
SingletonSetdata structure, which makes it easy to store a single instance each of various types within a single set -
twine-components
A collection of components for Twine, a Rust framework for functional and composable system modeling
-
rand_pool
Create a pool of random numbers pre generated thread safe
-
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.
-
snowflake-ng
Dead easy and high performance
snowflakeimplemented in Rust -
tagged_ufs
A union-find-set implementation, in which sets can be associated with tags. When two sets are united, their tags are merged
-
bitvek
bit vector implementation
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
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… -
linked-list
An alternative implementation of std::collections::LinkedList
-
signalk
parse signalk maritime data
-
identity_map
Identity-based maps
-
key-path
Key path for Rust
-
orn
A general implementation of the sum type. Meant to be a generic counterpart to tuples.
-
flat-tree
Series of functions to map a binary tree to a list
-
aliasable
Basic aliasable (non unique pointer) types
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
spaghetto
making double-ended data structures, like an always-contigouous double-ended queue (deque) and double-ended string
-
rpds-pathtree
Immutable, path-addressable tree data structure
-
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
-
smooth-json
opinionated, customizable utility to flatten serde_json Value variants into serde_json Objects ready for use in columnar or table-like usages
-
lctree
Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees
-
HArcMut
mutable arc
-
data-source
that fetches data from different sources
-
space
providing abstractions for spatial datastructures and search
-
queues
Efficient FIFO Queue data structures
-
bin-it
efficient Rust library for binary serialization and deserialization
-
taskchain
A block-based, non-circular double-linked list implementation for Rust
-
ligature
Ligature's data model in Rust
-
covey-plugin
APIs for creating Covey plugins
-
lesbar
String types that must encode legible text
-
blas-array2
Parameter-optional BLAS wrapper by ndarray::Array (Ix1 or Ix2)
-
equivalent-flipped
Similar to
equivalentcrate, but flipsKandQ -
ndarray-histogram
Histogram support for n-dimensional arrays
-
Sparse-Voxel-64Tree
A lib for handling Sparse Voxel Contrees
-
threshold
data structures
-
loc_api
interact with the loc.gov API
-
stackmap
A fast stack-only hashmap for small high-performance scenarios
-
microkelvin
tree traversal over annotated data structures
-
data_registry
An unordered data structure with immediate insertion, removal and access
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
idbag
A bag of integers
-
enum-table
creating tables with enums as key
-
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
cow_hashmap
Hashmap with copy-on-write semantics that requires no locks
-
a-tree
A dynamic data structure for efficiently indexing arbitrary boolean expressions
-
aliri_base64
Wrappers that make debugging and using byte arrays a bit nicer
-
schema_generator
part of the ClimateForest project, which takes place between 01.03.2024–28.02.2027. It is funded by Interreg Aurora and supported by its contributors, including Metsäkeskus, Lapland University of Applied Sciences…
-
rtree_rs
R-tree for Rust
-
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.
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
tri-mesh
A triangle mesh data structure including basic operations
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
lookupvec
Container with Vec-like properties that also offers O(1) lookup of items based on an id field
-
prefix-sum-vec
Compressed storage for highly repeating elements, with
O(log n)lookups -
persian-rug
Framework for bringing together disparate objects with inconvenient relationships
-
pfds
Purely Functional Data Structures
-
plane-2d
Continuous 2D data structure representing infinite 2d plane
-
implies
A parser for logical formulas
-
pstd
parts of Rust std library ( different implementations, features not yet stabilised etc )
-
firims
fixed range integer maps and sets
-
hora-id
A 64-bit time-based sorted unique ID generator that includes the current time in the ID
-
sequential
A configurable sequential number generator
-
lox
Fast polygon mesh library with different data structures and traits to abstract over those
-
rindex
dynamic spatial index for efficiently maintaining *k* nearest neighbors graph of multi-dimensional clustered datasets
-
cve
Mappings for parsing the CVE JSON files
-
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
chinese-rand
Random generation of data structures in Chinese, using Rust
-
float16
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
serde_map
Mapbased onVecfor serialization purposes -
closed-interval-set
Unions of closed intervals as containers of pairs
-
untis
accessing the Untis API
-
swimos_client_api
SwimOS Client API
-
weak-table
Weak hash maps and sets
-
usize-set
Set data structures optimized to store sparsely distributed usize values
-
slas
Static Linear Algebra System
-
grovedb-costs
Costs extension crate for GroveDB
-
radix-heap
Fast monotone priority queues
-
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.
-
smodel
Symbol semantic modeling for Rust
-
orx-tree
A beautiful tree 🌳 with convenient and efficient growth, mutation and traversal features
-
markov-generator
Highly customizable library for building Markov chains and generating random data
-
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…
-
damped-springs
damped springs for smooth and springy motion
-
poppy-filters
providing serializable Bloom filters implementations
-
anymap2
A safe and convenient store for one value of each type
-
tld
Top Level domain static hash map, tld list is obtained from of iana.org
-
named_colors
that provides named colors in RGB and Hexadecimal formats
-
radicle-cob
Radicle Collaborative Objects library
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
whale
A lock-free, dependency-tracking primitive for incremental computation
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
settrie
Fast subset and superset queries
-
rb_tree
A Red Black Tree implementation in Rust
-
identified_vec
Like HashSet but retaining INSERTION order and without
Hashrequirement on the Element type -
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
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 -
sif-rtree
immutable, flat R-tree
-
incrementalmerkletree-testing
Common types, interfaces, and utilities for testing Merkle tree data structures
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
delatin
Fast TIN generation using Delaunay triangulation
-
linkedin-csv
Structs defined to hold the data as exported from LinkedIn
-
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.
-
beach_map
slotmap
-
arraysetcell
A fixed-capacity, vector-like array with interior mutability and no ordering guarantees
-
sigmars
sigmahq rule collections
-
ankurah-storage-sled
Ankurah storage engine using Sled
-
spart
A collection of space partitioning tree data structures for Rust
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
lru-mem
An LRU cache implementation bounded by memory
-
sharded
Safe, fast, and obvious concurrent collections
-
gh-workflow-tailcall
macros for gh-workflow
-
binary-greedy-meshing
A port of https://github.com/cgerikj/binary-greedy-meshing to Rust
-
walker-extras
Additional functionality for SBOM and CSAF walker
-
cbsk_socket
socket callback tool
-
gtfs-geojson
converter for GTFS to GeoJSON formats
-
vector
The package provides a vector database allowing for efficient search of nearest neighbors
-
standard_card
A Lightweight Library for Efficient Card Representation
-
libwebnovel-storage
A complement to libwebnovel: this package handles downloading and organizing collections of followed webnovels
-
atomic_ptr_cell
Safe no_std repr(transparent) wrapper for AtomicPtr and &AtomicPtr with an api similar to a cell
-
lignin
A virtual DOM structure, primarily for web use
-
scribe
Text editor toolkit
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
statiki
Static friendly data structures
-
basic_trie
Trie implementation in Rust
-
ascent-byods-rels
data structures for Ascent relations, made possible by Ascent's BYODS feature
-
iterable
collection like types
-
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
-
balanced-tree-index
constant-time manipulation of a complete binary tree with a flat in-memory representation
-
argmap
parse command-line arguments into a hashmap and vec of positional args
-
filesystem-trustfall-adapter
Filesystem Trustfall adapter
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
csvenum
Generate code for enums with associated constants from a .csv in your command line
-
retworkx
A python graph library implemented in Rust
-
dmfr-dataset-reader
Reads transitland folder and outputs graph of valid feeds and operators
-
lum_libs
Serves as a central collection and re-export of all external crates used in the lum framework to ensure consistent dependency versions across the framework
-
rust_cascade
bloom filter cascade implementation in Rust
-
trybox
stable,
no_std-compatible, fallible heap allocation -
nullnet-liberror
Error handling library for NullNet
-
rust_redux
A Redux-like state management library for Rust
-
splay-safe-rs
Splay implemented with safe rust
-
prepona
A graph crate with simplicity in mind
-
akita
Mini orm for rust
-
compact-rc
Low-memory reference-counting pointers
-
lophat
Lockfree Persistent Homology Algorithm Toolbox
-
multi_containers
Ergonomically work with multiple values per key
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
array_list
A dynamic container that combines the characteristics of a Vec and a LinkedList
-
ndim
N-dimensional array for numerals in Rust similar to NumPy
-
tf-semver
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
host-port-pair
Host-port pair type
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
btree-slab
A memory compact Slab-based B-tree implementation
-
openligadb
API
-
medea-reactive
Reactive mutable data containers
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
coca
Data structures with constant capacity
-
circbuf
A growable circular buffer for working with bytes
-
multidict
Python MultiDict implementation
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
bitvector
in Rust
-
doubloon
Money datatype that supports both statically and dynamically typed currencies
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
triangle_matrix
Triangle matrix indexing operations
-
clash_rules
a clash yaml rule parser and matching algorithms provider
-
timekeep-rs
efficient and reliable timekeeping functionalities, providing data structures and methods for creating, manipulating, and performing set operations on intervals
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
cseq
compact sequences
-
regroup
regrouping arrays
-
no_std_collections
Auxiliary structures and traits for using dynamically resizable arrays (Vectors) in flexible environments, supporting both std and no_std contexts
-
libnv
Safe and rustic wrapper around libnv-sys
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
semver-eq
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
gcollections
Generic traits over Rust collections library
-
id_collections
Index-oriented programming in Rust
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
indexed_json
Index json files like a database
-
hicollections
C-liked Collections
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
true_crab_utils
A collection of algorithms and data structures implemented in Rust
-
bitstring
traits and implementations
-
iowrap
Small helpers for using io::Read/io::Write
-
gridlife
generate and simulate Conways Game of Life cellular automatons
-
urcu2
Safe API to liburcu
-
tiled_parse_tree
Tree data structure
-
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…
-
geosite-rs
that parses geosite.dat file format
-
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
sweetrpg-kv-objects
Objects for Key-value store
-
alloc-checked
Collections that don't panic on alloc failures
-
opt_struct
Optional collections
-
motec-i2
MoTeC i2 file format parser and writer
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
lambda-runtime-types
Common structures for lambda architecture
-
floating_bar
Representing rational numbers using the floating-bar number type
-
onebuck
An efficient unordered dynamically-sized data structure
-
pi_append_vec
Only supports append vectors, lock free
-
indexland
Rust Collections with Newtype Indices
-
unnamed_entity
Strongly-typed indexing for vectors and other structures
-
graphplan
planning algorithm from Avrim L. Blum and Merrick L. Furst in Rust
-
pinned-deque
A high-performance double-ended queue, inspired by BOOST deque. Every element in this deque is pinned until its popping
-
i_tree
Red-black tree implementation for rust. Only for uniq elements
-
bye_octomap_rs
OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees. Implemented in pure Rust.
-
digit-sequence
Sequence of u8 digits
-
bitlab
Extracting a range of bits from a binary data source
-
ux-dx
3D Graphics Primitives for Angular Rust
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
ztimer
A block-based, non-circular double-linked list implementation for Rust
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
micromap-rawl
Fork of Micromap https://github.com/yegor256/micromap, the fastest alternative to HashMap, for maps smaller than 20 keys
-
ladata
& modular data model
-
golomb-coded-set
BIP158 Golomb-Coded Set data structure
-
atelier
a Computational Workshop for Market Microstructure Modeling, Synthetic Simulation and Historical Replay
-
mirl
Miners Rust Lib - A collection of ever growing functions and structs
-
fpq
Priority Queue with scoring Function
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
hydroperfox-smodel
Semantic modeling for Rust
-
forgy
Derive macro for building dependency graphs
-
rspack_collections
rspack collections
-
pfx
A prefix tree (map and set), implemented without any unsafe
-
evento
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
retaker
ecs implementation
-
chainbuf
Fast chained buffers
-
rdf-format
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
sql-json-path
SQL/JSON Path implementation in Rust
-
merkle_light
Light merkle tree implementation with SPV support and dependency agnostic
-
hash-rings
Implementations of various hash rings
-
syntastica-themes
A collection of themes for syntastica
-
rbtree
the rbtree for Rust
-
quadtree_simple
quadtree implementation
-
entity
that provides entity-like constructs
-
range-map
Maps and sets implemented using ranges
-
trk-io
TrackVis (*.trk) reader and writer
-
timeless
storing in-memory timeseries data
-
cplit
Competitive Programming Library in Rust
-
cantrip
Practical extension methods for standard Rust collections
-
ostr
Owned str
-
xskiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
header-vec
Vector with user-specified header, length, capacity, and array elements all stored on the heap together
-
croaring-sys
Raw bindings to CRoaring
-
shortguid
Short URL-safe Base64 encoded UUIDs
-
mset
/ multiset / bag implementation
-
varlen
Ergonomic variable-length types
-
lanyard
UTF-8 C string types
-
hit-data
Hierarchical Indexed Typed data structure
-
flatarray
Fast implementation of SeqEval, a sequence evaluation framework
-
generic-btree
Generic BTree for versatile purposes
-
commitlog
Sequential, disk-backed commit log library
-
sum
General-purpose sum types
-
ux-dataflow
Data Processing Library
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
fenwick
tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
umt_rust
UMT is a collection of useful functions that I personally created
-
weak-lists
Lists with weak references and concurrent iteration and modification
-
vectree
Vector-buffered tree collection with post-order, depth-first, mutable/immutable iterator
-
dcl_data_structures
Data structures for for deep_causality crate
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
kn0sys_ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
tree-iter
iterating over tree structures
-
cistring
A string type that preserve case, but compares insensitiveley
-
cgp-error-std
Context-generic programming error handlers implemented using
std::error::Error -
aatree
in Rust
-
type-set
A set of heterogeneous types
-
small-fixed-array
providing fixed length immutable collections with a low memory footprint
-
rangeset
Integer collection backed by ranges with set operation support
-
shiftnanigans
contains different iteration data structures for either iterating or for shifting iteratively forward and backward
-
bit-array-rs
Bit Array
-
modern-multiset
A hash multiset implementation
-
text-style
Types and conversions for styled text
-
fixed-collections
Dynamically allocated ungrowable collections
-
gridly
managing fixed-size 2D spaces
-
sliding_tree
A tree that grows from the leaves and recedes from the root
-
rt-lists
Link lib
-
twovec
A data structure for storing 2 types of data in a packed, heap allocated array
-
xorfilter-rs
Xor Filters: Faster and Smaller Than Bloom and Cuckoo Filters
-
enso-data
A collection of useful data structures
-
flammkuchen
Some data structures for fun and flammkuchen (e.g. a 2d grid which permits negative indices)
-
gw_signal
Package with signal processing tools for graviational waves studies
-
limq
Queue with optional maximum number of elements constraint
-
x-map
Extended map/vector structures for Rust
-
keysymdefs
A collection of key symbol definitions
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
inplace-vec-builder
Build a vec from a vec, in place
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
cses-rs
A CSES spec impl in Rust
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
set_genome
A genetic data structure for neuroevolution algorithms
-
iterlist
Linked list with a cursor based api
-
rtdlib
TDLib for rust
-
contexts
Implements a type for treating several hashmaps as one
-
tinyvec_string
tinyvec based string types
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
i24
working with 24-bit integers
-
segment-tree
Quickly perform interval queries or modifications
-
constructivism
Simplify the construction of structured data
-
micro_autotile
LDTK autotiling
-
atree
An arena based tree structure with removal support
-
fuzzy_prefix_search
Fuzzy search for prefix matches
-
merkle-heapless
Statically-allocated Merkle Tree and Mountain Range
-
nonempty-containers
Fast, zero-cost conversion, and fully inter-operable nonempty container types
-
merkle-log
"Merkle Tree-Structured Log" defined in the paper "Transparent Logs for Skeptical Clients." https://research.swtch.com/tlog
-
magnetise
asses the similarity between SQL queries
-
enum_meta
Add metadata to Enum Variants
-
gapbuf
Generic gap buffer
-
swaybar-types
building swaybar status commands in rust
-
indexlist1
A doubly linked list, backed by a vector
-
genmap
generational map data structure with no dependencies
-
monistode-assemblers
A collection of assemblers for the monistode set of architectures
-
lodtree
help create octrees and quadtrees for chunked level of detail
-
try-lazy-init
Fallible lazy initialization
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
density-mesh-core
Core module for density mesh generator
-
linear_collections
Map and Set types backed by linear data structures
-
quickselect
基于rust的选择算法
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
no-order
A transparent wrapper to ignore ordering and hashing of any value
-
sortedvec
a sorted vector that enables quick lookups
-
ordered_hash_map
HashMap which preserves insertion order
-
smallbitset
series of allocation free sets capable of holding small integer values
-
beat_saber_map
Read and write Beat Saber maps with Rust
-
gsgdt
Generic Stringly Typed Graph Datatype
-
nimbusqueue
fifo collection
-
codama-korok-plugins
Korok plugins definitions
-
wolf-graph-mermaid
Adds support for generating Mermaid diagrams from wolf-graph graphs
-
Xorfilter
No alloc membership approximation
-
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
-
scored_set
A scored sorted set data structure for Rust
-
sparse_set_container
A container based on sparse set. Stable keys, O(1) lookup, cache-friendly iterations, and no hashing.
-
linestring
line string toolbox
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
chronofold
A conflict-free replicated data structure (a.k.a CRDT) for versioned text
-
pocketbase-sdk
Pocketbase SDK
-
sentry-contrib-breakpad
Unopinionated crash collection for Sentry reporting purposes
-
malwaredb-api
Common API endpoints and data types for MalwareDB components
-
handlemap
A collection that produces handles that can be used as keys to retrieve the stored items
-
pvec
RRB-Tree based persistent vector implementation
-
mago-reflection
Offers data structures and APIs to represent and inspect PHP code elements—like classes, functions, and interfaces—enabling introspection and analysis
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
suff_collections
Fast realization of suffix array and suffix tree
-
debug_match
debugging and matching patterns in data structures
-
intervaltree
generic implementation of an immutable interval tree
-
hirpdag
procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
cmdtree
(Rust) commands tree
-
sparse-merkle-tree
Sparse merkle tree implement in rust
-
tree-sitter-traversal2
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
uberbyte
Bit manipulation for dummies
-
aircraft_icao_country
aircraft ICAO codes and their country of origin
-
rexsgdata
Scatter-Gather Data Descriptors
-
umili
Mutate and observe Rust data structures
-
gctree
cache-friendly, graph-like, arena-allocated datastructures
-
lru-st
A package providing a Vec based doubly linked list implementation and related data structures
-
gecs
A generated entity component system
-
minimizer-queue
Fast computation of minimizers using a monotone queue
-
compact-calendar
Compact representation of a set of days based on a bit-maps
-
open-payments-iso20022-camt
Open Payments - Message Parsing Library - ISO20022 CAMT
-
densevec
Map like collection with usize indices that stores values contiguosly
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
schema2struct
Convert a JSON schema into Rust structs for efficient and type-safe data management
-
ahtable
Array Hash Table implementation
-
higher
Functors, Applicatives, Monads and other bad ideas
-
sparseset
A Sparse Set
-
rive
ecosystem crate
-
intervals-rs
intervals
-
parallel_vec
A generic contiguous collection of heterogenous values
-
every_variant
EveryVariant trait that provides the every_variant method on types. Allows you to easily generate every combination of variants in structures that contains Enums, or in nested enum trees…
-
erased_set
A set of erased types
-
lazy-cow
Copy-on-write pointers with lazy modification support to minimise clones with a cost counter to limit work duplication
-
p7m-alarm
Rust bindings for the alarm API of P7M
-
range_bounds_map
[
RangeBoundsMap] and [RangeBoundsSet], Data Structures for storing non-overlapping intervals based of [BTreeMap] -
search_trail
manager of variables that can save and restore their values
-
cmsketch
A count min sketch implementation in Rust
-
td-wavegen
Tower Defense mob wave generator
-
seq-set
A Set collection that maintains insertion order
-
espalier
Very simple flattened tree structure
-
tinyvecdeq
VecDeque-like data structures -
set_derive
Using Macros to Implement List comprehension Similar to Python Language
-
fn-store
A dynamic persistent value store using closure type as key and storing its return value
-
emap
A map with a fixed capacity and integers as keys
-
url-hash
types that provide secure and stable hash values for Urls
-
arc-bytes
A reference-counted byte buffer
-
alignment-exporter
Proc macro providing alignment info for a user-defined struct
-
keylist
Elixir keyword list in Rust
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
intrusive-lru-cache
An LRU cache implementation using intrusive data structures
-
frozen-collections
Fast partially-immutable collections
-
cbsk_base
locked version cargo crates
-
netcrab
creating and exporting Petri nets
-
sbwt
Indexing sets of DNA k-mers with the spectral Burrow-Wheeler transform
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
exact-covers
Knuth's algorithm for solving the exact cover problem with colors
-
bytering
A ring buffer specialized for vectored reading and writing in blocking and async I/O
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
kodiak-sets
manage generic sets supporting unique features
-
bit-int
An arbitrary fixed bit-width integer library
-
dayendar
advanced days calendar operations
-
vecset
A vector-based sorted map, set and keyed-set implementation
-
diffogus
calculate the difference between 2 instances of a type
-
expiremap
Key-Value map where each value has a custom expiry time
-
vec-reg
Generalized regex like pattern matching for vector
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16coordinates. -
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
ascent_base
support library for the ascent package
-
sideko_postman_api
Rust API bindings - spostman_api
-
qptrie
A QP-Trie implementation for Rust
-
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… -
sweetrpg-model-core
Core model definitions for SweetRPG
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
boolvec
A vector of boolean stored contiguously in memory
-
morton-index
Types and functions for efficiently and easily work with Morton indices
-
slablit
Literal for slab creation
-
index_many
A proof of concept for indexing an slice at multiple locations at once
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
extract_map
A HashMap for memory efficent storage of value types which contain their own keys
-
kushi
A queue built for the Dango Music Player and Oden Music Bot
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
non_empty_continuous
Non-empty continuous collections
-
fixedvec
A heapless version of the Rust vector type
-
fixed_deque
A fixed size VecDeque to match Python Deque
-
get-full-year
An unofficial Rust client for getfullyear.com that helps you get the full year
-
redmaple
offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
typed_index_collection
Manage collection of objects
-
yakvdb
Kev-Value DataBase
-
messaging
two-way messaging crate
-
orchestrator
Orchestration sequences
-
expiringmap
a HashMap-backed TTL map
-
type-rules
easily constrain a struct
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
tensorism
Multidimensional arrays with bounds included in the type system
-
compt
A complete binary tree visitor library
-
dashmap-shard
port of Google's SwissTable hash map
-
anylist
a list type for any type
-
plugin_tls
Thread-local and statics storage across dynamic library boundaries
-
forest-ds
secure tree structure
-
string_manipulation_utf8
String manipulation functions using character indexing (UTF-8) instead of bytes
-
delta-collections
Data structures with revertable operations called deltas
-
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!
-
atlv
Algebraic Tag Length Value encoding
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
vec-x
structure
VecXto manage fixed-length arrays, supporting numeric operations and assignment operations betweenVecXand scalar values -
roers
prepare augmented annotations for single-cell RNA-seq analysis
-
point-nd
flexible no-std struct to model points on axes of any dimensions
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections
-
ads-rs
(Algorithms and Data Structures) is a set of useful generic production-ready algorithms and data structures
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
type-freak
Collection of typed data structures, trait operators and aliases
-
ord-by-set
providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
rep
A small tool for representation/class invariants
-
pna
PNA(Portable-Network-Archive) decoding and encoding library
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
lurk-elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
raphy
A graph data structure library
-
indexed_vec
IndexVecfromlibrustc_data_structures -
precedence-net
Create and analyse precedence networks
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
memvec
Memory-backed vector, not buffer. Designed for for mmap. Not MemMap, but MemVec!
-
crater
Very generic containers including KD trees, fibonacci heaps, minmax heaps,
-
radyx
A basic radix tree implementation
-
singletonThread
thread in a singleton
-
miniqueue
A minimalistic single-thread job queue based on fold/reduce
-
cueue
High performance SPSC circular byte buffer with batch operations
-
dyn_list
A linked list that can hold dynamically sized values in its nodes
-
sif-itree
immutable, flat interval tree
-
bitmap
A dense bitmap
-
iter_seq
Stateless, transformable, abstract sequence of values
-
replicante_models_agent
Replicante Agent API request/response models
-
rj
reactive json
-
school_library
structures to manage school-related data, including students, classes, and schools
-
grdf
Generalized RDF graphs and datasets
-
mco-gen
Stackfull Generator Library in Rust
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
btree-ondisk
BTree structure on persistent storage in userspace
-
tnaps
entity-component-system framework in Rust
-
succinct
data structures for Rust
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
onigiri
handling chars
-
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
wasmrs-frames
WasmRS RSocket frame decoding, encoding, and data structures
-
simple-triplestore
graph database for storing triples with support for custom node and edge properties
-
block-array-cow
In memory array de-duplication, useful for efficient storing of a history of data versions
-
reactive-signals
dx-first scope-based fine-grained reactive system
-
fairqueue
Spatially distancing fair queue. A kind of queue for sequential round-robin processing.
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
two-sided-vec
Double ended vectors for rust, which can grow in both the front and back
-
safe_index
Type-safe indexes
-
anor-storage
Anor In-Memory Data Storage
-
fixstr
fixing strings
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
object-collection
A collection that can store multiple values of types
-
cds
Collection of Optimized Data Structures
-
hashbrown_tstd
port of Google's SwissTable hash map
-
kv6
Collection of structs to allow reading of Ken Silverman's voxel formats
-
luka
working with graphs
-
ord-collections
offering collections which are pre-sorted automatically
-
omango-util
Utililites
-
entoli
A functional programming library inspired by haskell
-
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
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
path-value
Universal type and access property(s) by path
-
assoc
Treat vectors like associative arrays
-
btreemultimap
A multimap implementation with range support
-
cbsk_log
log tool
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
kodiak-taxonomy
manage generic taxonomies supporting unique features
-
bdaddr
Bluetooth Device Address
-
hibit_tree
Hierarchical bitmap tree. Integer-key map that can intersect FAST.
-
bitwrap_extra
pack/unpack data into byte array
-
contack
easy contact library
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
expiringdict
A dict / HashMap whose items expire over time
-
medianheap
A median heap for keeping track of a running median
-
sbom-walker
work with SBOM data
-
artie_common
Common Library for Artie Rust Projects
-
string-hash-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
mismatch
abstract mismatching. Useful for error propagation.
-
shortcut
an indexed, queryable column-based storage system
-
syntastica-queries
Collection of tree-sitter queries for syntastica
-
flex-alloc
Data structures with extra flexible storage
-
mc-oblivious-ram
Implementations of Oblivious RAM data structures
-
validiter
Iterator adapters for validating iterations
-
sparse_set
sparse set data structure
-
froop
A functional reactive stream library for rust
-
wolf-derivation-graph
Adds support for memoizing data flow graphs to wolf-graph
-
physical_constants
CODATA recommended values of physical constants
-
box-collections
A no_std compatible implementation of the collection crate
-
art-tree
The Adaptive Radix Tree
-
rust_twostack
Support for two-dimentional stacks for the Rust programming language
-
word-dictionary
data structure for word mapping. It can be used for language translation.
-
compare
Experimental comparators for collections to be generic over
-
mori
orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
libreda-splay
Splay map and splay set data structures
-
pulz-arena
A generational arena allocator with compact generational indices
-
charcoal
Implements tree data structures and interfaces to work with them
-
plod
deriving plain old data
-
mikufans-proto-intl
gRPC APIs for Mikufans (Intl)
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
sequential_gen
sequential generator
-
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)
-
dsalgo
A package for Datastructures and Algorithms
-
ultragraph
Hypergraph data structure
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
indextreemap
A BTreeMap implementation that allows for key and or positional insertion and retreival
-
osmgraph
Convert OSM queries into graphs
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
nakadi-types
A connector for the Nakadi Event Broker
-
aligned-utils
Common utilities to work with aligned values and allocation
-
riblt
Rateless Invertable Bloom Lookup Table (RIBLT) data structure
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
raw-btree
Generic B-Tree implementation
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within 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.
-
prefix-tree-rs
A Trie (prefix tree) implementation
-
div-int
Rational numbers with a compile-time denominator
-
merkle-tree-bulletin-board
A public bulletin board based upon Merkle trees
-
membuffer
A very fast flat memory buffer used to deserialize at a fast speed
-
simple-file-manifest
Interact with lists of files through a storage-agnostic interface
-
orx-selfref-col
SelfRefCol is a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
spaceindex
-
bosque
A very fast in-place kdtree library
-
minsize
Collections with a statically known minimum size (using const generics)
-
union-fn
Proc. macro for creating efficient "inline closures".
-
vicardi
JSON VCardArray Generator that uses Serde
-
groupex
Syncronization primitive that allows acquire lock by index
-
grangers
working with genomic ranges and annotations
-
once-list2
A single linked list which is backed by
OnceCell. You can append the value to the non-mutableOnceList. -
disjoint-sets
Three union-find implementations
-
arr-rs
arrays library
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
data-buffer
low-level data buffer type useful for IO and in homogeneous collections
-
compact_strings
A more compact but limited representation of a list of strings or bytestrings
-
bit-parallelism
Small integer specialized, word level, parallel algorithms and data structures
-
prehash
storing values with precomputed hashes
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
dirbuf
reusable directory bufferes
-
tree-index
Index a flat-tree
-
vec-btree-map
Basically just a sorted Vec that can be used as a HashMap
-
bstree-file-readonly
Query read-only binary-search tree file, supporting billions of entries in files of tens of GB
-
ndshape
fast linearization of N-dimensional array indices
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
bitvec_simd
bitvec with SIMD
-
latestmap
latest map
-
valog
A lock-free, generic, lightweight value log
-
grovedb-path
Path extension crate for GroveDB
-
rustz
functional programming in Rust
-
is_affected_lib
checking and listing the affected resources across a range of commits, useful when working with monorepos
-
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…
-
alist
Association list offering fast lookups while preserving insertion order
-
mzdata-spectra
A subset of
mzdata’s traits and spectrum data model -
light-curve-interpol
Interpolations tools for time series
-
supertrees
Supervision trees for Tokio-based services inspired by Erlang/OTP
-
grovedb-visualize
Debug prints extension crate for GroveDB
-
wolf-graph-dot
Adds support for generating Graphviz DOT files from wolf-graph graphs
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
realhydroper-smodel
Semantic modeling for Rust
-
lumberjack
Read and modify constituency trees
-
linked-vector
A hybrid linked list and vector data structure
-
rutenspitz
А procedural macro to be used for testing/fuzzing stateful models against a semantically equivalent but obviously correct implementation
-
nslice
Structures for interpreting slices of variable length as arrays
-
yaiouom-check
Linter for yaiouom. If you're using yaiouom, you want to use yaiouom-checker :)
-
v9
A slim data engine for Data Oriented Design
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
cbsk_timer
rayon thread runtime
-
aversion
Versioned data structures with auto-upgrading
-
rotated-array-set
An ordered set supporting O(1) rank and O(√n) inserts and deletes
-
gh-workflow
A type-safe GitHub Actions workflow generator
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
tdlg
Generates a grid of cells that could be used to build a top-down game map. Used by me to learn Rust.
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
dendron
Generic tree data structure
-
range_map_vec
range map data structure backed by a Vec
-
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 -
nereon
Riboseinc configuration library for Rust
-
recursion-visualize
visualized cache-aware stack safe recursion
-
liblet
learning about formal languages and grammars
-
overtone
An API for creation and management of rich (as in rich-text) musical-ish projects
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
hff-std
Hierarchical File Format: synchronous support
-
newnum
traits for number API and hierarchy
-
keybindings-parser
parsing human keyboard shortcuts
-
awid
Small, simple, universally unique identifiers
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
rahashmap
Fork of standard library HashMap with additional functionality
-
stringz
A way to use strings in generic paramters
-
hrtb-lending-iterator
A lending iterator trait based on higher-rank trait bounds (HRTBs)
-
chesspos
Basic structs for representing chess squares
-
tcgeneric
Generic data types used internally by TinyChain
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
ordmask
To check if a value is included efficiently
-
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…
-
stac-extensions
Manage STAC extensions (https://stac-extensions.github.io/)
-
index-utils
working with indices
-
memory_storage
memory storage comparable to a Vec where removing items doesn't shift all the items after the removed item to the left and doesn't invalidate their IDs. It allows you to remove items…
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
pbloom
A portable bloom filter implementation in Rust
-
surface-grid
providing data structures for square-tiled grids wrapped around the surface of certain objects
-
common-path
Finds the common prefix between a set of paths
-
enumoid
Enum Indexed Containers
-
xsd
XSD.rs
-
siraph
A node-based digital signal processing crate
-
villa01-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
median-heap
A median heap implementation in Rust, used to keep track of a running median of a sequence of numbers
-
rdf-reader
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
json_to_struct
Convert JSON into Rust structs for efficient and type-safe data management
-
open-coroutine-timer
The time utils
-
typed_index
A strongly typed Index that know what it is indexing
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
histogram-sampler
Sampling from a distribution given by a histogram
-
open-payments-common
Open Payments - Message Parsing Library - ISO20022
-
foreign_vec
Unofficial implementation of Apache Arrow spec in safe Rust
-
mapack
mapbox vector tiles
-
set_env
Sets environment variables permanently across all major platforms
-
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
graphlib
powerful rust library for the graph data-structure
-
rudac
common data structures and algorithms
-
fallback
A helper library to implement fallback mechaism
-
bitf
procedural macro to easily create a bitfield out of a struct
-
merkle
tree implementation with support for generation of inclusion proofs
-
partial-array
potentially partially-filled arrays
-
atomic_lifo
Lock free thread-safe lifo for rust
-
relational_types
Manage relations between objects
-
make-message-bus
Generate a pub-sub bus for use in async applications
-
arraylist
wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
seq-map
Sequential Map
-
shash
An arbitrary-length-input hash function for competitive programming and experimental purposes
-
grid-tree
Pixel quadtrees and voxel octrees
-
crio
An easy to use persistent data storage library
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
serde_gelf
Gelf serialization using serde
-
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 -
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
-
clnooms
Assembly-level implementation of interesting data types
-
nostd-bv
Bit-vectors and bit-slices
-
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.
-
elastic_hash_rs
Elastic Hashing from Optimal Bounds for Open Addressing without Reordering
-
xtree
general purpose tree data structure
-
smolvec
A lightweight vector implementation with small-vector optimization for rust
-
nibble_vec
Vector data-structure for half-byte values
-
israeli_queue_etc
various queues
-
multiset
Multisets/bags
-
bktree
BK-tree datastructure
-
bndpresbufq
Bounds-preserving, optionally limited, buffer queue
-
total-maps
Maps where every possible key has an associated value
-
designal
Procedural macro for use with futures-signals
-
altv_internal_core_resource
An internal crate for alt:V module. Not intended for direct use.
-
trie
An ordered map and set based on a trie
-
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
erased-type-arena
A type-erased allocation arena with proper dropping
-
cbor-tag-index
Tag index
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
isomorphism
2 directional hashmaps
-
resizing-vec
An automatic resizing vector for data with linear increasing ids
-
dependency-graph
building and resolving dependency graphs
-
inline-css
Embed CSS directly in your Rust code
-
sets_multisets
API for working with sets and multisets of elements of type usize
-
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 -
delsum-poly
NTL bindings for the delsum crate
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
panoradix
A generic map and a set, both backed by a Radix tree
-
flat_collections
Lightweight and memory-efficient associative data structures
-
array_map
Map backed array for fixed size keys with O(1) performance
-
prototty_common
Definition of common ui elements and views for use with prototty
-
kvv-efa-api
Rust bindings for the KVV (Karlsruher Verkehrs Verbund) "EFA"-API
-
object-chain
Ad-hoc structure builder
-
treez
A collection of useful data structures
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
serde-request-envelope
A serde request envelope with named type and data fields
-
sycamore-state-core
sycamore-state core types and trait definitions
-
fns
add common fn, eg: debounce, throttle
-
statemachine-rs
A statemachine crate which have zero dependencies
-
contigious-tree
Write and read tree graphs to and from contigious blocks of memory
-
zond
standard rust collections but with collecting statistics
-
simple-matrix
generic matrix library
-
fwdlist
A simply linked (forward) list
-
incremental-map
combinators for incremental immutable maps (see crate
incremental) -
rive-models
Revolt API models for the Rive ecosystem
-
fenwick-bit-tree
Slighly over-engineered FenwickTree implmentation
-
tangu-lints
A collection of lints for the Tangu language
-
luthor
A collection of lexers for various languages/formats, and the tools required to build them
-
typed_graph
Staticly typed graph library
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
rosary
About Rose Trees
-
polystore
Polymorphic data store
-
kd-tree-rs
k-d tree
-
rust_list
Singly linked list in Rust, with macros for easy instantiation
-
comprende
Python-style collection comprehensions in Rust
-
interval-rbtree
An interval tree implementation using Red-Black Tree as its underlying data structure
-
ensure
target state of an object
-
rs_blank_example
Example implementation of the rs_blank template
-
patricia_router
Radix Tree implementation for Rust
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
pq-tree
consecutive ones property (C1P) and graph planarity testing
-
arq
manage Arq Backup data formats
-
astack
offers a Stack data structure with fixed capacity capable of fast LIFO operations
-
simple-vec-collections
Collections implemented using Vec
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
large_int
An ease-of-use unbounded signed integer
-
indexkv
A performance-focused, persistent, async, key-value store
-
dltree
Doubly linked tree with leaf-considering typing
-
ident
wrapping types with an immutable identifier and storing/accessing such types in collections
-
dyn_trie
Dynamic trie is trie capable of mapping any T to any char iterator
-
inspector
General purpose inspection for popular data structures
-
evicting_cache_map
An Evicting LRU cache supporting prune hooks
-
sid
Id. Tiny crate providing strongly typed ids and an id-based vector.
-
hedge
An index based half-edge mesh implementation
-
modupipe
A modular and extensible ETL-like pipeline builder
-
slack-bk
Slack BlockKit API abstraction for Rust
-
usher
Parameterized routing for generic resources in Rust
-
beehive
collections for 3D hexagonal maps
-
btree_experiment
implements a BTreeMap similar to std::collections::BTreeMap
-
heapq
Priority Queue with scoring function
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
sweeper
A foundation for Minesweeper implementations in Rust
-
slotmap-fork-otter
Slotmap data structure - temporary fork for Otter
-
retrace
Safe, generic rollback log with predictable latency
-
cmp_wrap
Let you compare structes by context
-
arbutus
Trees
-
list-any
Type erased slices and Vecs
-
folketinget-api-models
Autogenerated Rust structures based on the Danish Parliament's OData metadatafile
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
molecule
Rust bindings for molecule
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
castle_api
Castle API, graph api
-
open-payments-iso20022-reda
Open Payments - Message Parsing Library - ISO20022 REDA
-
purse
Bag data structure implementation in Rust
-
mine_sweeperr
Minimalist interface to manage the backed of a mine sweeper game
-
hayami
general use symbol table
-
prototty
Wrapper crate for frontend-independent prototty crates
-
xsparseset
sparse set
-
serde_either
set to enums to deserialize and serialize data that can either be string, struct or vec
-
associated_list
An associated list, for cases when the key implements neither Hash nor Ord
-
sized-vec
Type level sized vectors
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
amalgamator
A set/map like data structure that allows you to combine members together
-
indexedlinkedhashmap
An indexable LinkedHashMap. The user defines the data structure that controls order.
-
actions
Software without side-effects. Redo and Undo. Macro's.
-
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
-
small_iter
A 3-pointer iterator that moves out of a
Vec<T>orBox<[T]> -
rs-collections
generic collections (no dependency on std)
-
iunorm
Map normalized floating-point numbers to/from (un)signed integers
-
benchmark-counters
Light-weight data structures to help with monitoring and benchmarking
-
eytzinger
implements the "eytzinger" (aka BFS) array layout
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
holyhashmap
A hash map with stable indices
-
fuzzy-search
collections for fuzzy search
-
range_union_find
A union-find data structure for ranges
-
tierkreis-core
Core implementation for the tierkreis quantum-classical hybrid workflow orchestration tool
-
generic_event_queue
generic event-queue API
-
syntastic
Generic abstract syntax representation
-
wccg-models
WCCG Data
-
u64_array_bigints
biginteger library based on u64 arrays
-
landfill
Various types for dealing with on-disk data
-
mergle
A data structure with fast merging and comparison
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
crfsuite-sys
Rust binding to crfsuite
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
rmat
minimal implementation of two-dimensional matrix algebra
-
hj_ds
A data structure library for Rust
-
rds-tensors
Rust Data Science Tensors crate
-
shogiutil
A collection of tools to handle shogi data
-
granite
Generic backing storage framework for building data structures
-
indexvec
Simplified copy of rustc's index crate
-
find-all-the-kitty-cats-in-charlotte
A collection of crates for working with cats
-
output_iter
An iterator that performs calculation during iteration
-
zotero
Communicate with Zotero API
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
counted_map
a hashmap that automatically assigns keys to pushed values
-
fxd
Fixed-point decimal implementation
-
willowtree
Lazily evaluated trees
-
voml-collection
Collections for VOML
-
truncate-integer
Truncate integers
-
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
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
-
app_properties
reading application properties from a file
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
graphstack
Graph-structured stack
-
processing_chain
set up processing chains of large amounts of data
-
dade
data definition for Rust structures
-
simple-undo
Easy to use undo-redo library
-
enum-tag
Proc. macro for generating enum discriminant types.
-
hamst
Hash Array Mapped Shareable Trie
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
ninja-files-data
Core data structures for ninja files
-
libflow
grouping network flow data
-
persistent_hashmap
Persistent hashmap is a library for working with memory mapped hashmaps
-
bytes-quilt
data structure for tracking random-access writes to a buffer
-
construe
Compile-Time Growable Array: Vec & String for const!
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
fenny
working with Fenwick trees
-
functional_vec
Owning versions of mutable Vec methods
-
queue-rs
queue
-
quickphf_codegen
Code generator for creating static maps and sets for use with quickphf
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
fast_collections
noheap zero copy collections
-
crdt-sample
containing samples of crdts
-
uniquevec
A
Vec-like datastructure which only contains unique entries. It is no_std and has optional serde support. -
bengbenge
inifity array for round-robin dns, beng, beng
-
shortlist
An efficient data structure to track the largest items pushed to it
-
small-ord-set
A set data-structure represented by a sorted
SmallVec -
errling
A collection of intrinsically useful errors
-
miny
Box<T> with small value optimization
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
llist
Lisp-style singly-linked list
-
uintx
Unaligned unsigned integers with exact size in memory and arithmetic operations for them
-
leetcode-solutions
A collection of leetcode solution in rust
-
hashcons
Hash cons'ing for compact representations of shared, immutable data structures
-
rotbl
Read Only Table
-
blocked-vec
A vector of byte blocks behaving like files
-
starship-battery
Cross-platform information about the notebook batteries
-
restorable
An iterator adapter for saving and restoring iterator state
-
ttmap
Trivial implementation of type map
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
rustic_core
fast, encrypted, deduplicated backups that powers rustic-rs
-
voxide
voxel project in rust
-
l6t-file
A part of l6t library: reading, writing and deconding for L6T IFF data
-
double-map
A HashMap with double key to single data/value
-
grovedb-version
Versioning library for Platform
-
tryingarraylist
arraylist implementation
-
option-block
A minimal utility Rust crate for small, fixed-size blocks of optional types
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
ropey
A fast and robust text rope for Rust
-
sorted_vector_map
maps and sets backed by sorted vectors
-
tiny-test
tiny-testis collection of functions simplifying test assertions in rust -
genindex
Generational index library
-
corresponding
Move corresponding fields between structs
-
partial
Optional monad with fake variant
-
yagraphc
working with Graph data structures and common algorithms on top of it
-
nanotweaks-proc
moved to https://crates.io/crates/spread_macros
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
atom_table
Assign easy-to-handle typed IDs to large, hard to handle things like strings
-
colony
A fast associative data-structure that chooses its own keys
-
mkargs
Build command arguments
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
rust-ds
Custom data structures crate for Rust
-
rusty-files
files is a simple collection of file functions that I use in my projects
-
timer-queue
Pure, minimal, and scalable timers
-
broomdog
A type-erased map with 'indefinite loanership'
-
whirlybird
generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
collect_result
collecting an iterator of results into a result of a collection
-
mini_uuid
A small and URL-safe UUID crate for Rust
-
comparer
track changes in a HashMap over several iterations
-
epoch-timestamp
Boilerplate collection for epoch timestamping
-
bytes
Types and traits for working with bytes
-
circularbuf
Rust fixed size circular (ring) buffer
-
jsonmap
store values of multiple types value in one Map
-
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…
-
bio
A bioinformatics library for Rust. This library provides implementations of many algorithms and data structures that are useful for bioinformatics, but also in other fields.
-
multi_key_map
a hash table that shares one value across multiple keys
-
small-world-rs
The easiest HNSW vector index you'll ever use
-
sot
Object Tree
-
slotgraph
Graph implementation built with slotmap and petgraph
-
default_macro
My default!() macro
-
quadboard
Typed fixed-length buffers of chess pieces
-
know
Framework for Rust
-
plurals
singular/plural forms, mostly in English
-
twodarray
A 2D array library
-
interval-map
A vector-based, non-duplicate range-keyed, sorted array
-
read-copy-update
locking primitive
-
moka-cht
Lock-free resizeable concurrent hash table
-
windowed-futures
Helpers for windowed parallel execution of collections of futures
-
loki-logger
A loki logger for the log facade
-
compressed_vec
Floating point and integer compressed vector library, SIMD-enabled for fast processing/iteration over compressed representations
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
snapshotor
An abstraction layer of snapshot for developing multiple versions storage
-
board
creating a single vector with coordinate based access, and a few nice functions for easy use
-
bubbletree
Bubble-tree
-
nanovec
Arrays and Vec-likes of small integers packed in an integer or two
-
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
byte_set
Efficient sets of bytes
-
cycler
A simultainious write/read data structure
-
im-pathtree
Immutable, path-addressable tree data structure
-
datazoo
Bitset and jagged array data structures
-
simple-graph
Graph library with ability to serialize/deserialize Trivial Graph Format
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
rpos
Cursor Manager on Table
-
stackbt_automata_impl
Automata implementations for StackBT
-
sif-kdtree
immutable, flat k-d tree
-
safer_owning_ref
creating references that carry their owner with them
-
openfga_common
Common OpenFGA package, contains shared data structures
-
google-contacts-csv
Struct defined to hold the contact information from the Google contact file
-
spatialize
collection of spatial data structures used for efficent spatial partitioning
-
uwheel
Embeddable Aggregate Management System for Streams and Queries
-
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. -
underscore
rust. Inspired by underscore.js.
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
btree-vec
A growable array (vector) implemented using a B-tree
-
starbase-tools
A collection of tools created to help with ship building in the game Starbase by FrozenByte
-
bit-vec-omnitool
A vector of bits
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
subset-map
A map where the keys are subsets of an initial set of elements
-
flow-graph
A representation of a graph data structure for flow-based programming
-
priority_container
Datastructure to find n biggest/smallest items within a large set
-
restor
A dynamic resource storage system in rust
-
graphene
A general purpose, extensible Graph Theory data type and algorithm library for Rust
-
caffeine
Collection of data structures I'm writing for fun. Originally written for use with my crafting interpeters tutorial implementation.
-
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.
-
multipath
split file path, like
/home/{user,admin}/file.txt -
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
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
-
tudelft-dsmr-output-generator
Companion library for the TU Delft Software Fundamentals individual assignment
-
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.
-
jsonnlp
JSON-NLP data structure
-
boxing
cross-platform implementations for NaN and ptr boxes
-
hash_ring
Consistent Hashing library for Rust
-
index-map
A map with automatically generated usizes as keys
-
usage
A convenient alternative to the newtype pattern
-
phf_macros
Macros to generate types in the phf crate
-
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
aph_disjoint_set
Disjoint set implementation with optimized memory usage and ability to detach elements
-
rl-bandit
multi-armed bandit implementation
-
nvpair-rs
Safe and rustic wrapper around nvpair
-
lodash-rs
Lodash but in Rust
-
zetacore
in-memory vector store library with Python bindings
-
thot-core
Core functionality and types for Thot data management and analysis software
-
rusty_v8_m
Rust bindings to V8
-
inditech
A set of technical indicators for time series analysis
-
fast_forward
Quering collections blazing fast
-
grammers-tl-types
Rust definitions for Telegram's API types and functions
-
neurarbor
manipulating tree graphs, for the analysis of neuronal arbors
-
dd_statechart
A Data-Driven implementation of Harel Statecharts designed for high-reliability systems
-
lazy-seq
constructing lazily evaluated sequences
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
fenwick-tree
binary indexed tree (Fenwick tree) data structure in Rust
-
wrapped_slab
WrappedSlab: Auto-generate newtype idiom based on a Slab
-
subranges
manage non-interssecting integer intervals
-
rs_filter
filter library for matching on complex data structures
-
product-os-openapi
Product OS : OpenAPI provides a set of structs for defining the structure of an OpenAPI / Swagger specification. This crate is intended to be used with Product OS : Connector.
-
graphs
Graph data-structure implementations based off graph-traits
-
numas
multidimensional array for efficient computing
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
colours
Color types for different color models with conversions between it
-
twitter/rustcommon-streamstats
Statistics calculated for a stream of samples
-
wagon-parser
Parser for the WAGon DSL
-
const_array_map
A const-capable Map type backed by a static array
-
scoped_stack
A scoped stack data structure
-
cset
Fine-grained and reversible struct transactions
-
priq
Array implementation of the min/max heap
-
circular_vec
A fixed length vector that provides a next function that loops infinitely
-
synthax
Synthesize syntax with quasiquoting plugins
-
num-bigint
Big integer implementation for Rust
-
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
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…
-
tinymap
A map structure that stores its data on the stack
-
wordsworth
A collection of natural language analysis functions
-
raii-map
Map and set types in Rust in which the presence of the entry in the data structure is tied to the lifetime of a RAII handle returned by the insertion
-
delete_if_not
unsafely in-place delete function
-
prometheus-tokio
A collection of tokio runtime metrics for prometheus consumption
-
droll
Dice notation parser and interpeter library
-
predicates
boolean-valued predicate functions
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
trying
Basic trie crate
-
simple-ref-fn
function wrappers that do not require virtual tables
-
cliquers
Manage filesequences with a common numeric component
-
changed
change detection
-
fsort
sort files in a fast, OS-independent and 'rusty' way
-
bit-index
A little-endian zero-indexed bitstring representation
-
rs-bush
Bush data structure
-
epoch32
32-bit Epoch with specified starting year
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
ketsugou
merges two arrays
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
deltastruct
Allows defining deltas for tagged structs for later application
-
bittyset
A BitSet type for manipulating bit sets
-
nstack
Arity 4 stack for the kelvin merkle toolkit
-
extended-rational
implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
exosphere-core
Core crate for Exosphere
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
gml_parser
A fast and simple Graph Modeling Language (GML) parser
-
simplecountry
Country Library
-
dyn-slice
&dyn [Trait] implementation, inspired by a Reddit thread
-
cnctd_smart_home
A collection of Smart Home APIs
-
goodreads
deserializing a Goodreads library export
-
cbsk_log_tokio
log tool, using tokio as the runtime
-
quantity
Representation of quantites, i.e. of unit valued scalars and arrays.
-
qualomat_schema
Rust bindings for the *Qual-O-Mat* open data format for the german voting advice tool *Wahl-O-Mat*
-
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…
-
skog
Adobe's stlab::forest data structure
-
temporary-annex
Helper for creating temporary annex on a collection
-
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
hyperbitbit
data structure
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
b100m-filter
The fastest bloom filter in Rust. No accuracy compromises. Use any hasher.
-
tennis
data structures
-
bitstr
contiguous sequence of bits in memory
-
puruda
Pure Rust DataFrame
-
current
setting current values for stack scope, such as application structure
-
valord-map
A dictionary sorted by values
-
libpaprika
read and generate Paprika recipe files and recipe collections
-
stringid
Lightweight system to manage identifier as human readable string and unique number
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
tbytes
A tiny library for reading and writing typed data into buffers
-
system-config
storing application properties on disk
-
tinyid
A tiny ID type that's like UUID except shorter and easier for a user to type in
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
graphlib_rust
Dagre's Graphlib implementation in Rust
-
motivations
a collection of motivating messages
-
minecraft_nether_generation
The minecraft nether generation implemented in rust
-
run-loop
Run loop for thread, provide message post, deadline timer and future executor
-
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
stable_node_set
An ordered set with handles to values
-
implhm
Simplified library of collision-handling HashMaps
-
leetcode-trees-rs
Tree Node LeetCode problems
-
ro
stuff read-only
-
geomprim2d
2D geometric primitive types
-
char-list
A persistent string type with the same API as a linked-list of characters
-
offset
Glorified offsets for arbitrary structures
-
jec
My collection of general-purpose crates
-
biosphere
fast random forests
-
afrim-memory
handle of sequential codes easier for an input method
-
dag_compute
construction of arbitrary computation DAGs and the expression of dataflow graphs
-
insrcdata
Embed static data as source code
-
sorted-vec2
Maintained successor to the sorted-vec crate
-
xdag
DAG(Directed Acyclic Graph) lib
-
f1d2d2f924e986ac86fdf7b36c94bcdf32beec15
Test for XSS on docs.rs
-
milvus-sdk-rust
The official Milvus Rust SDK
-
aleo-agent
Agent library to communicate with the Aleo Blockchain, following the Public Specification
-
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"
-
tilecoding
Dr. Richard S. Sutton's tile coding software.
-
cad_import
importing CAD data from different formats into a uniform in-memory structure
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
vecs_file
vecs file reader (fvecs, ivecs, bvecs)
-
rustupolis_server
using space tuples in fog computing
-
standards
A collection of standards for international trade facilitation
-
mivim
-
sdsl
interface for the Succinct Data Structure Library
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
domain-lookup-tree
A tree structure in Rust optimized for looking up domain names, with wildcard support
-
plant
Tree data structures
-
nfe
NF-e - Manipulação da nota fiscal eletrônica
-
hashify
Fast perfect hashing without dependencies
-
vector-expr
Vectorized expression parser and evaluator
-
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
-
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
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
pax-properties-coproduct
Static container for program-variable data structures and polymorphic components
-
lockfree-cuckoohash
lockfree cuckoo hashmap
-
asdl
Parser for ASDL format. Describes the abstract syntax of compiler intermediate representations and other tree-like data structures
-
literally
Macro literals for members of std::collections
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
vivalaakam_seattle_collection
Collection provider
-
rs-arboretum
A study in trees
-
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…
-
sos-system-messages
System message notifications for the Save Our Secrets SDK
-
fibis
fixed range bitset
-
bitworks
meant to provide easy to use bitsets with emphasis on safety
-
xarray
version of the XArray with copy-on-write capabilities
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
sharedvec
A fast but limited collection for storing values of a single type
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
viral32111-xml
XML parser crate for my Rust projects
-
thin-string
A String with a smaller stack footprint
-
wolf-graph
Data structures and algorithms for working with graphs with reference or value semantics
-
stac-duckdb
Client for querying stac-geoparquet using DuckDB
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
arrsingh-lists
A test crate to test publishing
-
take-some
that provides a way to obtain *some* value from various collections
-
minidom
A small, simple DOM implementation on top of rxml, targeting the subset of XML useful for XMPP
-
orx-imp-vec
ImpVecstands for immutable push vector 👿, it is a data structure which allows appending elements with a shared reference -
dawgdic
Port of DAFSA in safe Rust (original implementation courtesy to Susumu Yata)
-
undo_2
Undo and redo done the right-way
-
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)…
-
trie-db-fun
Merkle-Patricia Trie generic over key hasher and node encoding
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
array2ds
Package for handling sized 2d arrays in rust, without the usage of the keyword unsafe cuz why not
-
recursive_array
arrays using recrusive data structures to avoid limitations of the rust compiler
-
threshold-dict
A data structure to find smallest key that is larger than the query
-
rolling-set
A first in first out set that never grows above a certain size
-
byteflags
A macro to generate bitflag-like structures with u8 flag values
-
tc-state
TinyChain's general state enum
-
courgette
Colour manipulation/conversion library
-
qt-json
JSON library for QT
-
arrsingh
A top level crate in the workspace
-
containers
Containers
-
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
pi_slotmap_tree
A tree structure implemented by dense memory linked list
-
ordered_hashmap
Ordered Hashmap implementation to overcome arbitrary order of key-values problem in Rust
-
cosmic_undo_2
Undo and redo done the right-way
-
rust_release_artefact
Safely extract installable files from Rust release artefacts
-
parse_tree
A non-abstract syntax tree type
-
const_std_vec
const std vec
-
once-list
an append-only per-item list
-
stremio-official-addons
All of the stremio official addons
-
foba
A test crate
-
rtlp-lib
This create provide structures to parse PCI TLPs
-
prototty_storage
Interface to persistent storage
-
treeid
rational buckets for lexically ordered collections
-
art
adaptive radix trie
-
the_one
bst crate, created as a project for class
-
simple-collections
Collection of simple collections
-
default-vec2
Vec-like data structure with default elements and a bitset built using it -
default-vec
A specialized vector that has a default value
-
bittree
O(1) find functions in a special data structure called a bit tree
-
bitmac
Structure for accessing to single bits
-
bitint
Integer types that have a logical size measured in bits
-
rs-collect
This package is meant to mirror the functionality of Collections, a subsection of Illuminate\Support created by Taylor Otwell
-
try-push
A trait for attempting potentially expensive actions
-
motivation
A collection of motivating messages
-
dsa_sport
revision material for undergrads
-
xtd
An extended utility library
-
padded-number
Work with numbers containing significant leading zeros
-
pinned_vec
Vec-like data structure whose elements never move
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
guppy
Track and query Cargo dependency graphs
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
discrete_range_map
DiscreteRangeMap and DiscreteRangeSet, Data Structures for storing non-overlapping discrete intervals based off BTreeMap
-
art22-05-23
Art is a collection of tools for creating and manipulating colors
-
lim-bit-vec
Limited bit vectors
-
sliding-window-aggregation
Sliding window aggregation
-
fuzzy-datetime
Detects, completes and normalises fuzzy date and date-time strings for interoperability with chrono or direct output as ISO-8601-compatible strings
-
slop-rs
Official implementation of the SLOP data storage language
-
is_even_odd
categorizing and operating on integers
-
file_graph-rs
A tiny crate to generate a tree like structure starting from a folder and branching inwards
-
graphia
graph data structure
-
chtholly_tree
Rust bindings for Chtholly Tree
-
rimu
A data structure template system
-
deinterleave
your datastructures
-
simd-r-drive-extensions
Storage extensions for SIMD R Drive
-
nthD_Matrix
using matrixes of any arbitrary size and dimension
-
task-group
manage groups of tokio tasks
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII's gridd)
-
vevtor
vector index
-
same_elements
Function to test if two collections contain the same values
-
rust_fixed_width
that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
kv-par-merge-sort
External sorting algorithm for (key, value) data sets
-
static-files
help automate static resource collection
-
bfield
B-field datastructure implementation in Rust
-
value_pool
implements a ValuePool struct that makes the creation of self-referential data structures easier and safer
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
prefix_array
A generic container for searching on prefixes of keys
-
chained
lazily chaining functions
-
p8n-types
Basic types for representing binary programs
-
sandpile
do sandpile computations
-
scc
High-performance containers and utilities for concurrent and asynchronous programming
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
lazyfunctions
A collections of functions for lazy people, or highly efficient programmers
-
aoc-framework-utils
such as data types, algorithms and functions for aoc-framework-rs
-
zang
A test crate which is also a collection of some libraries which I tend to use for hobby projects
-
fufu
-
arc-atomic
atomic pointer to an
Arc -
equivalence
Trait and derive macro for comparing and hashing types modulo an equivalence relation
-
bin_file
Mangling of various file formats that conveys binary information (Motorola S-Record, Intel HEX, TI-TXT and binary files)
-
deferred_vector
A deferred vector implementation
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
frozen-collections-core
logic for frozen collections
-
gitdag
Git DAG used for source control
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
peapod
Ultra-compact storage for enums
-
key_set
KeySet representing concepts of All, None, Some(list), and AllExceptSome(list), with basic set calculations (intersection, difference, inverse)
-
awint_core
Core no-std and no-alloc
awintfunctionality -
ploc-bvh
A Bounding Volume Hierarchy based on PLOC
-
xuid
in Rust
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/History -
slice-rbtree
A slice-based Red-black tree
-
ts-builder
Timestamp builder
-
hdf5-hl
High level bindings to HDF5 High Level API
-
lunk
Event graph processing
-
kd_interval_tree
Implements a K-dimensional interval tree, for fast interval-overlap lookup. Binary-tree based implementation, i.e. O(log(n)) lookups.
-
embedded-async-helpers
staticfriendly helpers for async on embedded -
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
version-rs
A struct for Versions, with the methods you expect
-
big-tuple
providing trait implementations for tuples of up to 128 elements
-
bitarr
A fast and efficient Rust implementation of a BitSet, supporting multiple backing stores
-
fast-list
A doubly linked list using SlotMap for improved cache locality, and to solve the ABA problem
-
foxy_types
Types for
foxy -
rc-dlist-deque
Doubly-linked list based on std::Rc
-
modql-macros
Macros for modql. Not intended to be used directly.
-
pheap
A (fast) implementation of pairing heap data structure for priority queue and some graph algorithms
-
wrflib_widget
The widget toolkit for Wrflib
-
p-chan
Multimedia (Audio, Raster) Channel Newtypes and Conversions
-
vortex-scalar
Vortex Scalars
-
fusefilter
No alloc membership approximation
-
sac
A macro for constructing collections
-
ttl-queue
A queue that drops its content after a given amount of time
-
range-mutex
A
Mutex<[T]>-like type, that allows locking different ranges separately -
fill_canvas
FillCanvas is a wrapper around a matrix with special methods to fill the cells
-
lookups
Improve the data retrieval operations for collections
-
graviton_ast
abstract syntax tree for Graviton which is passed between the frontend and backend
-
nbits_vec
Small bits value (e.g. 1,2.. bits) vector implementation.
-
lockerroom
Readers-writer access to individual cells of your collection!
-
alloc-wg
Attempt of collection several proposals of the allocators-wg
-
ankurah-core
Core state management functionality for Ankurah
-
idmap
Efficient maps of integer id keys to values, backed by an underlying
Vec -
grit-bitvec
BitVec, a vector type that can store fixed-width data with irregular bit widths
-
anystruct
that provides traits for converting between JSON and Protocol Buffers (Proto) data structures
-
irox-tools
Stuff that should have been in the Rust STL, but aren't
-
benchling
client, generated from the OpenAPI spec
-
ibuilder
Interactive builder for Rust types
-
gen-vec
Vector indexed with generational indices
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
bloomfx
Bloom filter implementation backed by fxhash
-
collectioner
collection helper
-
rdf-writer
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
ultrametric_matrix_tools
Toolbox that provides functions and data structures to generate and handle ultrametric matrices
-
sequencetree
a new type of collection to store keys and their corresponding values
-
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.
-
pathlink
A URL type whose path can also be used as a filesystem path, for Rust
-
front-vec
Efficiently-prependable Vec and String types
-
json_tables
A structure that eases operations with a local json storage of undetermined items
-
sc-scraping
functions and structures to scrape data from the Roberts Space Industries website
-
multi-stash
Vector-based arena data structure that reuses vacant slots
-
shuttlings
Types for Shuttlings libraries
-
evento-store
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
triskell
A tri-partite ring buffer
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
hkalbasi-rustc-ap-rustc_graphviz
Automatically published version of the package
rustc_graphvizin the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
cumulfreqtable
A Cumulative Frequency Table implemented with a Binary Indexed Tree
-
dynprops
Creating and extending objects with typed dynamic properties
-
scratchbuffer
A Vec<u8> like data-structure, that can be used as slices of different types
-
sbbf-rs-safe
Split block bloom filter implementation
-
recursive_reference
way to walk on recursive structures easily and safely
-
lr_trie
Left-Right trie is trie capable of mapping any string to any string
-
another-option
option data type; useful when allocations are expensive
-
collectivity
Generic collection traits
-
nodefx
NodeFX
-
Project2
Implementations of red black tree and AVL tree
-
rudy
Judy array implementation in pure Rust
-
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
vmcircbuf
A circular buffer that magically wraps around without any copying
-
j2ds
A small collection of data structures not found in the standard library
-
basic_functions
Just a collection of functions that I might want to use in my projects
-
mutable
keep track of changes in structures
-
soak
Transform a struct into arrays of its fields
-
sortedcontainers
An experimental sorted data structure
-
petal-clustering
A collection of clustering algorithms
-
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
quotient-filter
A quotient filter implementation
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
uwheel-stats
profiling utility for uwheel
-
deviz
access to a VS Code extension for displaying structured program output
-
packed_array
Packed Array aka sparse set structure with compile-time known size
-
oas3
Structures and tools to parse, navigate, and validate OpenAPI v3.1 specifications
-
nonogram
generation and solution package
-
vox_writer
writer module for MagicaVoxel file format
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
ioc
An Inversion-of-Control library in Rust
-
bitbag
A useful struct for dealing with bit flags
-
traitgraph-dimacs-io
Functions to read and write graphs in DIMACS format
-
range_vec
Fast indexed access to a range of mostly-default values
-
baffa
Generic buffer for bytes
-
array_stump
A data structure mixing dynamic array and sorted set semantics
-
ware
middleware chains
-
l6t-symbolic
A part of l6t library: symbolic data model for different known devices
-
regexsolver
Manipulate regex and automaton as if they were sets
-
bb-qol
Small collection of quality-of-life functions
-
tinysearch-cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
chaste
Parser for npmjs lockfiles
-
RustyDSA
A libary for Rust data structure
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
disjoint_set_forest
A disjoint set data structure implemented using a disjoint set forest
-
aabel-identifier-rs
defines identifier behavior, such comparing them, or generating sequences of identifiers
-
cbsk_unique
unique value generator
-
static_merkel_tree
Static Merkel Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
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>… -
elaru
Memory safe implementation of LRU cache
-
rc-box
Known unique versions of Rc and Arc
-
vortex-alp
Vortex ALP array
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
louds-rs
High performance LOUDS (Level-Order Unary Degree Sequence) library
-
bnr-xfs
Pure Rust implementation of the BNR XFS USB
-
structbuf
Capacity-limited structured data buffer
-
satificator
Generates dimacs file from SAT on graphs
-
moodle-xml
generating Moodle quizzes in XML format
-
rust-fp-pfds
A Functional Programming Library in Rust, Purely Functional Data Structure
-
no_proto
Flexible, Fast & Compact Serialization with RPC
-
elinor
Evaluation Library in Information Retrieval
-
lobby-queue
Const-size queue-like data structure
-
html-types
HTML Data structures
-
nave
Thinking about the construction of distributed systems starting from the *consistent hash* algorithm
-
ternary-tree
Ternary Search Trees, with no unsafe blocks
-
roaring-graphs
Graph data structure backed by roaring bitmaps
-
rsfuzzy
Basic Rust fuzzy logic library
-
veclist
contains single simple collection. It can be used to push, access and pop with
O(1)complexity -
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.
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
rustifact_extra
Extra features for Rustifact
-
seg-tree
segment tree library
-
varset
an any type set of items
-
jsonpath-rust
basic functionality to find the set of the data according to the filtering query
-
easy_graph
Data structure that represent generic vertices and undirected connections
-
sesstype
Multiparty Session Types
-
index_graph
Graph library that only stores indexes from a base array
-
vec-entries
Entry API for iterating over and removing elements from a
Vec -
tinybitset
Generic implementation of small, fixed size, copyable bitsets
-
graphrepresentations
providing efficient abstract implementations of different graph representations
-
bitsvec
A bit vector with the Rust standard library's portable SIMD API
-
cognitive-frames
Managing windows for
cognitive -
lambda-apigateway-response
Response object for AWS Lambda with API Gateway
-
handler_map
Map from types to functions that receive them
-
dlist
List data structure based on AVL tree. It can store elements which have dimension and quickly search for elements by distance from 0.
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
fuzzy_trie
Key-value collection to make fuzzy searches
-
brarchive
Bedrock Archives in Rust
-
merkle-lite
fast, and composable binary Merkle tree and proof for Rust Crypto hash functions
-
content-tree
An efficient data structure for compacted RLE data
-
ipld-core
IPLD core types
-
jui_file
file tool
-
capped_multiset
A Multiset that can return a capped value on the elements
-
graph-rs
graph library
-
appendlist
An append-only list that preserves references to its elements
-
memcell
providing a MemoryCell struct, which stores a current and previous value
-
hgg
Approximate nearest neighbor search collection
-
judy-wrap
Judy arrays FFI mid-level binding
-
eztd
Quick start Rust
-
vec-belt
Multi-threaded bulk-append, single-threaded consume
Vec<T> -
wick-settings
Wick's Resource Configuration file data structures and normalization logic
-
pile
append only collection to manage lifetimes
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
fp-collections
An alternate collections library for rust
-
grafana-dashboard
grafana import/export data serializable structures
-
moc
made to create and manipulate HEALPix Multi-Order Coverages maps (MOCs), see https://ivoa.net/documents/MOC/
-
comparable
comparing data structures in Rust, oriented toward testing
-
qris
QRIS Parser & Editor
-
ndcopy
Fast N-dimensional array memcpy
-
watermark
watermarking set for in-order insertions
-
dogged
Persistent vector, similar to Clojure
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
simple-collection-macros
configurable macros for maps and sets
-
kodama
Agglomerative hierarchical clustering
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
hdf5-dst
DST extensions for HDF5
-
hashtree
A Merkle Tree implementation in Rust
-
scopegraphs-lib
A port of scopegraphs to Rust
-
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.
-
strawberry_fields
Consume, read, and mutate struct fields with an iterator-like api
-
kn0sys_ndarray_rand
Constructors for randomized arrays.
randintegration forndarray. -
binn-ir
-
tagged-tree
A tree-like data structure where the values are tagged
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
rbtset
A set based on a RB-Tree for efficient operations
-
evillatoro-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
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. -
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.
-
brainwords
easy to use Brainfuck code generator in Rust
-
write_x86_64
help you write x86_64 assembly code
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
laizy
stable and thread-safe implementation of a lazy value
-
slice-find
SliceFind trait add .find() method (for search sub-slice in slice) to Vec, slice, fixed-length-slice in standard library
-
dyn_vec
A Vec<T: ?Sized>
-
tracker-macros
Macros for the tracker crate
-
ndtensor
n-dimensional tensor library for Rust
-
reusable-vec
A Vec wrapper that allows reusing contained values
-
bigvec
A really big vec
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
brownstone
building fixed-size arrays
-
res
build-script dependency for managing your project's resources
-
smallobjectpool
A small object pool for Rust
-
insert_multiple
insert multiple items into a stream in reasonable runtime
-
prcn_lib
private library for atcoder
-
open-payments-iso20022
Open Payments - Message Parsing Library - ISO20022
-
rust_flightplan
Loads a flight plan from SimBrief and decodes it
-
transit_model_collection
Manage collection of objects
-
sliced
A segmented vector for iterating over slices
-
pg_filters
helper to generate postgres sql for pagination, sorting and filtering
-
hexarr
working with hexagonal grids
-
blend-bindgen-rs
generated Blender's data structures
-
paged
Read and create read-only paged database files
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
sorbus
A tree manipulation library
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
open-payments-iso20022-pain
Open Payments - Message Parsing Library - ISO20022 PAIN
-
es-entity
Event Sourcing Entity Framework
-
stochastic-data-structures
Various stochastic datastructures implemented
-
tree-experiments
Experiments with tree-like data structures
-
hashable_weak
A hashable weak pointer
-
transit_model_relations
Modeling the relations between objects
-
data_tree
Hierarchical data tree with pathing and search support
-
batbox-approx
Approximate comparison
-
tongrams
Tons of N-grams
-
cbsk_log_rayon
log tool, using tokio as the runtime
-
magiclist
List with O(log n) random access, insertion, splitting, and merging
-
csv2struct
Generate Rust struct definitions from CSV
-
chainmap
mutability of intermediate maps
-
rope_rd
A Read/Seek rope implementation
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
valet
Stores your objects and gives you a tag to retrieve them later
-
simple-canvas
generic 2 dimensional canvas struct
-
backtracking_iterator
generic iterator with an item history, capable of backtracking and forgetting
-
gpt_disk_io
GPT (GUID Partition Table) disk IO no_std library
-
trailer
Store a type with an associated buffer in contiguous memory
-
trips
generic triple store written in Rust
-
soa-vec
Vec-like API over a struct of arrays layout
-
rdf-vocab
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
hdrhistogram
A port of HdrHistogram to Rust
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
shelves
Storing values referenced by a unique typed index
-
mmap_json_file
parse, count, filter JSON files using memory mapped io library
-
ittapi
High-level Rust bindings for ittapi
-
gsrs
Generic Self Referencing Struct
-
upair
Unordered pair data structure
-
kurve
Adjacency list graph data structure
-
apid
Collection of type definitions from several APIs
-
partial_const
way to handle constant and non-constant values in a unified way
-
mashmap
A flat HashMap that supports multiple entries per key
-
bc-envelope
Gordian Envelope for Rust
-
mycelial-crdt
mycelial crdt
-
aggregate-map
Collect key-values pairs into a mapping from keys to collections of values
-
lilbits
Super fast u8 set (ie bitmap) relying on the assumption that elements are <= 63
-
forgetful
Track and forget values within a specific scope, enabling detection of repeated values
-
hex-game
Hex for Rust
-
fusebox
Mostly safe and sound append-only collection of trait objects
-
smol_str
small-string optimized string type with O(1) clone
-
pretree
package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
kukoo
lockfree cuckoo hashmap
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
bmap
A bitmap with an internal counter
-
winvec
Windowed Vector (TTL) Collection for Rust
-
progress-streams
Progress callbacks for types which implement Read/Write
-
pared
Projected reference counted pointers
-
oxc_index
Newtype-style helpers for
Vecandusize -
composite_types
Compose type definitions in the style of typescript
-
arena-graph
a questionable library for arena-allocated graphs
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
swimmer
Thread-safe object pool type
-
quantized-density-fields
Quantized Density Fields data structure
-
hashable_rc
Hashable wrappers for reference countings
-
sqlite-collections
Rust collection types backed by sqlite database files
-
ctxmap
A collection that can store references of different types and lifetimes
-
mexset
Implementing a set with MEX support
-
iodyn
An incremental collections library making use of Adapton
-
automap
pattern to implement key-value maps where the value type contains the key type
-
dastral
Reduce boilerplate code, learn data structures & algorithms with Dastral
-
rt_vec
Runtime managed mutable borrowing from a vec
-
identifier
Generate 128 bits id structs easily
-
nary_tree
A vec-backed tree structure with tree-specific generational indexes
-
igraph
A graph representation data structure with a built in index on keys
-
futures-bounded
bounding futures in size and time
-
hipstr
string for Rust: zero-cost borrow and slicing, inline representation for small strings, (atomic) reference counting
-
perm-vec
Datatype representing permutations of indices
-
dynamic-matrix
work with matrices
-
aabel-hashmap-rs
implements extensions for HashMap
-
break_array
For breaking array indexing
-
another_radix_trie
Rust built radix tree library
-
graphvizier
A dot file generator
-
flex-algo
Rust commonly used data structure and algorithms
-
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
-
ascii_num
digit to ascii numbers
-
workit
single-threaded work queueing utility
-
funnel
data structure that makes it easy to read from multiple channels from a single source
-
pegitan
A bunch of random algorithms library
-
aoc-framework-rs
A framework for AdventOfCode coding competition, that handles input, output and provides some core utilities
-
fpdec
Decimal fixed-point arithmetic
-
weighted_random_list
A Vec<T> that allows you to define the weight of each entry and randomly get entries
-
mycelium-bitfield
Structured bitfields, courtesy of Mycelium
-
dst-container
Containers for DST objects
-
json-node
A way to work with JSON as a node tree
-
lending-library
A key-value store that loans full ownership of items
-
grid_trait
2D and 3D grids with combinators
-
bstree
A Binary Search Tree written in Rust
-
byte-sequence
A little marco that creates structs to be used as byte sequences (for ApiKeys, SessionIds and so on)
-
transient_map
Hashmap with eviction of unused elements
-
latticequeries
Allows for fast hierarchical queries on Vecs
-
funcmap
Derivable functorial mappings for Rust
-
baz-tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
lumberjack-utils
Read and modify constituency trees
-
causal-length
CRDT's based on causal length sets
-
multi_mut
Methods on HashMap and BTreeMap for safely getting multiple mutable references to the contained values
-
fcsd
Front-coding string dictionary
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
key-node-list
Doubly-linked list that stores key-node pairs
-
combinations
give you all the combinations of values in a vec
-
better_peekable
Create a Peekable structure like Rust's Peekable except allowing for peeking n items ahead
-
compressed_map
'Static functions': compressed maps with the keys removed
-
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
-
chronological
Multi-timeline graph, representing state(s) varying over time. Inter-dependency of events between timelines. Supports interpolation.
-
wrapping
slices and arrays
-
mmap_bytey_byte_buffer
Mmap Bytey MByteBuffer code, use Mmap Bytey instead
-
m6coll
Small Smart Collections using prefix m6
-
bidirectional-map
A two-way map data structure for small keys and values
-
go-heap-rs
Golang's heap written in Rust
-
thot-local
Local functionality for Thot data management and analysis software
-
internode
Smart references to your graph nodes
-
tangibl
A parser for generating an AST from a set of predefined TopCodes
-
dot_tree
Create, query and store binary trees
-
isx
Traits for checking certain conditions of values
-
setting
The styles of all graphics elements
-
big_enum_set
creating sets of enums with a large number of variants
-
stac-cli
Command line interface for stac-rs
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
pi_map
Define a Triat: map for the mapped schema, and provide two built-in implementations of HashMap and vecmap
-
mvbitfield
Generates types to work with bit-aligned fields
-
nutype
The newtype with guarantees
-
trie-alg
Trie implementation
-
mtgjson
Unofficially provided lightweight models of the data provided by MTGJSON
-
tadm
A collection of algorithms and data structures wrote out while reading The Algorithm Design Manual book
-
crdt
Conflict-free Replicated Data Types for Rust
-
trie_of_lists
Trie library for storing and searching lists of arbitrary data structures efficiently that have substantial overlap. For example file paths
-
streamhist
streaming histogram
-
flat-multimap
A multimap and multiset implementation using a flattened hash table
-
to-offset
developer-friendly methods to manipulate strings with character indices
-
rstmt-core
focuses on building a music theory library that can be used to generate music theory data structures and algorithms
-
moretypes
Named tuples, records, and more!
-
structo
Data structures made in Rust
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
oid
Rust-native library for building, parsing, and formating Object Identifiers (OIDs)
-
octarr
dynamic cubic octree capable of storing class data, accessed via indexers
-
arc-swap-for-cow
Atomically swappable Arc
-
bufferring
Ring buffers for Rust
-
ipld-dagpb
IPLD DAG-PB codec
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
containers-rs
'Collections' interfaces for describing objects that contain other objects
-
nybbles
Efficient nibble-sized (4-bit) byte sequence data structure
-
const_queue
A stack-only, no_std queue using const generics
-
marked-yaml
A simplified YAML structure with provenance spans
-
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
apint
Arbitrary precision integers library
-
authenticode
working with Authenticode (no-std)
-
collect
An experimental extension of std::collections
-
owned_chunks
a collection of traits and iterators to get owned chunks from collections
-
gauze
Probabilistic set membership filters with a simple interface
-
no_vec
modifying sized arrays
-
keymaps
standardized encoding for key codes
-
rocstr
An immutable fixed capacity stack based generic copy string
-
binary-tree-view
A binary tree visualization application built in Rust
-
bloom_filter_plus
rust_bloom_filter
-
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 -
tsil_cev
LinkedList on Vec
-
fixed-slice-deque
A fixed size deque implementation
-
hdf5-hl-sys
Bindings to HDF5 High Level API
-
typed_id
Make your IDs strongly typed!!
-
type-info
Meta type information and type reflection at compile-time and runtime
-
jmt-blake3
Jellyfish Merkle Tree based on BLAKE3 hash function
-
rustfsm
Define state machines that can accept events and produce commands
-
vecvec
Two-dimensional Vec with support for mutable splits in either dimension
-
packed-vec
Sorted, deduped, compressed vector of integers
-
line-index
Maps flat
TextSizeoffsets to/from(line, column)representation -
learn_together
Curated collection of lists of useful resources to learn Rust together
-
pi_phf_map
phf_map
-
decoded-char
wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
indexed_bitvec
An indexed bitvector with (hopefully) fast rank and select operations
-
mori_parallel
parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
py_env
A wrapper for Python commands to easily install dependencies and run Python scripts in an optionally impersistent environment
-
flexstr
A flexible, simple to use, immutable, clone-efficient
Stringreplacement for Rust -
prust_core
encoding/decoding PUS-C packet data structures with ease
-
data_structure_traits
data structure collection traits
-
id-pool
Create and recycle integer ids using a ranged pool
-
one_way_slot_map
SlotMap with minimal restrictions on Keys and Values
-
periodic-rs
Bounded datastructures
-
db_meta_derive
db-meta-derive is a wrapper around PostgresSOL using tokio-postgres
-
ciborium
serde implementation of CBOR using ciborium-basic
-
dst
Data structures for DSTs
-
vec_ptr
An unsafe vector that uses raw pointers to perform standard vector operations
-
spigal
fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
hashable-map
Wrappers for HashMap and HashSet that implement Hash
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
tree_by_path
A tree data structure featuring nodes addressable using a &Vec<usize> path and avoiding recursion and run-time borrow checking
-
vfs-tools
A collection ofttools to work with VFS
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
vesema
Map/Set collections optimized for very small problem sizes
-
keyed_vec
Vector type where the key is a custom object to avoid mixing indices between vectors
-
package-json
package.json manager for Rust
-
hash-trie
Hash Array Mapped Trie (HAMT) Immutable Set Implementation
-
iron_rose
Invertable Bloom Filters & Strata Estimators as found in https://www.ics.uci.edu/~eppstein/pubs/EppGooUye-SIGCOMM-11.pdf
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
bloomfilter-rust
A bloomfilter implementation in Rust
-
seq_watcher
A pair of structures for monitoring a stream of data for one or more sequences
-
non-empty-vec
NonEmptyvector implementation, ensure non-emptiness by construction -
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits-sized unsigned integer elements -
unicase_collections
Collection of UniCase datastructures
-
const-assoc
A const-capable Map type backed by a static array
-
ransel
rank/select succinct data structures
-
gardiz
integer geometry on 2D planes, focused on games
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
serde-ordered-collections
Ordered serialization/deserialization serde functionality
-
vortex-dtype
Vortex's core type system
-
tyght-map
A static type map implementation
-
downsample
keep downsampled history of data over long period of time
-
ldap-types
Implements the basic LDAP types so they can be used in other crates
-
append-only
Append only versions of std data structures
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
rust-bloomfilter
bloom filter implementation in Rust programming language
-
foxy_util
Util for
foxy -
allehanda
Miscellaneous data structures and algorithms
-
healm
**He**ap **al**located **me**rkle tree
-
secured_linked_list
A cryptographically secured and provable linked list
-
cursed-collections
Collections that (seem to) break Rust safety
-
rangelist
A representation of sets as lists of inclusive ranges
-
hv-alchemy
Heavy Alchemy - the black arts of transmutation, wrapped for your safe usage and enjoyment
-
any_key
Dynamically typed keys for associative arrays
-
clash-rs-config
a clash yaml config parser
-
contiguous_collections
collections backed by flat contiguous arrays
-
treers
Sedgewick's tree maps
-
kdt
k-dimensional tree implemented with const generics
-
id_sys
data structures which can be marked such that they only work with similarly marked integer data types
-
loaf
Why have a slice when you can have a loaf?
-
lesbar-text
String extensions and queries for legible text
-
datastreams-rs
DataStreams container
-
velect
A Vec with item / index selection
-
slice-cell
A
Cell<[T]>-like mutable slice, that allows slice-like APIs -
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…
-
algae-rs
A collection of abstract algebraic structures implemented in Rust
-
typemap_core
A no_std typemap with trait-based value-presence guarantees (on nightly)
-
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 -
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
banyan
Persistent indexable tree data structure
-
variant-set
A set-like data structure for enum variants, allowing you to store at most one value for each variant of an enum
-
ckb_multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
const-vec
Vec-like data structure with immutable push method
-
bounded
numeric types
-
gridd
A generic, dirt-simple, two-dimensional grid
-
compressed-sparse-fiber
Compressed sparse fiber implementation for Rust
-
map-trait
Generic Map trait
-
bucket
Offers a very simple container for any value without mutation
-
ramp_table
RampTable, a data structure useful for certain specialized situations
-
arrav
Sentinel-based heapless vector
-
intersection
Find the intersection over a collection of sets; when you need more than the intersection between two sets
-
dag-cbor-references
Extract blake3 ipld links from dag-cbor blocks
-
local_vec
fixed-capacity vector allocated on the stack
-
avl-cont
A contiguous AVL Tree
-
dynvec
DynVectype that acts like a vector to store any datatype -
push-while-ref
push while having a reference
-
eclectic
Experimental collection traits
-
argmin_testfunctions
Test functions for optimization algorithms
-
packed_str
Store immutable strings in a single packed allocation
-
datastruct
A pure-data structure builder
-
win-variant
that aims to provide a more ergonomic way of working with variants in winapi based projects
-
zipcodes
Query US zipcodes without SQLite
-
packbytes
Convert structures to and from packed representavises - byte arrays of fixed size that live on stack
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
fid-rs
High performance FID (Fully Indexable Dictionary) library
-
hylo-fix
Fixed-point number types with Solana Anchor support
-
intervalsets
bounded and unbounded intervals implemented as sets with all the associated set operations
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
graphiti
macro dsl and builder for creating and describing arbitrary sets of related data using a serializable description type
-
lru-slab
Pre-allocated storage with constant-time LRU tracking
-
prefix_dictionary
Data structure similar to a dictionary, but enabling search for prefixes
-
evenio
An event-driven entity component system
-
scopegraphs-prust-lib
fork of prust for scopegraphs
-
field_accessor
A procedural macro to get and set a struct field by String dynamically
-
bfilters
bloom filter implementation in Rust
-
bloomy
Bloom filter using only two hash functions
-
cyclic_data_types
Cyclic data types are series of structs, enums, types and functions to create a series of fast data types
-
mrkl
Generic, minimalist, parallelizable Merkle tree
-
struct2vec
Rust structure to slice
-
imf
processing .imf files
-
hexgridspiral
Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers
-
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.
-
stride
A strided slice type
-
btree_network
A generic network (undirected graph) data structure
-
kvtree
Heterogenous in memory key value tree storage
-
user-balance-merkle-tree
Merkle tree implementation in Rust for user/balance storage
-
insertion-set
Performs a set of batched insertions on a vector
-
negatable-set
Wrapper for sets that allows full boolean operations including negation
-
gridava
2D coordinate systems
-
zhifeng_impl_barnes_hut_tree
implements Barns-Hut Tree for accelerated N-body force calculation
-
time_value
A collection of functions related to time value analysis
-
u64_array_bigints_core
Core library for
u64_array_bigints -
arbitrary-int
Modern and lightweight implementation of u2, u3, u4, ..., u127
-
contextual
deal with data in context
-
into_enum
Rust macro to generate trivial From impls
-
data-query
Query library that allows for Querying Serializable data using string queries
-
chain-map
A chain of maps with a single view into the aggregated values
-
vpb
key-value proto buffer for veladb
-
dense_bitset
A variably sized, heap allocated, dense bitset implemented using no
unsafecode -
treena
Tree stored in an arena
-
not-so-fast
data validation with derive macro
-
option_set
Bitflags on steroids
-
murmurhash64
MurmurHash2 (64bit version)
-
fast-btree
A fast B-tree implementation ported from tlx library
-
gtrie
Generic trie implementation with a support of different key and value types
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
extended-collections
An extension to the collections in the standard library with various data structures
-
priority-matrix
A matrix that supports per-row, per-column and whole-matrix maximum key queries
-
automatic-relations
Tree automatic relations
-
tag-vec
A vector used for storing tags
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
ser_mapper
Mapped DTO serialzation wrapper for DBO/Model
-
gavl
A fast implementation for a map and a set using an AVL tree
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
tensr
A high-performance, cross-platform, multi-backend tensor/array library for Rust
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
abbrev-tree
highly inefficient data structure for text completion
-
evento-query
A collection of libraries and tools that help you build DDD, CQRS, and event sourcing
-
ref_kind
Different reference kinds
-
kaola
A Persistent Delayed Queue in Rust
-
bookfile
A container file format with chapters and an index
-
eitherq
Queue which support two different types
-
lifetimed-bytes
Bytes, but with attached lifetime
-
cdumay_result
serialize and deserialize result using serde
-
array-ops
Automatic method implementations for array data types
-
disjoint-collections
Disjoint-set data structures
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
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
-
associative_positional_list
AssociativePositionalList is a list-like container in which each value is associated with an index, but unlike other list containers, the index for a value can be determined efficiently
-
chemrust-scanner
The core modules defining the flow and structs of data in computational chemistry routines
-
aneubeck-daachorse
Daachorse: Double-Array Aho-Corasick
-
nanobox
NanoBoxoptimization: store small item on stack and fallback to heap for large item -
reservoir-buf
Dead simple interning
-
range-traits
Ranges related traits
-
index-ext
Index slices with arbitrary ints and as arrays
-
bit-set-omnitool
A set of bits
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
inline-str
Efficent and immutable string type, backed by inline-array
-
unique-id-collection
Collection with unique Id
-
anyid
ambiguous identifier
-
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…
-
pokeapi-model
Data structures for PokéAPI v2
-
shared-string
Split a string without another allocation
-
nstree
construct branched 'namespace strings' for nested subcomponents, often for logging
-
hubs
The horribly unsafe buffer structure
-
lightning-containers
A set of lock-free data structures
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
flat-veb
Fast implementation of vEB trees without internal allocation
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
tyson
Typed Simple Object Notation
-
indexed-bitfield
An indexed bitfield, to track presence or absence of up to 128 elements
-
queueue
Queue-like data structures used in rCore
-
kappendlist
Append to a growable list in O(1) without needing &mut
-
deqmap
A double-ended queue with optional keys
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
semver-store
An HashMap structure that uses semver strings as keys
-
open-payments-iso20022-pacs
Open Payments - Message Parsing Library - ISO20022 PACS
-
rdf-query
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
tampon
Contains SAFE Rust functions, macro and trait to serialize / deserialize data structure and/or object and generate buffer
-
fplist
An immutable, persistent, singly-linked list
-
event-queue
crates.io için bir paket nasıl hazırlanırın ele alındığı öğrenme amaçlı modüldür
-
qt-json-rs
JSON library for QT
-
tapa-trait-serde
A collection of Tapalogi's reusable crates
-
justly
justified containers
-
cdl-list-rs
A circular doubly linked list implementation using Rc<T> and RefCell<T>
-
lineartree
tree data structure for rust
-
fieldfilter
trait that lets you filter stuff!
-
honeycomb-core
Core structure implementation for combinatorial maps
-
two_three
A two-three (2-3) tree implementation in Rust. Includes a map and set interface
-
an-rope
an rope for large text documents
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
largeint
that supports large integer arithmetic
-
slotmap-map
Slotmap data structure
-
arenavec
An arena backed implementation of vectors and related types
-
higher_order_point
An experimental higher order data structure for 3D points
-
vec_key_value_pair
A drop-in replacement for std::HashMap and std::HashSet that use Vec on the backend
-
vlsm-tree
Versioned Log Stream Merkle Tree
-
phenotype-internal
Defines
Phenotypetrait forPeapodcrate -
weakheap
Weak Heap data structure implementation in Rust
-
fallacy-hash
fallible hash collections
-
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).
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
data_structures_SD
collection of data structures. In other words a collection of ways to handle your data in your code and/or program.
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
simple-observable
observable pointer for mutable and immutable data
-
uguid
GUID (Globally Unique Identifier) no_std library
-
rstructure
A thread-safe data structure library
-
batbox-collection
Collection of identifiable objects
-
preferences-ron
Read and write user-specific application data using RON format
-
map-to-const
Easily convert HashMap<K, V> to constant [(K, V); N] values
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
applejack
Radix tree
-
btreelist
A list data structure that has efficient insertion and removal in the middle
-
unrolled-linked-list
unrolled linked list in rust
-
spectacle
Opt-in runtime introspection
-
rsurf
A data structure providing range query filtering with Fast Succinct Tries
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
altdeque
An alternative deque implementation
-
rust_dot
RustDOT is mostly the Graphviz DOT language, lightly rustified
-
hexing
A basic Rust library to manipulate hexagonal grids
-
segmentmap
A collection that maintains insertion order
-
type-pools
A data structure to store values of multiple types
-
enum-ref
Proc. macro for generating enum discriminant types.
-
staticbitset
A container like std::collections::BitSet but static storage + Copy trait
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
flowerbloom
fast bloom filter implementation with thorough documentation and tests
-
more_ranges
Range types not provided in the standard library
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
branchless
Algorithms and data structures designed to maximize performance on superscalar processors
-
mini-linked-list
A package containing a minimal i32 LinkedList implementation
-
okasaki
A collection of peristent datastructures
-
fuid
A UUID-compatible identifier in a friendly base-62 format
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
congruence
closure
-
utf8char
that supplies a utf8 encoded char
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
mop-structs
Low-level structures for MOP
-
bipbuffer
Simon Cooke's Bip-Buffer
-
pinned-bucket
Mutable container for pinned and immutable items
-
twie
fast and compact prefix tries
-
prioq
Priority Queue implemented using std::collections::BinaryHeap
-
nom-midi
Parse a simple midi file into data structures using nom
-
stix
working with STIX 2.0 threat intelligence
-
loro-preload
Loro internal lib for loading data
-
realm_io
Realm's high performance IO collections
-
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) -
bet
parsing and evaluating binary expression trees
-
bsp-pathfinding
Runtime path finding using Binary Spatial Partitioning
-
graph6
converting between strings in graph6 format and adjacency matrices
-
passive
A trio of marker traits to classify passive data structures
-
automerge-persistent-sled
A sled adapter for persisting Automerge documents
-
vortex-flatbuffers
Flatbuffers definitions for Vortex types
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
static-bytes
Bytes for embedded devices
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
street_index
small utility crate for working with road name / street indexing for cartographic purposes
-
stacking
using a stack datastructure in rust
-
ux
Implement the following non standard integers: u2, u3, u4, u5, u6, u7, u9, u10, u11, u12, u13, u14, u15, u17, u18, u19, u20, u21, u22, u23, u24, u25, u26, u27, u28, u29, u30, u31, u33…
-
flat-zip
An iterator adaptor to help traverse two-level collections
-
blobary
place for blobs
-
erasable
Type-erased thin pointers
-
bytesstr
An immutable reference-counted UTF8 String
-
ranged_set
A set that stores contiguous values as a range. Designed to be used with numeric types.
-
btree_dag
A generic DAG (undirected graph) data structure
-
sorting-vec
Sorts a vector using a btreemap
-
grafferous
graph library with a focus on generic data in nodes
-
simple-bitrange
manipulating bit ranges which is common when working with IC registers
-
graphific
graph data structure library
-
blocklist
The project is based on blocklistproject. It provides perfect hash map/set structures for fast lookup of blocklisted items.
-
bitsetium
One stop shop for all bitset needs
-
frbf
robust, and efficient implementation of the Bloom Filter data structure in Rust
-
ppar
Persistent immutable array
-
slots
Fixed size data structure with constant-time operations
-
tree-cursor
non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
head
Common types with inline headers, such as HeaderVec for Vec
-
flat_bit_set
有序、稀疏、节省空间的 bitset，适用于小数据量
-
nimrodshn-btree
A persistent copy-on-write B+Tree implementation, designed as an index for a key-value store, inspired by SQLite
-
num-rational
Rational numbers implementation for Rust
-
vortex-datetime-dtype
Vortex datetime extension dtype
-
ov
a collection of traits that allow you to chain off of anything
-
offset-views
Create and index offset views of arrays, slices, strings, etc
-
rb
A thread-safe ring buffer with blocking IO
-
rusted_list
A ever sorted list for rust that is operating on binary search
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
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.
-
nd-slice
Wrapping
std::slices to represent n-dimensional arrays -
flashtext
algorithm to search and replace keywords in given text
-
treesome
tree creation, manipulation, traversal and visualization
-
ax_banyan
Persistent indexable tree data structure
-
intsplit
splitting numeric types into their binary component arrays
-
uvector
access two slices as a single continuous vector
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
crdt-list
Abstract CRDTs for lists
-
cursorvec
Cursored vector container
-
pinned-queue
Queue-like data structure whose elements can never move
-
svec
Dart-style list in Rust
-
unsized_enum
Unsized enum implementation
-
tapestry
Generic 2D grid data structure and utilities
-
lk_math
Collection of reusable mathematical tools
-
bloom_filter_plush
rust_bloom_filter
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
small_vec2
Vector on the stack or heap need nightly rustc
-
butils
shared by software included in BSuccinct
-
copy-range
core::ops::Range et al, but Copy and IntoIterator
-
upto
Fixed-capacity and variable length stack allocated arrays
-
bugu
Cuckoo Filter: Practically Better Than Bloom
-
bk-tree
A Rust BK-tree implementation
-
fixedbitset-stack
A forked version of FixedBitSet that supports const generics
-
vector-trees
Vector backed B and AVL trees
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
intset
Various integer set data structures, each efficient for different operations
-
rankmap
rust hash table supporting key ranking
-
linked_lists
Different types of linked lists
-
fn-map
Abstraction around HashMap. Uses closure to compute and store value.
-
lean-imt
A lightweight incremental Merkle tree library
-
rs-bucket-filter
Skips slow scans using cache, bloom filter,
-
binary_tree_zy
binary tree
-
collection
Deterministic, copy-on-write balanced search trees
-
disjoint-hash-set
A disjoint set / union-find data structure suitable for incremental tracking of connected component identified by their hash
-
ttgraph_macros
Proc-macros for TTGraph
-
buf-ref-reader
Faster, growable buffering reader for when there's little to no need to modify data, nor to keep it alive past next read
-
batbox-android
Helper crate for android
-
fast_trie_tree
A fast
TrieTreefor multiple data types -
prefix_tree_map
generic prefix tree (trie) map with wildcard capture support
-
collection_macros
Collection of macros for collections
-
cons-rs
containing a Cons data structure
-
librualg
Collection of basic algorithms for everyday development
-
rdf_rs
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
set-trie
A trie for fast subset and superset queries
-
matrixcompare-core
Core traits for matrixcompare
-
structurray
Easy psuedo-array generation for database optimization
-
rblist
A block-based, non-circular double-linked list implementation for Rust
-
recollection
implementations and reimplementations of common data structures and algorithms, and other personally commonly used utilities
-
nodegraph
A data structure in rust describing a graph of nodes, where each node may contain arbitrary data
-
string-err
String error type
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
plum
Probabilistic data structures for rust
-
const-arrayvec
A vec-like type backed by an array on the stack
-
neighborgrid
A 2-D grid datastructure with easy to use iterators and adjacent cell methods
-
nexum
collection of commonly used data structures
-
render_as_tree
visualizing tree data structures via text
-
b_trees
Implementations for various binary trees including AVL tree
-
clampf
Clamped floating-point types
-
hamt
Purely functional hash array mapped tries
-
any_handle
A thread-safe, type-safe smart pointer that can share, store and downcast a
dyn Any -
dsu-tree
A non-invasive disjoint-set-like data structure implementation
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
value-trait
Traits to deal with JSONesque values
-
ldtk_map
reading ldtk maps for usage in games
-
leak
Safely leak data from owned data structures
-
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…
-
smallbytes
= SmallVec + impl BufMut (from the bytes crate)
-
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
dot_json
Tools for dot map representations of serde_json Maps
-
chtholly
Tree, a data structure originated from CF896C
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
simple_ringbuf
Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
zom
A collection of zero, one or many elements
-
ego-binary-tree
Binary tree API built by wrapping ego-tree
-
stac-async
Asynchronous I/O for stac-rs
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
freezable
immutable data
-
ensf594-project-mmap
Final project for the ENSF 594 course of the University of Calgary, summer 2022
-
history-buffer
A fixed capacity, write-only, ring buffer
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
range-set-blaze
Integer sets as fast, sorted, integer ranges with full set operations
-
probly-search
A lightweight full-text search engine with a fully customizable scoring function
-
tree-graphviz
Generate GraphViz DOT directed trees, based on an arbitrary tree structure
-
collidea
Collision-prone memory-efficient collections
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
slotmapd
orlp/slotmap fork where serialization cycle doesn't change observable behavior
-
hex-string
a data structure for managing hex strings in both string and byte vector representation
-
enum-set
A structure for holding a set of enum variants
-
bitwrap
pack/unpack data into byte array
-
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)…
-
bit-array
A compile time sized array of bits
-
learn_rust_together
Curated collection of lists of useful resources to learn Rust together
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
valued
Describe your data in terms of basic data structures. Get serialization and other facilities for free
-
toboggan-kv
abstraction layer over multiple KV stores
-
hato
Heterogeneous Arenas of Trait Objects
-
judy-sys
Low-level Judy array FFI binding
-
graphsearch
graph search and representation library
-
modular-bitfield-ordering
Provide u8be..u128be, u8le..u128le for modular-bitfield
-
hashindexed
A cache. A set which compares elements in a customisable way without overriding the eq() and hash() functions on the type itself.
-
mapped_vec
vector that not only stores it's data but also it's order
-
single_byte_hashmap
HashMap for storing singular bytes as keys
-
vcdiff-common
Common structs, functions, and traits for vcdiff format
-
artsy
ART Tree data structure library
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
flit
Bloom filter backed by xxHash
-
tournament_tree
A tournament tree library
-
hashed
type you can convert any hashable type into and still do equality checks on
-
building_blocks_core
The core data types for defining 2D and 3D integer lattices
-
mc-oblivious-map
Oblivious Hash Map data structures on top of Oblivious RAM
-
know_yaml
The Know Framework for Rust
-
short-lease-map
A map collection optimized for brief internship of values
-
searchy
Search index (in-memory), that can be constructed and searched using a bag of words model, with cosine similarity scoring based on tf-idf. Supports multiple search terms, permissions…
-
f256
Octuple-precision floating-point arithmetic
-
variant-map
defines maps to store variants of enums
-
hashmap2
Fork of Rust Nightly's HashMap
-
batbox-diff
Easy struct diffing
-
pointer-value-pair
A pair of a pointer and a small integer packed into a pointer-sized object
-
xio_instructionset
XIO instructionset data structures
-
treelike
A trait to abstract over trees, and simplify implementing them, all in one handy crate
-
cycle_cursor
Cyclic cursor implementation over generic iterators
-
pi_world
ecs world
-
golomb-set
A Golomb Coded Set implementation
-
rust-fixed-point-decimal
Decimal fixed-point arithmetic
-
structures
collection data structures
-
disk-ringbuffer
lock free on disk ringbuffer to be used in the implementation of Franz
-
photonix
Solutions for functional optics
-
tdf_utils
such as tree
-
tdb-succinct
succinct data structures used by terminusdb
-
flats
flattens nested structures into a flat single dimension map
-
itybity
An itty bitty crate providing bit iterators and bit iterator accessories
-
siebencorgie/jakar-tree
-
batbox-range
Helpers for working with ranges
-
fixed-index-vec
A vector-like data structure whose indices do not change when elements are removed
-
zeen_filter
A fast and optimized Bloom Filter implementation in Rust
-
zero_ecs
Entity Component System (ECS), using only zero-cost abstractions
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
elastic-array-plus
Elastic vector backed by fixed size array
-
transiter
An Iterator suitable for navigating recursive structures and DAGs
-
tensorism-gen
Multidimensional arrays with bounds included in the type system
-
prust-lib
Persistent & Immutable Data Structures in Rust
-
trie-generic
A trie with generic content
-
const_lookup_map
Rust map that can be defined in a const context
-
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
-
hashmap_vec
A HashMap with lists a values
-
disjoint-set
Tarjan's Union-Find Data Structure
-
unsized-stack
Fast heterogeneous / unsized stack
-
adts
Common abstract data type traits and implementations
-
algostru
Algorithms (algo) and Data Structures (stru)
-
lmfu
Low Memory Footprint Utilities (String, HashMap, JSON)
-
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.
-
slice-deque
A double-ended queue that Deref's into a slice
-
btree_monstousity
a code port of BTreeMap but with comparator functions
-
id-map
Data structure of values indexed by IDs
-
hashmap_ext
Extensions to std::collections::HashMap
-
simple-octree
octree implementation written in Rust
-
merkle-search-tree
A data structure for efficient state-based CRDT replication and anti-entropy
-
adjacency-list
Adjacency List and Adjacency Graph
-
hedel-rs
A Hierarchical Doubly Linked List
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
mphf_benchmark
The program for benchmarking Minimal Perfect Hash Functions
-
sixarm_collections
Collections for HashMapToSet and BTreeMapToSet as trait extensions. By SixArm.com.
-
bitman
An easy to use bit manipulation library for Rust
-
dyobj
improved version of the ECS pattern
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
explicit-discriminant
Macro for enforcing enum discriminants
-
open-payments-iso20022-admi
Open Payments - Message Parsing Library - ISO20022 ADMI
-
map-of-indexes
A compact key-value map for unique but not dense indexes
-
slice-dst
Slice-based custom DSTs
-
trait-map
Rust map for dynamic trait storage and references
-
tagid-derive
Defines a derive macro for the tagid newtype labeled tagging for different types of ids
-
tree_multiset
A tree-based multiset for Rust
-
doublets-decorators
Decorators for doublets
-
common-tree
common tree lib
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
fremkit
broadcast log
-
iso20022-common
Open Payments - Message Parsing Library - ISO20022
-
comprehend
Python like list, set and hashmap comprehensions via macros
-
flexible-string
A stack heap flexible string designed to improve performance
-
tree-automata
Term Rewriting Systems
-
nclist
finding overlapping intervals using a nested containment list
-
bitarray-set
A set of bits backed by bit-array
-
stack-stack
stack-allocated stack
-
provenance
Container structures that generate key upon insertion that only works with the map that generated it
-
vizz
creating GraphViz/DOT visualizations of Rust data structures
-
my-stack
stack implementation in Rust
-
whistlinoak
Annotated even-arity trees backed by mmaps
-
final
Wrap a value in a type that does not give out mutable references
-
persistent_rope
An immutable persistent rope data structure
-
linked_list_c
Safely work with c compatible linked lists
-
twilio-data
Twilio API data structures
-
num-complex
Complex numbers implementation for Rust
-
tranche
Tranches are an alternative to slices
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
darts
A double array trie, A Forward Maximum Matching Searcher
-
uset
set and a map designed for speed, with unsigned integers as keys
-
option_vec
Vec<Option<T>>-like container
-
batbox-logger
logging
-
enum_from_variant
macro to generate From<T> trait implementations for enum variants, simplifying error conversions and enum mapping
-
suffix_trie
Suffix trie for searching
-
treemap
Squarified Treemap algorithm
-
compact_arena
some types to allow indexed arenas with small memory footprint
-
len-trait
Len trait for collectons
-
fral
Functional random-access lists
-
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
-
c_linked_list
handling NULL-terminated C linked lists
-
aximate
core data structures and utilities
-
map_ext
Extensions to std::collections::HashMap and std::collections::BTreeMap
-
datastructures
A variety of data structures for learning purpose
-
anycollections
Rust Vec and HashMap which can contain arbitrary types
-
pui-arena
Generalized Arenas that can be used on
no_std -
fixed-vectors
Lightweight library implementing fixed-length vectors for Rust applications not compiled with the standard library
-
faex
A fast and efficient Compact Data Structures Library
-
awint
Arbitrary width integers
-
lf-sll
A lock-free singly-linked list
-
dirty
Holds a value with a dirty flag which is set on writes and cleared on clear()
-
typeslice
type-level slices
-
tiny-interner
Easy to use string interner with fast access to underlying strings and minimal memory footprint
-
rusty-priority-queue
A priority queue implementation
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
maybe-string
newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
banyan-utils
work with banyan trees
-
priority-set
A no_std Priority Set
-
unempty
Non-empty data structures for Rust
-
prefix-tree
A map and set interfaces using trie data structure
-
keyed
Implement comparison traits by specifying a key
-
orx-concurrent-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance concurrent collection
-
btree_graph
A generic graph data structure
-
init_trait
A small helper trait to simplify the initialisation of 'indexable' data structures
-
smolbox
Like a Box, but small objects are stored on the stack
-
stable-bloom-filter
A Rust-implementation of a stable Bloom filter for filtering duplicates out of data streams
-
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. -
littlechestnutgames-trie
A generalized trie implementation for quick prefix searching
-
ez-bitset
bitset implementation
-
fibheap
but actually useful Fibonacci Heaps
-
cranelift-bforest
A forest of B+-trees
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
sbf-blake3
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
string32
A string that is indexed by u32 instead of usize
-
unstorable
An interface for requiring that a type is only used on the current stack frame
-
miniconf
Serialize/deserialize/access reflection for trees
-
vortex-datetime-parts
Vortex physical encoding that compresses temporal components individually
-
terms
Tree terms and patterns data structures
-
entry_put_ext
Map entry extension for put operations
-
quarkrs
A collection of small life improvements for rust
-
blfilter
Bloom filter implementation using farmhash
-
grafite
Range Filter
-
scell
A smart container for objects in recursive data structures
-
async_value
persistent, asynchronous values
-
arenas
Arena data structure for efficiently adding & removing items with stable IDs
-
rdf-borsh
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
trie-rs
Memory efficient trie (prefix tree) and map library based on LOUDS
-
sorted-list
SortedList data structure which allows mapping an Ord key to multiple distinct PartialEq values
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
handlebox
A map-like collection that reuses unused keys
-
compacts
compact data structures
-
stac-validate
Validate STAC objects with jsonschema
-
kvstructs
General basic key-value structs for Key-Value based storages
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
regex-map
Associative container where the keys are regular expressions
-
lfbs
Lock-free stack with batched pop
-
parity-hash
A collection of fixed-size byte array representations
-
zallocators
Bringing Zig like allocators to Rust
-
rbtree-arena
A cache friendly red black tree where nodes live on sequential memory
-
opt_arrayvec
Vector-like container with fixed capacity, using options instead of stored length
-
bigraph
Different representations with implemented operations on bigraphs
-
base-traits
base traits (for Rust)
-
raw-vec
A Raw utility for managing contiguous heap allocations
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
rbloom
efficient and minimalistic bloom filter
-
get-many-mut
Stable polyfill for slice::get_many_mut
-
expire
data structure for data maybe expired
-
moonlight_collections
Collections for Rust
-
succinct_rs
Succinct Data Structures library for Rust
-
nth-cons-list
The nth cons list implementation
-
ranno
Annotations over recursive data structures
-
projected-hash-map
projected HashMap over HashSet
-
sliding_window
A fixed size, heapless sliding window
-
sequence_buffer
Sequence buffer data structure implementation
-
vortex-bytebool
Vortex byte-boolean array
-
index_queue
A queue for unique indices with constant-time query and removal
-
null-vec
A specialized vector that stores nullable values
-
trie-standardmap
Standard test map for profiling tries
-
map1
@ErichDonGubler's fancy template for new Rust projects
-
linked_array
Arbitrarilly long fixed-size arrays
-
stacked
Stack-allocated data structures. This was a good learning experience, and these container types work well, but in the end, I was not able to beat the performance of Vec
-
rc-borrow
Borrowed forms of Rc and Arc
-
simple_trie
array backed trie
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
tibitset
bitset replacement for HashSet
-
cowvert
a flexible data container supporting owned, reference-counted, and copy-on-write semantics. designed for use in interpreters
-
tuco-core
Contains the Tuco trait, used by the Tuco crate
-
autocomplete
Auto-complete feature using Trie data structure
-
unrecurse
Helper crate for rewriting your recursive code in iterative way
-
awint_dag
DAG
awintfunctionality -
dynstr
A string implementation optimized for manipulations
-
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
b-tree
A persistent B+ tree using freqfs
-
bitty
Extract bits from, and put back into integer types
-
hashmap_union
Allows the union and intersection of hashmaps
-
diskqueue
Unordered persistent on-disk queue that can be consumed from multiple processes
-
nonempty_range
Range representing nonempty ranges
-
dpc-simplemap
map with default value and compacting
-
hitree
Indexable containers for Rust: HiSet and HiMap
-
compacts-dict
succinct dictionary
-
ring-vec
A zero-dependency, no-std compatible, producer-consumer, fixed-size, item-oriented ring buffer backed by a vector
-
zerovec
Zero-copy vector backed by a byte array
-
open-payments-iso20022-head
Open Payments - Message Parsing Library - ISO20022 HEAD
-
freezie
small library that disables mutation for the contained type
-
slicedvec
A segmented vector for iterating over slices
-
rustgym-gvc
generate svg for some data structure in rustgym
-
bloomy-rs
Fast bloom filter implementation
-
compacts-bits
succinct bit vector
-
very_simple_trie
A Trie or prefix tree is a specialized tree-like data structure used for efficient storage
-
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
-
construct
A macro for building container literals
-
by_address
Wrapper for comparing and hashing pointers by address
-
querable
Quer(y)able data structure implementation
-
non-empty
list data structure for Rust
-
map_err
map error values
-
kinded
Generate enums with same variants, but without data
-
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 -
samplify-rs
A procedural macro to generate sample data for Rust structs
-
htable
extenable table that can hold hold many different types at once
-
dsll
Fast Thread Safe Doubly Sorted Linked List
-
history_stack
A collection of containers that support generic history tracking mechanisms
-
fst_stringstring
String-to-String Map built from fst
-
token_deque
A double-ended queue backed by a vector that allows access to interior values
-
cuml_map
A trait representing cumulative mappings, and several implemntations of this trait
-
capillary
HashMap-like storage of key-value pairs, but allowing for step-by-step (partial) search of value
-
vector-commit
A collection of traits to use with vector commitment schemes, and a few implementations of VC
-
fe_data
Data structures for FE
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
batbox-cmp
Traits & functions related to Ord
-
corosensei
A fast and safe implementation of stackful coroutines
-
tree-struct
A general-purpose Tree implementation in Rust
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
doubly
linked lists in rust
-
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
pulz-bitset
bitset implementation
-
yuuang_dominators
null
-
geogrid
Manipulate geographic data on a grid
-
poison
writing poisoned types
-
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…
-
sparse_vec
Datastructure that stores separate but contiguous ranges of values efficiently
-
cli_tree
A CLI tool to generate a tree of user defined nodes
-
radixt
A fast, memory-efficient radix tree implementation in Rust
-
const_enum_map
Get const value from enum handle
-
simple-tree
Create, edit and iterate over tree structures
-
indexed-vector
that implements vector container that can be indexed with specified function
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
vortex-fastlanes
Vortex fastlanes arrays
-
ringvec
ring buffer implementation based on a vector
-
to-display
A trait that is Display or can be converted to Display
-
afmt
Basic data structure parsing from strings
-
immutable-avl
An Immutable map and set implement for rust based on an AVL tree
-
smallqueue
A queue with a no-alloc optimization when the size is 1 or 0
-
skip-linked-list
a skiplist-backed linked list that support fast random writes, written in Rust
-
xx-bloomfilter
Bloom filter implementation using xx hash
-
bit_range
A small library for getting bits and ranges of bits from byte collections
-
clouseau
A query language for inspecting Rust data structures at runtime
-
qlrumap
A HashMap with an LRU feature
-
to_any
Auto derive ToAny trait for any structure
-
graph-traits
Traits for graph data structures
-
quetta
Immutable, reference-counted strings for rust
-
rand_map
A map that creates a random handle on insertion to use when retrieving
-
hff-core
Hierarchical File Format: core structure
-
recursion-schemes
cache-aware stack safe recursion (this is the really haskell brained one)
-
tree-rizzen-yazston
Tree Library using the Any trait for data
-
open-payments-iso20022-remt
Open Payments - Message Parsing Library - ISO20022 REMT
-
graph-arena
Collection type to store immutable graph structures efficiently
-
percentile_rank
calculates percentiles, ranks and positions of the data(repeated values as well) in given vector
-
immutable_string
Immutable Single Instance Strings for Rust
-
sexpr_matcher
Structural pattern matching macro for S-Expressions and other list-like data structures
-
sparse-slot
minimal sparse slot (sparse vector)
-
pi_tree
A tree structure implemented by dense memory linked list
-
arkive
Immutable archive manipulation library
-
grapes
Persistent graph data structures: Tree, Graph, Arena & more
-
ngds
Rust bindings for AVFounation
-
compact-map
'Small map' optimization: store up to a small number of key-value pairs on the stack
-
low-map
A convenient wrapper around a vector of options
-
data-structures
data structures crate in rust, WIP
-
sn-trie-proofs
Starknet Transaction Trie Proofs
-
enum_set2
A bit-set indexed by enum variants
-
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… -
vortex-runend
Vortex run end encoded array
-
json-syntax
Strict JSON parsing and mapping library
-
bytebufrs
A ring buffer for bytes implementing io::Read and io::Write
-
extensions
typemap container with FxHashMap
-
louds
LOUDS implementation for Rust
-
intrusive-containers
intrusive data structures
-
comparable_test
comparing data structures in Rust, oriented toward testing
-
theban_interval_tree
Interval Tree implementation
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
smt_map
A uint-to-uint map backed by Sparse Merkle Tree (SMT), which supports generating Merkle Proofs of key-values
-
orx-pinned-concurrent-col
A core data structure with a focus to enable high performance, possibly lock-free, concurrent collections using a PinnedVec as the underlying storage
-
nohashmap
Use HashMap syntax in Rust for non-hashable types
-
fixed_circular_buffer
A queue (the abstract data structure) implemented using a fixed size circular buffer
-
vecmap
Vec-based Map and Set data structures
-
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
illist
An indexable linked list implementation backed by a Vec
-
anymap3
A safe and convenient store for one value of each type
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
triemap
Triemaps for Rust
-
immutable-seq
Immutable sequence data structure
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
simple-stack
linked list-based implementation of the Stack data type
-
generic-json
Generic JSON traits
-
lenses
An optics library loosely inspired by Julien Truffaut's Monocle
-
object-merge
Traits useful for recursively merging document-like objects
-
hyper-tree-router
Routing middleware for Hyper http library using Prefix tree (trie) for path finding
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
generic-bloom
A generic implementation of Bloom filters using traits
-
succinct_vec
A Vec-like datastructure with less memory overhead
-
insert_many
optimization for vec-like structures
-
bintrie
A performant binary trie data structure that doesnt store data or keys
-
palettevec
A palette compressed vector library for potentially insane runtime compression ratios
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
ixlist
The “ixlist” is a linked list in a vector, or if you want a list in a pond or an arena-allocated linked index-chasing fest. Implements a queue interface and a cursor.
-
abin
working with binaries and strings. The library tries to avoid heap-allocations / memory-copy whenever possible by automatically choosing a reasonable strategy: stack for small binaries;…
-
rotating-buffer
Small helper data structure that allows retaining unused data
-
array-linked-list
A data structure, which combines the advantages of dynamic arrays and linked lists
-
vortex-proto
Protocol buffer definitions for Vortex types
-
immer-rs
A wrapper around the C++ library immer for persistent datastructures
-
hodgepodge
enums
-
texcraft-stdext
Rust data structures and algorithms used in the Texcraft project
-
elu
Traits and implementations for EVAL-LINK-UPDATE data structures
-
collectables
collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
linked_lists_rs
various data structures using linked lists in rust
-
flattree
A series of functions to map a binary tree to a list
-
persistent-list
A singly-linked persistent thread safe list
-
bitmatrix
A bitvec based bitmatrix, akin to bit-matrix which is based on bit-vec
-
random-access-storage
Abstract interface to implement random-access instances