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