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