-
smallvec
‘Small vector’ optimization: store up to a small number of items on the stack
-
hashbrown
A Rust port of Google’s SwissTable hash map
-
bytes
Types and traits for working with bytes
-
num
A collection of numeric types and traits for Rust, including bigint, complex, rational, range iterators, generic integers, and more!
-
generic-array
Generic types implementing functionality of arrays
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
bitvec
A crate for manipulating memory, bit by bit
-
predicates
An implementation of boolean-valued predicate functions
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
arc-swap
Atomically swappable Arc
-
scroll
A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers
-
hdrhistogram
A port of HdrHistogram to Rust
-
publicsuffix
A native library for Mozilla’s Public Suffix List
-
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
bimap
Bijective maps
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
rpds
Persistent data structures with structural sharing
-
array-init
Safe wrapper for initializing fixed-size arrays
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
enumset
A library for creating compact sets of enums
-
generator
Stackfull Generator Library in Rust
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
tinystr
A small ASCII-only bounded length string representation
-
enum-map
A map with C-like enum keys represented internally as an array
-
heapless
staticfriendly data structures that don’t require dynamic memory allocation -
vec1
a std Vec wrapper assuring that it has at least 1 element
-
sized-chunks
Efficient sized chunk datatypes
-
fixedbitset
FixedBitSet is a simple bitset collection
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
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…
-
colorous
Professional color schemes ported from d3-scale-chromatic
-
prometheus
Prometheus instrumentation library for Rust applications
-
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. -
vec_map
A simple map based on a vector for small integer keys
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
bit-vec
A vector of bits
-
enum-ordinalize
This crates provides a procedural macro to let enums not only get its variants’ ordinal but also be constructed from an ordinal
-
radix_trie
Generic radix trie data-structure
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
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
-
weak-table
Weak hash maps and sets
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
im
Immutable collection datatypes
-
slice-deque
A double-ended queue that Deref’s into a slice
-
molecule
Rust bindings for molecule
-
bitstream-io
Library for reading/writing un-aligned values from/to streams in big-endian and little-endian formats
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
guppy
Track and query Cargo dependency graphs
-
roaring
http://roaringbitmap.org : A better compressed bitset - pure Rust implementation
-
rstar
R*-tree library for the rust ecosystem
-
cidr-utils
This crate provides data structures and functions to deal with IPv4 CIDRs and IPv6 CIDRs
-
slice-dst
Slice-based custom DSTs
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
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…
-
flatk
Flat layout abstraction toolkit
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
merkle-cbt
A library for generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
griddle
A HashMap variant that spreads resize load across inserts
-
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.
-
id_tree
A library for creating and modifying Tree structures
-
bloomfilter
Bloom filter implementation
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
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
-
trees
General purpose tree data structures
-
bitmaps
Fixed size boolean arrays
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
array-macro
Array multiple elements constructor syntax
-
uluru
A simple, fast, LRU cache implementation
-
fast_paths
Fast shortest path calculations on directed graphs made possible by pre-processing the graph using Contraction Hierarchies
-
index_vec
Newtype-style helpers for
Vecandusize -
predicates-tree
Render boolean-valued predicate functions results as a tree
-
defaultmap
Provides a HashMap with an automatic default for missing keys
-
undo
Low-level undo-redo functionality
-
zbus_macros
proc-macros for zbus
-
sorted-iter
Typesafe extensions for sorted iterators, including set and relational operations
-
kiddo
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
feattle
Featture toggles for Rust, extensible and with background synchronization and administration UI
-
wide
A crate to help you go wide
-
bv
Bit-vectors and bit-slices
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
blender-armature
Serialize / deserialize Blender armatures
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
lignin
A virtual DOM structure, primarily for web use
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
spade
Spatial datastructures like r-trees and delaunay triangulations for rust
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
solvent
Dependency Resolver library
-
dlv-list
Semi-doubly linked list implemented using a vector
-
typescript-definitions-ufo-patch
serde support for exporting Typescript definitions
-
unstructured
Generic types for unstructured data
-
threshold
Threshold data structures
-
smartstring
Compact inlined strings
-
string
A UTF-8 encoded string with configurable byte storage
-
building_blocks_storage
Efficient storage for maps on sparse or dense, 2D and 3D integer lattices
-
intervaltree
A simple and generic implementation of an immutable interval tree
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
ndsparse
Sparse structures for N-dimensions
-
openapiv3
This crate aims to provide data structures that represent the Open API v3 specification easily deserializable with serde
-
microkelvin
A library for tree traversal over annotated datastructures
-
keyvi
Keyvi - the key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
ringbuffer
A fixed-size circular buffer
-
ordered-multimap
Insertion ordered multimap
-
kstring
Key String: optimized for map keys
-
enso-data
A collection of useful data structures
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
trie-root
In-memory patricia trie operations
-
lfchring
Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication
-
suff_collections
Fast realization of suffix array and suffix tree
-
rtdlib
TDLib for rust
-
scapegoat
Embedded-friendly ordered set and map data structures via an arena-based scapegoat tree
-
bitvector
BitVector implementation in Rust
-
macaddr
MAC address types
-
space
A library providing abstractions for spatial datastructures and search
-
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…
-
smallbitvec
A bit vector optimized for size and inline storage
-
entity
Library that provides entity-like constructs
-
kserd
Kurt’s Self-Explanatory Rust Data
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
histogram
histogram storage and percentile metrics with precision guarentees
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
ux-primitives
Graphics Primitives for Angular Rust
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
trk-io
TrackVis (*.trk) reader and writer
-
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
rust-fsm
A framework for building finite state machines in Rust
-
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
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
stronghold_engine
A rust implementation of the IOTA Stronghold low-level libraries
-
linestring
2d and 3d polylines
-
ena
Union-find, congruence closure, and other unification code. Based on code from rustc.
-
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…
-
retworkx
A python graph library implemented in Rust
-
ibuilder
Interactive builder for Rust types
-
hash_ring
Consistent Hashing library for Rust
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
queues
Efficient FIFO Queue data structures
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
flatgeobuf
FlatGeobuf for Rust
-
cactus
Immutable parent pointer tree
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
circular-queue
A circular buffer-like queue
-
egg
An implementation of egraphs
-
rsdict
Fast static rank and select data structure
-
panoradix
A generic map and a set, both backed by a Radix tree
-
ra_ap_la-arena
Simple index-based arena without deletion
-
typescript-definitions
serde support for exporting Typescript definitions
-
c_vec
Structures to wrap C arrays
-
min-max-heap
An efficient, double-ended priority queue
-
ux-dataflow
Data Processing Library
-
llvm-ir
LLVM IR in natural Rust data structures
-
kd-tree
k-dimensional tree
-
delay
A collection of trait and classes to make your thread wait (and timeout)
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/spsc/History -
bitlab
Extracting a range of bits from a binary data source
-
cc-traits
Common collection traits
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
misc_utils
A small collection of convenient and utility functions developed for personal use
-
floating_bar
Representing rational numbers using the floating-bar number type
-
biodivine-lib-bdd
A simple thread-safe implementation of basic binary decision diagrams
-
banyan
Persistent indexable tree data structure
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
petal-clustering
A collection of clustering algorithms
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
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.
-
rexsgdata
Scatter-Gather Data Descriptors
-
idlset
Fast u64 set operations library
-
toodee
A lightweight 2D wrapper around a Vec
-
grammers-tl-types
Rust definitions for Telegram’s API types and functions
-
treez
A collection of useful data structures
-
gstore
Global state management and easy-to-use widget macros for GTK applications written in Rust
-
nested_containment_list
A data structure for efficiently storing and querying nested intervals
-
leb128
Read and write DWARF’s “Little Endian Base 128” (LEB128) variable length integer encoding
-
optional
This crate supplies a number of Option-like primitive types
-
uid
A crate for the creation of unique IDs
-
flat-tree
Rust module for encoding/decoding varints that doesn’t do any IO. Inspired by the Node.js varint module
-
designal
Procedural macro for use with futures-signals
-
gapbuf
Generic gap buffer
-
buffer-trigger
A data collection trigger based on the maximum number and refresh time
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
merkle
Merkle tree implementation with support for generation of inclusion proofs
-
fwdlist
A simply linked (forward) list
-
sum
General-purpose sum types
-
subset-map
A map where the keys are subsets of an initial set of elements
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
binn-ir
An implementation of Binn - https://github.com/liteserver/binn
-
bit_mask_ring_buf
A fast ring buffer implementation with cheap and safe indexing
-
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…
-
graphity
Model signal flow between nodes within a directed graph
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
usher
Parameterized routing for generic resources in Rust
-
anymap
A safe and convenient store for one value of each type
-
velcro_core
Core dependencies 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. -
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
genmap
A simple generational map data structure with no dependencies
-
verify
A validation library
-
typed_index_collection
Manage collection of objects
-
identifier
Generate 128 bits id structs easily
-
minivec
A version of Vec that’s only the size of a single pointer
-
ulid-generator-rs
A Rust crate for generating ULIDs
-
siraph
A node-based digital signal processing crate
-
large_int
An ease-of-use unbounded signed integer
-
sgf-parse
A parser for the SGF file format for Go games
-
cedarwood
efficiently-updatable double-array trie in Rust (ported from cedar)
-
binary-layout
The binary-layout library allows type-safe, inplace, zero-copy access to structured binary data. You define a custom data layout and give it a slice of binary data, and it will allow…
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
comp_input
Input library for competitive programming
-
ware
Immutable middleware chains
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
rudac
A crate for common data structures and algorithms
-
slack-blocks
Models + clientside validation for Slack’s JSON Block Kit
-
osproto
Protocol structures for OpenStack API (Obsolete)
-
option_set
Bitflags on steroids
-
sequencetree
a new type of collection to store keys and their corresponding values
-
bounded-spsc-queue
A bounded SPSC queue
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
ternary-tree
A Rust implementation of Ternary Search Trees, with no unsafe blocks
-
dusk-kelvin-map
BST Map implementation with Microkelvin backend
-
granite
Generic backing storage framework for building data structures
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
disjoint-sets
Three union-find implementations
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
dynvec
This crate provides the
DynVectype that acts like a vector to store any datatype -
cervine
A slightly more flexible Cow; roughly to T: Borrow as alloc::borrow::Cow is to B: ToOwned
-
do-notation
Monadic do syntactic sugar
-
gridly
A library for managing fixed-size 2D spaces
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
rb_tree
A Red Black Tree implementation in Rust
-
streamson-generator
A library which integrates streamson with generators
-
xml-schema
Structure generator from XSD source file
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
fingertrees
Immutable persisten finger trees
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
btree_graph
A generic graph data structure
-
beach_map
Implementation of a slotmap
-
graphlib
Graphlib is a simple and powerful rust library for the graph data-structure
-
watermark
A simple watermarking set for in-order insertions
-
tc-value
Tinychain’s representation of a value which can be collated and stored. Unstable.
-
rbxm
Reader for Roblox model files
-
any-range
AnyRange enum can hold any Range* type
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
ha
Ha provides core structs and traits for programming with higher order structures in Rust
-
vast
Verilog AST library
-
dary_heap
A d-ary heap
-
xtree
A simple general purpose tree data structure
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
rusty-perm
Rusty permutation with no-std
-
charcoal
Implements tree data structures and interfaces to work with them
-
plum
Probabilistic data structures for rust
-
tri-mesh
A triangle mesh data structure including basic operations
-
one_way_slot_map
An implementation of SlotMap with minimal restrictions on Keys and Values
-
hibitset
Hierarchical bit set structure
-
libflow
library grouping network flow data
-
rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit fe62c6e2958abfe54a9410a24a5750baf4c157e0 The publishing script for this crate lives at: https://github… -
rc-borrow
Borrowed forms of Rc and Arc
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
exprz
An Expression Library
-
noise_rs
The perlin and simplex noise implementation in 2d and 3d
-
cast-rs
A collection of types cast for Rust
-
kodama
Agglomerative hierarchical clustering
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
nstack
Arity 4 stack for the kelvin merkle toolkit
-
relational_types
Manage relations between objects
-
static_type_map
A type map that works over all types implementing
Any -
bk-tree
A Rust BK-tree implementation
-
intrusive_splay_tree
An intrusive splay tree implementation that is no-std compatible and free from allocation and moves
-
tugger-windows
Collection of packaging primitives specific to Windows
-
slotmap-fork-otter
Slotmap data structure - temporary fork for Otter
-
ldpc
A toolbox for classical (and soon quantum) LDPC codes
-
strchunk
Data types for working with UTF-8 text in I/O
-
onigiri
This crate is a tool of handling chars
-
safe_index
Type-safe indexes
-
exonum-merkledb
Persistent storage implementation based on RocksDB which provides APIs to work with Merkelized data structures
-
mset
A mset / multiset / bag implementation
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
wccg-models
WCCG Data
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
graph_solver
An undirected graph constraint solver for node and edge colors
-
va_list
Provides a rust implementation of the ‘va_list’ type for a small set of ABIs. Allowing rust implementations of functions like vprintf.
-
aliasable
Basic aliasable (non unique pointer) types
-
debt64
An implementation of Base64 - https://en.wikipedia.org/wiki/Base64
-
big_enum_set
A library for creating sets of enums with a large number of variants
-
kvdb
Generic key-value trait
-
allwords
Generate all the words over a given alphabet
-
deltastruct
Allows defining deltas for tagged structs for later application
-
index-map
A map with automatically generated usizes as keys
-
succinct
Succinct data structures for Rust
-
succinct_rs
Succinct Data Structures library for Rust
-
outils
Graph and tree data structure library. Providing utilities which aren’t easily available in Rust.
-
langtag
Language tags implementation following RFC 5646
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
hypergraph
Hypergraph is data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
isolanguage-1
ISO 639-1 library with optional Serde support
-
redo
Provides advanced undo-redo functionality with static dispatch
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
tsil_cev
LinkedList on Vec
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
bigraph
Different representations with implemented operations on bigraphs
-
vec-dimension-shift
N-Dimension shift features for Vec
-
osm-xml
OSM xml parser for Rust
-
simple-grid
A simple 2d-grid structure
-
csv2json
Converts CSVs into JSON documents
-
ux_serde
Implement the following non standard integers: u2, u3, u4, u5, u6, u7, u9, u10, u11, u12, u13, u14, u15, u17, u18, u19, u20, u21, u22, u23, u24, u25, u26, u27, u28, u29, u30, u31, u33…
-
fuzzy_trie
Key-value collection to make fuzzy searches
-
slist
Algebraic lists with statically determined size that live on stack
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
todo_lib
Collection of utilities for todo.txt format
-
modular-bitfield-impl
Bitfields for structs that allow for modular use of enums
-
ux-dx
3D Graphics Primitives for Angular Rust
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
treers
Simple implementation of Sedgewick’s tree maps
-
cycler
A simultainious write/read data structure
-
rio_api
Common data structures for RDF formats parsers and serializers
-
type-map
Provides a typemap container with FxHashMap
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
theban_interval_tree
A simple Interval Tree implementation
-
erasable
Type-erased thin pointers
-
multiset
Multisets/bags
-
fm-index
FM index and its variant implementations for Rust
-
patricia_router
Radix Tree implementation for Rust
-
quickscope
Multi-layer HashMap and HashSet implementations for performant representation of variable scopes
-
yoke
Abstraction allowing borrowed data to be carried along with the backing data it borrows from
-
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 -
dicom-object
A high-level API for reading and manipulating DICOM objects
-
ic-cdk
Canister Developer Kit for the Internet Computer
-
mergle
A data structure with fast merging and comparison
-
statemachine-rs
A statemachine crate which have zero dependencies
-
galemu
Provides a workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
tokio-cadence
Tokio-based metric sinks for Cadence
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
blender-mesh
Serialize / deserialize Blender armatures
-
smallstr
String-like container based on smallvec
-
entity_data
A container for entity component data
-
contack
A simple and easy contact library for rust
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
simple-matrix
A simple generic matrix library
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
intervallum
Generic interval and interval set library
-
xi
A functional reactive stream library for rust
-
boolvec
A vector of boolean stored contiguously in memory
-
handy
A library providing handles and handlemaps
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
jirachi
A collision resistant runtime agnostic key-generator
-
inspector
General purpose inspection for popular data structures
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
tiny_ecs
A tiny ECS that tries to avoid unnecessary copy/clones
-
sparsevec
Compress vectors using row displacement
-
fenwick-tree
An implementation of a binary indexed tree (Fenwick tree) data structure in Rust
-
staticstep
Provides truly zero-cost alternatives to
Iterator::step_byfor both incrementing and decrementing any type that satisfiesRangeBounds<T: Copy + Default + Step> -
packedvec
Store vectors of integers efficiently
-
partial_const
This library provides a way to handle constant and non-constant values in a unified way
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
collectables
Collectables: Rust crate of collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
rbtset
A set based on a RB-Tree for efficient operations
-
shortlist
An efficient data structure to track the largest items pushed to it
-
toboggan-kv
Toboggan-kv is an abstraction layer over multiple KV stores
-
polytype
A Hindley-Milner polymorphic typing system
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
block-grid
A quick, cache-conscious, tiled 2D array
-
libreda-db
Layout and netlist datastructures for chip design
-
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 -
swimmer
Thread-safe object pool type
-
ordsearch
A data structure for efficient lower-bound lookups
-
bip_utracker
Communication with bittorrent UDP trackers
-
stride
A strided slice type
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
enumoid
Enum Indexed Containers
-
uuid-rs
A Simple Universally Unique IDentifier (UUID)
-
skiplist
Skiplist implementation in rust, providing fast insertion and removal. A normal skiplist is implemented, as well as an ordered skiplist and a skipmap.
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
index-ext
Index slices with arbitrary ints and as arrays
-
slabmap
HashMap-like collection that automatically determines the key
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
multiref
Multireferences: a safe way to do [&T] -> &[T]
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent ‘flat’ access
-
tcgeneric
Generic data types used internally by Tinychain. Unstable.
-
bailamos
Simple notification manager
-
python-packed-resources
Manage data structures containing Python resources
-
dynamization
Fast insertion for static containers
-
cmp_wrap
Let you compare structes by context
-
btree-slab
A memory compact Slab-based B-tree implementation
-
word_filter
A Word Filter for filtering text
-
pour
Optionally consed radix tries for fast set operations
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
iowrap
Small helpers for using io::Read/io::Write
-
keylist
Elixir keyword list in Rust
-
alloc-wg
Attempt of collection several proposals of the allocators-wg
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
passive
A trio of marker traits to classify passive data structures
-
validbr
Provides data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
orderbook
Orderbook for Rust
-
code_location
A library to automatically acquire a code location in a rust source code file
-
resources
Safe store for one value of each type, with interior mutability
-
stadium
A allocated chunk of memory populated with a fixed set of types
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
atomic-take
Atomically take a value out of a container once
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
graphific
Graphific is a graph data structure library
-
tui-tree-widget
Tree Widget for tui-rs
-
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) -
smallbitset
This crate provides a series of allocation free sets capable of holding small integer values
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
watchface
A smartwatch watchface implementation
-
deadqueue
Dead simple async queue
-
raphy
A graph data structure library
-
lending-library
A key-value store that loans full ownership of items
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
email-format
Email message format (parser and data structure)
-
iset
This crates implements map and set with interval keys
-
transaction-pool
Generic transaction pool
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
swaybar-types
A library for building swaybar status commands in rust
-
syntastic
Generic abstract syntax representation
-
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
-
bex
A rust library for working with boolean expressions (syntax trees, decision diagrams, algebraic normal form, etc.)
-
packed-integers
A growable array for integer types in the range
u1tou31 -
anti-r
A spatial data structure outperforming r-trees for low numbers of elements
-
guzzle
A derivable trait for consuming key value pairs into structs
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
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…
-
pasture-io
Support for reading and writing point cloud files with pasture
-
higher_order_functions
A small collection of traits for implementing higher order functions
-
zc-derive
Derive macro for zc crate
-
elaru
Memory safe implementation of LRU cache
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
either
The enum
Eitherwith variantsLeftandRightis a general purpose sum type with two cases -
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
isomorphism
2 directional hashmaps
-
hash-rings
Implementations of various hash rings
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
libnv
Safe and rustic wrapper around libnv-sys
-
av-data
Multimedia data structures
-
dst
Data structures for DSTs
-
hashcons
Hash cons’ing for compact representations of shared, immutable data structures
-
liblet
Library for learning about formal languages and grammars
-
leak
Safely leak data from owned data structures
-
smart-hash
partial queries in HashSets, the traits
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
indexed
Convenient allocator for index-linked data structures
-
bloom_filter_simple
A simple and generic bloom filter implementation
-
rustz
A library for functional programming in Rust
-
hit-data
Hierarchical Indexed Typed data structure
-
aci_ppm
Encode and decode PNM image files (TODO: so far only PPM)
-
arrsingh
A top level crate in the workspace
-
hierarchical_hash_wheel_timer
A low-level timer implementantion using a hierarchical four-level hash wheel with overflow
-
hashable_rc
Hashable wrappers for reference countings
-
multipath
A library to split file path, like
/home/{user,admin}/file.txt -
soa-vec
A simple Vec-like API over a struct of arrays layout
-
path-value
Universal type and access property(s) by path
-
data_reader
A data loading library for data scientist
-
grdf
Generalized RDF graphs and datasets
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
feattle-core
Featture toggles for Rust, extensible and with background synchronization and administration UI
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
traitsequence
Traits to abstract over sequences
-
backtracking_iterator
A simple implementation of a generic iterator with an item history, capable of backtracking and forgetting
-
bip_metainfo
Parsing and building of bittorrent metainfo files
-
graphrepresentations
A crate providing efficient abstract implementations of different graph representations
-
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. -
growable-bitmap
A growable (and shrinkable) compact boolean array
-
truetree
Trees in Rust
-
grafana-dashboard
grafana import/export data serializable structures
-
push-while-ref
push while having a reference
-
bigs
A bipartite graph sampler
-
data_structure_traits
data structure collection traits
-
minecraft_end_generation
The minecraft end generation implemented in rust
-
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
serde_either
Simple set to enums to deserialize and serialize data that can either be string, struct or vec
-
nibble_vec
Vector data-structure for half-byte values
-
offset
Glorified offsets for arbitrary structures
-
hedge
An index based half-edge mesh implementation
-
elementtree
Parse an XML file into Python elementtree like structure
-
coca
Data structures with constant capacity
-
bo
Bo is a library for functional programming in rust
-
chainmap
A ChainMap with mutability of intermediate maps
-
token-lists
A simple token list representation
-
tetsy-transaction-pool
Generic transaction pool
-
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. -
static_merkle_tree
Static Merkle Tree is dedicated for generating Merkle Root and Merkle Proof for a static list of items
-
trie
An ordered map and set based on a trie
-
rustfsm
Define state machines that can accept events and produce commands
-
uvector
access two slices as a single continuous vector
-
vk_api
The Vulkan API XML exposed as a byte string constant
-
tilecoding
Rust implementation of Dr. Richard S. Sutton’s tile coding software.
-
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.
-
spool
Simple object pool for upfront allocation!
-
bittle
A library for working with small and cheap bit sets and masks
-
object-chain
Ad-hoc structure builder
-
vecn
A procedural macro that transforms user-defined structs into general vector types
-
matrix-sdk-common
Collection of common types and imports used in the matrix-sdk
-
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…
-
roadmap
model a project roadmap as a directed acyclic graph
-
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.
-
arraystring
Fixed capacity stack based generic string
-
syncbuf
Append-only data structures with lock-free thread-safety and constant-time indexing
-
set_genome
A genetic data structure for neuroevolution algorithms
-
ds-bst
Binary search tree implementation
-
same-alloc
Reuse an allocated buffer for data with different types
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
text-style
Types and conversions for styled text
-
incr
Simple, fast and self-contained data structures for checking whether a new value is greater than the previous maximum
-
hashtree
A Merkle Tree implementation in Rust
-
ensure
Ensure target state of an object
-
causal-length
CRDT’s based on causal length sets
-
rosary
A Library About Rose Trees
-
pod
Plain Old Data (POD) encoding and I/O
-
radix-heap
Fast monotone priority queues
-
btree_network
A generic network (undirected graph) data structure
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
partial
Optional monad with fake variant
-
derive_wrapper
Rust custom derive macro for wrapping types
-
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
-
actions
Software without side-effects. Redo and Undo. Macro’s.
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
win-idispatch
This is a rust crate that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
gen-vec
Vector indexed with generational indices
-
mop-structs
Low-level structures for MOP
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
alphabet-macro
Provides a macro that can be used to easily create const alphabets
-
pl-lens
Provides support for lenses, which are a mechanism in functional programming for focusing on a part of a complex data structure
-
arq
Arq library to manage Arq Backup data formats
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
apint
Arbitrary precision integers library
-
adivon
Data Structures of daily use: Graph, HashTable, PriorityQueue, Trie, SuffixTree, Rope, SplayTree, SkipList, RedBlackTree
-
hirpdag
Library and procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
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.
-
restorable
An iterator adapter for saving and restoring iterator state
-
set-trie
A trie for fast subset and superset queries
-
bidirectional-map
A two-way map data structure for small keys and values
-
gsrs
Generic Self Referencing Struct
-
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)…
-
extended-rational
Provides implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
keyed
Implement comparison traits by specifying a key
-
lumberjack
Read and modify constituency trees
-
coins-core
Abstract UTXO transactions to enable code reuse across chains
-
graphstack
Graph-structured stack
-
froop
A functional reactive stream library for rust
-
version-rs
A struct for Versions, with the methods you expect
-
varuint
Variable length signed and unsigned integer types
-
dispatchtable
Small library used to specify function dispatch tables HashMap<K, Box<Fn(..)>>
-
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.
-
ball-tree
Ball-tree implementation for K-nearest neighbors
-
bytes-utils
Additional utilities for working with the bytes crate
-
igraph
A graph representation data structure with a built in index on keys
-
nave
Thinking about the construction of distributed systems starting from the consistent hash algorithm
-
replicante_logging
Replicante common logging logic
-
Project2
Implementations of red black tree and AVL tree
-
slice_ring_buf
A fast ring buffer implementation optimized for working with slices
-
simple-rate-limit
Rate limit enforcement as simple data structures, no atomics
-
collectable
Fallible, no_std-friendly collection traits
-
mush
Visual graph/dialogue editor
-
grid
Dynamic generic 2D data structure
-
more_ranges
Range types not provided in the standard library
-
iterable
An iterable library for Rust collection like types
-
wordsworth
A collection of natural language analysis functions
-
linux-stats
typesafe procfs info
-
shared-string
Split a string without another allocation
-
safe-graph
Graph implementation (refactored version of GraphMap from popular crate petgraph)
-
geomprim2d
2D geometric primitive types
-
graphsearch
A simple graph search and representation library
-
lhlist
Labeled heterogeneous lists
-
slots
Fixed size data structure with constant-time operations
-
bens_naive_rational_number
A crate centered around a naive implementation of a Rational Number structure
-
funnel
A simple data structure that makes it easy to read from multiple channels from a single source
-
freezebox
FreezeBox: a deref’able lazy-initialized container
-
ub
Can bundle multiple sources to a single one and extract back
-
ethercat-types
Common EtherCAT data structures
-
bytes_chain
Zero copy bytes chain based on crate
bytes -
entity_table
Data structure for associating data with entities in an Entity Component System
-
unbox-box
“Wait why did I put a
*in front of that variable yesterday?” - Ifvaris a Box, usevar.unbox_ref()instead of&*varfor better readability -
mmap_json_file
A library to parse, count, filter JSON files using memory mapped io library
-
la-arena
Simple index-based arena without deletion
-
segment-tree
Quickly perform interval queries or modifications
-
typemap_core
A no_std typemap with trait-based value-presence guarantees (on nightly)
-
chunked-bytes
A rope-like non-contiguous buffer for efficient data structure serialization and vectored output
-
id-map
Data structure of values indexed by IDs
-
attck
Structure representation of MITRE ATT&CK matrices
-
avl
A map and a set implemented with an AVL tree
-
tapa-trait-serde
A collection of Tapalogi’s reusable crates
-
puruda-macro
proc macro for puruda
-
dsa_sport
crate of revision material for undergrads
-
reso_dd
Structures and Enumerations that implement the Real Estate Standards Organization (RESO) Data Dictionary
-
edit_tree
Edit trees in rust
-
debruijn
Tools for DNA sequences: efficient k-mer manipulation, De Bruijn graph construction and compaction and handling of DNA strings
-
range_union_find
A union-find data structure for ranges
-
htmldom_read
HTML reader that parses the code into easy-use tree
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
tag-vec
A vector used for storing tags
-
hotmic
high-speed metrics collection library
-
geogrid
Manipulate geographic data on a grid
-
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
terms
Tree terms and patterns data structures
-
clampf
Clamped floating-point types
-
transducers
A transducer library for Rust
-
named_tuple
A macro for declaring a
structthat manages a set of fields in atuple -
ibuilder_derive
Interactive builder for Rust types
-
ttv-rs
A hopefully-eventually-comprehensive interface to the Twitch API. Somewhat modeled after Twitch4j.
-
tapestry
Generic 2D grid data structure and utilities
-
sesstype
An implementation of Multiparty Session Types
-
persistent_rope
An immutable persistent rope data structure
-
building_blocks_partition
Acceleration structures for spatial queries on voxel data
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
simple_ringbuf
Simple Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
minimal-id
A library that implements generating short, unique ids with minimal collisions and good locality
-
densevec
Map like collection with usize indices that stores values contiguosly
-
iron-shapes
Basic data types and routines for computational geometry focused on VLSI chip design
-
perm-vec
Datatype representing permutations of indices
-
pvec
RRB-Tree based persistent vector implementation
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
lineartree
A simple tree data structure for rust
-
collect_result
Crate for collecting an iterator of results into a result of a collection
-
tiled-json-rs
A crate to parse and interact with Tiled editor JSON files
-
epoch-timestamp
Boilerplate collection for epoch timestamping
-
tugger-file-manifest
Interact with lists of files through a storage-agnostic interface
-
noindexmap
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…
-
bitstring
Bitstring traits and implementations
-
rabbithole
JSON:API Data Structure & Query implementation
-
protocoll
clojure inspired protocols for rust collections
-
cliquers
Manage filesequences with a common numeric component
-
empty-box
Allows for
Boxs to have their values moved out and replaced with new values, while reusing the same allocation -
catalog
A file-based map to store key/value pairs in a file and get them using binary search
-
pciids
A library to parse the pci.ids data file
-
flats
flattens nested structures into a flat single dimension map
-
hodgepodge
A hodgepodge of enums
-
vega-lite
Generated code for using the Vega-Lite schema from 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…
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
rusty_ulid
Rust ULID (Universally Unique Lexicographically Sortable Identifier) generation and processing
-
automerge
Rust implementation of the Automerge replicated JSON datatype
-
MBrane
MBrane implementations in Rust
-
restor
A dynamic resource storage system in rust
-
paginate
A framework agnostic pagination crate, that is especially suited for databases, collections and web pages
-
entity_macros
Macro library that provides ability to generate ent logic at compile-time
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
thermostat
Finite state machine for a thermostat controlling a centralized HVAC system or other heating and/or cooling apparatus
-
rust_fixed_width
library that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
quantized-density-fields
Rust implementation of Quantized Density Fields data structure
-
flo_rope
An attributed and streaming implementation of the rope data structure
-
break_array
For breaking array indexing
-
aterm
Implementation of the Annotated Terms data structure
-
afi
Audio & video structures, plus encoder & decoder traits
-
tree-cursor
A simple, non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
options
The package provides a data structure for managing named parameters
-
string-err
String error type
-
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 -
cita_trie
Modified Patricia Tree (aka Trie)
-
depot
A (disk) persistent queue library
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
flit
Bloom filter backed by xxHash
-
untagged-option
An unsafe Option type without discriminant. Nightly only.
-
binary-data-schema
Meta language for raw binary serialization
-
rust_release_artefact
Safely extract installable files from Rust release artefacts
-
ppar
Persistent immutable array
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
anymap2
A safe and convenient store for one value of each type
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
deepmesa-lists
A collection of list data structures and algorithms designed for performance
-
bip_bencode
Efficient decoding and encoding for bencode
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
dinotree
An aabb space partitioning 2d tree data structure
-
street_index
street_index is a small utility crate for working with road name / street indexing for cartographic purposes
-
atree
An arena based tree structure with removal support
-
static-box
A stack-allocated box that stores trait objects
-
another-option
Another option data type; useful when allocations are expensive
-
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
indexmap-amortized
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…
-
sprs_suitesparse_camd
sprs bindings to the suitesparse camd fill-in reducting ordering
-
coitrees
A very fast data structure for overlap queries on sets of intervals
-
simple-bitrange
A simple crate for manipulating bit ranges which is common when working with IC registers
-
be-tree
B𝛆 Tree library in Rust
-
win-variant
This is a rust crate that aims to provide a more ergonomic way of working with variants in winapi based projects
-
lightning-containers
A set of lock-free data structures
-
ic-types
Types related to the Internet Computer Public Specification
-
advancedresearch-higher_order_point
An experimental higher order data structure for 3D points
-
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
enum_meta
Add metadata to Enum Variants
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
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… -
mju-bits
no_std typed bitfield access for u8, u16, u32 and u64
-
word-dictionary
This crate provides a data structure for word mapping. It can be used for language translation.
-
byte_set
Efficient sets of bytes
-
region_buffer
A growable array allowing for multiple mutable non overlapping regions
-
bittyset
A BitSet type for manipulating bit sets
-
matmath
Matrix and Vector Math with generic type elements
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
ego-tree
Vec-backed ID-tree
-
soak
Transform a struct into arrays of its fields
-
comprende
Python-style collection comprehensions in Rust
-
dlist
List data structure based on AVL tree. It can store elements which have dimension and quickly search for elements by distance from 0.
-
transmute-tools
Proc macros and traits to assist with safely creating transmutable data structures
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
fenwick
Fenwick tree: data structure that efficiently calculates prefix sums in a changing array of numbers
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
json-trait-rs
Rust interface (aka trait) to deal with objects as they are JSON objects
-
pdatastructs
Simple probabilistic data structures
-
any_key
Dynamically typed keys for associative arrays
-
bytes-expand
Types and traits for working with bytes
-
entity_macros_data
Companion library for entity_macros that provides data structures that describe ents
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
type-freak
Collection of typed data structures, trait operators and aliases
-
take-some
A simple library that provides a way to obtain some value from various collections
-
wrapping
Wrapping slices and arrays
-
ro
Helps make stuff read-only
-
vk_generator
Generate Rust bindings to the Vulkan API
-
numas
numas library is implementation of multidimensional array for efficient computing
-
gtrie
Generic trie implementation with a support of different key and value types
-
head
Common types with inline headers, such as HeaderVec for Vec
-
bipbuffer
A Rust implementation of Simon Cooke’s Bip-Buffer
-
hashbrown_tstd
A Rust port of Google’s SwissTable hash map
-
ttv-tmi
Wrapper around
twitch_api2for publishing as part ofttv_rs -
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
rc-box
Known unique versions of Rc and Arc
-
atlist-rs
A LinkedList which is allowed to insert/remove element by immutable iterator.Adding, removing and moving the elements within the list or across several lists does not invalidate the iterators or references…
-
xml-schema-derive
Structure generator from XSD source file
-
hashbag
An unordered multiset implementation using a hash bag
-
puruda
Pure Rust DataFrame
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
fricgan
A simple crate for performing basic input and output on bytes
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
consume
Memory order consume for when it’s known that the compiler can’t elide the dependency
-
bip_select
Bittorrent Infrastructure Project Piece Selection Module
-
replicante_models_agent
Replicante Agent API request/response models
-
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.
-
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)
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
small_vec2
Vector on the stack or heap need nightly rustc
-
canonical_collections
Data structures for use with Canonical
-
histogram-sampler
Sampling from a distribution given by a histogram
-
mori
An orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
itc
Interval Tree Clocks as described in the itc2008 paper
-
compacts
compact data structures
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
banyan-utils
Utilities to work with banyan trees
-
exotic-iter
My personal collection of special-case iterator methods
-
unsized_enum
Unsized enum implementation
-
dot_json
Tools for dot map representations of serde_json Maps
-
matrixmultiply_mt
Multithreaded Fork of bluss’s matrixmultiply crate. General matrix multiplication of f32 and f64 matrices in Rust. Supports matrices with general strides. Uses a microkernel strategy…
-
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.
-
ic-utils
Collection of utilities for Rust, on top of ic-agent, to communicate with the Internet Computer, following the Public Specification
-
traitgraph
Different representations with implemented operations on graphs
-
cbloom
Concurrent implementation of Bloom filters
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
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)
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions. -
simple-uuid
A Simple Universally Unique IDentifier (UUID)
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
ahtable
Array Hash Table implementation
-
provenance
Container structures that generate key upon insertion that only works with the map that generated it
-
bittree
A crate for O(1) find functions in a special data structure called a bit tree
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
eclectic
Experimental collection traits
-
fp-collections
An alternate collections library for rust
-
evobox
A pointer type which allows for safe transformations of its content without reallocation
-
divsufsort
Rust port of Yuta Mori’s divsufsort
-
tetsy-kvdb
Generic key-value trait
-
minecraft_nether_generation
The minecraft nether generation implemented in rust
-
handlebox
A map-like collection that reuses unused keys
-
holyhashmap
A hash map with stable indices
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
heatmap
time-series of histograms with precision guarantees
-
queue-file
queue-file is a lightning-fast, transactional, file-based FIFO
-
sparseset
A Sparse Set
-
reflection
reflects of type’s fields’ names and their type names in a hierarchical tree
-
htable
A simple to use and extenable table that can hold hold many different types at once
-
btree_dag
A generic DAG (undirected graph) data structure
-
bip_handshake
Common handshaking interface as well as a default handshake implementation
-
feattle-ui
Featture toggles for Rust, extensible and with background synchronization and administration UI
-
gcollections
Generic traits over Rust collections library
-
guzzle-derive
The derive macro for guzzle, please use that crate not this one
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
ngds
Rust bindings for AVFounation
-
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
-
automap
Simple pattern to implement key-value maps where the value type contains the key type
-
fral
Functional random-access lists
-
arc-string-interner
An efficient string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
maybe-string
Provides a newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
hayami
A simple, general use symbol table
-
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…
-
frombytes
Defines a cursor over a slice of bytes
-
rudy
Judy array implementation in pure Rust
-
appendlist
An append-only list that preserves references to its elements
-
prehash
A crate for storing values with precomputed hashes
-
easy_graph
Data structure that represent generic vertices and undirected connections
-
dense_mats
A strided dense tensor implementation
-
vecdeque-stableix
Deque with stable index values
-
prefix-tree
A map and set interfaces using trie data structure
-
semver-store
An HashMap structure that uses semver strings as keys
-
mrslac
A Rust crate with sparse matrix data structures
-
immutable-seq
Immutable sequence data structure
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
baffa
Generic buffer for bytes
-
map_vec
The Map and Set APIs backed by Vec
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
loader-rs
Rust interface to load generic objects from an URI
-
sized-vec
Type level sized vectors
-
nue
I/O, POD, and misc. binary data encoding
-
ttmap
Trivial implementation of type map
-
tapa-cgloop-nats
A collection of Tapalogi’s reusable crates
-
array-concat
Macros for concatenating const arrays
-
refactory_string
A library to modify a string using original indices. Useful for Source Code transformations.
-
dynstr
A string implementation optimized for manipulations
-
transit_model_collection
Manage collection of objects
-
takeable
Container type that allows for temporarily moving out of the container
-
enumoid_derive
Derive macro for Enum Indexed Containers
-
tree-automata
Term Rewriting Systems
-
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
lock-free-stack
Lock-free (atomic-based) Collection which internally represent data as a Stack, and exposes an interface allowing to add elements, get size, and remove all giving a reverse-iterator
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
transit_model_relations
Modeling the relations between objects
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
tapa-trait-serde-derive
Tapalogi’s derive macro for tapa-trait-serde
-
stonks
Sets that allow borrowing while inserting entries
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
hashindexed
A cache. A set which compares elements in a customisable way without overriding the eq() and hash() functions on the type itself.
-
ring-vec
A zero-dependency, no-std compatible, producer-consumer, fixed-size, item-oriented ring buffer backed by a vector
-
bitset-fixed
Bitset for DP
-
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.