-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
hashbrown
A Rust port of Google’s SwissTable hash map
-
smallvec
‘Small vector’ optimization: store up to a small number of items on the stack
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
hdrhistogram
A port of HdrHistogram to Rust
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
tinystr
A small ASCII-only bounded length string representation
-
predicates
An implementation of boolean-valued predicate functions
-
fixedbitset
FixedBitSet is a simple bitset collection
-
bit-vec
A vector of bits
-
half
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
generic-array
Generic types implementing functionality of arrays
-
bimap
Bijective maps
-
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
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
indexmap
A 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…
-
enum-map
A map with C-like enum keys represented internally as an array
-
rowan
Library for generic lossless syntax trees
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
egg
An implementation of egraphs
-
roaring
http://roaringbitmap.org: A better compressed bitset - pure Rust implementation
-
rpds
Persistent data structures with structural sharing
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
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.
-
sized-chunks
Efficient sized chunk datatypes
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
oci-spec
Open Container Initiative Specifictions in Rust
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
daggy
A directed acyclic graph data structure library. It is Implemented on top of petgraph’s Graph data structure and attempts to follow similar conventions where suitable.
-
index_vec
Newtype-style helpers for
Vecandusize -
tinyvec
tinyvecprovides 100% safe vec-like data structures -
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
string
A UTF-8 encoded string with configurable byte storage
-
trees
General purpose tree data structures
-
smartstring
Compact inlined strings
-
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
-
guppy
Track and query Cargo dependency graphs
-
kstring
Key String: optimized for map keys
-
molecule
Rust bindings for molecule
-
enumset
A library for creating compact sets of enums
-
scapegoat
Safe, fallible, embedded-friendly ordered set/map via a scapegoat tree. Validated against BTreeSet/BTreeMap.
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
prometheus
Prometheus instrumentation library for Rust applications
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
kiddo
Performant and ergonomic kd tree library. Generic over number of dimensions, stored items, and axes values. Ideal for geo- and astro- NN queries
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
radix_trie
Generic radix trie data-structure
-
griddle
A HashMap variant that spreads resize load across inserts
-
intmap
Specialized HashMap for u64 keys
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
bloomfilter
Bloom filter implementation
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
ringbuffer
A fixed-size circular buffer
-
bit-set
A set of bits
-
flatk
Flat layout abstraction toolkit
-
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…
-
trie-root
In-memory patricia trie operations
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
intervallum
Generic interval and interval set library
-
ic-cdk
Canister Developer Kit for the Internet Computer
-
zerovec
Zero-copy vector backed by a byte array
-
enum-ordinalize
This crates provides a procedural macro to let enums not only get its variants’ ordinal but also be constructed from an ordinal
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
generator
Stackfull Generator Library in Rust
-
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. -
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
leb128
Read and write DWARF’s “Little Endian Base 128” (LEB128) variable length integer encoding
-
sorted-iter
Typesafe extensions for sorted iterators, including set and relational operations
-
scc
A collection of building blocks for concurrent programming
-
rust-fsm
A framework for building finite state machines in Rust
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
ciborium
serde implementation of CBOR using ciborium-basic
-
array-init
Safe wrapper for initializing fixed-size arrays
-
id_tree
A library for creating and modifying Tree structures
-
uint
Large fixed-size integer arithmetic
-
esaxx-rs
Wrapping around sentencepiece’s esaxxx library
-
vec_map
A simple map based on a vector for small integer keys
-
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.
-
microkelvin
A library for tree traversal over annotated datastructures
-
undo
A undo-redo library
-
bitstream-io
Library for reading/writing un-aligned values from/to streams in big-endian and little-endian formats
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
cc-traits
Common collection traits
-
indxvec
Sets implemented as generic vectors.
Efficiently sorting, merging, ranking, searching, reversing, intersecting, etc. -
ux-primitives
Graphics Primitives for Angular Rust
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
uluru
A simple, fast, LRU cache implementation
-
cita_trie
Modified Patricia Tree (aka Trie)
-
commitlog
Sequential, disk-backed commit log library
-
ibuilder
Interactive builder for Rust types
-
bitmaps
Fixed size boolean arrays
-
queue-file
queue-file is a lightning-fast, transactional, file-based FIFO
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
flatgeobuf
FlatGeobuf for Rust
-
radix-heap
Fast monotone priority queues
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
solvent
Dependency Resolver library
-
ntex-bytes
Types and traits for working with bytes (bytes crate fork)
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
ordered-multimap
Insertion ordered multimap
-
smallbitvec
A bit vector optimized for size and inline storage
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
funspace
N-dimensional function spaces and transforms
-
intervaltree
A simple and generic implementation of an immutable interval tree
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
simple-grid
A simple 2d-grid structure
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
histogram
histogram storage and percentile metrics with precision guarentees
-
hypergraph
Hypergraph is data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
space
A library providing abstractions for spatial datastructures and search
-
ndsparse
Sparse structures for N-dimensions
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
circular-queue
A circular buffer-like queue
-
merkle-cbt
A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
bitlab
Extracting a range of bits from a binary data source
-
blender-mesh
Serialize / deserialize Blender armatures
-
lignin
A virtual DOM structure, primarily for web use
-
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
-
banyan
Persistent indexable tree data structure
-
leveled-hash-map
A 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…
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
slack-blocks
Models + clientside validation for Slack’s JSON Block Kit
-
paginate
A 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…
-
slice-deque
A double-ended queue that Deref’s into a slice
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
nstack
Arity 4 stack for the kelvin merkle toolkit
-
block-grid
A quick, cache-conscious, tiled 2D array
-
threshold
Threshold data structures
-
slice-ring-buffer
A double-ended queue that Deref’s into a slice
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
entity
Library that provides entity-like constructs
-
oxidebpf
A pure-Rust library for managing eBPF programs
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
mt-dom
A library for generating patches as a result diffing virtual DOM tree
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
spade
Spatial datastructures like r-trees and delaunay triangulations for rust
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
arraylist
A rust wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
data_reader
A data loading library for data scientist
-
bondrewd
Bit-Level field packing with proc_macros
-
idlset
Fast u64 set operations library
-
fast_paths
Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
fingertrees
Immutable persisten finger trees
-
skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
big_unsigned_ints
A Crate For Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
dims
Unit-Aware Types Library
-
ware
Immutable middleware chains
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
array-macro
Array multiple elements constructor syntax
-
odht
A Rust crate for hash tables that can be mapped from disk into memory without the need for up-front decoding
-
try-lazy-init
Fallible lazy initialization
-
rtdlib
TDLib for rust
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
hashbag
An unordered multiset implementation using a hash bag
-
luka
Library for working with graphs
-
one_way_slot_map
An implementation of SlotMap with minimal restrictions on Keys and Values
-
polytype
A Hindley-Milner polymorphic typing system
-
contack
A simple and easy contact library
-
llvm-ir
LLVM IR in natural Rust data structures
-
bloom-filters
Rust port of https://github.com/tylertreat/BoomFilters
-
rudac
A crate for common data structures and algorithms
-
rstar
R*-tree library for the rust ecosystem
-
suff_collections
Fast realization of suffix array and suffix tree
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
fixed-vectors
Library implementing fixed-length Vectors meant for representing dimensional values
-
building_blocks_storage
Efficient storage for maps on sparse or dense, 2D and 3D integer lattices
-
sgf-parse
A parser for the SGF file format for Go games
-
lfchring
Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication
-
lambda-runtime-types
Common structures for lambda architecture
-
index-ext
Index slices with arbitrary ints and as arrays
-
ic-types
Types related to the Internet Computer Public Specification
-
ulid-generator-rs
A Rust crate for generating ULIDs
-
dary_heap
A d-ary heap
-
rb_tree
A Red Black Tree implementation in Rust
-
secured_linked_list
A cryptographically secured and provable linked list
-
path-value
Universal type and access property(s) by path
-
fdec
A collection of macros for generating fixed-size fixed-point numeric types for Rust
-
sparsevec
Compress vectors using row displacement
-
bk-tree
A Rust BK-tree implementation
-
graphviz-rust
The library provides the basic access to the graphs in graphviz format with ability to import into or export from it
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
aversion
Versioned data structures with auto-upgrading
-
slas
Static Linear Algebra System
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
unstructured
Generic types for unstructured data
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
kd-tree
k-dimensional tree
-
tcgeneric
Generic data types used internally by TinyChain. Unstable.
-
bevy-ui-build-macros
A collection of macros to speed up the process of defining UIs in bevy
-
kvdb-rocksdb
kvdb implementation backed by RocksDB
-
roadmap
model a project roadmap as a directed acyclic graph
-
sharded
Safe, fast, and obvious concurrent collections
-
gcollections
Generic traits over Rust collections library
-
lodtree
A simple crate to help create octrees and quadtrees for chunked level of detail
-
grid
Dynamic generic 2D data structure
-
vmm-sys-util
A system utility set
-
random-access-storage
Abstract interface to implement random-access instances
-
adapton
programming abstractions for general-purpose incremental computations
-
Xorfilter
No alloc membership approximation
-
libnv
Safe and rustic wrapper around libnv-sys
-
dcc-lsystem
An implementation of a Lindenmayer system together with some rendering tools
-
xml-builder
Easy and highly-configurable XML builder/writer
-
goya
Yet another morphological analyzer for Rust and WebAssembly
-
fixed-queue
no_std, no_alloc, lock-free, wait-free, use [T; N]. support
Vec/VecDeque/spsc/History -
tongrams
Tons of N-grams
-
hierarchical_hash_wheel_timer
A low-level timer implementantion using a hierarchical four-level hash wheel with overflow
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
timely_communication
Communication layer for timely dataflow
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
imbl
Immutable collection datatypes
-
flo_rope
An attributed and streaming implementation of the rope data structure
-
bdaddr
Bluetooth Device Address
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
anymap2
A safe and convenient store for one value of each type
-
bitstring
Bitstring traits and implementations
-
tinyvec_string
tinyvec based string types
-
sucds
Succinct data structures in Rust
-
fwdlist
A simply linked (forward) list
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
queues
Efficient FIFO Queue data structures
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
skiplist-rs
Skip list is a kind of ordered map and can store any value inside. See skip list wikipedia page to learn more about this data structure.
-
min-max-heap
An efficient, double-ended priority queue
-
biodivine-lib-bdd
A simple thread-safe implementation of basic binary decision diagrams
-
tar-no-std
Library to 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… -
bitf
This crate provides a procedural macro to easily create a bitfield out of a struct
-
designal
Procedural macro for use with futures-signals
-
uid
A crate for the creation of unique IDs
-
array-init-cursor
Utility crate to help keep track of arrays of MaybeUninit
-
graphlib
Graphlib is a simple and powerful rust library for the graph data-structure
-
dependency-graph
Library for building and resolving dependency graphs
-
petal-clustering
A collection of clustering algorithms
-
static_type_map
A type map that works over all types implementing
Any -
rc-writer
A tiny implement for writing data to a reference counted instance
-
compt
A complete binary tree visitor library
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
todo_lib
Collection of utilities for todo.txt format
-
rsdict
Fast static rank and select data structure
-
aliasable
Basic aliasable (non unique pointer) types
-
merkle
Merkle tree implementation with support for generation of inclusion proofs
-
trk-io
TrackVis (*.trk) reader and writer
-
cifar-ten
Parses the CIFAR-10 dataset binary files, and returns them as a Rust ndarray tuple
-
pulz-arena
A generational arena allocator with compact generational indices
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
bv
Bit-vectors and bit-slices
-
typed_index_collection
Manage collection of objects
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
lru-mem
An LRU cache implementation bounded by memory
-
stride
A strided slice type
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
bitvector
BitVector implementation in Rust
-
panoradix
A generic map and a set, both backed by a Radix tree
-
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
ioc
An Inversion-of-Control library in Rust
-
bigs
A bipartite graph sampler
-
usher
Parameterized routing for generic resources in Rust
-
dachshund
Dachshund is a 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…
-
bloom_filter_plus
rust_bloom_filter
-
gtfs-geojson
A simple converter for GTFS to GeoJSON formats
-
misc_utils
A small collection of convenient and utility functions developed for personal use
-
tracker-macros
Macros for the tracker crate
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
recursive_reference
This crate provides a way to walk on recursive structures easily and safely
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
llml
Implementation of basic math data types with high level frontend and low level backend
-
optional
This crate supplies a number of Option-like primitive types
-
tugger-windows
Collection of packaging primitives specific to Windows
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
floating_bar
Representing rational numbers using the floating-bar number type
-
elementtree
Parse an XML file into Python elementtree like structure
-
activation_functions
This is a collection of activation functions
-
smallbitset
This crate provides a series of allocation free sets capable of holding small integer values
-
rexsgdata
Scatter-Gather Data Descriptors
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
pareto_front
Builds a Pareto front incrementaly
-
slice_ring_buf
A fast ring buffer implementation optimized for working with slices
-
safe_index
Type-safe indexes
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
swaybar-types
A library for building swaybar status commands in rust
-
mset
A mset / multiset / bag implementation
-
partial-array
Provides potentially partially-filled arrays
-
dlv-list
Semi-doubly linked list implemented using a vector
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
rb
A thread-safe ring buffer with blocking IO
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
moka-cht
Lock-free resizeable concurrent hash table
-
disjoint-sets
Three union-find implementations
-
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.
-
xtree
A simple general purpose tree data structure
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
defaultmap
Provides a HashMap with an automatic default for missing keys
-
pasture-core
A framework for working with point cloud data
-
strchunk
Data types for working with UTF-8 text in I/O
-
sum
General-purpose sum types
-
key-node-list
Doubly-linked list that stores key-node pairs
-
c_vec
Structures to wrap C arrays
-
retworkx
A python graph library implemented in Rust
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
toodee
A lightweight 2D wrapper around a Vec
-
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.
-
bigraph
Different representations with implemented operations on bigraphs
-
yoke
Abstraction allowing borrowed data to be carried along with the backing data it borrows from
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
intervals-rs
A Rust crate for intervals
-
ux-dataflow
Data Processing Library
-
tc-value
TinyChain’s representation of a value which can be collated and stored. Unstable.
-
statiki
Static friendly data structures
-
hash_ring
Consistent Hashing library for Rust
-
slice-dst
Slice-based custom DSTs
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
libflow
library grouping network flow data
-
clarion
A library to simplify working with Clarion software data formats
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
esdl
Event-Sourcing Schema Definition Language parser
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
packedvec
Store vectors of integers efficiently
-
tri-mesh
A triangle mesh data structure including basic operations
-
system-config
A library for storing application properties on disk
-
do-notation
Monadic do syntactic sugar
-
debt64
An implementation of Base64 - https://en.wikipedia.org/wiki/Base64
-
granite
Generic backing storage framework for building data structures
-
matrix-sdk-common
Collection of common types and imports used in the matrix-sdk
-
ldpc
A toolbox for classical and quantum LDPC codes
-
extindex
Persisted immutable index
-
generic-json
Generic JSON traits
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
smallstr
String-like container based on smallvec
-
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!
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
art-tree
The Adaptive Radix Tree
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
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”
-
cds
Collection of Data Structures
-
shortlist
An efficient data structure to track the largest items pushed to it
-
array_map
Map backed array for fixed size keys with O(1) performance
-
twilight-gateway-queue
Discord Gateway connection queue implementation for the Twilight ecosystem
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
verify
A validation library
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
cactus
Immutable parent pointer tree
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
pfds
Purely Functional Data Structures
-
vk_api
The Vulkan API XML exposed as a byte string constant
-
treez
A collection of useful data structures
-
fn_graph
Batched function execution
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
sentry-contrib-breakpad
Unopinionated crash collection for Sentry reporting purposes
-
kravltree
AVL Tree implementation based on fastutil AVLTreeMap
-
canutils
A can-utils implementation in pure Rust
-
beach_map
Implementation of a slotmap
-
succinct_rs
Succinct Data Structures library for Rust
-
any-range
AnyRange enum can hold any Range* type
-
gardiz
A library for integer geometry on 2D planes, focused on games
-
osm-xml
OSM xml parser for Rust
-
genmap
A simple generational map data structure with no dependencies
-
dd_statechart
A Data-Driven implementation of Harel Statecharts designed for high-reliability systems
-
fm-index
FM index and its variant implementations for Rust
-
gapbuf
Generic gap buffer
-
set_genome
A genetic data structure for neuroevolution algorithms
-
galemu
Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
subgraph-matching
A library for subgraph matching
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
ds-bst
Binary search tree implementation
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
radix-tree
A radix tree implementation for router, path search
-
ternary-tree
A Rust implementation of Ternary Search Trees, with no unsafe blocks
-
kserd
Kurt’s Self-Explanatory Rust Data
-
python-packed-resources
Manage data structures containing Python resources
-
bitsetium
One stop shop for all bitset needs
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent ‘flat’ access
-
array-concat
Macros for concatenating const arrays
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
modular-bitfield-impl
Bitfields for structs that allow for modular use of enums
-
qt-json-rs
JSON library for QT
-
velcro_macros
Procedural macros used by the
velcrocrate. Seevelcrofor documentation. It is not advised to depend on this crate directly; it is an internal dependency ofvelcroand may be subject to breaking changes. -
entity_data
A container for entity component data
-
minivec
A version of Vec that’s only the size of a single pointer
-
pinned_vec
Vec-like data structure whose elements never move
-
btree_graph
A generic graph data structure
-
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
congruence
A simple implementation of congruence closure
-
large_int
An ease-of-use unbounded signed integer
-
bytes-utils
Additional utilities for working with the bytes crate
-
data_structure_traits
data structure collection traits
-
identifier
Generate 128 bits id structs easily
-
records
Proc macro for defining data storage structs
-
relational_types
Manage relations between objects
-
minsize
Collections with a statically known minimum size (using const generics)
-
blender-armature
Serialize / deserialize Blender armatures
-
object-chain
Ad-hoc structure builder
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
xmltree-parse_with_config
Parse an XML file into a simple tree-like structure
-
grammers-tl-types
Rust definitions for Telegram’s API types and functions
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
orderbook
Orderbook for Rust
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
derangement
A Rust implementation of a permutation with no fixed points, a derangement
-
range_union_find
A union-find data structure for ranges
-
jirachi
A collision resistant runtime agnostic key-generator
-
dynprops
Creating and extending objects with typed dynamic properties
-
siraph
A node-based digital signal processing crate
-
nfe
NF-e - Manipulação da nota fiscal eletrônica
-
inspector
General purpose inspection for popular data structures
-
cervine
A slightly more flexible Cow; roughly to T: Borrow as alloc::borrow::Cow is to B: ToOwned
-
vast
Verilog AST library
-
comp_input
Input library for competitive programming
-
mergle
A data structure with fast merging and comparison
-
epsg
EPSG Coordinate Reference System tools & data
-
subset-map
A map where the keys are subsets of an initial set of elements
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
dynamic-matrix
A simple crate to work with matrices
-
hotel
Collection Data-structure to associate values with keys
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
mori
An orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
bengbenge
Simple inifity array for round-robin dns, beng, beng
-
wccg-models
WCCG Data
-
ppar
Persistent immutable array
-
truncate-integer
Truncate integers
-
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 -
charcoal
Implements tree data structures and interfaces to work with them
-
unrolled-linked-list
The implementation of the unrolled linked list in rust
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
simple-undo
Easy to use undo-redo library
-
tsil_cev
LinkedList on Vec
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
screech
A collection of helpers for handling audio data in real time
-
timesource-core
Core library for timesource
-
largeint
A library that supports large integer arithmetic
-
bailamos
Simple notification manager
-
rep
A small tool for representation/class invariants
-
histogram-sampler
Sampling from a distribution given by a histogram
-
stronghold_engine
A rust implementation of the IOTA Stronghold low-level libraries
-
plum
Probabilistic data structures for rust
-
minecraft_end_generation
The minecraft end generation implemented in rust
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
keylist
Elixir keyword list in Rust
-
outils
Graph and tree data structure library. Providing utilities which aren’t easily available in Rust.
-
ball-tree
Ball-tree implementation for K-nearest neighbors
-
ego-tree
Vec-backed ID-tree
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
retrace
Safe, generic rollback log with predictable latency
-
bittle
A library for working with small and cheap bit sets and masks
-
binn-ir
An implementation of Binn - https://github.com/liteserver/binn
-
hashtree
A Merkle Tree implementation in Rust
-
xsparseset
A rust sparse set
-
enso-data
A collection of useful data structures
-
marked-yaml
A simplified YAML structure with provenance spans
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
deltastruct
Allows defining deltas for tagged structs for later application
-
patricia_router
Radix Tree implementation for Rust
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
ttmap
Trivial implementation of type map
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
dims_macro
Macros for Generating Systems of Units
-
hayami
A simple, general use symbol table
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
lending-library
A key-value store that loans full ownership of items
-
elastic-array-plus
Elastic vector backed by fixed size array
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
rustz
A library for functional programming in Rust
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
bitfield-struct
Procedural macro for bitfields
-
tapa-trait-serde
A collection of Tapalogi’s reusable crates
-
graph_solver
An undirected graph constraint solver for node and edge colors
-
liblet
Library for learning about formal languages and grammars
-
watchface
A smartwatch watchface implementation
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
rusty-perm
Rusty permutation with no-std
-
fenwick
Fenwick tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
changed
Simple change detection
-
slabmap
HashMap-like collection that automatically determines the key
-
email-format
Email message format (parser and data structure)
-
gridly
A library for managing fixed-size 2D spaces
-
libarena
Arena allocated graph implementation
-
fux_kdtree
K-dimensional tree implemented in Rust for fast NN querying
-
prefix_tree_map
A Rust implementation of generic prefix tree (trie) map with wildcard capture support
-
fqdn
FQDN (Fully Qualified Domain Name)
-
sp-im
Immutable datatypes for no_std use within Substrate
-
bitstring-trees
Trees based on bitstrings
-
bip_metainfo
Parsing and building of bittorrent metainfo files
-
watermark
A simple watermarking set for in-order insertions
-
applejack
Simple implementation of Radix tree
-
guzzle
A derivable trait for consuming key value pairs into structs
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
isomorphism
2 directional hashmaps
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
text-style
Types and conversions for styled text
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
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
-
narrow-derive
Derive macros for Narrow: A Rust implementation of Apache Arrow
-
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).
-
certified-vars
Certified variable friendly data structures for the Internet Computer
-
index-map
A map with automatically generated usizes as keys
-
exprz
An Expression Library
-
local_vec
fixed-capacity vector allocated on the stack
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
avm1-types
Types for the Flash ActionScript Virtual Machine (AVM1)
-
boolvec
A vector of boolean stored contiguously in memory
-
soa-vec
A simple Vec-like API over a struct of arrays layout
-
exonum-merkledb
Persistent storage implementation based on RocksDB which provides APIs to work with Merkelized data structures
-
partial_const
This library provides a way to handle constant and non-constant values in a unified way
-
range-collections
Sets and maps of ranges, backed by smallvec
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
doson
Dorea Data Struct Parser
-
pl-hlist
Provides support for heterogeneous lists (known as
HLists), which are functional, tuple-like, strongly-typed data structures that can contain elements of differing types -
numas
numas library is implementation of multidimensional array for efficient computing
-
backtracking_iterator
A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting
-
quetta
Immutable, reference-counted strings for rust
-
multiset
Multisets/bags
-
usage
A convenient alternative to the newtype pattern
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
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…
-
fxd
Fixed-point decimal implementation
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
graphrepresentations
A crate providing efficient abstract implementations of different graph representations
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
vec-dimension-shift
N-Dimension shift features for Vec
-
diag
Directed Acyclic Graphs with integer vertices represented as a Strictly Upper Triangular Matrix stored in a bit set
-
bravery_router
Radix Tree implementation
-
syntastic
Generic abstract syntax representation
-
iowrap
Small helpers for using io::Read/io::Write
-
sbf-blake3
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
ordsearch
A data structure for efficient lower-bound lookups
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
cast-rs
A collection of types cast for Rust
-
priority-set
A no_std Priority Set
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
grid-tree
Pixel quadtrees and voxel octrees
-
succinct
Succinct data structures for Rust
-
hedge
An index based half-edge mesh implementation
-
folketinget-api-models
Autogenerated Rust structures based on the Danish Parliament’s OData metadatafile
-
rattish
Cast between trait objects
-
ux-dx
3D Graphics Primitives for Angular Rust
-
static_merkle_tree
Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
abin
A library for working with binaries and strings. The library tries to avoid heap-allocations / memory-copy whenever possible by automatically choosing a reasonable strategy: stack for…
-
traitgraph
Different representations with implemented operations on graphs
-
tracker
A macro to track changes to your structs
-
tugger-file-manifest
Interact with lists of files through a storage-agnostic interface
-
zifu_core
Core library for zifu (command line tool to fix Windows-dependent encoded filenames of ZIP files)
-
froggy
Froggy is a 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
-
fenwick-tree
An implementation of a binary indexed tree (Fenwick tree) data structure in Rust
-
aatree
AATree implementation in Rust
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
sequencetree
a new type of collection to store keys and their corresponding values
-
dag_compute
A library for the construction of arbitrary computation DAGs and the expression of dataflow graphs
-
tilecoding
Rust implementation of Dr. Richard S. Sutton’s tile coding software.
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
value-trait
Traits to deal with JSONesque values
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
rangetools
Extending the Rust Range structs found in std::ops
-
froop
A functional reactive stream library for rust
-
segment-tree
Quickly perform interval queries or modifications
-
ohsl
A collection of numerical routines and mathematical types for use in scientific computing
-
spdx-toolkit
Toolkit for interacting with SPDX Documents
-
hex_color
A Rust library for parsing, serializing, and operating on hex colors
-
graphity
Model signal flow between nodes within a directed graph
-
iterable
An iterable library for Rust collection like types
-
globalmaptile
Convert a raster into TMS tiles, create KML SuperOverlay EPSG:4326, generate a simple HTML viewers based on Google Maps and OpenLayers. Ported from globalmaptiles.py
-
hashcons
Hash cons’ing for compact representations of shared, immutable data structures
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
cycler
A simultainious write/read data structure
-
elaru
Memory safe implementation of LRU cache
-
validbr
Provides data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
try-push
A trait for attempting potentially expensive actions
-
uvector
access two slices as a single continuous vector
-
toboggan-kv
Toboggan-kv is an abstraction layer over multiple KV stores
-
prehash
A crate for storing values with precomputed hashes
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
leak
Safely leak data from owned data structures
-
code_location
A library to automatically acquire a code location in a rust source code file
-
arc-bytes
A reference-counted byte buffer
-
kvdb
Generic key-value trait
-
asyncapi
This crate aims to provide data structures that represent the AsyncAPI specification easily deserializable with serde
-
yoke-derive
Custom derive for the yoke crate
-
lumberjack
Read and modify constituency trees
-
varuint
Variable length signed and unsigned integer types
-
cmp_wrap
Let you compare structes by context
-
ensure
Ensure target state of an object
-
mwmatching
Maximum-Weight Matching: Compute a maximum-weighted matching in the general undirected weighted graph given by ‘edges’
-
uuid-rs
A Simple Universally Unique IDentifier (UUID)
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
domain-lookup-tree
A tree structure in Rust optimized for looking up domain names, with wildcard support
-
eztd
Quick start Rust
-
entity_table
Data structure for associating data with entities in an Entity Component System
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
langtag
Language tags implementation following RFC 5646
-
half_edge_mesh
A basic implementation of the half-edge mesh data structure. It has a bunch of the functions you probably want in a half-edge mesh, but probably not all of them. I’m intending to add more methods and mutation techniques…
-
reso_dd
Structures and Enumerations that implement the Real Estate Standards Organization (RESO) Data Dictionary
-
tui-tree-widget
Tree Widget for tui-rs
-
mop-structs
Low-level structures for MOP
-
raphy
A graph data structure library
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
actions
Software without side-effects. Redo and Undo. Macro’s.
-
json-trait-rs
Rust interface (aka trait) to deal with objects as they are JSON objects
-
partial
Optional monad with fake variant
-
hgg
Approximate nearest neighbor search collection
-
traitsequence
Traits to abstract over sequences
-
flat-tree
Rust module for encoding/decoding varints that doesn’t do any IO. Inspired by the Node.js varint module
-
yeast-rs
Tiny but linear growing unique id generator
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
dia-i18n
ISO 3166-1 and ISO 639 codes
-
content-tree
An efficient data structure for compacted RLE data
-
exclusion-merkle-cbt
Complete Binary Merkle Tree for verify exclusion
-
restorable
An iterator adapter for saving and restoring iterator state
-
hibitset
Hierarchical bit set structure
-
hash-rings
Implementations of various hash rings
-
statemachine-rs
A statemachine crate which have zero dependencies
-
tennis
Tennis data structures
-
intpack
intpack is a collection of functions for packing/unpacking unsigned integers into other unsigned integers of different sizes. For example, packing 4 u8’s into a u32.
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
geomprim2d
2D geometric primitive types
-
bookfile
A container file format with chapters and an index
-
lhlist
Labeled heterogeneous lists
-
passive
A trio of marker traits to classify passive data structures
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
treers
Simple implementation of Sedgewick’s tree maps
-
inditech
A set of technical indicators for time series analysis
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 9a27044f42ace9eb652781b53f598e25d4e7e918 The publishing script for this crate lives at: https://github… -
safe-graph
Graph implementation (refactored version of GraphMap from popular crate petgraph)
-
nslice
Structures for interpreting slices of variable length as arrays
-
extended-rational
Provides implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
stack-array
A data structure for storing and manipulating fixed number of elements of a specific type
-
shared-string
Split a string without another allocation
-
ahtable
Array Hash Table implementation
-
tibitset
TiBitSet is a simple bitset replacement for HashSet
-
pod
Plain Old Data (POD) encoding and I/O
-
sweeper
A foundation for Minesweeper implementations in Rust
-
bounded-spsc-queue
A bounded SPSC queue
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
derive_wrapper
Rust custom derive macro for wrapping types
-
comn
my common rust code
-
nave
Thinking about the construction of distributed systems starting from the consistent hash algorithm
-
polystore
Polymorphic data store
-
multipath
A library to split file path, like
/home/{user,admin}/file.txt -
id-map
Data structure of values indexed by IDs
-
recollection
implementations and reimplementations of common data structures and algorithms, and other personally commonly used utilities
-
ethercat-types
Common EtherCAT data structures
-
grafana-dashboard
grafana import/export data serializable structures
-
jsonnlp
an implementation of the JSON-NLP data structure
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
apint
Arbitrary precision integers library
-
mush
Visual graph/dialogue editor
-
adivon
Data Structures of daily use: Graph, HashTable, PriorityQueue, Trie, SuffixTree, Rope, SplayTree, SkipList, RedBlackTree
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
btree-slab
A memory compact Slab-based B-tree implementation
-
version-rs
A struct for Versions, with the methods you expect
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
numbrs
A flexible numerical computing package
-
basiccountminsketch
A basic count min sketch implementation
-
Project2
Implementations of red black tree and AVL tree
-
simple-matrix
A simple generic matrix library
-
dst
Data structures for DSTs
-
clampf
Clamped floating-point types
-
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII’s gridd)
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
fcsd
Front-coding string dictionary
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
wordsworth
A collection of natural language analysis functions
-
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
splay
A 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)…
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
zot
Provides Option-like enums for working with ordered collections of zero, one, or two items (
Zot), or ordered collections of one or two items (Ot) -
hit-data
Hierarchical Indexed Typed data structure
-
truetree
Trees in Rust
-
vega-lite
Generated code for using the Vega-Lite schema from Rust
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
enum_meta
Add metadata to Enum Variants
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
safer-bytes
safe, non-panicking wrappers around the ‘bytes’ crate
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
hashbrown_tstd
A Rust port of Google’s SwissTable hash map
-
narrow
A Rust implementation of Apache Arrow
-
linux-stats
typesafe procfs info
-
av-data
Multimedia data structures
-
simple_ringbuf
Simple Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
type-map
Provides a typemap container with FxHashMap
-
dynamization
Fast insertion for static containers
-
pl-lens
Provides support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
pciids
A library to parse the pci.ids data file
-
epoch-timestamp
Boilerplate collection for epoch timestamping
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
replicante_logging
Replicante common logging logic
-
torrent-common
A set of data structures used for bittorrent implementations
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
keyed
Implement comparison traits by specifying a key
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
graphific
Graphific is a graph data structure library
-
kekbit-core
Defines the main abstractions and provides the core components required to work with kekbit channels
-
rosary
A Library About Rose Trees
-
phollaits
Here is a collection of traits that I use in my projects from time to time - feel free to use them in your projects as well
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
depot
A (disk) persistent queue library
-
rust_fixed_width
library that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
coca
Data structures with constant capacity
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
dusk-kelvin-map
BST Map implementation with Microkelvin backend
-
tree-cursor
A simple, non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
graphsearch
A simple graph search and representation library
-
named_tuple
A macro for declaring a
structthat manages a set of fields in atuple -
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
lightning-containers
A set of lock-free data structures
-
slist
Algebraic lists with statically determined size that live on stack
-
gsrs
Generic Self Referencing Struct
-
token-lists
A simple token list representation
-
serde_either
Simple set to enums to deserialize and serialize data that can either be string, struct or vec
-
swimmer
Thread-safe object pool type
-
collectable
Fallible, no_std-friendly collection traits
-
another-option
Another option data type; useful when allocations are expensive
-
puruda
Pure Rust DataFrame
-
break_array
For breaking array indexing
-
cliquers
Manage filesequences with a common numeric component
-
string-err
String error type
-
hashable_rc
Hashable wrappers for reference countings
-
sesstype
An implementation of Multiparty Session Types
-
thermostat
Finite state machine for a thermostat controlling a centralized HVAC system or other heating and/or cooling apparatus
-
no_vec
A library for modifying sized arrays
-
go-heap-rs
Golang’s heap written in Rust
-
stomp
A full STOMP 1.2 client implementation. Allows programs to interact with message queueing services like ActiveMQ and RabbitMQ.
-
atree
An arena based tree structure with removal support
-
set-trie
A trie for fast subset and superset queries
-
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 -
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
specs-hierarchy
Scene graph type hierarchy abstraction for use with specs
-
empty-box
Allows for
Boxs to have their values moved out and replaced with new values, while reusing the same allocation -
bip_handshake
Common handshaking interface as well as a default handshake implementation
-
protocoll
clojure inspired protocols for rust collections
-
dists
2d distribution generator
-
bicoro
Bidirectional co-routine data structures
-
tf_playlist
The playlist feature used in Tubefeeder
-
tagged-tree
A tree-like data structure where the values are tagged
-
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
spdx-rs
Parse and interact with SPDX Documents
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
tiled-json-rs
A crate to parse and interact with Tiled editor JSON files
-
roccodev-api
Rust library for RoccoDev’s API
-
closures
Abstraction for seperating code and state in closures
-
aterm
Implementation of the Annotated Terms data structure
-
afi
Audio & video structures, plus encoder & decoder traits
-
enumoid
Enum Indexed Containers
-
theban_interval_tree
A simple Interval Tree implementation
-
nats-types
Enumerations and types for representing NATS protocol messages
-
minecraft_nether_generation
The minecraft nether generation implemented in rust
-
kurobako_solvers
A collection of black-box optimization solvers
-
bidirectional-map
A two-way map data structure for small keys and values
-
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
big_enum_set
A library for creating sets of enums with a large number of variants
-
awint_macros
Accompanying procedural macros to
awint -
sliding_window
A fixed size, heapless sliding window
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
rtrees
A Bunch of completely safe augmented tree implementation in rust
-
inplace-vec-builder
Build a vec from a vec, in place
-
push-while-ref
push while having a reference
-
flats
flattens nested structures into a flat single dimension map
-
fusefilter
No alloc membership approximation
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
fill_canvas
FillCanvas is a wrapper around a matrix with special methods to fill the cells
-
automerge
Rust implementation of the Automerge replicated JSON datatype
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
more_collections
Additional collections not found in std::collections
-
qptrie
A QP-Trie implementation for Rust
-
pui-arena
Generalized Arenas that can be used on
no_std -
dirty_static
A container for an immutable value that allows sneaky reloading in debug mode (via UnsafeCell) while keeping the data safe and constant in release mode. This allows you to tweak data while testing an application…
-
be-tree
B𝛆 Tree library in Rust
-
pour
Optionally consed radix tries for fast set operations
-
qt-json
JSON library for QT
-
btree_network
A generic network (undirected graph) data structure
-
restor
A dynamic resource storage system in rust
-
clnooms
Assembly-level implementation of interesting data types
-
indexvec
Simplified copy of rustc’s index crate
-
collect-mac
This crate provides the
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… -
dims_core
Core Utils for Generating Units and Systems
-
advanced_collections
Library with advanced data structures (collections). Includes counter (hash-bag, multiset), disjoint set (union-find, merge-find), circular buffer (cyclic buffer) and interval (range)
-
more_ranges
Range types not provided in the standard library
-
rasn-smi
Data types for handling Structure for Management Information
-
bloom2
Fast, compressed 2-level bloom filter and bitmap
-
onigiri
This crate is a tool of handling chars
-
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
-
funnel
A simple data structure that makes it easy to read from multiple channels from a single source
-
map_vec
The Map and Set APIs backed by Vec
-
hv-alchemy
Heavy Alchemy - the black arts of transmutation, wrapped for your safe usage and enjoyment
-
quantized-density-fields
Rust implementation of Quantized Density Fields data structure
-
perpendicular
Perpendicular is a simple general purpose n-dimensional vector library
-
nibble_vec
Vector data-structure for half-byte values
-
llml_derive_crate
Derive macros for llml
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
sparsemat
A simple sparse matrix library
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
dot-generator
The library provides macroses to generate dot structures
-
arrsingh
A top level crate in the workspace
-
type-freak
Collection of typed data structures, trait operators and aliases
-
bit_mask_ring_buf
A fast ring buffer implementation with cheap and safe indexing
-
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
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 -
pvec
RRB-Tree based persistent vector implementation
-
ctxmap
A collection that can store references of different types and lifetimes
-
vec-strings
Store any string efficiently in an immutable way
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
avl
A map and a set implemented with an AVL tree
-
flexible-string
A stack heap flexible string designed to improve performance
-
banyan-utils
Utilities to work with banyan trees
-
arraystring
Fixed capacity stack based generic string
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
flit
Bloom filter backed by xxHash
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
deepmesa-lists
A collection of list data structures and algorithms designed for performance
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
vk_generator
Generate Rust bindings to the Vulkan API
-
collectivity
Generic collection traits
-
entity_macros
Macro library that provides ability to generate ent logic at compile-time
-
impl-num-traits
num-traits implementation for uint
-
bloom_filter_simple
A simple and generic bloom filter implementation
-
last-git-commit
Simple wrapper arround git2-rs to get info about the last commit. Useful for when you want to show the git hash in a program.
-
pdatastructs
Simple probabilistic data structures
-
skog
Rust implementation of Adobe’s stlab::forest data structure
-
coitrees
A very fast data structure for overlap queries on sets of intervals
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
dlist
List data structure based on AVL tree. It can store elements which have dimension and quickly search for elements by distance from 0.
-
street_index
street_index is a small utility crate for working with road name / street indexing for cartographic purposes
-
offset
Glorified offsets for arbitrary structures
-
eztd-core
Quick start Rust
-
take-some
A simple library that provides a way to obtain some value from various collections
-
alphabet-macro
Provides a macro that can be used to easily create const alphabets
-
simple_tables-core
The core functionality of the simple_tables crate
-
dynamic-grid
Dynamic grid Structure for Rust
-
gtrie
Generic trie implementation with a support of different key and value types
-
lifetimed-bytes
Bytes, but with attached lifetime
-
handlebox
A map-like collection that reuses unused keys
-
fricgan
A simple crate for performing basic input and output on bytes
-
unsized_enum
Unsized enum implementation
-
binary-data-schema
Meta language for raw binary serialization
-
dynvec
This crate provides the
DynVectype that acts like a vector to store any datatype -
fr-trie
Fuzzy Radix Trie
-
ro
Helps make stuff read-only
-
history-buffer
A fixed capacity, write-only, ring buffer
-
packed-integers
A growable array for integer types in the range
u1tou31 -
single_byte_hashmap
A simple HashMap for storing singular bytes as keys
-
bipbuffer
A Rust implementation of Simon Cooke’s Bip-Buffer
-
chainmap
A ChainMap with mutability of intermediate maps
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
grdf
Generalized RDF graphs and datasets
-
simple-bitrange
A simple crate for manipulating bit ranges which is common when working with IC registers
-
cbloom
Concurrent implementation of Bloom filters
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
trie
An ordered map and set based on a trie
-
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)
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
dot_json
Tools for dot map representations of serde_json Maps
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
rbtset
A set based on a RB-Tree for efficient operations
-
vecfile
A Vec-type collection that sits in a file vs in memory
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
sized-vec
Type level sized vectors
-
holyhashmap
A hash map with stable indices
-
wrapping
Wrapping slices and arrays
-
tugger-binary-analysis
Inspect platform binaries
-
slots
Fixed size data structure with constant-time operations
-
hirpdag
Library and procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
deepmesa
This crate provides fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
eitherq
Queue which support two different types
-
indexmap-rmw
A 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…
-
guzzle-derive
The derive macro for guzzle, please use that crate not this one
-
appendlist
An append-only list that preserves references to its elements
-
tapa-trait-serde-derive
Tapalogi’s derive macro for tapa-trait-serde
-
small-ord-set
A set data-structure represented by a sorted
SmallVec -
static-box
A stack-allocated box that stores trait objects
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
takeable
Container type that allows for temporarily moving out of the container
-
word-dictionary
This crate provides a data structure for word mapping. It can be used for language translation.
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
heatmap
time-series of histograms with precision guarantees
-
building_blocks_partition
Acceleration structures for spatial queries on voxel data
-
init_trait
A small helper trait to simplify the initialisation of ‘indexable’ data structures
-
tapa-cgloop-nats
A collection of Tapalogi’s reusable crates
-
modular-bitfield-msb-impl
Bitfields for structs that allow for modular use of enums. MSB-first version.
-
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. -
event-queue
crates.io için bir paket nasıl hazırlanırın ele alındığı öğrenme amaçlı modüldür
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
bittyset
A BitSet type for manipulating bit sets
-
tree-automata
Term Rewriting Systems
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
refactory_string
A library to modify a string using original indices. Useful for Source Code transformations.
-
divsufsort
Rust port of Yuta Mori’s divsufsort
-
lumberjack-utils
Read and modify constituency trees
-
simple-uuid
A Simple Universally Unique IDentifier (UUID)
-
cbor-tag-index
Tag index
-
const-arrayvec
A vec-like type backed by an array on the stack
-
compacts
compact data structures
-
bisetmap
BisetMap is a 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…
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
eclectic
Experimental collection traits
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
vhr_datatypes
An implementation of the data/file structures used in the computer game Valheim
-
vecdeque-stableix
Deque with stable index values
-
polymap
A map containing varying types of value
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
owned_chunks
a collection of traits and iterators to get owned chunks from collections
-
fplist
An immutable, persistent, singly-linked list
-
std_collection_traits
Abstraction of operations in std collection types
-
sparseset
A Sparse Set
-
mori_parallel
A parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
semver-store
An HashMap structure that uses semver strings as keys
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
loaf
Why have a slice when you can have a loaf?
-
automap
Simple pattern to implement key-value maps where the value type contains the key type
-
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
-
prio-queue
A simple priority queue implemented as a heap stored in a Vec
-
tapestry
Generic 2D grid data structure and utilities
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
appendix
Append-only, on-disk key-value index
-
tranche
Tranches are an alternative to slices
-
btree-vec
A growable array (vector) implemented using a B-tree
-
im
Immutable collection datatypes
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
prima
Generic 2D library used to handle graph structures and basic geometry
-
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
projected-hash-map
Implementation of a projected HashMap over HashSet
-
byte_set
Efficient sets of bytes
-
arrsingh-lists
A test crate to test publishing
-
ringvec
A simple ring buffer implementation based on a vector
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
fral
Functional random-access lists
-
bytesstr
An immutable reference-counted UTF8 String
-
binary_search_tree
Binary search tree implementation
-
small_vec2
Vector on the stack or heap need nightly rustc
-
btree_dag
A generic DAG (undirected graph) data structure
-
entity_macros_data
Companion library for entity_macros that provides data structures that describe ents
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
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.
-
persistent_rope
An immutable persistent rope data structure
-
immutable-seq
Immutable sequence data structure
-
bitset-fixed
Bitset for DP
-
mmap_json_file
A library to parse, count, filter JSON files using memory mapped io library
-
len-trait
Len trait for collectons
-
rotating-buffer
Small helper data structure that allows retaining unused data
-
index-utils
Utilities for working with indices
-
prefix-tree
A map and set interfaces using trie data structure
-
gen-vec
Vector indexed with generational indices
-
embedrs-bytes
Types and traits for working with bytes
-
normalize_interval
Normalizing interval library
-
dot-structures
The library provides macroses to generate dot structures
-
fixed-map-derive
A fixed map where storage layout is calculated by a procedural macro. This crate contains the procedural macros
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
dashmap-shard
A Rust port of Google’s SwissTable hash map
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
collect-once-hashmap
A hashmap that can be collected only when there are unique keys in the iterator
-
bset
Fast and compact sets of bytes or ASCII characters
-
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.
-
judy-wrap
Judy arrays FFI mid-level binding
-
rudy
Judy array implementation in pure Rust
-
artsy
ART Tree data structure library
-
stonks
Sets that allow borrowing while inserting entries
-
automatic-relations
Tree automatic relations
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
core_collections
This is a copy of libstd::collections with all the parts that don’t work in core removed. Most importantly, it provides HashMap and HashSet. This crate is (mostly) automatically generated from the rust git source…
-
board
A simple crate for creating a single vector with coordinate based access, and a few nice functions for easy use
-
maybe-string
Provides a newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
stavec
Stack-allocated vector with static capacity