-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
smallvec
‘Small vector’ optimization: store up to a small number of items on the stack
-
hdrhistogram
A port of HdrHistogram to Rust
-
generic-array
Generic types implementing functionality of arrays
-
bitvec
A crate for manipulating memory, bit by bit
-
bit-vec
A vector of bits
-
predicates
An implementation of boolean-valued predicate functions
-
hashbrown
A Rust port of Google’s SwissTable hash map
-
arc-swap
Atomically swappable Arc
-
bytes
Types and traits for working with bytes
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
im
Immutable collection datatypes
-
radix_trie
Generic radix trie data-structure
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
slice-deque
A double-ended queue that Deref’s into a slice
-
string
A UTF-8 encoded string with configurable byte storage
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
heapless
staticfriendly data structures that don’t require dynamic memory allocation -
bimap
A fast two-way bijective map implementation
-
crdts
Practical serializable thoroughly tested CRDTs (ORSWOT, counters, LWW) ported from riak_dt
-
enumset
A library for creating compact sets of enums
-
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…
-
hibitset
Hierarchical bit set structure
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
sized-chunks
Efficient sized chunk datatypes
-
id_tree
A library for creating and modifying Tree structures
-
kdtree
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
getzola/zola
A fast static site generator with everything built-in
-
string-interner
An efficient string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
rpds
Persistent data structures with structural sharing
-
spade
Spatial datastructures like r-trees and delaunay triangulations for rust
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
generator
Stackfull Generator Library in Rust
-
bv
Bit-vectors and bit-slices
-
array-init
Safe wrapper for initializing fixed-size arrays
-
sharded-slab
A lock-free concurrent slab
-
rusty_ulid
Rust ULID (Universally Unique Lexicographically Sortable Identifier) generation and processing
-
trees
General purpose tree data structures
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
typescript-definitions
serde support for exporting Typescript definitions
-
smallbitvec
A bit vector optimized for size and inline storage
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
min-max-heap
An efficient, double-ended priority queue
-
tinystr
A small ASCII-only bounded length string representation
-
c_vec
Structures to wrap C arrays
-
path-tree
path-tree is a lightweight high performance HTTP request router for Rust
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
enum-map
A map with C-like enum keys represented internally as an array
-
sprs
A sparse matrix library
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
flat-tree
Rust module for encoding/decoding varints that doesn’t do any IO. Inspired by the Node.js varint module
-
adapton
programming abstractions for general-purpose incremental computations
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
arr_macro
Initialize arrays with ease!
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
redo
Provides advanced undo-redo functionality with static dispatch
-
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…
-
rstar
R*-tree library for the rust ecosystem
-
optional
This crate supplies a number of Option-like primitive types
-
landon
A collection of tools, data structures and methods for exporting Blender data (such as meshes and armatures) and preparing it for your rendering pipeline
-
enum-ordinalize
This crates provides
create_ordinalized_enummacro to let enums can not only get its variants’ ordinal but also be constructed from an ordinal -
graphlib
Graphlib is a simple and powerful rust library for the graph data-structure
-
dinotree_alg
Dinotree algorithms
-
treeflection
A library that provides reflection for tree structures
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
trie-root
In-memory patricia trie operations
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
pagetable
simple wait-free two-level pagetable with 2mb pages
-
usher
Parameterized routing for generic resources in Rust
-
bit-set
A set of bits
-
ternary-tree
A Rust implementation of Ternary Search Trees, with no unsafe blocks
-
tri-mesh
A triangle mesh data structure including basic operations
-
roaring
http://roaringbitmap.org : A better compressed bitset - pure Rust implementation
-
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.
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
bitlab
Extracting a range of bits from a binary data source
-
alloc-wg
Attempt of collection several proposals of the allocators-wg
-
circular-queue
A circular buffer-like queue
-
transit_model_collection
Manage collection of objects
-
macaddr
MAC address types
-
guppy
Track and query Cargo dependency graphs
-
typescript-definitions-ufo-patch
serde support for exporting Typescript definitions
-
histogram
histogram storage and percentile metrics with precision guarentees
-
ego-tree
Vec-backed ID-tree
-
bitvector
BitVector implementation in Rust
-
trk-io
TrackVis (*.trk) reader and writer
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
abi_stable_shared
Implementation detail of abi_stable
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
daab
DAG aware artifact builder
-
hash-rings
Implementations of various hash rings
-
panoradix
A generic map and a set, both backed by a Radix tree
-
unstructured
Generic types for unstructured data
-
intervaltree
A simple and generic implementation of an immutable interval tree
-
merkle-cbt
A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
exonum-merkledb
Persistent storage implementation based on RocksDB which provides APIs to work with Merkelized data structures
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
vec_map
A simple map based on a vector for small integer keys
-
ibuilder
Interactive builder for Rust types
-
anymap
A safe and convenient store for one value of each type
-
slice-dst
Slice-based custom DSTs
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
user-error
Simple error type that display in a clear and beautiful manner to the user of a CLI application
-
tiled
A rust crate for loading in maps created by the Tiled editor
-
concread
Concurrently Readable Data-Structures for Rust
-
onigiri
This crate is a tool of handling chars
-
treebitmap
Fast IPv4/IPv6 lookup trie
-
cactus
Immutable parent pointer tree
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
subset-map
A map where the keys are subsets of an initial set of elements
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
uluru
A simple, fast, LRU cache implementation
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
cidr-utils
This crate provides data structures and functions to deal with IPv4 CIDRs and IPv6 CIDRs
-
cita_trie
Modified Patricia Tree (aka Trie)
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
ndsparse
Sparse structures for N-dimensions
-
treez
A collection of useful tree data structures
-
molecule
Rust bindings for molecule
-
hashbrown_tstd
A Rust port of Google’s SwissTable hash map
-
outils
Graph and tree data structure library. Providing utilities which aren’t easily available in Rust.
-
merkle
Merkle tree implementation with support for generation of inclusion proofs
-
rustfst
Library for constructing, combining, optimizing, and searching weighted finite-state transducers (FSTs)
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
succinct_rs
Succinct Data Structures library for Rust
-
fp_rust
Implement fp features for Rust
-
threshold
Threshold data structures
-
imag-id-in-collection
Part of the imag core distribution: imag-ids command
-
index_vec
Newtype-style helpers for
Vecandusize -
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent ‘flat’ access
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
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. -
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
queues
Efficient FIFO Queue data structures
-
immutable-chunkmap
A cache efficient immutable map and set with lookup performance equivalent to BTreeMap and BTreeSet, fast batch insert and update methods, and efficient implementations of all set operations
-
contest-algorithms
Common algorithms and data structures for programming contests
-
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. -
bounded-spsc-queue
A bounded SPSC queue
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
galemu
Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
fenwick
Fenwick tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
smallstr
String-like container based on smallvec
-
succinct
Succinct data structures for Rust
-
csv2json
Converts CSVs into JSON documents
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
space
A library providing abstractions for spatial datastructures and search
-
fm-index
FM index and its variant implementations for Rust
-
bitmaps
Fixed size boolean arrays
-
bloomfilter
Bloom filter implementation
-
libnv
Safe and rustic wrapper around libnv-sys
-
extindex
Persisted immutable index
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
debt64
An implementation of Base64 - https://en.wikipedia.org/wiki/Base64
-
rangemap
Map data structure whose keys are stored as ranges. Contiguous and overlapping ranges that map to the same value are coalesced into a single range
-
numas
numas library is implementation of multidimensional array for efficient computing
-
fwdlist
A simply linked (forward) list
-
bitwrap
pack/unpack data into byte array
-
defaultmap
Provides a HashMap with an automatic default for missing keys
-
kserd
Kurt’s Self-Explanatory Rust Data
-
rexsgdata
Scatter-Gather Data Descriptors
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
linked_hash_set
HashSet with insertion ordering
-
transit_model_relations
Modeling the relations between objects
-
ordered-multimap
Insertion ordered multimap
-
tinyvec
Just, really the littlest Vec you could need. So smol.
-
startin
A Delaunay triangulator for terrains
-
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
sparsevec
Compress vectors using row displacement
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
blender-armature
Serialize / deserialize Blender armatures
-
lasso
A concurrent string interner that allows strings to be cached with a minimal memory footprint, allowing them with a unique key that can be used to retrieve them at any time
-
undo
Provides simple undo-redo functionality with dynamic dispatch
-
dlv-list
Semi-doubly linked list implemented using a vector
-
polytype
A Hindley-Milner polymorphic typing system
-
fingertrees
Immutable persisten finger trees
-
fixedbitset
FixedBitSet is a simple bitset collection
-
modular-bitfield
Bitfields for structs that allow for modular use of enums
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
orderbook
Orderbook for Rust
-
idcontain
Generational (or tagged) ID-based containers
-
array-macro
Array multiple elements constructor syntax
-
option_set
Bitflags on steroids
-
big_unsigned_ints
A Crate For Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
ordsearch
A data structure for efficient lower-bound lookups
-
compt
A complete binary tree visitor library
-
sorted-iter
Typesafe extensions for sorted iterators, including set and relational operations
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
queue-file
queue-file is a lightning-fast, transactional, file-based FIFO
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
atree
An arena based tree structure with removal support
-
egg
An implementation of egraphs
-
broom
An ergonomic tracing garbage collector that supports mark ’n sweep garbage collection
-
range
A library for range addressing
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
guzzle
A derivable trait for consuming key value pairs into structs
-
flatgeobuf
FlatGeobuf for Rust
-
heaparray
Flexible support for dynamically-sized types, using heap-allocated array of structs
-
inspector
General purpose inspection for popular data structures
-
kissunits
Different units (like distances or coordinates), keeping it small and simple
-
appro-eq
Approximately equal traits and assertion
-
chainkov
HashMap / Tuple-backed Markov Chains
-
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.
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
indexed
Convenient allocator for index-linked data structures
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
disjoint-sets
Three union-find implementations
-
retworkx
A python graph library implemented in Rust
-
ensure
Ensure target state of an object
-
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.
-
cmp_wrap
Let you compare structes by context
-
backtracking_iterator
A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting
-
moving_min_max
Tracking minimum or maximum of sliding windows
-
gridly
A library for managing fixed-size 2D spaces
-
bipbuffer
A Rust implementation of Simon Cooke’s Bip-Buffer
-
toolbox
Simple tools for daily use
-
binn-ir
An implementation of Binn - https://github.com/liteserver/binn
-
arraystring
Fixed capacity stack based generic string
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
static_merkle_tree
Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
json-trait-rs
Rust interface (aka trait) to deal with objects as they are JSON objects
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
sea-canal
Identifies patterns in sequences of integers
-
bip_handshake
Common handshaking interface as well as a default handshake implementation
-
poisson
Poisson-disk distribution generator
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
map_vec
The Map and Set APIs backed by Vec
-
simple-matrix
A simple generic matrix library
-
midas_cli
Rust port of MIDAS (Microcluster-Based Detector of Anomalies in Edge Streams)
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
sparseset
A Sparse Set
-
iset
This crates implements map and set with interval keys
-
bex
A rust library for working with boolean expressions (expression trees, decision diagrams, etc.)
-
afi
Audio & video structures, plus encoder & decoder traits
-
minimal-id
A library that implements generating short, unique ids with minimal collisions and good locality
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
lumberjack
Read and modify constituency trees
-
multiset
Multisets/bags
-
moving_gc_arena
Lightweight Garbage-collectable regions using indices and explicit roots
-
no_vec
A library for modifying sized arrays
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
kailua_env
Basic environments for Kailua
-
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.
-
atomic-take
Atomically take a value out of a container once
-
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)
-
data_structure_traits
data structure collection traits
-
smart-hash
partial queries in HashSets, the traits
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
resources
Safe store for one value of each type, with interior mutability
-
ami
Useful data structures that are not in the standard library
-
mset
A mset / multiset / bag implementation
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
gtrie
Generic trie implementation with a support of different key and value types
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
hedge
An index based half-edge mesh implementation
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
rahashmap
Fork of standard library HashMap with additional functionality
-
packedvec
Store vectors of integers efficiently
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
atlatl
Double-array tries
-
kstring
Key String: optimized for map keys
-
floating_bar
Representing rational numbers using the floating-bar number type
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
watermark
A simple watermarking set for in-order insertions
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
grammers-tl-types
Rust definitions for Telegram’s API types and functions
-
vec3
vec3
-
isomorphism
2 directional hashmaps
-
region_buffer
A growable array allowing for multiple mutable non overlapping regions
-
rc-borrow
Borrowed forms of Rc and Arc
-
skew-forest
Skew-binary random access lists
-
predicates-tree
Render boolean-valued predicate functions results as a tree
-
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
-
restor
A dynamic resource storage system in rust
-
dashmap-shard
A Rust port of Google’s SwissTable hash map
-
histogram-sampler
Sampling from a distribution given by a histogram
-
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
nclist
Crate for finding overlapping intervals using a nested containment list
-
tag-vec
A vector used for storing tags
-
dia-i18n
ISO 3166-1 and ISO 639 codes
-
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
treeflection_derive
#[derive(Node)] macro for the Treeflection library
-
rtable
Generic Routing Table Library with Radix Tree
-
paginate
A framework agnostic pagination crate, that is especially suited for databases, collections and web pages
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
fast_paths
Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies
-
bip_metainfo
Parsing and building of bittorrent metainfo files
-
osproto
Protocol structures for OpenStack API
-
safe_index
Type-safe indexes
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
matmath
Matrix and Vector Math with generic type elements
-
tiled-json-rs
A crate to parse and interact with Tiled editor JSON files
-
segment-tree
Quickly perform interval queries or modifications
-
mdbookshelf
Create epubs from a list of mdbook repositories
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
vector-map
VecMap<K, V>: the Map API for Vec<(K, V)>
-
reso_dd
Structures and Enumerations that implement the Real Estate Standards Organization (RESO) Data Dictionary
-
Project2
Implementations of red black tree and AVL tree
-
rep
A small tool for representation/class invariants
-
strchunk
A utility library for working with UTF-8 text in I/O
-
uid
A crate for the creation of unique IDs
-
big_enum_set
A library for creating sets of enums with a large number of variants
-
sqa-bounded-spsc-queue
A bounded SPSC queue (temporary version so I can publish sqa-engine)
-
lending-library
A key-value store that loans full ownership of items
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
ring_buffer
RingBuffer is a mix of a vector and a queue
-
rust-fsm
A framework for building finite state machines in Rust
-
radix-tree
A radix tree implementation for router, path search
-
gsrs
Generic Self Referencing Struct
-
json-parser
JSON parser
-
prefix-tree
A map and set interfaces using trie data structure
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
marked-yaml
A simplified YAML structure with provenance spans
-
soak
Transform a struct into arrays of its fields
-
webe_id
Unique ID generator based on Snowflake, but for us wizards
-
string_map
Create a record to store any type of value
-
wccg-models
WCCG Data
-
restorable
An iterator adapter for saving and restoring iterator state
-
arc-string-interner
An efficient string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
data_reader
A data loading library for data scientist
-
rustz
A library for functional programming in Rust
-
varuint
Variable length signed and unsigned integer types
-
intervallum
Generic interval and interval set library
-
biodivine-lib-bdd
A simple thread-safe implementation of basic binary decision diagrams
-
hex2d
Helper library for working with 2d hex-grid maps
-
iowrap
Small helpers for using io::Read/io::Write
-
sortedvec
a sorted vector that enables quick lookups
-
roadmap
model a project roadmap as a directed acyclic graph
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
mju-bits
no_std typed bitfield access for u8, u16, u32 and u64
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
another-option
Another option data type; useful when allocations are expensive
-
intrusive_splay_tree
An intrusive splay tree implementation that is no-std compatible and free from allocation and moves
-
string-err
String error type
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
radix-heap
Fast monotone priority queues
-
automerge
Rust implementation of the Automerge replicated JSON datatype
-
xlru-cache
A cache that holds a limited number of key-value pairs
-
beach_map
Implementation of a slotmap
-
stomp
A full STOMP 1.2 client implementation. Allows programs to interact with message queueing services like ActiveMQ and RabbitMQ.
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
basic_tree
basic tree for rust, for now including only trie
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
grafana-dashboard
grafana import/export data serializable structures
-
untagged-option
An unsafe Option type without discriminant. Nightly only.
-
soa-vec
A simple Vec-like API over a struct of arrays layout
-
gridd
A generic, dirt-simple, two-dimensional grid
-
sum
General-purpose sum types
-
simple_ringbuf
Simple Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
tilecoding
Rust implementation of Dr. Richard S. Sutton’s tile coding software.
-
froop
A functional reactive stream library for rust
-
sesstype
An implementation of Multiparty Session Types
-
swaybar-types
A library for building swaybar status commands in rust
-
vec-collections
Rust collections that are newtype wrappers around vectors
-
hash_ring
Consistent Hashing library for Rust
-
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…
-
idlset
Fast u64 set operations library
-
erasable
Type-erased thin pointers
-
vf-rs
A set of classes generated from the ValueFlows JSON schemas along with various VF utilities
-
edit_tree
Edit trees in rust
-
gapbuf
Generic gap buffer
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
arrav
Sentinel-based heapless vector
-
colours
Color types for different color models with conversions between it
-
aci_ppm
Encode and decode PNM image files (TODO: so far only PPM)
-
partial
Optional monad with fake variant
-
len-trait
Len trait for collectons
-
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)…
-
cast-rs
A collection of types cast for Rust
-
uvector
access two slices as a single continuous vector
-
terms
Tree terms and patterns data structures
-
flot
Generate HTML documents with embedded charts using Flot
-
genmap
A simple generational map data structure with no dependencies
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
rtrees
A Bunch of completely safe augmented tree implementation in rust
-
divsufsort
Rust port of Yuta Mori’s divsufsort
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
lhlist
Labeled heterogeneous lists
-
teardown_tree
A binary search tree that supports fast clone and delete-range operations
-
trie_lib
A small library implementing a trie data structure
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
visit_diff
Efficiently finding differences between data structures
-
semver-store
An HashMap structure that uses semver strings as keys
-
evobox
A pointer type which allows for safe transformations of its content without reallocation
-
actions
Software without side-effects. Redo and Undo. Macro’s.
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
funnel
A simple data structure that makes it easy to read from multiple channels from a single source
-
patricia_router
Radix Tree implementation for Rust
-
querable
Quer(y)able data structure implementation
-
diffus-derive
Finds the difference between two instances of any data structure. Supports derive on structs and enums.
-
extended-rational
Provides implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
bayesic
A string classification library that focuses on efficiency when dealing with many possible classifications
-
refactory_string
A library to modify a string using original indices. Useful for Source Code transformations.
-
bytes_chain
Zero copy bytes chain based on crate
bytes -
bk-tree
A Rust BK-tree implementation
-
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.
-
doubly
Doubly linked lists in rust
-
ro
Helps make stuff read-only
-
ball-tree
Ball-tree implementation for K-nearest neighbors
-
ware
Immutable middleware chains
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
theban_interval_tree
A simple Interval Tree implementation
-
geomprim2d
2D geometric primitive types
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
named_tuple
A macro for declaring a
structthat manages a set of fields in atuple -
stack
DSTs and arrays on the stack!
-
adivon
Data Structures of daily use: Graph, HashTable, PriorityQueue, Trie, SuffixTree, Rope, SplayTree, SkipList, RedBlackTree
-
telegram-typings
Structs represents telegram bot typings
-
apint
Arbitrary precision integers library
-
neolistqueue
A buffer?
-
infinibuffer
A buffer?
-
pdatastructs
Simple probabilistic data structures
-
alg_ds
Algorithms & data structures
-
blender-mesh
Serialize / deserialize Blender armatures
-
catalog
A file-based map to store key/value pairs in a file and get them using binary search
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
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 -
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
map-trait
Generic Map trait
-
dockerfile
A Rust library for dynamically generating Dockerfiles
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
ttmap
Trivial implementation of type map
-
nibble_vec
Vector data-structure for half-byte values
-
grid_trait
2D and 3D grids with combinators
-
cord-broker
The server-side routing platform for the Cord Platform that exchanges messages between publishers and subscribers
-
linebuffer
ringbuffer for dynamic sized u8-elements
-
rust_release_artefact
Safely extract installable files from Rust release artefacts
-
ketree
A tree representing a symbolic expression that can be created with Ketos
-
shuffled-iter
Iterate through a set of values in random order without allocating them all
-
terminal-linked-hash-map
A fork of linked-hash-map that builds on stable in exchange for not allowing custom hashers
-
bitstring
Bitstring traits and implementations
-
break_array
For breaking array indexing
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
run-loop
Run loop for thread, provide message post, deadline timer and future executor
-
fral
Functional random-access lists
-
fitnesstrax-lib
Library for managing fitness time series data
-
map1
@ErichDonGubler’s fancy template for new Rust projects
-
tirocks
Place holder for yet another rust wrapper for rocksdb
-
MBrane
MBrane implementations in Rust
-
pod
Plain Old Data (POD) encoding and I/O
-
enum_meta
Add metadata to Enum Variants
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
vec2
vec2
-
isolanguage-1
ISO 639-1 library with optional Serde support
-
clampf
Clamped floating-point types
-
aterm
Implementation of the Annotated Terms data structure
-
transducers
A transducer library for Rust
-
rate_limit
A simple token-bucket style rate limiter
-
mori
An orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
relational_types
Manage relations between objects
-
compare
Experimental comparators for collections to be generic over
-
hamt-rs
A Hash Array Mapped Trie implementation based on the Ideal Hash Trees paper by Phil Bagwell
-
par-array-init
Convenience functions for initializing arrays in parallel
-
protocoll
clojure inspired protocols for rust collections
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
derive_wrapper
Rust custom derive macro for wrapping types
-
handy
A library providing handles and handlemaps
-
eclectic
Experimental collection traits
-
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…
-
fux_kdtree
K-dimensional tree implemented in Rust for fast NN querying
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
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… -
swimmer
Thread-safe object pool type
-
sprs-ldl
Sparse cholesky factorization
-
array-ops
Automatic method implementations for array data types
-
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.
-
shellexpand
Shell-like expansions in strings
-
thermostat
Finite state machine for a thermostat controlling a centralized HVAC system or other heating and/or cooling apparatus
-
type-map
Provides a typemap container with FxHashMap
-
bytes-expand
Types and traits for working with bytes
-
vec_saver
Rust Vector Saving Library
-
arq
Arq library to manage Arq Backup data formats
-
loosen_map
Calls a function with self
-
flats
flattens nested structures into a flat single dimension map
-
esc-seq
Library to print simple escape sequences
-
csv2struct
Generate Rust struct definitions from CSV
-
tree-cursor
A simple, non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
const-vec
Vec-like data structure with immutable push method
-
rabbot-plugin
Compiler plugin for Rabbot
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
bidule
Ultra simple Functional Reactive Programming, made with stuff, things, device, thingumajig, etc
-
graphrepresentations
A crate providing efficient abstract implementations of different graph representations
-
dimsum
Simple multi-dimensional array 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
-
chickenwire
A library for representing and manipulating hexagonal grids
-
empty-box
Allows for
Boxs to have their values moved out and replaced with new values, while reusing the same allocation -
shared_slice
Thread-local and thread-safe shared slice types, like
&[T]but without lifetimes. This library depends only onallocandcore, so can be used in environments withoutstd. -
svec
A utility for Dart-style list in Rust
-
bailamos
Simple notification manager
-
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 -
artsy
ART Tree data structure library
-
vecfile
A Vec-type collection that sits in a file vs in memory
-
any_key
Dynamically typed keys for associative arrays
-
const-arrayvec
A vec-like type backed by an array on the stack
-
closures
Abstraction for seperating code and state in closures
-
vec_box
A single macro to create a vec of boxed elements, for trait objects
-
type-info
Meta type information and type reflection at compile-time and runtime
-
arenavec
An arena backed implementation of vectors and related types
-
lumberjack-utils
Read and modify constituency trees
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions. -
big_s
Rust’s missing
Stringliteral -
aspen
A behavior tree implementation in Rust
-
statiki
Static friendly data structures
-
ibuilder_derive
Interactive builder for Rust types
-
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
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
lsp_msg_internal
Definitions used for testing lsp_msg_derive
-
id-map
Data structure of values indexed by IDs
-
loader-rs
Rust interface to load generic objects from an URI
-
multiarray
Small Rust library for handling multi-dimensional data
-
polymap
A map containing varying types of value
-
ringbuffer
A fixed-size circular buffer
-
hashbag
An unordered multiset implementation using a hash bag
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
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…
-
stable-skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap. This is modified to work on stable Rust 1.9.0.
-
bigint-base10
Experimental API for dealing with big integers in base-ten
-
htable
A simple to use and extenable table that can hold hold many different types at once
-
redbpf-probes
eBPF probe-related types for redbpf
-
iodyn
An incremental collections library making use of Adapton
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
halo
elm inspired state manager in rust
-
bytes32
Used to create a custom type for 32-bit-wide byte arrays. Used for Drops of Diamond (more information about DoD is available at https://github.com/Drops-of-Diamond/Diamond-drops).
-
take-some
A simple library that provides a way to obtain some value from various collections
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
hashed
A Hashed type you can convert any hashable type into and still do equality checks on
-
modular-bitfield-impl
Bitfields for structs that allow for modular use of enums
-
untis
Rust library to access the webuntis jsonrpc
-
fix
Fixed-point number types
-
map_in_place
Reuse the memory of a Vec, Box<[T]> or Box when mapping the elements if possible
-
pets
Predicate existential types
-
linear-map
A map implemented by searching linearly in a vector
-
guzzle-derive
The derive macro for guzzle, please use that crate not this one
-
rundo
Rundo is a redo / undo library for rust which can auto generate undo op. Below is an example to use Rundo.
-
smt_map
A uint-to-uint map backed by Sparse Merkle Tree (SMT), which supports generating Merkle Proofs of key-values
-
chainbuf
Fast chained buffers
-
handler_map
Map from types to functions that receive them
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
insert_multiple
insert multiple items into a stream in reasonable runtime
-
rc-box
Known unique versions of Rc and Arc
-
trie_tree
basic trie tree for rust
-
jyx
Command line tool for manipulating data structures
-
weighted_random_list
A Vec that allows you to define the weight of each entry and randomly get entries
-
ansi_term
Library for ANSI terminal colours and styles (bold, underline)
-
compacts
compact data structures
-
synctree
Thread-safe tree data structure
-
deoxy-core
Core utilities for deoxy
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
nbits_vec
Small bits value (e.g. 1,2.. bits) vector implementation.
-
street_index
street_index is a small utility crate for working with road name / street indexing for cartographic purposes
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
courgette
Colour manipulation/conversion library
-
collectioner
collection helper
-
holyhashmap
A hash map with stable indices
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
topia
a simple tree library
-
abbrev-tree
highly inefficient data structure for text completion
-
blockbuffers
Blockbuffers is a serialization tool which builds strict Flatbuffers binaries
-
fixed-map-derive
A fixed map where storage layout is calculated by a procedural macro. This crate contains the procedural macros
-
flit
Bloom filter backed by xxHash
-
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)
-
dot_json
Tools for dot map representations of serde_json Maps
-
vec-vp-tree
A vantage-point tree implementation backed by vectors for good performance with no unsafe code
-
linked_array
Arbitrarilly long fixed-size arrays
-
rsbloom
A simple bloom filter implementation in Rust
-
plurals
Helps with singular/plural forms, mostly in English
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
slice_as_array
Cast slices to arrays
-
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 -
wordlist-generator
A handy wordlist generator
-
plant
Tree data structures
-
probabilistic-collections
Various implementations of collections that use randomization to improve on running time or memory, but introduce a certain amount of error
-
generic
Higher level serialization of rust values to rust values
-
heatmap
time-series of histograms with precision guarantees
-
ziptree
Tarjan’s zip tree implemented in Rust
-
const_enum_map
Get const value from enum handle
-
easy_strings
Ergonomic, garbage collected strings for Rust
-
slice_mip
Mutate a slice in place with a map function
-
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…
-
consume
Memory order consume for when it’s known that the compiler can’t elide the dependency
-
rbtset
A set based on a RB-Tree for efficient operations
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
aiowrap
Small helpers for using AsyncRead/AsyncWrite
-
bit-array
A compile time sized array of bits
-
fricgan
A simple crate for performing basic input and output on bytes
-
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 -
sized-vec
Type level sized vectors
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
array_ext
Extra functionality for Rust arrays
-
reflection
reflects of type’s fields’ names and their type names in a hierarchical tree
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
gcollections
Generic traits over Rust collections library
-
col_proc_macros
A bunch of procedural macros for declare collections of various kinds from their contents as fast as possible
-
louds
LOUDS implementation for Rust
-
typed_index_collection
Manage collection of objects
-
suitesparse_ldl_sys
Raw bindings to SuiteSparse’s LDL algorithm
-
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.
-
dense_bitset
A variably sized, heap allocated, dense bitset implemented using no
unsafecode -
tensor
Currently, a sketch of a Tensor library
-
index_key
lexicographic sort order encoding
-
handlebox
A map-like collection that reuses unused keys
-
keyvi
Keyvi - the key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
flashtext
Rust implementation of flashtext algorithm to search and replace keywords in given text
-
sliding-window-aggregation
Sliding window aggregation
-
soak-derive
Custom derive macro for #[derive(Columns)]
-
medianheap
A median heap for keeping track of a running median
-
mrslac
A Rust crate with sparse matrix data structures
-
uset
An implementation of a set and a map designed for speed, with unsigned integers as keys
-
takeable
Container type that allows for temporarily moving out of the container
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
immutable-seq
Immutable sequence data structure
-
weak_static
A macro for declaring lazy droppable statics
-
golomb-coded-set
An implementation of BIP158 Golomb-Coded Set data structure
-
vec4
vec4
-
scell
A smart container for objects in recursive data structures
-
kelvin-radix
Radix Tree data structure
-
dpc-simplemap
Simple map with default value and compacting
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
quantized-density-fields
Rust implementation of Quantized Density Fields data structure
-
range-collections
Sets and maps of ranges, backed by smallvec
-
thin_str
A string type that’s smaller than
Box<str>or String -
zerobuf
A growable chunk of zeroed memory
-
rust_release_channel
A data structure for Rust release channel metadata
-
tree
An ordered map and set based on a binary search tree
-
glowygraph
A library for drawing glowy graphs
-
darts
A double array trie, A Forward Maximum Matching Searcher
-
r-graph
Modular Graph library for Rust-lang
-
rudy
Judy array implementation in pure Rust
-
higher_order_point
An experimental higher order data structure for 3D points
-
bit_range
A small library for getting bits and ranges of bits from byte collections
-
dependy
Dependency resolution with variable dependency types
-
vertree
A persistent trie where each node is typed and versioned
-
mori_parallel
A parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
bitarray
A compile time sized array of bits
-
vec_file
A Vec-type collection that sits in a file vs in memory
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
slicevec
A vector using an external slice as backing storage
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
static_merkel_tree
Static Merkel Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
compacts-dict
succinct dictionary
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
appendix
Append-only, on-disk key-value index
-
intarray
memory efficient integer array
-
typescript-definitions-derive-ufo-patch
serde support for exporting Typescript definitions
-
suffix_tree
Suffix trees
-
bintrie
A performant binary trie data structure that doesnt store data or keys
-
skew-heap
A priority queue based on a skew heap
-
bitset
A simple bitset library like C++ (interface adapted)
-
discrimination-tree
discrimination tree term indexing
-
map_split
A library providing simultaneous mutable access to disjoint portions values stored in a hash map
-
mwmatching
Maximum-Weight Matching: Compute a maximum-weighted matching in the general undirected weighted graph given by ‘edges’
-
ctrs
Rust implementations and notes on category theory
-
push-trait
Push trait for collectons
-
hex2d-dpcext
dpc’s hacky extensions to hex2d-rs library
-
persistent_rope
An immutable persistent rope data structure
-
ascii_num
digit to ascii numbers
-
trie
An ordered map and set based on a trie
-
smallqueue
A queue with a no-alloc optimization when the size is 1 or 0
-
typescript-definitions-derive
serde support for exporting Typescript definitions
-
enum-set
A structure for holding a set of enum variants
-
circle_buffer
A simple circular buffer
-
coll
Some basic (persistent) collections
-
bitset-fixed
Bitset for DP
-
default-vec
A specialized vector that has a default value
-
bitarray-set
A set of bits backed by bit-array
-
maybe_utf8
Byte container optionally encoded as UTF-8
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
fixed_circular_buffer
A queue (the abstract data structure) implemented using a fixed size circular buffer