-
hashbrown
port of Google's SwissTable hash map
-
indexmap
A hash table with consistent order and fast iteration
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
bitvec
Addresses memory by bits, for packed collections and bitfields
-
ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
phf
Runtime support for perfect hash function data structures
-
predicates
boolean-valued predicate functions
-
ahash
A non-cryptographic hash function using AES-NI for high performance
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
ropey
A fast and robust text rope for Rust
-
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
-
bit-set
A set of bits
-
petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
roaring
A better compressed bitset - pure Rust implementation
-
hashlink
HashMap-like containers that hold their key-value pairs in a user controllable order
-
bimap
Bijective maps
-
tinystr
A small ASCII-only bounded length string representation
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
litemap
A key-value Map implementation based on a flat, sorted Vec
-
bit-vec
A vector of bits
-
string-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
croaring
Rust wrapper for CRoaring
-
fraction
Lossless fractions and decimals; drop-in float replacement
-
smartstring
Compact inlined strings
-
generator
Stackfull Generator Library in Rust
-
zerofrom
trait for constructing
-
linked_hash_set
HashSet with insertion ordering
-
fixedbitset
bitset collection
-
rowan
generic lossless syntax trees
-
indextree
Arena based tree structure by using indices instead of reference counted pointers
-
intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
im
Immutable collection datatypes
-
typed-index-collections
Typed index version of Rust slice and Vec containers
-
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.
-
faststr
string library that reduces the cost of clone
-
enumset
creating compact sets of enums
-
ego-tree
Vec-backed ID-tree
-
vec1
a std Vec wrapper assuring that it has at least 1 element
-
yrs
High performance implementation of the Yjs CRDT
-
bloomfilter
Bloom filter implementation
-
radix_trie
Generic radix trie data-structure
-
index_vec
Newtype-style helpers for
Vecandusize -
circular-buffer
Efficient, fixed-size, overwriting circular buffer
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
imbl
Immutable collection datatypes
-
firestore
API for Google Firestore and own Serde serializer based on efficient gRPC API
-
bitmaps
Fixed size boolean arrays
-
guppy
Track and query Cargo dependency graphs
-
patricia_tree
Memory-efficient data structures based on patricia tree
-
rpds
Persistent data structures with structural sharing
-
slice-ring-buffer
A double-ended queue that Deref's into a slice
-
ecow
Compact, clone-on-write vector and string
-
ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
smallbitvec
A bit vector optimized for size and inline storage
-
arbitrary-int
Modern and lightweight implementation of u2, u3, u4, ..., u127
-
nonempty-collections
Correct-by-construction non-empty collections
-
array-init
Safe wrapper for initializing fixed-size arrays
-
spade
Delaunay triangulations for the rust ecosystem
-
indxvec
Vecs sorting, merging, indexing, ranking, searching, reversing, intersecting, printing, etc
-
multimap
A multimap implementation
-
thin-vec
A vec that takes up less space on the stack
-
aligned-vec
Aligned vector and box containers
-
egg
egraphs
-
smallbox
Small Boxoptimization: store small item on stack and fallback to heap for large item -
index_list
A doubly linked list implemented in safe Rust using vector indexes
-
intmap
Specialized HashMap for integer keys
-
uluru
fast, LRU cache implementation
-
datalogic-rs
A fast, type-safe Rust implementation of JSONLogic for evaluating logical rules as JSON. Perfect for business rules engines and dynamic filtering in Rust applications.
-
orx-split-vec
An efficient dynamic capacity vector with pinned element guarantees
-
dlv-list
Semi-doubly linked list implemented using a vector
-
vob
Vector of Bits with Vec-like API and usize backing storage
-
growable-bloom-filter
Scalable Bloom Filters with serde support
-
blobby
Iterator over simple binary blob storage
-
str-buf
Static string buffer
-
fastbloom
The fastest Bloom filter in Rust. No accuracy compromises. Compatible with any hasher.
-
linked-hash-map
A HashMap wrapper that holds key-value pairs in insertion order
-
narrow
Apache Arrow
-
uguid
GUID (Globally Unique Identifier) no_std library
-
cordyceps
Mycelium intrusive data structures
-
hybrid-array
Hybrid typenum-based and const generic array types designed to provide the flexibility of typenum-based expressions while also allowing interoperability and a transition path to const generics
-
array-macro
Array multiple elements constructor syntax
-
hashbag
An unordered multiset implementation using a hash bag
-
micromap
The fastest alternative to HashMap, for maps smaller than 20 keys
-
jaq-json
JSON values for jaq
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
equivalent
Traits for key comparison in maps
-
modql
Model Query Language support
-
grid
Dynamic generic 2D data structure
-
gix-hashtable
that provides hashtable based data structures optimized to utilize ObjectId keys
-
qfilter
Efficient bloom filter like datastructure, based on the Rank Select Quotient Filter (RSQF)
-
crop
A pretty fast text rope
-
dary_heap
A d-ary heap
-
esaxx-rs
Wrapping around sentencepiece's esaxxx library
-
mycelium-bitfield
Structured bitfields, courtesy of Mycelium
-
bitfield-struct
Struct-like procedural macro for bitfields
-
boa_interner
String interner for the Boa JavaScript engine
-
lsm-tree
A K.I.S.S. implementation of log-structured merge trees (LSM-trees/LSMTs)
-
tree_iterators_rs
built to provide you with the iterators to easily work with tree data structures in Rust
-
bounded-vec
Non-empty rust Vec wrapper with type guarantees on lower and upper bounds for items quantity
-
st-map
Runtime for a stack-alocated map
-
mirror-mirror
Reflection library for Rust
-
qp-trie
An idiomatic and fast QP-trie implementation in pure Rust, written with an emphasis on safety
-
string
A UTF-8 encoded string with configurable byte storage
-
conjure-object
Runtime support for generated Conjure objects
-
csaf-walker
work with CSAF data
-
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
-
indexset
A two-level BTree with fast iteration and indexing operations
-
newtype-uuid
Newtype wrapper around UUIDs
-
portgraph
Data structure library for directed graphs with first-level ports
-
vers-vecs
A collection of succinct data structures supported by fast implementations of rank and select queries
-
cita_trie
Modified Patricia Tree (aka Trie)
-
las
Reads and writes point clouds stored in the ASPRS las file format
-
fixed-map
A fixed map where storage layout is calculated by a procedural macro
-
append-only-vec
Append-only, concurrent vector
-
iset
Map and set with interval keys (x..y)
-
multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
vecmap-rs
A vector-based map and set implementation
-
sorted-vec
Create and maintain sorted vectors and vector-backed sets
-
circular-queue
A circular buffer-like queue
-
bloom2
Fast, compressed, 2-level bloom filter and bitmap
-
fqdn
FQDN (Fully Qualified Domain Name)
-
range-collections
Sets and maps of ranges, backed by smallvec
-
rln
APIs to manage, compute and verify zkSNARK proofs and RLN primitives
-
ringbuffer
A fixed-size circular buffer
-
cranelift-entity
Data structures using entity references as mapping keys
-
ndarray-ndimage
Multidimensional image processing for ArrayBase, the n-dimensional array data structure provided by ndarray
-
mitsein
Strongly typed APIs for non-empty collections, slices, and iterators
-
i256
Optimized implementations of 256-bit signed and unsigned integers
-
vart
An immutable versioned adaptive radix trie
-
vec_map
map based on a vector for small integer keys
-
oxc_index
Newtype-style helpers for
Vecandusize -
timed-map
Lightweight map implementation that supports expiring entries and fully compatible with both std and no_std environments
-
fastbloom-rs
Some fast bloom filter implemented by Rust for Python and Rust!
-
yaque
disk-backed persistent queue for Rust
-
atone
A VecDeque and Vec variant that spreads resize load across pushes
-
submap
B-Tree map for pub/sub services
-
lib-sokoban
Sokoban: compact, efficient data structures packed into contiguous byte arrays
-
fm-index
FM index and its variant implementations for Rust
-
sqrid
Square coordinates and grid-like arrays, with zero dependencies, in a single file
-
open-payments-iso20022-acmt
Open Payments - Message Parsing Library - ISO20022 ACMT
-
tar-no-std
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 as GNU Longname… -
iso7816-tlv
tools and utilities for handling TLV data as defined in ISO/IEC 7816-4
-
qwt
Quad Wavelet Tree
-
raphtory
temporal graph library
-
keyvi
key value index. It is an in-memory FST-based data structure highly optimized for size and lookup performance.
-
rsdict
Fast static rank and select data structure
-
iptrie
IPv4/v6 prefixes lookup structures (based on tries)
-
xsd-types
XSD data types
-
array-concat
Macros for concatenating const arrays
-
xml-builder
Easy and highly-configurable XML builder/writer
-
bao-tree
BLAKE3 verfiied streaming with custom chunk groups and range set queries
-
rc-box
Known unique versions of Rc and Arc
-
sbat
UEFI Secure Boot Advanced Targeting (SBAT) no_std library
-
btree-range-map
B-tree range map implementation
-
rustica
functional programming library for the Rust language
-
phf_shared
Support code shared by PHF libraries
-
trees
General purpose tree data structures
-
loro-delta
Loro internal library. It's used as a delta between two versions of text or lists. It's also an efficient Rope.
-
collection_tools
General purpose tools to manipulate collections( containers like Vec/HashMap/HashSet )
-
sparsevec
Compress vectors using row displacement
-
arraydeque
A ring buffer with a fixed capacity, which can be stored on the stack
-
pg_filters
helper to generate postgres sql for pagination, sorting and filtering
-
tinyset
Size-optimized sets
-
shapemap
RDF data shapes implementation in Rust
-
rust_dynamic
Support for dynamically-typed values in run-time
-
short-uuid
generate and parse short uuids
-
numeric-array
Wrapper around generic-array that adds efficient numeric trait implementations
-
tagged-pointer
Platform-independent space-efficient tagged pointers
-
cow_hashbrown
port of Google's SwissTable hash map with copy-on-write support
-
hypergraph
data structure library to create a directed hypergraph in which an hyperedge can join any number of vertices
-
undo
An undo-redo library
-
modular-bitfield
Allows to easily define bitfield types with modular building blocks
-
orx-iterable
Defines and implements Iterable, Collection and CollectionMut traits to represent types that can be iterated over multiple times
-
bitflag-attr
A macro to generate bitflags structures from C-like enums
-
cueue
High performance SPSC circular byte buffer with batch operations
-
uuid-rng-internal
Private implementation details of the uuid crate
-
tree-ds
manipulate tree data structures
-
cc-traits
Common collection traits
-
simple_endian
A create for defining endianness within your data structures, to make handling portable data structures simpler
-
ordinal-map
Ordinal trait to map values to integers and efficient maps and sets for such types
-
spatialtree
A fast and flexible generic spatial tree collection (Octree, Quadtree, etc)
-
bytes-utils
Additional utilities for working with the bytes crate
-
im-lists
Persistent unrolled linked lists and vlists
-
walker-common
Common functionality for SBOM and CSAF walker
-
intervallum
Generic interval and interval set library
-
keyed_priority_queue
Priority queue that support changing priority or early remove by key
-
tracker
A macro to track changes on structs
-
vortex-sampling-compressor
Vortex compressor that uses statistical sampling
-
zarray
Cache-optimized 2D and 3D arrays using Morton order (aka Z-order) Z-indexed storage, with a convenient API for common 2D and 3D access patterns. Use of zarray in place of a Vec of Vecs often improves performance…
-
xgraph
A comprehensive Rust library providing efficient graph algorithms for solving real-world problems in social network analysis, transportation optimization, recommendation systems, and more
-
slotmap-careful
Wrap the slotmap crate and prevent key reuse
-
hash_hasher
A hasher which is designed to work with already-hashed or hash-like data
-
zen-engine
Business rules engine
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
cactus
Immutable parent pointer tree
-
delay_map
HashMap collections whose entries expire after a given time
-
hibitset
Hierarchical bit set structure
-
chat-prompts
Chat prompt template
-
dogma
Named,MaybeNamed,Labeled,MaybeLabeled,Collection, andCollectionMuttraits -
cdg_api
interact with api.congress.gov
-
docker-compose-types
Deserialization and Serialization of docker-compose.yml files in a relatively strongly typed fashion
-
ordered
A wrapper for adding arbitrary partial/total order to a type
-
orx-linked-list
A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations
-
pin-list
A safe
Pin-based intrusive doubly linked list -
interavl
An optimised interval tree for efficient interval stabbing
-
ordered-multimap
Insertion ordered multimap
-
mzpeaks
representing peaks in mass spectrometry data
-
blart
adaptive radix tree packaged as a BTreeMap replacement
-
wildbird
Rust Framework 🐦
-
id_tree
creating and modifying Tree structures
-
imbl-sized-chunks
Efficient sized chunk datatypes
-
queue-file
lightning-fast, transactional, file-based FIFO
-
scalable_cuckoo_filter
A variant of Cuckoo Filter whose size automatically scales as necessary
-
array2d
A fixed sized two-dimensional array
-
lunk
Event graph processing
-
static-files
help automate static resource collection
-
block-grid
A quick, cache-conscious, tiled 2D array
-
bittle
Zero-cost bitsets over native Rust types
-
prio-graph
A lazily populated directed acyclic graph with top-level priority ordering
-
smallstr
String-like container based on smallvec
-
merkletree
Light merkle tree implementation with SPV support and dependency agnostic
-
faststr-fork
Faststr is a string library that reduces the cost of clone
-
depends
Ergonomic, performant, incremental computation between arbitrary types
-
orange-trees
Tree data structure with several methods to query and manipulate nodes
-
value-log
Value log implementation for key-value separated LSM storage
-
rpds-pathtree
Immutable, path-addressable tree data structure
-
idlset
Fast u64 set operations library
-
awint
Arbitrary width integers
-
flex_array
A
#[no_std]flexible array much like std::Vec but with custom indices and length and capacity types -
normalize_interval
Normalizing interval library
-
ntex-bytes
Types and traits for working with bytes (bytes crate fork)
-
valkyrie-ast
Strong typed abstract syntax tree of valkyrie language
-
graph_process_manager_loggers
Generic loggers for graph_process_manager_core
-
libwebnovel
enabling users to get chapters of a webnovel, with multiple available backends
-
parquetry
Runtime library for Parquet code generator
-
freyr
A UI component library for Dioxus web
-
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. -
rt_ref
Internal
Reftypes forrt_refandrt_vec -
linearize
Types that are enumerable and an array-backed map
-
is-tree
Everything is a tree
-
slice_ring_buf
A ring buffer implementation optimized for working with slices
-
ftree
A very fast fenwick tree implementation
-
raft-log
Raft log implementation
-
indexical
indexed collections
-
diff-struct
A trait for diffing and applying diffs to types
-
itybity
An itty bitty crate providing bit iterators and bit iterator accessories
-
stac-server
SpatioTemporal Asset Catalog (STAC) API server
-
any_vec
Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.
-
xor_name
Xor Type
-
enum-collections
Collections data structures optimized for Enum, initializable at runtime
-
byteview
Thin, immutable zero-copy slice type
-
sync-ptr
Sync & Send wrappers for raw pointer's
-
beap
Bi-parental heap data structure implementation in Rust
-
rrd
Bindings to librrd to create and interact with round robin databases created with Tobias Oetiker's rrdtool (https://www.rrdtool.org/)
-
f3l_search_tree
3D Point Cloud Library
-
adflib
handle amiga disk files
-
vec-strings
Store any string efficiently in an immutable way
-
farmfe_plugin_tree_shake
Tree shake plugin of farm
-
tetengo_trie
A trie library implemented with a double array
-
matreex
matrix implementation
-
rc-borrow
Borrowed forms of Rc and Arc
-
spacetimedb-data-structures
Assorted data structures used in spacetimedb
-
map_vec
The Map and Set APIs backed by Vec
-
more_collections
Additional collections not found in std::collections
-
sized-chunks
Efficient sized chunk datatypes
-
kempt
Ordered collection types with no unsafe code and no_std support
-
roadmap
model a project roadmap as a directed acyclic graph
-
rdf-types
Data-structures and traits definitions for RDF
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
unsized-vec
Like Vec, but for unsized values
-
stacked_errors
high level error propogation with software controlled backtraces
-
ocpp_rs
Protocol implementation for Open Charge Point Protocol (OCPP) in Rust
-
uuid-rs
Universally Unique IDentifier (UUID)
-
nodit
Discrete Interval Tree Data-Structures, which are based off BTreeMap
-
mule-map
A hybrid between a HashMap and a lookup table
-
simd_aligned
Safe and fast SIMD-aligned data structures with easy and transparent 'flat' access
-
min-max-heap
An efficient, double-ended priority queue
-
dot2
generating Graphviz DOT language files for graphs
-
test-assembler
A set of types for building complex binary streams
-
stavec
Stack-allocated vector with static capacity
-
bumparaw-collections
A small set of bumpalo-backed collections for low-level operations
-
incremental-topo
Data structure to maintain an incremental topological ordering over a collection of values
-
json-number
JSON number parsing and storage
-
hashslab
A hash table with data accessible by index
-
snowflake_me
A distributed unique ID generator inspired by Twitter's Snowflake
-
mut_set
A safe implementation for HashSet with iter_mut and get_mut
-
garage_table
Table sharding and replication engine (DynamoDB-like) for the Garage object store
-
edtui-jagged
A jagged array data structure for the edtui editor
-
traitgraph-algo
Graph algorithms based on the traitgraph crate
-
overlay-map
A two-layered map data structure for Rust that tracks current and previous values for each key — with zero-clone, in-place state transitions
-
heavykeeper
finding Top-K elephant flows with high precision and low memory footprint
-
packedvec
Store vectors of integers efficiently
-
polytype
A Hindley-Milner polymorphic typing system
-
orx-fixed-vec
An efficient fixed capacity vector with pinned element guarantees
-
ordsearch
A data structure for efficient lower-bound lookups
-
seoul
trait Isomorphism
-
compact-rc
Low-memory reference-counting pointers
-
merkle-cbt
generating efficient Merkle tree and combined Merkle proof based on complete binary tree
-
stash
An amortized
O(1)table for cases where you don’t need to choose the keys and want something faster than a HashTable -
c_vec
Structures to wrap C arrays
-
mikufans-proto
gRPC APIs for Mikufans
-
case_insensitive_hashmap
A HashMap that uses case-insensitive strings as keys
-
std-macro-extensions
A collection of macro extensions for Rust's standard library data structures, simplifying the creation and manipulation of common collections such as HashMap, Vec, and more
-
variadics
Variadic generics on stable Rust using tuple lists
-
evict
Page eviction policies: LRU, LRU-k, LIRS, SLRU etc
-
i_tree
Expiration key tree. Usable in algorithms like swipe line. Only for uniq elements
-
json_dotpath
Dotted path access to nested JSON objects (serde_json::Value)
-
rs-ecs
reasonably simple entity component system
-
ux-primitives
Graphics Primitives for Angular Rust
-
flatten_objects
A container that stores numbered objects. Each object can be assigned with a unique ID.
-
samply-symbols
Symbolication utilities for the Firefox profiler
-
snowid
generating SnowID - a Snowflake-like timestamp-based distributed unique identifier
-
mapgraph
A directed graph that can also be used as an arbitrary map
-
recycle_vec
method for Vec to recycle it's backing allocation for use with another Vec of different type
-
ergo_avltree_rust
cryptographically authenticated dictionary based on AVL tree
-
range-set
Smallvec-backed containers of sorted integer ranges
-
scyllax
A SQLx and Discord inspired query system for Scylla
-
im_ternary_tree
Structural sharing ternary tree, i.e. immutable data structure
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
span-map
A data structure for efficiently managing sets of values over spans/ranges
-
bv
Bit-vectors and bit-slices
-
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…
-
ttgraph
Typed/Transactional Graph container
-
simple-grid
2d-grid structure
-
easy-tree
efficient tree structure library for Rust with recursive traversal
-
exponential-decay-histogram
A histogram which exponentially weights in favor of recent values
-
signalk
parse signalk maritime data
-
jumprope
fast rope (fancy string) library built on top of Skiplists
-
vectree
Vector-buffered tree collection with post-order, depth-first, mutable/immutable iterator
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
intervaltree
generic implementation of an immutable interval tree
-
treeclocks
Various Tree Clock data-structures and utilities
-
facebookexperimental/mononoke_api
A Scalable, User-Friendly Source Control System
-
typemap_rev
A hashmap, but stores types as keys
-
among
The enum
Amongwith variantsLeft,MiddleandRightis a general purpose sum type with three cases -
small-fixed-array
providing fixed length immutable collections with a low memory footprint
-
ball-tree
K-nearest neighbors
-
fingertrees
Immutable persisten finger trees
-
lru-slab
Pre-allocated storage with constant-time LRU tracking
-
iter-tree
Convert between iterators and tree structures in both directions
-
windowed-infinity
data structure representing an infinite sequentially writable u8 vector of which a small view has writes to it preserved. This is primarily useful when implementing CoAP block-wise transfers…
-
field_access
Dynamically access struct fields
-
slabigator
A linked list that doesn't do dynamic memory allocations
-
cantrip
Practical extension methods for standard Rust collections
-
sector
A stateful vector implementation that provides different memory management behaviors through Rust traits and state machines
-
pi_slot
lock free Slotmap data structure
-
typeid_prefix
that implements a type-safe version of the TypePrefix section of the
TypeIDSpecification -
jaggedarray
Multidimensional jagged array
-
divbuf
Buffer object that can be recursively divided into smaller buffers
-
srdf
RDF data shapes implementation in Rust
-
lean_string
Compact, clone-on-write string
-
libcnb-package
cross-compiling and packaging buildpacks written with libcnb.rs
-
symbol_table
A symbol table that's fast, concurrent, and gives stable references
-
do-notation
Monadic do syntactic sugar
-
bitvec_helpers
BitVec based bitstream reader and writer
-
bye_octomap_rs
OctoMap - An Efficient Probabilistic 3D Mapping Framework Based on Octrees. Implemented in pure Rust.
-
clone-spl-type-length-value
Solana Program Library Type-Length-Value Management
-
vicardi
JSON VCardArray Generator that uses Serde
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
stack-queue
Heapless auto-batching queue
-
eastl-rs
EASTL binary-compatible Rust implementations
-
hextree
Location to value mapping
-
pasture-core
A framework for working with point cloud data
-
rdf-model
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
rust_multistack
Support for two-dimentional stacks for the Rust programming language
-
persistent-kv
Persistent key-value store
-
attribute-search-engine
Generic search engine for rows with attributes using different matchers
-
avl
A map and a set implemented with an AVL tree
-
ndarray-layout
definitions and transformations for multi-dimensional array data layouts
-
rbitset
A bit set, being able to hold a fixed amount of booleans in an array of integers
-
open-payments-iso20022-camt
Open Payments - Message Parsing Library - ISO20022 CAMT
-
cpx-mat2by2
power the rust-quantum project, this library provides a robust AltMat type for a single qubit, specifically optimized for the intensive complex number multiplications required for quantum…
-
h3o-ice
Frozen{Map,Set} for H3 cells, based on finite state transducers
-
orx-tree
A beautiful tree 🌳 with convenient and efficient growth, mutation and traversal features
-
atelier
a Computational Workshop for Market Microstructure Modeling, Synthetic Simulation and Historical Replay
-
cpx-coords
power the rust-quantum project, this library provides a robust
Cpxtype, specifically optimized for the intensive complex number multiplications required for quantum gate applications and tensor product operations… -
phf_generator
PHF generation logic
-
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. -
sparse-merkle-tree
Sparse merkle tree implement in rust
-
jsonbb
A binary representation of json value, optimized for parsing and querying
-
pfds
Purely Functional Data Structures
-
fast-graph
A fast, lightweight and extensible implementation of a graph data structure
-
plain_trie
Classic trie implementation capable of mapping any T to char iterator
-
vp-avl
A combined Vantage-Point AVL tree, to make VP trees updateable
-
cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
btree_experiment
implements a BTreeMap similar to std::collections::BTreeMap
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
pdatastructs
probabilistic data structures
-
vortex-sparse
Vortex Sparse array
-
superset_map
Map that stores distinct supersets based on the total order defined
-
avltriee
Customized version of AVLTree library.Process the same value in the third branch. One data is immovable from one row, and positional relationships such as left, right, and parent are all referenced by row numbers…
-
tailvec
Split Vec to mutable slice and TailVec, the TailVec can push or pop etc
-
odht
hash tables that can be mapped from disk into memory without the need for up-front decoding
-
lctree
Link-Cut-Tree: self-balancing data structure to maintain a forest of rooted trees
-
livestock-rs
comprehensive library and CLI tool for managing, identifying, and working with livestock breeds, growth rates, and health. Designed to support farming and ranching applications, breed registries…
-
velcro
Convenience macros for initializing vectors, hash maps and other Rust collections
-
uid_store
Generate random uid strings containing letters, numbers, or base62 values
-
bye_nanoflann_rs
KD-Tree, implemented based on nanoflann, primarily optimized for 2D or 3D point clouds
-
tuplez
Tuples represented in recursive form
-
graph-api-petgraph
Integration between graph-api and petgraph - use graph-api's traversal system with petgraph structures
-
smallvec-wrapper
Macro and common structs to play with
smallvec -
cola
A text CRDT for real-time collaborative editing
-
array-linked-list
A data structure, which combines the advantages of dynamic arrays and linked lists
-
pstd
parts of Rust std library ( different implementations, features not yet stabilised etc )
-
cve
Mappings for parsing the CVE JSON files
-
bitboard64
A 64-bit bitboard useful for chess programming
-
cell-grid
2d grid container
-
sucds
Succinct data structures in Rust
-
validit
Validate data structures internal state
-
entid
generating and validating type-safe, prefixed entity identifiers based on UUIDs and ULIDs
-
kollect
Collections made ergonomic for gamedev usecases
-
strumbra
Umbra-style strings (also known as German strings)
-
hashheap
data structures that combine a hashmap and a min/max priority heap, with main operations requiring O(1) or O(log n) time
-
arraystring
Fixed capacity stack based generic string
-
rspack_sources
webpack-sources port
-
graphix_io
reading and writing graphs from and to text files, based on the graphix crate
-
intrusive-lru-cache
An LRU cache implementation using intrusive data structures
-
data_reader
A data loading library for data scientist
-
nybbles
Efficient nibble-sized (4-bit) byte sequence data structure
-
sif-itree
immutable, flat interval tree
-
hashify
Fast perfect hashing without dependencies
-
griddle
A HashMap variant that spreads resize load across inserts
-
typeables
type aliases. By SixArm.com.
-
mediumvec
Vector types optimized for space, including a 32-bit Vec
-
optional
supplies a number of Option-like primitive types
-
json_deref
JSON internal field links resolver
-
dia-i18n
-
agb_hashmap
no_std hashmap implementation intended for use in the
agblibrary -
prefix-sum-vec
Compressed storage for highly repeating elements, with
O(log n)lookups -
decomp
Components of a decompilation pipeline
-
vec-belt
Multi-threaded bulk-append, single-threaded consume
Vec<T> -
segtri
Segment tree with customizable data type and update operations
-
unordered-pair
A tuple struct representing an unordered pair
-
swamp-script-source-map-lookup
Source map lookup for Swamp
-
space
providing abstractions for spatial datastructures and search
-
digit-sequence
Sequence of u8 digits
-
disjoint
Fast and safe implementation of the disjoint-set data structure
-
kn0sys-ndarray-stats
Statistical routines for ArrayBase, the n-dimensional array data structure provided by ndarray
-
ofilter
fast thread-safe Bloom filter
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
cdll
A circular doubly linked list
-
linear-hashtbl
Linear probing hash table
-
sigmars
sigmahq rule collections
-
exhaustive-map
An exhaustive map for types with finite inhabitants
-
bitstring
traits and implementations
-
minimizer-iter
Iterate over minimizers of a DNA sequence
-
windows-collections
Windows collection types
-
irange
A data structure to store and manipulate ranges of integers with set operations
-
tree-sitter-traversal2
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
paginate
framework agnostic pagination crate, that is especially suited for databases, slices and collections. Paginate calculates the range of pages indexes, making it ideal for accessing slices…
-
dsa_abc
basic data structure and algorithms. Usability and performance is priority
-
endpoints
A collection of data structures for the OpenAI-compatible endpoints
-
forest-ds
secure tree structure
-
sif-kdtree
immutable, flat k-d tree
-
indexed_arena
index-based arena without deletion
-
try_reserve
Stable implementation of the TryReserveError from std for custom collections
-
closed-interval-set
Unions of closed intervals as containers of pairs
-
ligature
Ligature's data model in Rust
-
cseq
compact sequences
-
roussillon-type-system
A type system for a programming language
-
the-zipper
zipper is a data structure that allows you to traverse and modify a tree-like structure efficiently. It provides a way to navigate through the tree while keeping track of the context…
-
tagid
Defines a newtype labeled tagging for different types of ids
-
range-map
Maps and sets implemented using ranges
-
dfir_rs
DFIR runtime for Rust, used by Hydro
-
astrie
High-performance hybrid data structure that combines the benefits of tries and B+ trees to provide efficient key-value storage with adaptive behavior based on data patterns
-
heapless_graphs
composable graphs for no_alloc environments
-
bit_mask_ring_buf
A ring buffer implementation with cheap indexing
-
orn
A general implementation of the sum type. Meant to be a generic counterpart to tuples.
-
lock_free_hashtable
Lock-free (almost) insertion only hashtable
-
rocstr
An immutable fixed capacity stack based generic copy string
-
any-rope
A fast and robust arbitrary rope for Rust. Based on Ropey.
-
tcgeneric
Generic data types used internally by TinyChain
-
rust-mcp-transport
Transport implementations for the MCP (Model Context Protocol) within the rust-mcp-sdk ecosystem, enabling asynchronous data exchange and efficient message handling between MCP clients and servers
-
orx-pseudo-default
PseudoDefault trait allows to create a cheap default instance of a type, which does not claim to be useful
-
orbweaver
designed for effortless construction and analysis of graph data structures
-
wrapped_slab
WrappedSlab: Auto-generate newtype idiom based on a Slab
-
lru-st
A package providing a Vec based doubly linked list implementation and related data structures
-
rust_decimal_macros
Shorthand macros to assist creating Decimal types
-
aliasable
Basic aliasable (non unique pointer) types
-
alot
A forbid-unsafe, generational slot map with usize-sized IDs
-
rbtree
the rbtree for Rust
-
anymap2
A safe and convenient store for one value of each type
-
bose_einstein
A data structure that efficiently partitions elements into two sets
-
general_stable_vec
A Vec implementation with stable indices
-
picocadrs
working with picoCAD saves
-
sentencepiece
Binding for the sentencepiece tokenizer
-
stable-map
A hash map with temporarily stable indices
-
disjoint-sets
Three union-find implementations
-
rust_flightweather
Decodes METAR and TAF
-
doubloon
Money datatype that supports both statically and dynamically typed currencies
-
arboriter
A tree traversal primitive for Rust, inspired by Tyler Glaiel's blog post
-
map-macro
Declarative macros for statically initializing collections
-
yffi
Bindings for the Yrs native C foreign function interface
-
rle_vec
A vector like struct that stores data as runs of identical values. Useful for storing sparse data.
-
rand-select
a tiny choice selector
-
hydroperfox-smodel
Semantic modeling for Rust
-
unsure
handling unsure (optional) values that might fail, with an additional rejection variant
-
rangetools
Extending the Rust Range structs found in std::ops
-
lsph
Learned Spatial HashMap
-
strict
collections with strict bounds
-
unbounded-interval-tree
An interval tree working with inclusive/exclusive bounds, as well as unbounded intervals. Provides helpers to fetch overlapping intervals, and difference of intervals.
-
prost-unwrap
A procedural macro for prost-generated structs validation and type-casting
-
ptrie
Generic trie data structure implementation (prefix tree) with support for different key and value types, and functions to search for common prefixes or postfixes
-
hi_sparse_bitset
Hierarchical sparse bitset. Incredibly high performance. Compact memory usage.
-
nested_intervals
nested & overlapping interval set functions, overlap, union, etc
-
nlist
inline-allocated list with statically tracked length
-
engcon
macros to define (eng)ineering (con)tracts on data-structure level
-
binary-greedy-meshing
A port of https://github.com/cgerikj/binary-greedy-meshing to Rust
-
hicollections
C-liked Collections
-
ringmap
A hash table with consistent deque-like order and fast iteration
-
suggest
A minimal library to provide similar name suggestions like "Did you mean?"
-
combination
A lib to do math jobs like permutate and combinate data from vec
-
taskchain
A block-based, non-circular double-linked list implementation for Rust
-
rs-snowflake
Rust version of the Twitter snowflake algorithm
-
idbag
A bag of integers
-
hash_histogram
HashHistogram creates histograms with keys of any hashable data type. Features include rank ordering and mode.
-
kg-tree
Generic object tree with Opath query language, similar to XPath
-
unnamed_entity
Strongly-typed indexing for vectors and other structures
-
populated
Collection types that are guaranteed to be populated (i.e. non-empty). Based on std::collections types.
-
dequemap
A no_std compatible implementation of the dequemap crate
-
suffixarrayview
Creates a view of a suffix array
-
ndarray-histogram
Histogram support for n-dimensional arrays
-
parallel_frontier
Queue-like frontier for breath-first visits on graphs that supports constant-time concurrent pushes and parallel iteration
-
slack-blocks
Models + clientside validation for Slack's JSON Block Kit
-
utote
Stack allocated uint multiset, with optional SIMD implementations
-
stac
SpatioTemporal Asset Catalog (STAC) specification
-
a-tree
A dynamic data structure for efficiently indexing arbitrary boolean expressions
-
text_trees
textual output for tree-like structures
-
merkle_light
Light merkle tree implementation with SPV support and dependency agnostic
-
smooth-json
opinionated, customizable utility to flatten serde_json Value variants into serde_json Objects ready for use in columnar or table-like usages
-
snowflake-ng
Dead easy and high performance
snowflakeimplemented in Rust -
onebuck
An efficient unordered dynamically-sized data structure
-
btree-slab
A memory compact Slab-based B-tree implementation
-
mco-gen
Stackfull Generator Library in Rust
-
dynarg
mechanism for dynamic robust argument handling
-
cirru_edn
Parser/Writer for Cirru EDN
-
lapce-xi-rope
A generic rope data structure built on top of B-Trees
-
zeropool-bn
Pairing cryptography with the Barreto-Naehrig curve
-
sharded
Safe, fast, and obvious concurrent collections
-
lox
Fast polygon mesh library with different data structures and traits to abstract over those
-
plane-2d
Continuous 2D data structure representing infinite 2d plane
-
psrutils
few utilities to facilitate pulsar science projects in rust
-
rand_pool
Create a pool of random numbers pre generated thread safe
-
fuid
A UUID-compatible identifier in a friendly base-62 format
-
basic_trie
Trie implementation in Rust
-
vec-collections
Rust collections that are newtype wrappers around smallvec
-
leveled-hash-map
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…
-
uf_rush
A lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure
-
scope-cell
temporary, scope-bound, and thread-safe mutation of data in Rust
-
keyed-set
Keyed Set: a hashbrown-based HashSet that indexes based on projections of its elements
-
coitrees
A very fast data structure for overlap queries on sets of intervals
-
HArcMut
mutable arc
-
ascent-byods-rels
data structures for Ascent relations, made possible by Ascent's BYODS feature
-
takeable
Container type that allows for temporarily moving out of the container, or permanently moving out and invalidating the container
-
gridly
managing fixed-size 2D spaces
-
smodel
Symbol semantic modeling for Rust
-
identified_vec
Like HashSet but retaining INSERTION order and without
Hashrequirement on the Element type -
iterlist
Linked list with a cursor based api
-
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.
-
samling-clorinde
Database queries etc for the
samlingcrate -
sk-store
SimKube trace store library
-
trie-root
In-memory patricia trie operations
-
cow_hashmap
Hashmap with copy-on-write semantics that requires no locks
-
gesha-collections
Collection utilities for the Gesha project
-
data-source
that fetches data from different sources
-
yrs_tree
implementing a CRDT-based tree data structure powered by Yrs
-
sweetrpg-kv-objects
Objects for Key-value store
-
gen_value
indexes and values with generations for vectors
-
libpna
PNA(Portable-Network-Archive) decoding and encoding library
-
azure_mgmt_cosmosdb
generated REST API bindings
-
delta-collections
Data structures with revertable operations called deltas
-
merkle-heapless
Statically-allocated Merkle Tree and Mountain Range
-
slab_tree
A vec-backed tree structure with tree-specific generational indexes
-
gapbuf
Generic gap buffer
-
qutee
A quadtree implementation
-
pipebuf
Efficient byte-stream pipe buffer
-
retaker
ecs implementation
-
lookupvec
Container with Vec-like properties that also offers O(1) lookup of items based on an id field
-
sparql-smith
A SPARQL test cases generator
-
fixed_deque
A fixed size VecDeque to match Python Deque
-
lignin
A virtual DOM structure, primarily for web use
-
type-map
typemap container with FxHashMap
-
bitvector
in Rust
-
cbsk_socket
socket callback tool
-
libwebnovel-storage
A complement to libwebnovel: this package handles downloading and organizing collections of followed webnovels
-
rabe-bn
Pairing cryptography with the Barreto-Naehrig curve. Update to use latest rand and serde crates.
-
mset
/ multiset / bag implementation
-
trie_rcv
Ranked Choice Voting implementation using Tries in Rust
-
mikel_binary_tree
search binary tree implementation
-
lesbar
String types that must encode legible text
-
cacheline-ef
Per-cacheline encoding of sorted integer sequences
-
host-port-pair
Host-port pair type
-
retworkx
A python graph library implemented in Rust
-
vax-floating
VAX floating-point types
-
token-string
Short (up to 65,535 bytes) immutable strings to e.g. parse tokens, implemented in Rust. These are sometimes called 'German Strings', because Germans have written the paper mentioning them.
-
btree_monstrousity
a code port of BTreeMap but with comparator functions
-
rb_tree
A Red Black Tree implementation in Rust
-
atree
An arena based tree structure with removal support
-
akita
Mini orm for rust
-
chunked_vec
A vector-like data structure that stores elements in fixed-size chunks for better memory management
-
spart
A collection of space partitioning tree data structures for Rust
-
lru-mem
An LRU cache implementation bounded by memory
-
heapix
providing heap data structures
-
orx-selfref-col
SelfRefCol is a core data structure to conveniently build safe and efficient self referential collections, such as linked lists and trees
-
singlevec
Vec-like container optimized for storing only a single item
-
array_list
A dynamic container that combines the characteristics of a Vec and a LinkedList
-
rbe
RDF data shapes implementation in Rust
-
imf
processing .imf files
-
rsor
Reusable slice of references
-
untis
accessing the Untis API
-
beach_map
slotmap
-
loose-semver
Loose parser for Semantic Versioning
-
convenient-skiplist
Convenient and Performant SkipList with serde support
-
digits
Custom “numeric” incrementor without u64 MAX limit in size. Like a score flipper for a custom character set.
-
gtfs-geojson
converter for GTFS to GeoJSON formats
-
mapack
mapbox vector tiles
-
openligadb
API
-
loc_api
interact with the loc.gov API
-
syntax-parser-generator
Independent library for generating lexical-analyzers and LALR parsers
-
beat_saber_map
Read and write Beat Saber maps with Rust
-
opt_struct
Optional collections
-
regroup
regrouping arrays
-
snowflaked
creating and working with snowflake ids
-
scryer-modular-bitfield
Allows to easily define bitfield types with modular building blocks. This is a forked version of the modular-bitfield crate with tweaks for use by Scryer Prolog.
-
walker-extras
Additional functionality for SBOM and CSAF walker
-
rangeset
Integer collection backed by ranges with set operation support
-
value-ext
Serde Json Value Extension Trait (more Value type later)
-
fastset
Fast set implementation for dense, bounded integer collections, optimized for quick updates and access
-
arc-string-interner
An efficient cuncurrent string interning data structure with minimal memory-footprint and fast access to the underlying contents
-
parametrized
Supply useful iterating methods for user-defined types which are parametrized by type parameters
-
debot_ml
ML prediction
-
moniker
Automatically derive variable binding and alpha equivalence for abstract syntax trees
-
no_std_collections
Auxiliary structures and traits for using dynamically resizable arrays (Vectors) in flexible environments, supporting both std and no_std contexts
-
cbsk_base
locked version cargo crates
-
fiftyonedegrees
A wrapper around the 51Degrees device detection C library
-
wasmedge-types
The common data structures for WasmEdge Rust bindings
-
probabilistic-collections
Various implementations of collections that use approximations to improve on running time or memory, but introduce a certain amount of error
-
linkedin-csv
Structs defined to hold the data as exported from LinkedIn
-
extindex
Persisted immutable index
-
enum-table
creating tables with enums as key
-
graphix
representing undirected graphs using a compressed adjacency list
-
whale
A lock-free, dependency-tracking primitive for incremental computation
-
expiremap
Key-Value map where each value has a custom expiry time
-
hora-id
A 64-bit time-based sorted unique ID generator that includes the current time in the ID
-
vsmtp-config
Next-gen MTA. Secured, Faster and Greener
-
bit-int
An arbitrary fixed bit-width integer library
-
arraysetcell
A fixed-capacity, vector-like array with interior mutability and no ordering guarantees
-
oxidd-rules-bdd
Binary decision diagrams (BDDs) for OxiDD
-
bin-it
efficient Rust library for binary serialization and deserialization
-
extract_map
A HashMap for memory efficent storage of value types which contain their own keys
-
floating_bar
Representing rational numbers using the floating-bar number type
-
id_collections
Index-oriented programming in Rust
-
frozen-collections
Fast partially-immutable collections
-
foyer-intrusive-collections
Intrusive collections for Rust (linked list and red-black tree)
-
pi_slotmap_tree
A tree structure implemented by dense memory linked list
-
makods
The Jostle Tree, a data structure for working with long sequences of variable-width items
-
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… -
sparta
software components specially designed for building high-performance static analyzers based on the theory of Abstract Interpretation
-
flange-flat-tree
A tree that can be expanded by attaching new values to the node without mutability of the old ones
-
bytering
A ring buffer specialized for vectored reading and writing in blocking and async I/O
-
nimbusqueue
fifo collection
-
equivalent-flipped
Similar to
equivalentcrate, but flipsKandQ -
rt-pods-client
Official Client for RtPods
-
suff_collections
Fast realization of suffix array and suffix tree
-
atomic_ptr_cell
Safe no_std repr(transparent) wrapper for AtomicPtr and &AtomicPtr with an api similar to a cell
-
alloc-checked
Collections that don't panic on alloc failures
-
hybridmap
Hybrid map using smallvec and the std hashmap
-
osmgraph
Convert OSM queries into graphs
-
any-range
AnyRange<T> enum can hold any Range*<T> type
-
diffogus
calculate the difference between 2 instances of a type
-
string_manipulation_utf8
String manipulation functions using character indexing (UTF-8) instead of bytes
-
indexmap-nostd
A no_std compatible implementation of the indexmap crate
-
bytes_deque
A growable bytes deque in Rust, providing access to the raw pointer
-
merkle-log
"Merkle Tree-Structured Log" defined in the paper "Transparent Logs for Skeptical Clients." https://research.swtch.com/tlog
-
kn0sys_ndarray
An n-dimensional array for general elements and for numerics. Lightweight array views and slicing; views support chunking and splitting.
-
dusa_collection_utils
A common library with standardized functions that the ais_platform, dusa, recs and others will depend on
-
thin-string
A String with a smaller stack footprint
-
tree-flat
TreeFlat is the simplest way to build & traverse a pre-order Tree for Rust
-
contexts
Implements a type for treating several hashmaps as one
-
tst
Ternary search trie collection in rust with similar API to std::collections as it possible
-
flammkuchen
Some data structures for fun and flammkuchen (e.g. a 2d grid which permits negative indices)
-
text-style
Types and conversions for styled text
-
fibonacci_heap
A Fibonacci Heap implementation in Rust
-
sbom-walker
work with SBOM data
-
linum
An open-source 2D-, and 3D-Vector Library
-
bloom-filter-yss
bloom filter for me or you
-
fast-ordered-buffer
A faster buffering implementation for asynchronous streams, trading off memory usage for speed
-
license-fetcher
Fetch licenses of dependencies at build time and embed them into your program
-
rust-tls-duplex-stream
Full Duplex stream Wrapper around rust-tls
-
luka
working with graphs
-
blas-array2
Parameter-optional BLAS wrapper by ndarray::Array (Ix1 or Ix2)
-
iowrap
Small helpers for using io::Read/io::Write
-
slice-of-array
Extension traits for casting between slices and slices of arrays. (&[T] <-> &[[T; n]])
-
cphf
Compile-time perfect hash function data structures
-
firims
fixed range integer maps and sets
-
ndshape
fast linearization of N-dimensional array indices
-
xuid
in Rust
-
rdf-format
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
microkelvin
tree traversal over annotated data structures
-
bitstring-trees
Trees based on bitstrings
-
tuple_list
macro-free variadic tuple metaprogramming
-
try-lazy-init
Fallible lazy initialization
-
rtree_rs
R-tree for Rust
-
indexed_json
Index json files like a database
-
compt
A complete binary tree visitor library
-
ux-dataflow
Data Processing Library
-
flat_enum
Expand nested enum into flattened enum
-
sum
General-purpose sum types
-
range_minimum_query
Range Minimum Query (RMQ) is used on arrays to find the position of an element with the minimum value between two specified indices
-
tinyvec_string
tinyvec based string types
-
bitvek
bit vector implementation
-
ztimer
A block-based, non-circular double-linked list implementation for Rust
-
lambda-runtime-types
Common structures for lambda architecture
-
libnv
Safe and rustic wrapper around libnv-sys
-
commitlog
Sequential, disk-backed commit log library
-
vecdeque-stableix
Deque with stable index values
-
usize-set
Set data structures optimized to store sparsely distributed usize values
-
traitgraph
Abstracting over different graph representations
-
ordered_hash_map
HashMap which preserves insertion order
-
disk-ringbuffer
lock free on disk ringbuffer to be used in the implementation of Franz
-
foreign_vec
Unofficial implementation of Apache Arrow spec in safe Rust
-
skiplist-rust
A lockless skiplist implementation in Rust
-
expiringdict
A dict / HashMap whose items expire over time
-
hprtree
A Hilbert-Packed-R-Tree implementation for rust
-
mih-rs
Multi-index hashing (MIH) for neighbor searches on binary codes in the Hamming space
-
flat-tree
Series of functions to map a binary tree to a list
-
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
deepmesa
fast Data Structures and Algorithms in Rust. Every data structure is hand crafted for performance, well tested and has an extensive API.
-
p3-field
Plonky3 is a toolkit for implementing polynomial IOPs (PIOPs), such as PLONK and STARKs
-
named_colors
that provides named colors in RGB and Hexadecimal formats
-
teo-generator
SDK generators for Teo
-
tiled_parse_tree
Tree data structure
-
bool_vec
A crates that exposes a vector called BoolVec which allows you to store a boolean in a single bit
-
ware
middleware chains
-
fixed-vec-deque
A fixed-size, zero-allocation circular buffer for Rust
-
modular-bitfield-msb
Allows to easily define bitfield types with modular building blocks. MSB-first version.
-
enum_meta
Add metadata to Enum Variants
-
ultragraph
Hypergraph data structure
-
ladata
& modular data model
-
dcl_data_structures
Data structures for for deep_causality crate
-
neighborhood-diversity
computing the neighborhood diversity of simple, undirected graphs
-
trie-hard
Fast implementation of trie data structure
-
glace
A type-safe, user-friendly proc macro for embedding a file tree into your code
-
shrink-to-fit
Recursively calls
shrink_to_fiton all elements of the container -
msg-store
A fast and light-weight message store designed to work as a priority queue in low hardware equiped devices
-
bbox
Managing axis aligned 3d Bounding Boxes
-
omango-util
Utililites
-
radyx
A basic radix tree implementation
-
rdftk_skos
data model for the Simple Knowledge Organization System (SKOS) vocabulary
-
segment-tree
Quickly perform interval queries or modifications
-
pi_vec_remain
vec remain range
-
vecs
Vector Math Crate
-
tuco
Tuco can automatically generate tuple representations of simple types. This is helpful if you want to create an API using plain types. Or if you want to provide an easy way to convert between types.
-
mown
Maybe owned values. Wrappers for values that can be either owned or borrowed.
-
compressed-intvec
A compressed integer vector with fast random access that stores values with instantaneous codes in a bitstream
-
safe_index
Type-safe indexes
-
rt_map
Runtime managed mutable borrowing from a map
-
binn-ir
-
geosite-rs
that parses geosite.dat file format
-
open-payments-iso20022-reda
Open Payments - Message Parsing Library - ISO20022 REDA
-
rc-dlist-deque
Doubly-linked list based on std::Rc
-
code_location
UNMAINTAINED! Use std::panic::Location instead!
-
cses-rs
A CSES spec impl in Rust
-
rustc_data_structures
Reuse rustc_data_structures for compiler_base
-
arrayset
An array-backed ordered set type
-
lodtree
help create octrees and quadtrees for chunked level of detail
-
croaring-sys
Raw bindings to CRoaring
-
entity
that provides entity-like constructs
-
radix-heap
Fast monotone priority queues
-
bicoro
Bidirectional co-routine data structures
-
indexlist1
A doubly linked list, backed by a vector
-
aircraft_icao_country
aircraft ICAO codes and their country of origin
-
hash-ids
a fast hashids (hashids.org) implementation
-
ux-dx
3D Graphics Primitives for Angular Rust
-
median-accumulator
fast, space-efficient, generic accumulator for computing median
-
variant-rs
VARIANT support for Rust. Clean, idiomatic handling of WinAPI/COM results.
-
espalier
Very simple flattened tree structure
-
bk-tree
A Rust BK-tree implementation
-
cow_vec_item
Copy-on-write Vec, available on stable rust
-
pollable-map
Utilites for storing futures and streams in as a pollable map
-
parallel_vec
A generic contiguous collection of heterogenous values
-
guppy-summaries
Build summaries for Cargo, created by guppy
-
ostr
Owned str
-
pas
strided slice
-
Xorfilter
No alloc membership approximation
-
sequential
A configurable sequential number generator
-
gamma
Graph primitives and traversals for Rust
-
cistring
A string type that preserve case, but compares insensitiveley
-
rtdlib
TDLib for rust
-
moka-cht
Lock-free resizeable concurrent hash table
-
multi_containers
Ergonomically work with multiple values per key
-
zhifeng_impl_barnes_hut_tree
implements Barns-Hut Tree for accelerated N-body force calculation
-
pvec
RRB-Tree based persistent vector implementation
-
ref_kind
Different reference kinds
-
gsgdt
Generic Stringly Typed Graph Datatype
-
markov-generator
Highly customizable library for building Markov chains and generating random data
-
fid
FID (Fully Indexable Dictionary) implementation for Rust
-
pocketbase-sdk
Pocketbase SDK
-
kdtree-simd
K-dimensional tree in Rust for fast geospatial indexing and nearest neighbors lookup
-
dinfrastructure
Ticket management systems for solo players
-
incremental-map
combinators for incremental immutable maps (see crate
incremental) -
trs-mlflow
contains an asynchronous client which implements 2.0 REST API of MlFlow server
-
contack
easy contact library
-
slablit
Literal for slab creation
-
varflags
exporting varflags macro, allowing to use unit-like enums in conjunction with Varflags struct to create easy to use bitflags data structure defined over enum variants
-
rexsgdata
Scatter-Gather Data Descriptors
-
spacetoken
Space allocator that is decoupled from actual storage
-
enid
parse Encrypted Numeric Identifiers
-
panoradix
A generic map and a set, both backed by a Radix tree
-
contigious-tree
Write and read tree graphs to and from contigious blocks of memory
-
py_env
A wrapper for Python commands to easily install dependencies and run Python scripts in an optionally impersistent environment
-
grove
A segment tree library enabling generic user-defined queries and actions on segments of your data
-
staticvec
Implements a fixed-capacity stack-allocated Vec alternative backed by an array, using const generics
-
grangers
working with genomic ranges and annotations
-
sodg
Surging Object DiGraph (SODG)
-
higher
Functors, Applicatives, Monads and other bad ideas
-
expanding_slice_rb
A self-expanding ring buffer similar to VecDeque optimized for working with slices of data
-
minivec
A version of Vec that's only the size of a single pointer
-
tnaps
entity-component-system framework in Rust
-
intervals-rs
intervals
-
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!
-
entity_data
A container for entity component data
-
vec_extract_if_polyfill
Polyfill for Vec::extract_if
-
vf-rs
A set of classes generated from the ValueFlows RDF schema
-
box-collections
A no_std compatible implementation of the collection crate
-
outils
Graph and tree data structure library. Providing utilities which aren't easily available in Rust.
-
redmaple
offers an oppinionated yet extremely flexible data modeling system based on events for backend applications
-
coca
Data structures with constant capacity
-
char-list
A persistent string type with the same API as a linked-list of characters
-
merkle-tree-bulletin-board
A public bulletin board based upon Merkle trees
-
dyn-iter
Wrapper around
Box<dyn Iterator<Item = V> + 'iter>to simplify your code -
sparseset
A Sparse Set
-
jsonmap
store values of multiple types value in one Map
-
wang_utils_map
个人使用的rust工具库
-
shortguid
Short URL-safe Base64 encoded UUIDs
-
rust_redux
A Redux-like state management library for Rust
-
sliding_window_alt
A structure that holds the last N items pushed to it
-
heapq
Priority Queue with scoring function
-
swamp-source-map-lookup
Trait and implementation for querying source text and locations (line/col/file)
-
nary_tree
A vec-backed tree structure with tree-specific generational indexes
-
linked-list
An alternative implementation of std::collections::LinkedList
-
netcrab
creating and exporting Petri nets
-
sweep-bptree
In memory locality aware b+ tree, faster for ordered access
-
sweetrpg-model-core
Core model definitions for SweetRPG
-
tournament-kway
k-way merge using a tournament tree
-
signvec
Vector implementation for fast, sign-based manipulation of dynamic collections
-
indexedlinkedhashmap
An indexable LinkedHashMap. The user defines the data structure that controls order.
-
liquemap
A two-level-list key-ordered LiqueMap with fast iteration. It supports fast indexing, including range iterators. Many implementation details are delegated to std's flatten iterators.
-
modern-multiset
A hash multiset implementation
-
typescript-definitions-ufo-patch
serde support for exporting Typescript definitions
-
sapling-dag
DAG used for source control
-
tree_by_path
A tree data structure featuring nodes addressable using a &Vec<usize> path and avoiding recursion and run-time borrow checking
-
orx-pinned-vec
PinnedVectrait defines the interface for vectors which guarantee that elements added to the vector are pinned to their memory locations unless explicitly changed -
aph_disjoint_set
Disjoint set implementation with optimized memory usage and ability to detach elements
-
malwaredb-api
Common API endpoints and data types for MalwareDB components
-
ndstruct
Structures for N-dimensions
-
big_unsigned_ints
Big Unsigned Integers ranging from U256 to U2048 using u64 arrays all under a fixed-size of 32
-
tensorism
Multidimensional arrays with bounds included in the type system
-
inplace-vec-builder
Build a vec from a vec, in place
-
riddance
retiring, recyclable, reservable IDs
-
stacked-set
Set interface, allowing stack-only implementations
-
astack
offers a Stack data structure with fixed capacity capable of fast LIFO operations
-
lockerroom
Readers-writer access to individual cells of your collection!
-
swamp-analyzer
analyzer for swamp
-
im-pathtree
Immutable, path-addressable tree data structure
-
char_index
efficient charwise indexing into a string
-
bitset-core
Straightforward, no-std compatible, simd optimized, BitSet API
-
ritelinked
HashMap-like containers that hold their key-value pairs in a user controllable order
-
rbtset
A set based on a RB-Tree for efficient operations
-
enum_vec
Efficiently store a vector of enum variants as a packed n-bit vec
-
emap
A map with a fixed capacity and integers as keys
-
write_x86_64
help you write x86_64 assembly code
-
bitpack-vec
A vector for arbitrary bitwidth integers, densely packed
-
circbuf
A growable circular buffer for working with bytes
-
timedmap
A hash map with expiring key-value pairs
-
roers
prepare augmented annotations for single-cell RNA-seq analysis
-
cachedb
In memory Key/Value store that stores RwLock<Value> which expire in LRU order when unused
-
sortedvec
a sorted vector that enables quick lookups
-
svdpi
Rust bindings for SystemVerilog DPI and VPI
-
serde_map
Mapbased onVecfor serialization purposes -
fn-traits
function traits like the standard library ones, but can be used in stable Rust
-
art-tree
The Adaptive Radix Tree
-
point-nd
flexible no-std struct to model points on axes of any dimensions
-
vec-btree-map
Basically just a sorted Vec that can be used as a HashMap
-
implhm
Simplified library of collision-handling HashMaps
-
objectionable
storage of unsized types inline inside allocated objects
-
streaming_algorithms
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
proptest-recurse
Helper for defining mutually recursive strategies with proptest
-
cbsk_log
log tool
-
fungi-lang
Fungi: A typed, functional language for programs that name their cached dependency graphs
-
semver-eq
Parser and evaluator for Cargo's flavor of Semantic Versioning
-
queues
Efficient FIFO Queue data structures
-
clonelicious
macro library that simplifies cloning and closure execution. The
clone!macro automatically clones variables and immediately executes the closure with the cloned values, streamlining… -
route_verification_graph
Parse RPSL in the IRR to verify observed BGP routes
-
union-fn
Proc. macro for creating efficient "inline closures".
-
agnes
A data wrangling library for Rust
-
froop
A functional reactive stream library for rust
-
generic-btree
Generic BTree for versatile purposes
-
rj
reactive json
-
grambulate
grambulation for positive integers in Rust
-
idmap
Efficient maps of integer id keys to values, backed by an underlying
Vec -
rive
ecosystem crate
-
higher-free-macro
macro that creates a (naive) Free Monad type based on a user-supplied Functor. It uses the traits from the "higher" crate. This macro is a port of the Control.Monad.Free part of the…
-
membuffer
A very fast flat memory buffer used to deserialize at a fast speed
-
llist
Lisp-style singly-linked list
-
concurrent-bloom-rs
thread-safe bloom filter
-
query-flow
A macro-free, data-oriented, general-purpose library for incremental, on-demand, self-adjusting computation using query-based dataflow
-
index-ext
Index slices with arbitrary ints and as arrays
-
simple_dot
API for creating GraphViz DOT files
-
gdsl
graph data-structure library including graph containers, connected node strutures and efficient algorithms on those structures. Nodes are independent of a graph container and can be used as connected smart pointers
-
broomdog
A type-erased map with 'indefinite loanership'
-
arikedb
Welcome to the ArikeDB Rust library! This library provides an interface to interact with the Arike Database, an advanced real-time database solution. This documentation will guide you…
-
onigiri
handling chars
-
persist-o-vec
A Vec type that aims to have stable indices and memory location
-
fixed_bitmaps
A small crate implementing bitmap functionality around primitive Rust unsigned integers
-
sparse_set_container
A container based on sparse set. Stable keys, O(1) lookup, cache-friendly iterations, and no hashing.
-
granite
Generic backing storage framework for building data structures
-
ttmap
Trivial implementation of type map
-
indexed_vec
IndexVecfromlibrustc_data_structures -
tinybox
Like
Box, but with an optimization that avoids allocations for small data-structures -
messaging
two-way messaging crate
-
range_map_vec
range map data structure backed by a Vec
-
utf8char
that supplies a utf8 encoded char
-
total-maps
Maps where every possible key has an associated value
-
hashbrown_tstd
port of Google's SwissTable hash map
-
lanyard
UTF-8 C string types
-
pi_map
Define a Triat: map for the mapped schema, and provide two built-in implementations of HashMap and vecmap
-
small-world-rs
The easiest HNSW vector index you'll ever use
-
tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
graphlib
powerful rust library for the graph data-structure
-
rtlola-hir
A high-level intermediate representation for RTLola specifications
-
cordic
Special functions for fixed-point numbers using the CORDIC method
-
reactive-signals
dx-first scope-based fine-grained reactive system
-
validiter
Iterator adapters for validating iterations
-
tinystr-raw
Raw string-to-integer conversions for tinystr
-
sortedlist-rs
A fast sorted list data structure in rust
-
limq
Queue with a controller for monitoring queue elements
-
rustz
functional programming in Rust
-
tc-value
TinyChain's representation of a value which can be collated and stored
-
uintx
Unaligned unsigned integers with exact size in memory and arithmetic operations for them
-
histogram-sampler
Sampling from a distribution given by a histogram
-
tpntree
A N-dimensional generalization of region quad/oc-trees
-
bdaddr
Bluetooth Device Address
-
large_int
An ease-of-use unbounded signed integer
-
word-dictionary
data structure for word mapping. It can be used for language translation.
-
designal
Procedural macro for use with futures-signals
-
alignment-exporter
Proc macro providing alignment info for a user-defined struct
-
bst-rs
Recursive & Iterative Binary Search Tree Implementations within Rust
-
mtnmomo
MTN Momo Payment API for Rust, with support for both the Sandbox and Production environments. All products are supported: Collections, Disbursements and Remittances.
-
singletonThread
thread in a singleton
-
minsize
Collections with a statically known minimum size (using const generics)
-
wolf-derivation-graph
Adds support for memoizing data flow graphs to wolf-graph
-
pathio
Data type for storing generic data on a virtual path tree hierarchy. The data is stored in memory, this is not OS file system abstraction, but immitation
-
btreemultimap
A multimap implementation with range support
-
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.
-
rc-writer
A tiny implement for writing data to a reference counted instance
-
holyhashmap
A hash map with stable indices
-
grid-arcium-fork
Dynamic generic 2D data structure (Arcium fork)
-
magnetise
asses the similarity between SQL queries
-
tree-iter
iterating over tree structures
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
vecshard
Split Vecs in constant time
-
surface-grid
providing data structures for square-tiled grids wrapped around the surface of certain objects
-
alist
Association list offering fast lookups while preserving insertion order
-
value_pool
implements a ValuePool struct that makes the creation of self-referential data structures easier and safer
-
wolf-graph
Data structures and algorithms for working with graphs with reference or value semantics
-
mori
orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data analysis…
-
groupex
Syncronization primitive that allows acquire lock by index
-
galemu
workaround for generic associated types (GAT) limited to lifetimes (GAL)
-
linker-set
Declarative programming via linker-constructed arrays
-
swaybar-types
building swaybar status commands in rust
-
assoc
Treat vectors like associative arrays
-
libgitdit
distributed issue tracking in git
-
indexmap-rmw
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…
-
linear_collections
Map and Set types backed by linear data structures
-
artie_common
Common Library for Artie Rust Projects
-
keysymdefs
A collection of key symbol definitions
-
lazy-cow
Copy-on-write pointers with lazy modification support to minimise clones with a cost counter to limit work duplication
-
arbitrary-chunks
An iterator that allows specifying an input array of arbitrary chunk-sizes with which to split a vector or array
-
hit-data
Hierarchical Indexed Typed data structure
-
mzdata-spectra
A subset of
mzdata’s traits and spectrum data model -
pinned_vec
Vec-like data structure whose elements never move
-
type-rules
easily constrain a struct
-
bstree-file-readonly
Query read-only binary-search tree file, supporting billions of entries in files of tens of GB
-
automap
pattern to implement key-value maps where the value type contains the key type
-
range_bounds_map
[
RangeBoundsMap] and [RangeBoundsSet], Data Structures for storing non-overlapping intervals based of [BTreeMap] -
generational-indextree
Arena based tree structure by using indices instead of reference counted pointers
-
chainbuf
Fast chained buffers
-
tiny-artnet-bytes-no-atomic
Vendored copy of Bytes fork for use in tiny-artnet. Types and traits for working with bytes
-
clash_rules
a clash yaml rule parser and matching algorithms provider
-
rdf-writer
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
compare
Experimental comparators for collections to be generic over
-
bitvec_simd
bitvec with SIMD
-
fast_collections
noheap zero copy collections
-
dayendar
advanced days calendar operations
-
phf_macros
Macros to generate types in the phf crate
-
sql-json-path
SQL/JSON Path implementation in Rust
-
td-wavegen
Tower Defense mob wave generator
-
composable-indexes
In-memory collections with composable indexes
-
enumoid
Enum Indexed Containers
-
raw-btree
Generic B-Tree implementation
-
object-collection
A collection that can store multiple values of types
-
ordered_hashmap
Ordered Hashmap implementation to overcome arbitrary order of key-values problem in Rust
-
fixed-collections
Dynamically allocated ungrowable collections
-
bittyset
A BitSet type for manipulating bit sets
-
btree-ondisk
BTree structure on persistent storage in userspace
-
hash-rings
Implementations of various hash rings
-
construe
Compile-Time Growable Array: Vec & String for const!
-
grdf
Generalized RDF graphs and datasets
-
twovec
A data structure for storing 2 types of data in a packed, heap allocated array
-
nstd_collections
NSTD collections crate
-
double-map
A HashMap with double key to single data/value
-
bucket_vec
A vector-like data structure that guarantees to never move its contained elements
-
deepmesa-collections
A collection of data structures and algorithms designed for performance
-
tinymap
A map structure that stores its data on the stack
-
win-variant
that aims to provide a more ergonomic way of working with variants in winapi based projects
-
swamp-std
standard library for swamp
-
willowtree
Lazily evaluated trees
-
open-payments-fednow
Open Payments - Message Parsing Library - FedNow
-
enum-tag
Proc. macro for generating enum discriminant types.
-
dirbuf
reusable directory bufferes
-
memvec
Memory-backed vector, not buffer. Designed for for mmap. Not MemMap, but MemVec!
-
snake_case
SnakeCase is a String-like type that can only contain valid non-empty snake_case
-
collect-rs
Special and custom Collections and Containers (for Rust)
-
goya
morphological analyzer for Rust and WebAssembly
-
lumberjack
Read and modify constituency trees
-
mcts-rs
Monte Carlo Tree Search (MCTS) using an arena allocator
-
bitlab
Extracting a range of bits from a binary data source
-
indexland
Rust Collections with Newtype Indices
-
siraph
A node-based digital signal processing crate
-
aligned-utils
Common utilities to work with aligned values and allocation
-
slas
Static Linear Algebra System
-
expiringmap
a HashMap-backed TTL map
-
bayesic
A string matching library similar to NaiveBayes but optimized for many small classifications
-
fenny
working with Fenwick trees
-
veilid-hashlink
Fork of hashlink. HashMap-like containers that hold their key-value pairs in a user controllable order
-
z_table
lookup functions for the standard normal table, also called Z table
-
arc-bytes
A reference-counted byte buffer
-
klingt
audio graph library?
-
wccg-models
WCCG Data
-
merkle-lite
fast, and composable binary Merkle tree and proof for Rust Crypto hash functions
-
sqlite-collections
Rust collection types backed by sqlite database files
-
brownstone
building fixed-size arrays
-
field-ref
Field reference (like a member pointer to non-static data field in C++) for Rust
-
varlen
Ergonomic variable-length types
-
ndim
N-dimensional array for numerals in Rust similar to NumPy
-
iter-group
grouping (key,value) iterators into maps of collections
-
dendron
Generic tree data structure
-
simple-triplestore
graph database for storing triples with support for custom node and edge properties
-
easy_collections
Wrappers around standard collections for ease of use and quick prototyping
-
overtone
An API for creation and management of rich (as in rich-text) musical-ish projects
-
flatarray
Fast implementation of SeqEval, a sequence evaluation framework
-
traversal
Generic and lazy tree traversal algorithms
-
exegraph
no_std execution graph library
-
rahashmap
Fork of standard library HashMap with additional functionality
-
data_tree
Hierarchical data tree with pathing and search support
-
vec-new
Generate a rust vector by parsing all lines in a file
-
noindexmap
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…
-
raphy
A graph data structure library
-
xorfilter-rs
Xor Filters: Faster and Smaller Than Bloom and Cuckoo Filters
-
ipld-core
IPLD core types
-
bytes
Types and traits for working with bytes
-
bonzai
An abstraction for optimizing the memory layout and pointer aliasing of trees
-
Sparse-Voxel-64Tree
A lib for handling Sparse Voxel Contrees
-
patricia_router
Radix Tree implementation for Rust
-
graph_symmetry
Symmetry perception for graphs and its applications on canonicalization
-
hgg
Approximate nearest neighbor search collection
-
advanced_collections
advanced data structures (collections). Includes counter (hash-bag, multiset), disjoint set (union-find, merge-find), circular buffer (cyclic buffer) and interval (range)
-
truncate-integer
Truncate integers
-
treers
Sedgewick's tree maps
-
rosary
About Rose Trees
-
const_array_map
A const-capable Map type backed by a static array
-
sliding_tree
A tree that grows from the leaves and recedes from the root
-
routrs
Geograph-based shortest distance calculation for Rust
-
stringid
Lightweight system to manage identifier as human readable string and unique number
-
xsparseset
sparse set
-
div-int
Rational numbers with a compile-time denominator
-
ra-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 5113ed28ea1451a13eae3a05dca0dbabfd56f587 The publishing script for this crate lives at:… -
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
fwdlist
A simply linked (forward) list
-
cbsk_timer
rayon thread runtime
-
pin_array
Tiny crate providing an array with structurally projected pinning
-
timer_list
A list of timed events that will be triggered sequentially when the timer expires
-
arrayvec-const
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
sets_multisets
API for working with sets and multisets of elements of type usize
-
spaceindex
-
wide
help you go wide
-
boxing
cross-platform implementations for NaN and ptr boxes
-
slice-rbtree
A slice-based Red-black tree
-
bufferring
Ring buffers for Rust
-
ldpc
A toolbox for classical and quantum LDPC codes
-
dyn_trie
Dynamic trie is trie capable of mapping any T to any char iterator
-
chesspos
Basic structs for representing chess squares
-
genindex
Generational index library
-
hash-chain
A tiered hashmap and hashset implementation that allows for easily representing lexically scoped variables
-
fallback
A helper library to implement fallback mechaism
-
dyn-slice
&dyn [Trait] implementation, inspired by a Reddit thread
-
optempty
Tools for working types that may be empty. E.g., an empty
String,Vec,HashMap, etc. -
partial-array
potentially partially-filled arrays
-
open-coroutine-timer
The time utils
-
prefix-tree-rs
A Trie (prefix tree) implementation
-
dynamic_graph
graph processing
-
statiki
Static friendly data structures
-
non_empty_continuous
Non-empty continuous collections
-
sycamore-state-core
sycamore-state core types and trait definitions
-
flow_arena
A HashMap managed Graph Model with the concept of ownership
-
tinyvecdeq
VecDeque-like data structures -
applejack
Radix tree
-
many-to-many
creating many-to-many data structures with the ability to query either side, useful for applications such as pubsub. Like a fusion between
bimapandmultimap. -
lurk-elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
xtree
general purpose tree data structure
-
seg-tree
segment tree library
-
charcoal
Implements tree data structures and interfaces to work with them
-
medianheap
A median heap for keeping track of a running median
-
keylist
Elixir keyword list in Rust
-
associated_list
An associated list, for cases when the key implements neither Hash nor Ord
-
mqfilters
Highly optimized approximate membership query filters (bloom, cuckoo, xor, quotient) with SIMD support
-
bktree
BK-tree datastructure
-
lim-bit-vec
Limited bit vectors
-
ahtable
Array Hash Table implementation
-
fast-list
A doubly linked list using SlotMap for improved cache locality, and to solve the ABA problem
-
finata
-
task-collection
Types for managing and waiting on groups of tasks
-
string-wrapper
A possibly-stack-allocated string with generic bytes storage
-
to-offset
developer-friendly methods to manipulate strings with character indices
-
dependency-graph
building and resolving dependency graphs
-
weak-self
WeakSelf is simple way to have a Weak pointer to yourself
-
sid_vec
Tiny library providing id types and an id-based vector
-
im-rc
Immutable collection datatypes (the fast but not thread safe version)
-
isomorphism
2 directional hashmaps
-
tc-state
TinyChain's general state enum
-
pointcloud
An accessor layer for goko
-
abi_stable
For doing Rust-to-Rust ffi,writing libraries loaded at program startup
-
dawg
Directed Acyclic Word Graph
-
meminterval
interval-tree in Rust made to store memory mappings
-
front-vec
Efficiently-prependable Vec and String types
-
whirlybird
generic type implementations for RedMaple library, that offers workflows for different events compatible with common contents like todos, blogs and etc
-
traitgraph-tsplib-io
Functions to read and write graphs in TSPLIB format
-
enso-data
A collection of useful data structures
-
bufferbuffer
Double Buffer design pattern from 'Game Programming Patterns' by Robert Nystrom
-
make-message-bus
Generate a pub-sub bus for use in async applications
-
rust_list
Singly linked list in Rust, with macros for easy instantiation
-
corresponding
Move corresponding fields between structs
-
dep-tree
Dependency tree structure for building dependency requirements
-
analytic
has been renamed to be the math crate https://crates.io/crates/math
-
collection_literals
macros for initializing std::collections
-
fns
add common fn, eg: debounce, throttle
-
statemachine-rs
A statemachine crate which have zero dependencies
-
chainmap
mutability of intermediate maps
-
elastic_hash_rs
Elastic Hashing from Optimal Bounds for Open Addressing without Reordering
-
workit
single-threaded work queueing utility
-
flat_collections
Lightweight and memory-efficient associative data structures
-
activitist
Models of ActivityPub
-
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"
-
vecbool
bit vector built on top of Vec<u8>
-
tree-graphviz
Generate GraphViz DOT directed trees, based on an arbitrary tree structure
-
vec_arith
Powerful vector/matrix arithmetic library written in Rust
-
pokeapi-model
Data structures for PokéAPI v2
-
ds-bst
Binary search tree implementation
-
space-search
providing basic generic depth-first, breadth-first, heuristic-guided, and A* search space exploration algorithms
-
numas
multidimensional array for efficient computing
-
luthor
A collection of lexers for various languages/formats, and the tools required to build them
-
lending-library
A key-value store that loans full ownership of items
-
linked-vector
A hybrid linked list and vector data structure
-
nopetgraph
Graph data structure library. Provides graph types and graph algorithms.
-
mashmap
A flat HashMap that supports multiple entries per key
-
vec_key_value_pair
A drop-in replacement for std::HashMap and std::HashSet that use Vec on the backend
-
memorable
Lock-free, ordered and multiple version memory table for key-value databases
-
tilecoding
Dr. Richard S. Sutton's tile coding software.
-
numberwang
custom number malarkey, including variable-bit-width integers
-
hashmap-entry-ownable
Variation of HashMap::entry() that accepts borrowed forms of keys
-
baz-tree-sitter-traversal
Traversal of tree-sitter Trees and any arbitrary tree with a TreeCursor-like interface
-
evicting_cache_map
An Evicting LRU cache supporting prune hooks
-
core_collections
copy of libstd::collections with all the parts that don't work in core removed. Most importantly, it provides HashMap and HashSet. This crate is (mostly) automatically generated from the rust git source…
-
bfield
B-field datastructure implementation in Rust
-
tyght-map
A static type map implementation
-
flex-algo
Rust commonly used data structure and algorithms
-
spatialize
collection of spatial data structures used for efficent spatial partitioning
-
fastgraph
Graph abstraction providing a generic interface and powerful parallelized traversals
-
cbsk_log_tokio
log tool, using tokio as the runtime
-
arr-rs
arrays library
-
fenwick-tree
binary indexed tree (Fenwick tree) data structure in Rust
-
eki
solver for steady and transient flow in fluid networks
-
pciids
parse the pci.ids data file
-
rust-bloomfilter
bloom filter implementation in Rust programming language
-
modupipe
A modular and extensible ETL-like pipeline builder
-
diskmap
disk based HashMap-like for shared concurrent memory usage
-
fxd
Fixed-point decimal implementation
-
nimble-steps
Nimble Steps Collections
-
ndcopy
Fast N-dimensional array memcpy
-
zot
Option-like enums for working with ordered collections of zero, one, or two items (
Zot), or ordered collections of one or two items (Ot) -
gridd-euclid
euclid-compatible grid data structure (forked from Frosh_VII's gridd)
-
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.
-
v9
A slim data engine for Data Oriented Design
-
extended-rational
implementations of high-accuracy projectively-extended rational numbers and macros for creating them
-
retrace
Safe, generic rollback log with predictable latency
-
wolf-graph-mermaid
Adds support for generating Mermaid diagrams from wolf-graph graphs
-
hedge
An index based half-edge mesh implementation
-
dynamic-list
A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
-
xot
Full-featured XML tree library for Rust
-
arith
containers with arithmetics
-
re_log_types
The basic building blocks of the Rerun data types and tables
-
sweeper
A foundation for Minesweeper implementations in Rust
-
get-full-year
An unofficial Rust client for getfullyear.com that helps you get the full year
-
multiset
Multisets/bags
-
list-any
Type erased slices and Vecs
-
cumulfreqtable
A Cumulative Frequency Table implemented with a Binary Indexed Tree
-
bitmap
A dense bitmap
-
graphrepresentations
providing efficient abstract implementations of different graph representations
-
hyperbitbit
data structure
-
vector2
2D vector library
-
serde_either
set to enums to deserialize and serialize data that can either be string, struct or vec
-
finite-automata
A collection of extendable finite automata with immutable state and transition data
-
mutcrab
written in rust that contains various classic data structures
-
python-objects
that implements the architecture of the CPython objects. with this crate you can crate a list with any data type from rust
-
actions
Software without side-effects. Redo and Undo. Macro's.
-
rs-collections
generic collections (no dependency on std)
-
pdfgen
PDF rendering library
-
fixedvec
A heapless version of the Rust vector type
-
hayami
general use symbol table
-
distant-protocol
Protocol library for distant, providing data structures used between the client and server
-
stac-cli
Command line interface for stac-rs
-
zsling
Rust Wrapper around a Sequentially lockign (SeqLock) Ring Buffer written in Zig
-
anylist
a list type for any type
-
chain-map
A chain of maps with a single view into the aggregated values
-
web-glitz-buffer-vec
Implements growing WebGlitz memory buffers for slices of data
-
kodiak-taxonomy
manage generic taxonomies supporting unique features
-
segment-map
A self-balancing binary search tree for mapping discrete, disjoint segments to values
-
upair
Unordered pair data structure
-
chunky-vec
A pin safe, append only vector never moves the backing store for an element
-
ctxmap
A collection that can store references of different types and lifetimes
-
string-hash-interner
Efficient string interner with minimal memory footprint and fast access to the underlying strings
-
partial_const
way to handle constant and non-constant values in a unified way
-
generic_event_queue
generic event-queue API
-
syntastic
Generic abstract syntax representation
-
wavelet-matrix
A wavelet matrix implementation. Supports various near-O(1) queries on large number of symbols or integers.
-
aliri_braid_examples
Examples demonstrating usage of the
aliri_braidcrate -
simple-vec-collections
Collections implemented using Vec
-
pq-tree
consecutive ones property (C1P) and graph planarity testing
-
minimizer-queue
Fast computation of minimizers using a monotone queue
-
slice-cell
A
Cell<[T]>-like mutable slice, that allows slice-like APIs -
try_map
try_mapandflipmethods forOption. These allow more ergonomic error handling when mapping functions that returnResultoverOption. -
mergle
A data structure with fast merging and comparison
-
optionee
The macro to create option struct easily
-
treelike
A trait to abstract over trees, and simplify implementing them, all in one handy crate
-
sequencetree
a new type of collection to store keys and their corresponding values
-
giftbox
A fun Rust crate called
giftboxto help Rustlings learn and explore generics -
rustic_core
fast, encrypted, deduplicated backups that powers rustic-rs
-
lockfree-cuckoohash
lockfree cuckoo hashmap
-
rds-tensors
Rust Data Science Tensors crate
-
goodreads
deserializing a Goodreads library export
-
odata-params
OData v4 query parameters parsers for handling paginated requests
-
wildfly_container_versions
WildFly container versions
-
id-set
A bitset implementation that stores data on the stack for small sizes
-
dynstr
A string implementation optimized for manipulations
-
cast-rs
A collection of types cast for Rust
-
simple-ref-fn
function wrappers that do not require virtual tables
-
igraph
A graph representation data structure with a built in index on keys
-
nonempty-containers
Fast, zero-cost conversion, and fully inter-operable nonempty container types
-
rust-ds
Custom data structures crate for Rust
-
simple-undo
Easy to use undo-redo library
-
ecstatic
Statically-typed ECS library
-
idcontain
Generational (or tagged) ID-based containers
-
dynsequence
Sequence-Like data-structure for storing dynamically sized types
-
light-id
Generate and manipulate incremental IDs effortlessly
-
app_properties
reading application properties from a file
-
unthbuf
Unsigned N-bit Buffer: A structure that holds a fixed buffer of
bits-sized unsigned integer elements -
awid
Small, simple, universally unique identifiers
-
artful
Low-memory overhead and high-performance adaptive radix tree
-
benchmark-counters
Light-weight data structures to help with monitoring and benchmarking
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
weak-map
BTreeMap with weak references
-
tinyid
A tiny ID type that's like UUID except shorter and easier for a user to type in
-
splay
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)…
-
gcollections
Generic traits over Rust collections library
-
singletonset
SingletonSetdata structure, which makes it easy to store a single instance each of various types within a single set -
one_way_slot_map
SlotMap with minimal restrictions on Keys and Values
-
fixed-slice-deque
A fixed size deque implementation
-
amplify
Amplifying Rust language capabilities: multiple generic trait implementations, type wrappers, derive macros
-
array-const-fn-init
Initializes an array with constant values calculated by a
const fn -
arc-atomic
atomic pointer to an
Arc -
cons-rs
containing a Cons data structure
-
erased_set
A set of erased types
-
bengbenge
inifity array for round-robin dns, beng, beng
-
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)
-
untyped_vec
A type-erased vector type for Rust
-
datazoo
Bitset and jagged array data structures
-
checked
Implements a wrapper over the primitive Rust types that better indicates overflow during arithmetic
-
copse
Direct ports of the standard library’s BTreeMap, BTreeSet and BinaryHeap collections, but that sort according to a specified total order rather than the
Ordtrait -
circularbuf
Rust fixed size circular (ring) buffer
-
composite_types
Compose type definitions in the style of typescript
-
polystore
Polymorphic data store
-
u64_array_bigints
biginteger library based on u64 arrays
-
triangle_matrix
Triangle matrix indexing operations
-
nave
Thinking about the construction of distributed systems starting from the *consistent hash* algorithm
-
good_lp
Mixed Integer Linear Programming for Rust, with an user-friendly API. This crate allows modeling LP problems, and lets you solve them with various solvers.
-
packed_ptr
A configurable & generic tagged pointer implementation in Rust
-
squall_dot_io_resp
A RESP parser implementation, written with edge performance in mind
-
array_map
Map backed array for fixed size keys with O(1) performance
-
ppar
Persistent immutable array
-
symbol
globally interned strings
-
typed_graph
Staticly typed graph library
-
schema2struct
Convert a JSON schema into Rust structs for efficient and type-safe data management
-
partial
Optional monad with fake variant
-
read-copy-update
locking primitive
-
tinybitset
Generic implementation of small, fixed size, copyable bitsets
-
datastructures
A variety of data structures for learning purpose
-
mkargs
Build command arguments
-
quirks_path
path library with quirks that is as platform-agnostic as possible
-
ospf-rust-multiarray
A multi-array utils for ospf-rust
-
discord-indexmap
A fork of the popular
indexmaplibrary that adds a few extra APIs that are yet to be upstreamed -
foxy_log
Common logging utilities for
foxy -
libarena
Arena allocated graph implementation
-
recursive_array
arrays using recrusive data structures to avoid limitations of the rust compiler
-
bitf
procedural macro to easily create a bitfield out of a struct
-
hashable_weak
A hashable weak pointer
-
octree
algorithm for nearest neighbor search in 3D space
-
trey
Writing V3000 CTfiles
-
nslice
Structures for interpreting slices of variable length as arrays
-
bpht
A bit-packed hash table implementation using hopscotch hashing for 32-bit keys and values
-
summavy
Search engine library
-
const_std_vec
const std vec
-
cervine
A slightly more flexible Cow; roughly to T: Borrow<R> as alloc::borrow::Cow is to B: ToOwned
-
froggy
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
-
deviz
access to a VS Code extension for displaying structured program output
-
moonlight_collections
Collections for Rust
-
geo-index
Fast, immutable, ABI-stable spatial indexes
-
bitrush-index
A serializable bitmap index library able to index millions values/sec on a single thread
-
microcrates-bytes
Types and traits for working with bytes (with no_std support by default)
-
changed
change detection
-
sequence_trie
Trie-like data-structure for storing sequences of values
-
manhattan-tree
A spatial tree which can effiently find closest key to a point, by manhattan distance
-
index_many
A proof of concept for indexing an slice at multiple locations at once
-
output_iter
An iterator that performs calculation during iteration
-
dyn_list
A linked list that can hold dynamically sized values in its nodes
-
multi_key_map
a hash table that shares one value across multiple keys
-
conlife
Backend-only implementation of Game of Life with minimal dependencies
-
tag-vec
A vector used for storing tags
-
defaultmap
HashMap with an automatic default for missing keys
-
restorable
An iterator adapter for saving and restoring iterator state
-
atlas-rb-tree
A textbook implementation of a Red-Black Tree
-
cursed-collections
Collections that (seem to) break Rust safety
-
arraylist
wrapper built on top of rust vector implementation. Taste like Java Arraylist, and intuitive to use like Python list and JavaScript array.
-
pfx
A prefix tree (map and set), implemented without any unsafe
-
spooles_ffi
Spooles C library FFI
-
inline-css
Embed CSS directly in your Rust code
-
dfb
Dynamic-Fifo-Buffer, like AnyMap but uses a VecDeque to store values and treats access as a Fifo
-
symbol-map
Memory-efficient mapping from values to integer identifiers (AKA a lexicon or symbol table), with options for fast bidirectional lookup
-
quadboard
Typed fixed-length buffers of chess pieces
-
bisetmap
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. The structure…
-
multipeek
An adapter to peek at future elements in an iterator without advancing the iterator cursor
-
realhydroper-smodel
Semantic modeling for Rust
-
rust_fixed_width
that allows for easier manipulation of fixed width files allowing for the ability to name fields and such using specs
-
priq
Array implementation of the min/max heap
-
flats
flattens nested structures into a flat single dimension map
-
path-value
Universal type and access property(s) by path
-
periodic-rs
Bounded datastructures
-
rive-models
Revolt API models for the Rive ecosystem
-
rdf-reader
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
btree-vec
A growable array (vector) implemented using a B-tree
-
ute
(U)biquitous (T)ile (E)ngine - library for matching and manipulating n-sided polygons with tagged sides (in rust)
-
maybe-cell
An UnsafeCell optionally containing a value, with the state externally managed
-
rolling_norm
Computes the rolling mean, variance, standard derivation and norm
-
grid2d
Two dimensional grid of runtime-defined, but unchangable size
-
collectable
Fallible, no_std-friendly collection traits
-
fastdivide
partial port of libdivide. It makes it possible to reduce the cost of divisions.
-
simple_event_bus
A basic, simple event bus in Rust
-
collect_result
collecting an iterator of results into a result of a collection
-
miny
Box<T> with small value optimization
-
array2ds
Package for handling sized 2d arrays in rust, without the usage of the keyword unsafe cuz why not
-
no-order
A transparent wrapper to ignore ordering and hashing of any value
-
relational_types
Manage relations between objects
-
atomic_lifo
Lock free thread-safe lifo for rust
-
colmac
Macros to work with
std::collections -
fqdn-trie
FQDN (Fully Qualified Domain Name) lookup structures (based on tries)
-
vector-trees
Vector backed B and AVL trees
-
quetta
Immutable, reference-counted strings for rust
-
inditech
A set of technical indicators for time series analysis
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
uvector
access two slices as a single continuous vector
-
cds
Collection of Optimized Data Structures
-
static_map
A static hashmap implementation, based on the Round-Robin hashing algorithm found in rustc
-
usage
A convenient alternative to the newtype pattern
-
ed
Encode and Decode traits
-
fera-graph
Graph data structures and algorithms
-
viral32111-xml
XML parser crate for my Rust projects
-
vector-store-flows
Vector store integration for flows.network
-
dd_statechart
A Data-Driven implementation of Harel Statecharts designed for high-reliability systems
-
collect-me
Additional collections not included in the Rust standard library
-
hibit_tree
Hierarchical bitmap tree. Integer-key map that can intersect FAST.
-
data-structures-algorithms
Data Structures and Algorithms in Rust!
-
colours
Color types for different color models with conversions between it
-
yuuang_petgraph
Graph data structure library. Provides graph types and graph algorithms.
-
pure-hfsm
A finite state machine library with a clear separation between the machine definition and its changing state
-
aatree
in Rust
-
b-tree
A persistent B+ tree using freqfs
-
know
Framework for Rust
-
smallbigint
Big integer types that have a small on-stack representation for small values. Uses num-bigint internally.
-
non-empty-collections
Non-empty hash-map and hash-set implementations
-
fplist
An immutable, persistent, singly-linked list
-
ptr_hash
A high-throughput minimal perfect hash function
-
ord-collections
offering collections which are pre-sorted automatically
-
swimmer
Thread-safe object pool type
-
calcit_fingertrees
(Calcit fork of )Immutable persisten
fingertrees -
multipath
split file path, like
/home/{user,admin}/file.txt -
sparsetools
2-D sparse matrix package for numeric data
-
endecode
encoding crate for types
-
bitworks
meant to provide easy to use bitsets with emphasis on safety
-
search_trail
manager of variables that can save and restore their values
-
yyid
Yyid generator (random tokens like UUIDv4, but using all the bits)
-
woodland
Easy to use implementations of popular tree data structures such as Binary, Binary Search, AVL, Red-Black, and more
-
plurals
singular/plural forms, mostly in English
-
rust-automata
A framework and a DSL for building finite state machines in Rust
-
subset-map
A map where the keys are subsets of an initial set of elements
-
parse_tree
A non-abstract syntax tree type
-
unicase_collections
Collection of UniCase datastructures
-
liblet
learning about formal languages and grammars
-
commandblock
providing utilities for working with Minecraft data
-
actionidmap-updater
A HashMap that can be updated from a URL. Intended to be used to keep reverse-engineered API's in use even as private referenced ID's get updated.
-
fn-map
Abstraction around HashMap. Uses closure to compute and store value.
-
half-2
Fork of starkat99/half-rs. Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types.
-
nostd-bv
Bit-vectors and bit-slices
-
nvpair-rs
Safe and rustic wrapper around nvpair
-
codemap2
maintained fork of the codemap crate that contains 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…
-
xdag
DAG(Directed Acyclic Graph) lib
-
quarkrs
A collection of small life improvements for rust
-
cliquers
Manage filesequences with a common numeric component
-
clubcard
exact membership query filter for static sets
-
mismatch
abstract mismatching. Useful for error propagation.
-
version-lp
a version struct library for use with version comparing, and wildcard resolving
-
any_of
A general optional sum of product type which can be Neither, Left, Right or Both
-
owned_chunks
a collection of traits and iterators to get owned chunks from collections
-
tree-mapper
generating a hierarchical mapping of files and directories represented as a HashMap. The mapping reflects the directory structure and file levels, allowing for efficient retrieval and…
-
stac-extensions
Manage STAC extensions (https://stac-extensions.github.io/)
-
mini_uuid
A small and URL-safe UUID crate for Rust
-
weight-cache
A cache that holds a limited number of key-value-pairs according to a user defined criterion
-
bitint
Integer types that have a logical size measured in bits
-
path_lookup
Find all executables in the PATH environment variable
-
foliage
Abstract syntax tree for first-order logic with integer arithmetics
-
hash_ring
Consistent Hashing library for Rust
-
honeycomb-core
Core structure implementation for combinatorial maps
-
simplecountry
Country Library
-
sampling-tree
sampling tree implementation for sampling discrete distributions with sparse dynamic updates. This allows us to sample efficiently from a distribution given the relative importance of each datapoint…
-
hashable-map
Wrappers for HashMap and HashSet that implement Hash
-
ads-rs
(Algorithms and Data Structures) is a set of useful generic production-ready algorithms and data structures
-
adts
Common abstract data type traits and implementations
-
rpos
Cursor Manager on Table
-
temporary-annex
Helper for creating temporary annex on a collection
-
wolf-graph-dot
Adds support for generating Graphviz DOT files from wolf-graph graphs
-
soa-vec
Vec-like API over a struct of arrays layout
-
cola-crdt
A text CRDT for real-time collaborative editing
-
vec-entries
Entry API for iterating over and removing elements from a
Vec -
cset
Fine-grained and reversible struct transactions
-
oats-rs
Short, unique ids without the hassle of random uuids
-
rustupolis
tuple space data structure in Rust
-
dyn-ptr
A box that stores types like pointers, forgetting everything besides
Self: Unsize<dyn Trait> -
Project2
Implementations of red black tree and AVL tree
-
indextreemap
A BTreeMap implementation that allows for key and or positional insertion and retreival
-
anas
Anas's Meta-data crate
-
qualomat_schema
Rust bindings for the *Qual-O-Mat* open data format for the german voting advice tool *Wahl-O-Mat*
-
kvv-efa-api
Rust bindings for the KVV (Karlsruher Verkehrs Verbund) "EFA"-API
-
run-loop
Run loop for thread, provide message post, deadline timer and future executor
-
dependy
Dependency resolution with variable dependency types
-
dyobj
improved version of the ECS pattern
-
okasaki
A collection of peristent datastructures
-
dynprops
Creating and extending objects with typed dynamic properties
-
mmdb
A std-collection-like database
-
big_enum_set
creating sets of enums with a large number of variants
-
epoch32
32-bit Epoch with specified starting year
-
bibliographix
A bibliography management crate
-
offset
Glorified offsets for arbitrary structures
-
ankurah-core
Core state management functionality for Ankurah
-
vector-map
VecMap<K, V>: a Linear Search with Map API
-
dltree
Doubly linked tree with leaf-considering typing
-
cad_import
importing CAD data from different formats into a uniform in-memory structure
-
win-idispatch
that aims to provide a more ergonomic way of working with idispatch in winapi based projects
-
async-func
providing macros to simplify the creation of asynchronous closures with external state captured by move. Useful for structuring asynchronous code with ease and clarity.
-
kd_interval_tree
Implements a K-dimensional interval tree, for fast interval-overlap lookup. Binary-tree based implementation, i.e. O(log(n)) lookups.
-
circular_vec
A fixed length vector that provides a next function that loops infinitely
-
final
Wrap a value in a type that does not give out mutable references
-
rcbytes
Rc version bytes crate
-
nsrb
Nifty Simple Ring Buffer (aka circular buffer) is a no_std library that provides 2 macros to easily create fixed circular buffer on the stack
-
graph-rs
graph library
-
gamozolabs/rangeset
Pure Rust x86_64 bootloader and kernel
-
noir_grumpkin
grumpkin curve
-
trips
generic triple store written in Rust
-
nfe
NF-e - Manipulação da nota fiscal eletrônica
-
lesbar-text
String extensions and queries for legible text
-
tinysearch-cuckoofilter
Cuckoo Filter: Practically Better Than Bloom
-
simple-matrix
generic matrix library
-
eytzinger-map
array/vec based map using eytzinger search algorithm
-
range-mutex
A
Mutex<[T]>-like type, that allows locking different ranges separately -
ndtensor
n-dimensional tensor library for Rust
-
handler_map
Map from types to functions that receive them
-
puruda
Pure Rust DataFrame
-
elastic-array-plus
Elastic vector backed by fixed size array
-
tobz1000-petgraph
Pseudo-namespaced fork of
petgraph: Graph data structure library. Provides graph types and graph algorithms. -
pinus
A prickly BTreeMap. You can insert through shared references and values are pin-projected.
-
swap-queue
A lock-free thread-owned queue whereby tasks are taken by stealers in entirety via buffer swapping
-
p8n-types
Basic types for representing binary programs
-
pulz-arena
A generational arena allocator with compact generational indices
-
stupid-add
If you want to add stuff this lib is the way to go
-
persistent_hashmap
Persistent hashmap is a library for working with memory mapped hashmaps
-
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
-
hdf5-hl
High level bindings to HDF5 High Level API
-
y-sync
Yrs synchronization protocol
-
sorted_vector_map
maps and sets backed by sorted vectors
-
zetacore
in-memory vector store library with Python bindings
-
spectacle
Opt-in runtime introspection
-
kn0sys_ndarray_rand
Constructors for randomized arrays.
randintegration forndarray. -
bidrag
input-binding system (API-Agnostic)
-
om2
A set of classes generated from the OM2 RDF schema (mainly Unit)
-
last-git-commit
wrapper arround git2-rs to get info about the last commit. Useful for when you want to show the git hash in a program.
-
aoc-framework-utils
such as data types, algorithms and functions for aoc-framework-rs
-
adjacency-list
Adjacency List and Adjacency Graph
-
safe-graph
Graph implementation (refactored version of GraphMap from popular crate petgraph)
-
version-rs
A struct for Versions, with the methods you expect
-
immer-rs
A wrapper around the C++ library immer for persistent datastructures
-
protocoll
clojure inspired protocols for rust collections
-
cosmic_undo_2
Undo and redo done the right-way
-
simple-bitrange
manipulating bit ranges which is common when working with IC registers
-
zond
standard rust collections but with collecting statistics
-
typed_floats
Types for handling floats with type checking at compile time
-
parst
declarative parsing
-
staticsort
Implements a macro providing a compile-time quicksort function for arrays of any length, containing any primitive Copy type with a PartialOrd implementation
-
tsil_cev
LinkedList on Vec
-
gvdb
glib gvdb file format
-
rand_map
A map that creates a random handle on insertion to use when retrieving
-
embedded-async-helpers
staticfriendly helpers for async on embedded -
dawgdic
Port of DAFSA in safe Rust (original implementation courtesy to Susumu Yata)
-
semver-store
An HashMap structure that uses semver strings as keys
-
shared-string
Split a string without another allocation
-
slotgraph
Graph implementation built with slotmap and petgraph
-
another-option
option data type; useful when allocations are expensive
-
serde-ordered-collections
Ordered serialization/deserialization serde functionality
-
bytes32
Used to create a custom type for 32-bit-wide byte arrays. Used for Drops of Diamond (more information about DoD is available at https://github.com/Drops-of-Diamond/Diamond-drops).
-
construct
A macro for building container literals
-
keymaps
standardized encoding for key codes
-
ucd-trie
A trie for storing Unicode codepoint sets and maps
-
fpq
Priority Queue with scoring Function
-
rust_release_artefact
Safely extract installable files from Rust release artefacts
-
eth2_ssz_types
types with unique properties required for SSZ serialization and Merklization
-
model_macro
traits collection
-
simple-collections
Collection of simple collections
-
ternary-tree
Ternary Search Trees, with no unsafe blocks
-
weekdays
Days of the week bit-mapped in a single byte
-
internode
Smart references to your graph nodes
-
undo_2
Undo and redo done the right-way
-
ketsugou
merges two arrays
-
fusebox
Mostly safe and sound append-only collection of trait objects
-
route_verification_bloom
Parse RPSL in the IRR to verify observed BGP routes
-
trying
Basic trie crate
-
json-node
A way to work with JSON as a node tree
-
dade
data definition for Rust structures
-
amadeus-streaming
SIMD-accelerated implementations of various streaming algorithms, including Count–min sketch, Top k, HyperLogLog, Reservoir sampling
-
rudy
Judy array implementation in pure Rust
-
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 -
stringmap
An immutable string map with pointers into frozen memory that can be shared between C, Ruby, Python and Rust
-
farmap
working with Farcaster label datasets
-
gap_vec
GapVec data structure in rust
-
sparse-bin-mat
A sparse implementation of a binary matrix optimized for row operations
-
simple_ringbuf
Ringbuf is a speedy lightweight fixed-size infinite-use collection optimized for straightforward single threaded use
-
quantity
Representation of quantites, i.e. of unit valued scalars and arrays.
-
tree-collection
Name reservation – Project will feature a collection of dependency-free pure rust implementations of tree varaints, such as AVL Tree, TTree and B+ Tree
-
ergo-lib-c-core
Common code for ergo-lib C and JNI bindings
-
lr_trie
Left-Right trie is trie capable of mapping any string to any string
-
system-config
storing application properties on disk
-
linked_array
Arbitrarilly long fixed-size arrays
-
bloom_filter_plus
rust_bloom_filter
-
my_crate_new
function collection
-
baggie
Container for storing mixed / heterogeneous values in a common structure
-
collections-rs
Generic collection types for rust
-
jagged_array
Owned
[[T]]-like 2D array where each row can differ in length -
immutable-map
An immutable ordered map and set based on weight-balanced tree
-
fromsuper
Macro helpers to derive new sub-structs from existing super-structs, potentially unpacking Options
-
afrim-memory
handle of sequential codes easier for an input method
-
cn-font-utils
utils of cn-font-split
-
strawberry_fields
Consume, read, and mutate struct fields with an iterator-like api
-
text_utils_s
edit array. Example delete duplicate in array. Clear string
-
collectioner
collection helper
-
serde_single_or_vec
Type which can be deserialized from either a sequence or a single value
-
aabel-multihash-rs
extends Hasher trait. The added functionality allows users to get sequeces of hash values. It can be used inside of implementations of probabilistic data structures such bloom filter or count-min.
-
kukoo
lockfree cuckoo hashmap
-
nibble_vec
Vector data-structure for half-byte values
-
elaru
Memory safe implementation of LRU cache
-
ploc-bvh
A Bounding Volume Hierarchy based on PLOC
-
threshold
data structures
-
fdm-toolkit
reading and writing 4D Miner (0.2.1.4 Alpha) game-data
-
hexarr
working with hexagonal grids
-
graphs
Graph data-structure implementations based off graph-traits
-
listfree
lockfree prepend-only list
-
vivalaakam_seattle_collection
Collection provider
-
string-err
String error type
-
tree-cursor
non-intrusive tree cursor that supports node mutation without Cell/RefCell
-
scaffolding-core
A software development kit that provides the scaffolding for building applications and services using OOP
-
kathy
Const-evaluated swift-style keypaths
-
polars-ad-hoc
Polars
-
dyn_vec
A Vec<T: ?Sized>
-
terminal-linked-hash-map
A fork of linked-hash-map that builds on stable in exchange for not allowing custom hashers
-
default-vec
A specialized vector that has a default value
-
indexmap-amortized
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…
-
hex-string
a data structure for managing hex strings in both string and byte vector representation
-
graphific
graph data structure library
-
bonsai
Index arithmetic functions for perfect binary trees
-
rbx_tree
Weakly-typed Roblox DOM implementation for Rust
-
rustfsm
Define state machines that can accept events and produce commands
-
interval-map
A vector-based, non-duplicate range-keyed, sorted array
-
restor
A dynamic resource storage system in rust
-
banyan
Persistent indexable tree data structure
-
unempty
Non-empty data structures for Rust
-
btree-plus-store
B-trees backed by a slab/arena to reduce allocations and increase locality + copyable, immutable B-trees which must be manually dropped
-
lumberjack-utils
Read and modify constituency trees
-
tiltflake
distributed database that uses the flake algorithm to generate unique IDs
-
nullvec
Rust nullable vector, which can contain null(missing) values as element
-
nats-types
Enumerations and types for representing NATS protocol messages
-
open-payments-iso20022-pain
Open Payments - Message Parsing Library - ISO20022 PAIN
-
valet
Stores your objects and gives you a tag to retrieve them later
-
bin_file
Mangling of various file formats that conveys binary information (Motorola S-Record, Intel HEX, TI-TXT and binary files)
-
fast_forward
Quering collections blazing fast
-
int-vec-2d
Vectors, points, rectangles, etc. with
i16coordinates. -
predicates-tree
Render boolean-valued predicate functions results as a tree
-
packed_str
Store immutable strings in a single packed allocation
-
ziptree
Tarjan's zip tree implemented in Rust
-
kodama
Agglomerative hierarchical clustering
-
map_in_place
Reuse the memory of a Vec<T>, Box<[T]> or Box<T> when mapping the elements if possible
-
fixed_str
Fixed-size, null-padded UTF-8 string type with const-safe construction and binary serialization support
-
nonoverlapping_interval_tree
Map data structure keyed on (non-overlapping) ranges that allows lookup of a point within a range. Can be no_std (with use of alloc crate).
-
arrow-message
implements a way to define messages according to the Arrow format in both Rust and Python
-
fuzzy-datetime
Detects, completes and normalises fuzzy date and date-time strings for interoperability with chrono or direct output as ISO-8601-compatible strings
-
pages
A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation.
-
stable_bst
An ordered map and set based on a binary search tree. Works with stable Rust 1.9.0.
-
simple-graph
Graph library with ability to serialize/deserialize Trivial Graph Format
-
abbrev-tree
highly inefficient data structure for text completion
-
simple-collection-macros
configurable macros for maps and sets
-
anycollections
Rust Vec and HashMap which can contain arbitrary types
-
proc-concat-bytes
Like std::concat but for byte strings
-
threshold-dict
A data structure to find smallest key that is larger than the query
-
stackvector
StackVec: vector-like facade for stack-allocated arrays
-
rustupolis_server
using space tuples in fog computing
-
k2_tree
A space-efficient representation of sparsely populated bit-matrices
-
sum-queue
Queue struct that keeps a fixed number of items by time, not capacity, and allows to get summarized stats of its content
-
bet
parsing and evaluating binary expression trees
-
bitstr
contiguous sequence of bits in memory
-
scoped_stack
A scoped stack data structure
-
stringz
A way to use strings in generic paramters
-
triskell
A tri-partite ring buffer
-
iterable
collection like types
-
vec_2d
2d vector for Rust
-
ensure
target state of an object
-
canopydb
Transactional key-value storage engine
-
thin_str
A string type that’s smaller than
Box<str>or String -
id-vec
Simplify Graphs in Rust. Introduces IdVec, which automatically creates Ids for each new object, reusing deleted Ids.
-
mutable
keep track of changes in structures
-
thinset
A data structure for sparse sets of unsigned integers that sacrifices space for speed
-
pair_macro
Create types consisting of the same type values such that Pair, Triplet, and so on
-
memcell
providing a MemoryCell struct, which stores a current and previous value
-
index-map
A map with automatically generated usizes as keys
-
elusion
modern DataFrame / Data Engineering / Data Analysis library that combines the familiarity of DataFrame operations (like those in PySpark, Pandas, and Polars) with the power of SQL query building…
-
dataflow-rs
A lightweight, rule-driven workflow engine for building powerful data processing pipelines and nanoservices in Rust. Extend it with your custom tasks to create robust, maintainable services.
-
es-entity
Event Sourcing Entity Framework
-
bucket_queue
A Bucket Queue data structure that can be used as a Priority Queue
-
range-set-blaze
Integer sets as fast, sorted, integer ranges with full set operations
-
graph-api-simplegraph
efficient graph implementation for the graph-api ecosystem with support for indexing
-
stringplus
A helper crate for dealing easily with Rust strings
-
gardiz
integer geometry on 2D planes, focused on games
-
kmmp-generator
allows one to automate the setup of Kotlin Multiplatform Mobile (KMM) projects. Simplify the creation of KMM projects by generating project structures, managing configurations, handling dependencies…
-
kvstructs
General basic key-value structs for Key-Value based storages
-
object-chain
Ad-hoc structure builder
-
case_insensitive_string
A case insensitive string struct
-
sesstype
Multiparty Session Types
-
nested
A memory efficient container for nested collections (like
Vec<String>orVec<Vec<T>>) -
streamhist
streaming histogram
-
courgette
Colour manipulation/conversion library
-
influxdb2-structmap
Procedural macro library for converting between Rust structs and associative containers
-
set_genome
A genetic data structure for neuroevolution algorithms
-
orx-imp-vec
ImpVecstands for immutable push vector 👿, it is a data structure which allows appending elements with a shared reference -
htmldom_read
HTML reader that parses the code into easy-use tree
-
alloc-wg
Attempt of collection several proposals of the allocators-wg
-
automerge-persistent-sled
A sled adapter for persisting Automerge documents
-
smallgraph
A small graph based on smallvec
-
pretree
package for storing and querying routing rules with prefix tree. Pretree 是一个用于存储和查询路由规则的包。它用前缀树存储路由规则，支持包含变量的路由。
-
structures
collection data structures
-
slice-find
SliceFind trait add .find() method (for search sub-slice in slice) to Vec, slice, fixed-length-slice in standard library
-
take-some
that provides a way to obtain *some* value from various collections
-
chtholly_tree
Rust bindings for Chtholly Tree
-
vectune
A lightweight VectorDB with Incremental Indexing, based on FreshVamana
-
twodarray
A 2D array library
-
futures-bounded
bounding futures in size and time
-
kushi
A queue built for the Dango Music Player and Oden Music Bot
-
typed_index_collection
Manage collection of objects
-
keyed_vec
Vector type where the key is a custom object to avoid mixing indices between vectors
-
izihawa-tantivy-columnar
column oriented storage for tantivy
-
grafferous
graph library with a focus on generic data in nodes
-
field_accessor
A procedural macro to get and set a struct field by String dynamically
-
form_builder
building forms with various fields and validation
-
acme-types
Types for implementing ACME (RFC 8555) providers and clients
-
smart-string
A collection of string types and traits designed for enhanced string manipulation
-
identifier
Generate 128 bits id structs easily
-
simd-r-drive-extensions
Storage extensions for SIMD R Drive
-
moretypes
Named tuples, records, and more!
-
sigma-rust
parsing and evaluating Sigma rules to create custom detection pipelines
-
judy-wrap
Judy arrays FFI mid-level binding
-
eziter
Wrapper around Iterator
-
forgetful
Track and forget values within a specific scope, enabling detection of repeated values
-
hamt-rs
A Hash Array Mapped Trie implementation based on the *Ideal Hash Trees* paper by Phil Bagwell
-
yagraphc
working with Graph data structures and common algorithms on top of it
-
trashmap
A HashMap and HashSet that operate directly on hashes instead of keys, avoiding rehashing
-
smol_str
small-string optimized string type with O(1) clone
-
dag_compute
construction of arbitrary computation DAGs and the expression of dataflow graphs
-
vecset
A vector-based sorted map, set and keyed-set implementation
-
push-while-ref
push while having a reference
-
trk-io
TrackVis (*.trk) reader and writer
-
map1
@ErichDonGubler's fancy template for new Rust projects
-
growable-bitmap
A growable (and shrinkable) compact boolean array
-
gpt_disk_types
GPT (GUID Partition Table) disk data types no_std library
-
prefix_array
A generic container for searching on prefixes of keys
-
criterium
Lightweigt dynamic database queries for rusqlite
-
graphrs
package for the creation, manipulation and analysis of graphs
-
bounded
numeric types
-
string-offsets
Converts string offsets between UTF-8 bytes, UTF-16 code units, Unicode code points, and lines
-
iodyn
An incremental collections library making use of Adapton
-
jirachi
A collision resistant runtime agnostic key-generator
-
lz_diet
An AVL balanced Discrete Interval Encoding Tree
-
disjoint-hash-set
A disjoint set / union-find data structure suitable for incremental tracking of connected component identified by their hash
-
hv-alchemy
Heavy Alchemy - the black arts of transmutation, wrapped for your safe usage and enjoyment
-
kodiak-sets
manage generic sets supporting unique features
-
rpkg-rs
Parse Glacier ResourcePackage (rpkg) files, allowing access to the resources stored within
-
deltastruct
Allows defining deltas for tagged structs for later application
-
csv2struct
Generate Rust struct definitions from CSV
-
id-map
Data structure of values indexed by IDs
-
segmentmap
A collection that maintains insertion order
-
byte-order
reading and writing numbers in big-endian and little-endian
-
geomprim2d
2D geometric primitive types
-
apint
Arbitrary precision integers library
-
extended-collections
An extension to the collections in the standard library with various data structures
-
rust_flightplan
Loads a flight plan from SimBrief and decodes it
-
vec_vec
When dealing with
Vec<Vec<T>>is unavoidable -
blocked-vec
A vector of byte blocks behaving like files
-
xsd
XSD.rs
-
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.
-
tiger-pkg
Tiger engine package reading library for Destiny 1/2 and Marathon
-
helgoboss-midi
Interfaces, data structures and utilities for dealing with MIDI messages according to the MIDI 1.0 specification
-
macaddr
MAC address types
-
light_merkle
A light-weight merkle tree implementation that allows to use any hashing algorithms from the packages sha2 and sha3
-
bpf-ins
working with eBPF instructions
-
cbsk_log_rayon
log tool, using tokio as the runtime
-
const-vec
Vec-like data structure with immutable push method
-
bytesstr
An immutable reference-counted UTF8 String
-
ransel
rank/select succinct data structures
-
medea-reactive
Reactive mutable data containers
-
arenas
Arena data structure for efficiently adding & removing items with stable IDs
-
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. -
grit-bitvec
BitVec, a vector type that can store fixed-width data with irregular bit widths
-
json_tables
A structure that eases operations with a local json storage of undetermined items
-
iostream
the project is rust io stream.you can easily use it to manipulate files stream and memory stream
-
scratchbuffer
A Vec<u8> like data-structure, that can be used as slices of different types
-
hpo
Human Phenotype Ontology Similarity
-
gridd
A generic, dirt-simple, two-dimensional grid
-
carpet
A thread-safe, fully-parallel directed graph
-
aliri_base64
Wrappers that make debugging and using byte arrays a bit nicer
-
bloomfilter-rust
A bloomfilter implementation in Rust
-
cdl-list-rs
A circular doubly linked list implementation using Rc<T> and RefCell<T>
-
largeint
that supports large integer arithmetic
-
voxelis
Sparse Voxel Octree DAG engine for building worlds, shaping matter, and mastering 3D space — powered by pure Rust
-
ioc
An Inversion-of-Control library in Rust
-
dashmap-shard
port of Google's SwissTable hash map
-
string32
A string that is indexed by u32 instead of usize
-
chronoflake
Generate unique IDs based on the Snowflake algorithm
-
res
build-script dependency for managing your project's resources
-
hashmap_settings
HashMap wrapper for layered Settings
-
weak-lists
Lists with weak references and concurrent iteration and modification
-
alpha-micrograd-rust
Expression tree, automatic gradients, neural networks, layers and perceptrons
-
go-heap-rs
Golang's heap written in Rust
-
petal-clustering
A collection of clustering algorithms
-
prcn_lib
private library for atcoder
-
brarchive
Bedrock Archives in Rust
-
big-tuple
providing trait implementations for tuples of up to 128 elements
-
implies
A parser for logical formulas
-
jui_file
file tool
-
cock-tier
Measure the power level of a peen
-
lexpr
A representation for Lisp data
-
simple-binary-tree
binary tree view representation
-
rust_dot
RustDOT is mostly the Graphviz DOT language, lightly rustified
-
bitsvec
A bit vector with the Rust standard library's portable SIMD API
-
binary_sort_tree
二叉树的new,insert,del,search等方法
-
miniqueue
A minimalistic single-thread job queue based on fold/reduce
-
precedence-net
Create and analyse precedence networks
-
biodivine-lib-bdd
thread-safe implementation of basic binary decision diagrams
-
sled
Lightweight high-performance pure-rust transactional embedded database
-
sot
Object Tree
-
priority-expiry-cache
A cache that evicts items based on their priority and expiry time (LRU + TTL) Add (O(1)), Get (O(1)), Evict (O(1)) in both time and space
-
tock-registers
Memory-Mapped I/O and register interface developed for Tock
-
subliminal
Base crate for subliminal microservices project
-
ipld-dagpb
IPLD DAG-PB codec
-
flowerbloom
fast bloom filter implementation with thorough documentation and tests
-
tiled-json-rs
parse and interact with Tiled editor JSON files
-
validated
The cumulative sibling of
ResultandEither -
hylo-fix
Fixed-point number types with Solana Anchor support
-
enum-ref
Proc. macro for generating enum discriminant types.
-
hdrhistogram
A port of HdrHistogram to Rust
-
elytra
An OGM for Neo4J built on the official Neo4j Rust driver
-
foxy_types
Types for
foxy -
lambda-apigateway-response
Response object for AWS Lambda with API Gateway
-
tiny-sparse-merkle-tree
Sparse Merkle Tree
-
collidea
Collision-prone memory-efficient collections
-
gridlife
generate and simulate Conways Game of Life cellular automatons
-
petitset
An ordered set data structure, optimized for stack-allocated storage of a tiny number of elements with a fixed cap
-
est
Extensions for the rust Standard library and Tokio
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
os_error
Struct
OsErrorrepresents only the OS error part ofstd::io::Error.OsErrorimplementsClone,Copy,PartialEq,PartialOrd,Eq,Ord,Display,Debug,Hash,TryFrom<std::io::Error>… -
gaps
Functionality for working with gaps/holes in ordered sequences of values
-
hashtree
A Merkle Tree implementation in Rust
-
csgo-gsi-payload
Data structures for CSGO Game State Integration
-
aabel-identifier-rs
defines identifier behavior, such comparing them, or generating sequences of identifiers
-
hecs
A fast, minimal, and ergonomic entity-component-system library
-
honeycomb-kernels
Meshing kernel implementations using combinatorial maps
-
exprz
An Expression Library
-
json_to_struct
Convert JSON into Rust structs for efficient and type-safe data management
-
ro
stuff read-only
-
range-traits
Ranges related traits
-
qlrumap
A HashMap with an LRU feature
-
hdf5-dst
DST extensions for HDF5
-
eztd
Quick start Rust
-
progress-streams
Progress callbacks for types which implement Read/Write
-
smolvec
A lightweight vector implementation with small-vector optimization for rust
-
tantivy
Search engine library
-
nimrodshn-btree
A persistent copy-on-write B+Tree implementation, designed as an index for a key-value store, inspired by SQLite
-
unrolled-linked-list
unrolled linked list in rust
-
once_map
Single assignment and lazy maps
-
float16
Half-precision floating point f16 and bf16 types for Rust implementing the IEEE 754-2008 standard binary16 and bfloat16 types
-
clone_cell
A Cell that works with a restrictive form of Clone
-
rblist
A block-based, non-circular double-linked list implementation for Rust
-
google-contacts-csv
Struct defined to hold the contact information from the Google contact file
-
equivalence
Trait and derive macro for comparing and hashing types modulo an equivalence relation
-
phylo
An extensible Phylogenetics library written in rust
-
bool_ext
defines and implements a complete set of
Option/Result-style Boolean functional combinators on Rust’sboolprimitive type -
bit-vec-omnitool
A vector of bits
-
p-chan
Multimedia (Audio, Raster) Channel Newtypes and Conversions
-
hj_ds
A data structure library for Rust
-
quantized-density-fields
Quantized Density Fields data structure
-
im_interval_tree
An immutable data structure for storing and querying a collection of intervals
-
nanovec
Arrays and Vec-likes of small integers packed in an integer or two
-
bitaccess
Macro for efficient and type-checked access to individual bits of a variable
-
omnitool
A curated respository of algorithms and data structures. The libraries are included as forks of Rust codebases
-
fixedstr
strings of constant maximum size that can be copied and stack allocated using const generics
-
avl-cont
A contiguous AVL Tree
-
thincollections
Alternative implementations for vector, map and set that are faster/smaller for some use cases
-
libreda-splay
Splay map and splay set data structures
-
bloomfx
Bloom filter implementation backed by fxhash
-
ecoord-core
Core primitives and operations for transforming between 3D coordinate frames
-
compact_path_tree
A data structure providing a compact in-memory representation of a tree of paths
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
jp_multimap
A barebones multimap (part of the jp project)
-
rep
A small tool for representation/class invariants
-
io_resp
A RESP parser implementation, written with edge performance in mind
-
theban_interval_tree
Interval Tree implementation
-
crdt
Conflict-free Replicated Data Types for Rust
-
ternary-tree-wasm
A simplified Wasm binding to ternary-tree crate
-
literally
Macro literals for members of std::collections
-
fill_canvas
FillCanvas is a wrapper around a matrix with special methods to fill the cells
-
jcm
Pure Rust implementation of the JCM USB communication protocol
-
rust-fsm
A framework and a DSL for building finite state machines in Rust
-
onevec
One-based indexed Vec wrapper
-
hoop
Fixed ring buffer that allows non-consuming iteration both ways
-
range-split
splitting sequences with range parameters
-
single_byte_hashmap
HashMap for storing singular bytes as keys
-
file_graph-rs
A tiny crate to generate a tree like structure starting from a folder and branching inwards
-
num-bigint-dig
Big integer implementation for Rust
-
rmat
minimal implementation of two-dimensional matrix algebra
-
flag_set
FlagSet can process operations of the infinite complementary sets and the origin sets
-
mucell
A cell with the ability to mutate the value through an immutable reference when safe
-
wagon-utils
Various utilities for WAGon
-
gsrs
Generic Self Referencing Struct
-
velarixdb
An LSM Storage Engine focused on reduced IO amplification
-
backtracking_iterator
generic iterator with an item history, capable of backtracking and forgetting
-
option-block
A minimal utility Rust crate for small, fixed-size blocks of optional types
-
leaderboard
functions for Vec such as ranking with ex aequos
-
key-node-list
Doubly-linked list that stores key-node pairs
-
uuid-timestamp
UUID timestamp
-
cloneless_cow
A greatly-reduced implementation of Cow that does not require T to be Clone but allows for storing either a reference or an owned instance for future needs of references to T
-
tapestry
Generic 2D grid data structure and utilities
-
tracker-macros
Macros for the tracker crate
-
contiguous_collections
collections backed by flat contiguous arrays
-
pna
PNA(Portable-Network-Archive) decoding and encoding library
-
stochastic-data-structures
Various stochastic datastructures implemented
-
ast2str-lib
pretty-printing ASTs and other recursive data structures
-
fsort
sort files in a fast, OS-independent and 'rusty' way
-
geogrid
Manipulate geographic data on a grid
-
better_peekable
Create a Peekable structure like Rust's Peekable except allowing for peeking n items ahead
-
common-data-model
Set of structs and traits for my network monitor system
-
hash_cons
A type-safe hash-cons library
-
ax_banyan
Persistent indexable tree data structure
-
uwheel-stats
profiling utility for uwheel
-
colony
A fast associative data-structure that chooses its own keys
-
immutable_string
Immutable Single Instance Strings for Rust
-
rdf-vocab
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
arrow-digest
Stable hashes for Apache Arrow
-
sxd-xpath
XML XPath library
-
binary_tree_zy
binary tree
-
ttgraph_macros
Proc-macros for TTGraph
-
hashmap_union
Allows the union and intersection of hashmaps
-
slabmap
HashMap-like collection that automatically determines the key
-
transitionable
A no_std compatible type to transition
T -> Twhere you have an&mut T -
vec-dimension-shift
N-Dimension shift features for Vec<T>
-
fr-trie
Fuzzy Radix Trie
-
num-rational
Rational numbers implementation for Rust
-
package-json
package.json manager for Rust
-
vector_mapp
A Vec based map
-
vortex-array
Vortex in memory columnar data format
-
primitive_fixed_point_decimal
Primitive fixed-point decimal types
-
cycle_map
Implementations of bi-directionally accessible hashmaps
-
tiny-interner
Easy to use string interner with fast access to underlying strings and minimal memory footprint
-
discrete_range_map
DiscreteRangeMap and DiscreteRangeSet, Data Structures for storing non-overlapping discrete intervals based off BTreeMap
-
hedel-rs
A Hierarchical Doubly Linked List
-
fcsd
Front-coding string dictionary
-
sorted-hlist
Type-level heterogeneous lists with compile-time intersection and sorting using typenum
-
fricgan
performing basic input and output on bytes
-
smt_map
A uint-to-uint map backed by Sparse Merkle Tree (SMT), which supports generating Merkle Proofs of key-values
-
deterministic-bloom
A deterministic Bloom filter with support for saturation. Suitable for distributed use cases and as a cryptographic primitive.
-
forged-in-lost-lands
Forged in Lost Lands is a simple game engine built in Rust that focuses on data control and ease of use
-
unsized_enum
Unsized enum implementation
-
tiny-solver
Factor graph solver
-
miniconf
Serialize/deserialize/access reflection for trees
-
typed_id
Make your IDs strongly typed!!
-
pui-arena
Generalized Arenas that can be used on
no_std -
collection_macros
Collection of macros for collections
-
pthash
Rust bindings for PTHash
-
sortedcontainers
An experimental sorted data structure
-
pui-vec
An append only vector, with guaranteed elided bounds checks
-
store-interval-tree
A balanced unbounded interval-tree in Rust with associated values in the nodes
-
cbor-tag-index
Tag index
-
ego-binary-tree
Binary tree API built by wrapping ego-tree
-
crio
An easy to use persistent data storage library
-
elu
Traits and implementations for EVAL-LINK-UPDATE data structures
-
aabb-quadtree
A quadtree that maps bounding-boxes to elements
-
algods
A collection of data structures and algorithms
-
treesome
tree creation, manipulation, traversal and visualization
-
fairqueue
Spatially distancing fair queue. A kind of queue for sequential round-robin processing.
-
bndpresbufq
Bounds-preserving, optionally limited, buffer queue
-
webgraph-algo
Algorithms for the Rust port of the WebGraph framework (http://webgraph.di.unimi.it/)
-
hash_table_datastruct
Adds a HashTable type, allowing to store values in a table with integer-indexed rows and hashable keys for columns
-
spigal
fixed-length ring buffer implementation, intended to be no-frills and easy to use, especially for embedded applications
-
stringvec
macro for creating Vec<String> from various types
-
trybox
stable,
no_std-compatible, fallible heap allocation -
jsonpath-rust
basic functionality to find the set of the data according to the filtering query
-
esdl
Event-sourcing Schema Definition Language parser
-
lightning-containers
A set of lock-free data structures
-
datastreams-rs
DataStreams container
-
mode
A behavioral state machine library written in Rust
-
contextual
deal with data in context
-
weakheap
Weak Heap data structure implementation in Rust
-
faex
A fast and efficient Compact Data Structures Library
-
mori_parallel
parallel orientation library built around commonly used orientation representations used in crystallography and engineering applications. It contains conversion, rotation, and data…
-
louds-rs
High performance LOUDS (Level-Order Unary Degree Sequence) library
-
kdt
k-dimensional tree implemented with const generics
-
mmdb_core
A std-collection-like database
-
fixed-queue
no_std, no_alloc, use [T; N]. support
Vec/VecDeque/History -
amazed
A graph maze building library
-
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…
-
merkle
tree implementation with support for generation of inclusion proofs
-
mikufans-proto-intl
gRPC APIs for Mikufans (Intl)
-
msiz_rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 74d5c70b174f06843049af2d764ff57ddc81c81c The publishing script for this crate lives at: https://github… -
ascii_num
digit to ascii numbers
-
random-access-storage
Abstract interface to implement random-access instances
-
tantivy-columnar
column oriented storage for tantivy
-
tensr
A high-performance, cross-platform, multi-backend tensor/array library for Rust
-
rust-mcp-schema
Type-safe implementation of the Model Context Protocol in Rust, designed to reduce errors and accelerate development with powerful utilities
-
inspector
General purpose inspection for popular data structures
-
varintrs
Golang Variable-Length Integers
-
free-ranges
An efficient data structure for keeping track of indices which are either free or not
-
decoded-char
wrapper to keep track of the original byte length of a decoded character in the encoded source file
-
modql-macros
Macros for modql. Not intended to be used directly.
-
symbolmap-trait
A trait for generic implementation of symbol tables
-
sorted-collections
providing useful extension traits and convenience methods for ordered collections in Rust. NOTE: This library is not currently in active development, and much of the functionality…
-
arrav
Sentinel-based heapless vector
-
jpostcode_rs
Japanese postal code lookup library in Rust, powered by jpostcode-data
-
no_proto
Flexible, Fast & Compact Serialization with RPC
-
stack-buf
Vector-like facade for arrays allocated entirely on the stack
-
ts-builder
Timestamp builder
-
rdftk_memgraph
Graph traits from rdftk_core::graph for simple in-memory usage
-
serde_single_or_vec2
Type which can be deserialized from either a sequence or a single value
-
tbytes
A tiny library for reading and writing typed data into buffers
-
art
adaptive radix trie
-
not_empty
Slices and vectors that are statically guaranteed to be not empty
-
hlist2
Compile-time heterogeneous list implementation
-
grapes
Persistent graph data structures: Tree, Graph, Arena & more
-
more_ranges
Range types not provided in the standard library
-
exhaustive-map-macros
Proc macros for the exhaustive-map crate
-
merged_range
rangeset that can merge overlap
-
tongrams
Tons of N-grams
-
cbsk_unique
unique value generator
-
fixed-macro
Macros for creating fixed-point constants for types in the
fixedcrate -
hexga_generational
GenVec, ideal for MAS (Multi-Agent System), where each agent can be removed at any time and has references to other agents
-
arc-swap
Atomically swappable Arc
-
cmp_wrap
Let you compare structes by context
-
rs-bucket-filter
Skips slow scans using cache, bloom filter,
-
slotmap
data structure
-
nanoset-py
A memory-optimized wrapper for Python sets likely to be empty
-
serde_str_helpers
Helpers for using serde with strings
-
bytes-quilt
data structure for tracking random-access writes to a buffer
-
matrixcompare-core
Core traits for matrixcompare
-
seq-set
A Set collection that maintains insertion order
-
sequence-map
Implements a map of unsigned 64-bit keys into strings. The map is optimized for creating it once, and then reading many times. The struct
Builderis used to build the map, and the structMapis used for lookups… -
insert_multiple
insert multiple items into a stream in reasonable runtime
-
spatial-neighbors
certain Spatial-Partitioning Algorithms | DataStructures
-
aces
Algebra of Cause-Effect Structures
-
arenavec
An arena backed implementation of vectors and related types
-
terees
a collection of tree-like data structures
-
bmap
A bitmap with an internal counter
-
minidom
A small, simple DOM implementation on top of rxml, targeting the subset of XML useful for XMPP
-
wordlist-generator
A handy wordlist generator
-
bitsetium
One stop shop for all bitset needs
-
plod
deriving plain old data
-
fusefilter
No alloc membership approximation
-
sized-vec
Type level sized vectors
-
open-payments-common
Open Payments - Message Parsing Library - ISO20022
-
reusable-vec
A Vec wrapper that allows reusing contained values
-
cow-rewrite
Rewrite copy-on-write types copying only when it's neccessary
-
priority-set
A no_std Priority Set
-
dst-container
Containers for DST objects
-
work-steal-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
bit-index
A little-endian zero-indexed bitstring representation
-
b100m-filter
The fastest bloom filter in Rust. No accuracy compromises. Use any hasher.
-
zvariant
D-Bus & GVariant encoding & decoding
-
batbox-collection
Collection of identifiable objects
-
weighted_random_list
A Vec<T> that allows you to define the weight of each entry and randomly get entries
-
moc
made to create and manipulate HEALPix Multi-Order Coverages maps (MOCs), see https://ivoa.net/documents/MOC/
-
boxed_array_ringbuffer
A ring buffer of fixed size, that uses a boxed array as storage, therefore avoiding re-allocations when converting from Vec or to VecDeque
-
f256
Octuple-precision floating-point arithmetic
-
mutuple
Replace items in Python's immutable tuples
-
freedesktop-icon-lookup
Freedesktop icons lookup
-
const-size-flatten
Flatten and FlatMap with constant inner iterator size
-
bloom_filter_plush
rust_bloom_filter
-
blazemap
Implements a vector-based slab-like map with an interface similar to that of HashMap, and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map
-
bitmac
Structure for accessing to single bits
-
vortex
file format with all builtin codecs and a sampling compressor
-
uwheel
Embeddable Aggregate Management System for Streams and Queries
-
stuff
Stuffing things into pointers
-
labelgraph
graph implementation, allowing random access to nodes via labels
-
idr-ebr
An efficient concurrent ID to object resolver
-
qris
QRIS Parser & Editor
-
boolvec
A vector of boolean stored contiguously in memory
-
aoc-framework-rs
A framework for AdventOfCode coding competition, that handles input, output and provides some core utilities
-
sparse_set
sparse set data structure
-
secured_linked_list
A cryptographically secured and provable linked list
-
arrsingh
A top level crate in the workspace
-
varset
an any type set of items
-
vox_writer
writer module for MagicaVoxel file format
-
oas3
Structures and tools to parse, navigate, and validate OpenAPI v3.1 specifications
-
cuml_map
A trait representing cumulative mappings, and several implemntations of this trait
-
hopscotch
A FIFO queue for efficiently hopping and skipping between tagged items
-
flat-multimap
A multimap and multiset implementation using a flattened hash table
-
crdt_rs
work with Conflict-free replicated data types (CRDT) in Rust
-
no_vec
modifying sized arrays
-
mvbitfield
Generates types to work with bit-aligned fields
-
guzzle
A derivable trait for consuming key value pairs into structs
-
sbf
Spatial Bloom Filter, a probabilistic data structure that maps elements of a space to indexed disjoint subsets of that space
-
staticstep
truly zero-cost alternatives to
Iterator::step_byfor both incrementing and decrementing any type that satisfiesRangeBounds<T: Copy + Default + Step> -
fid-rs
High performance FID (Fully Indexable Dictionary) library
-
anput
Scriptable Entity-Component-System (powered by Intuicio)
-
sparse_vec
Datastructure that stores separate but contiguous ranges of values efficiently
-
kvtree
Heterogenous in memory key value tree storage
-
cycler
A simultainious write/read data structure
-
vec-vp-tree
A vantage-point tree implementation backed by vectors for good performance with no unsafe code
-
triemap
Triemaps for Rust
-
projected-hash-map
projected HashMap over HashSet
-
hkalbasi-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the hkalbasi/rust repository from commit e77366b57b799dfa3ce1fcb850c068723a3213ee The publishing script for this crate lives at: https://github… -
rust_airport_supplier
Rust-AirportSupplier downloads airport data from OurAirports and decodes the information
-
ckb_multi_index_map
MultiIndexMap: A generic multi index map inspired by boost multi index containers
-
into_enum
Rust macro to generate trivial From impls
-
simple-canvas
generic 2 dimensional canvas struct
-
rustgym
solutions
-
hexgridspiral
Hexagonal Cube-Coordinate System with Spiralling Integer Tile Identifiers
-
la-arena
index-based arena without deletion
-
csbubble_sort
bubble sort implementation for Vec
-
ttl-queue
A queue that drops its content after a given amount of time
-
ord-by-set
providing a weakly ordered multi-set with compile-time configurable ordering scheme
-
btree_network
A generic network (undirected graph) data structure
-
qt-json
JSON library for QT
-
paged
Read and create read-only paged database files
-
itermap
Iterator tools for maps (
HashMap,BTreeMap, etc.) -
optionchain_simulator
OptionChain-Simulator is a lightweight REST API service that simulates an evolving option chain with every request. It is designed for developers building or testing trading systems…
-
posix-errors
Posix error codes and handy functions for using them
-
lookups
Improve the data retrieval operations for collections
-
structbuf
Capacity-limited structured data buffer
-
strck
Checked owned and borrowed strings
-
sliding_window
A fixed size, heapless sliding window
-
persistent_array
Persistent array is a library for working with memory mapped arrays
-
loglevel
way to set your log level
-
stride
A strided slice type
-
epoint
processing 3D point clouds
-
flexible-string
A stack heap flexible string designed to improve performance
-
hakari
Manage workspace-hack packages that do feature unification inside workspaces
-
loaf
Why have a slice when you can have a loaf?
-
dot_json
Tools for dot map representations of serde_json Maps
-
flexstr
A flexible, simple to use, immutable, clone-efficient
Stringreplacement for Rust -
aversion
Versioned data structures with auto-upgrading
-
array-ops
Automatic method implementations for array data types
-
shelves
Storing values referenced by a unique typed index
-
type-info
Meta type information and type reflection at compile-time and runtime
-
local_vec
fixed-capacity vector allocated on the stack
-
collect
An experimental extension of std::collections
-
pyrpds
Python Wrapper for Rust Persistent Data Structures
-
trait-map
Rust map for dynamic trait storage and references
-
whistlinoak
Annotated even-arity trees backed by mmaps
-
byte-sequence
A little marco that creates structs to be used as byte sequences (for ApiKeys, SessionIds and so on)
-
pgdb_to_struct
CLI application to generate Rust struct files from PostgreSQL database tables
-
data_structure_traits
data structure collection traits
-
oid
Rust-native library for building, parsing, and formating Object Identifiers (OIDs)
-
ensured_bufreader
A Bufreader ensures N bytes in buffer
-
collect-once-hashmap
A hashmap that can be collected only when there are unique keys in the iterator
-
checked_num
Overflow-checked numbers for safety without sacrificing ergonomics
-
typemap_core
A no_std typemap with trait-based value-presence guarantees (on nightly)
-
pi_phf_map
phf_map
-
const-assoc
A const-capable Map type backed by a static array
-
event-store-adapter-rs
DynamoDB an Event Store
-
randsort
A sorting library with an optimal complexity of O(n) (!!) by randomly sorting Vectors until they are sorted
-
insrcdata
Embed static data as source code
-
linked_list_c
Safely work with c compatible linked lists
-
i24
working with 24-bit integers
-
isx
Traits for checking certain conditions of values
-
atom_table
Assign easy-to-handle typed IDs to large, hard to handle things like strings
-
borrow-framework
More flexible borrowing
-
dastral
Reduce boilerplate code, learn data structures & algorithms with Dastral
-
short-lease-map
A map collection optimized for brief internship of values
-
variant-map
defines maps to store variants of enums
-
multi-stash
Vector-based arena data structure that reuses vacant slots
-
validbr
data structure and validation for Brazilian Registries, such as CPF, CNPJ and CNH (currently only CPF and CNPJ is supported)
-
unique-id-collection
Collection with unique Id
-
bstorage
A lightweight library for working with application configuration files
-
rt_vec
Runtime managed mutable borrowing from a vec
-
sixarm_collections
Collections for HashMapToSet and BTreeMapToSet as trait extensions. By SixArm.com.
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
nid
Generate and parse Nano IDs
-
modular-bitfield-ordering
Provide u8be..u128be, u8le..u128le for modular-bitfield
-
gen-vec
Vector indexed with generational indices
-
vpb
key-value proto buffer for veladb
-
fibheap
but actually useful Fibonacci Heaps
-
read-write-pipe
A trait for objects implementing Write, to write all content from a Read object
-
wildbird_macro_derive
Rust Framework 🐦 | Macro System
-
binary-tree
Collection of Binary Tree data structures and algorithms
-
static-box
A stack-allocated box that stores trait objects
-
nutype
The newtype with guarantees
-
quantities
Unit-safe computations with quantities
-
collect-mac
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, where possible. -
to-binary
Converts From Hex, UTF-8, Vector of Bytes, or a Byte Slice to a Binary String And Implements Many Useful Functions For Binary Strings
-
break_array
For breaking array indexing
-
jsonnlp
JSON-NLP data structure
-
neighborgrid
A 2-D grid datastructure with easy to use iterators and adjacent cell methods
-
const-buffer
A fixed-capacity memory buffer allocated on the stack using const generics
-
dag-cbor-references
Extract blake3 ipld links from dag-cbor blocks
-
automatic-relations
Tree automatic relations
-
slop-rs
Official implementation of the SLOP data storage language
-
prefix_tree_map
generic prefix tree (trie) map with wildcard capture support
-
fast-rustc-ap-rustc_data_structures
Automatically published version of the package
rustc_data_structuresin the rust-lang/rust repository from commit 15812785344d913d779d9738fe3cca8de56f71d5 The publishing script for this crate lives at: https://github… -
indexed-vector
that implements vector container that can be indexed with specified function
-
bounded-vec-deque
A double-ended queue|ringbuffer with an upper bound on its length
-
matrixgraph
A graph implementation based on dense adjacency matrices
-
bloomy
Bloom filter using only two hash functions
-
ute2
(U)biquitous (T)ile (E)ngine (2) - lib for parsing and manipulating abstract polygons with tagged sides
-
null-vec
A specialized vector that stores nullable values
-
graphsearch
graph search and representation library
-
crudite
A JSON CRDT
-
watermark
watermarking set for in-order insertions
-
nanobox
NanoBoxoptimization: store small item on stack and fallback to heap for large item -
sgf-parse
A parser for the SGF file format for Go games
-
pointer-value-pair
A pair of a pointer and a small integer packed into a pointer-sized object
-
claw-codegen
The Claw language Wasm code generator
-
lattice-graph
Set of Lattice(Grid) based Graph Structures
-
union-find-rs
Disjoint-set forest implementation to support the union-find algorithm in Rust
-
higher-cat
Functors, Applicatives, Monads and other bad ideas
-
grafana-dashboard
grafana import/export data serializable structures
-
bs
bitset with small-set (single-word) optimization
-
const_queue
A stack-only, no_std queue using const generics
-
tranche
Tranches are an alternative to slices
-
collections-more
Common data structure and algorithms for rust-lang to complete the already excellent std::collections
-
intrusive_splay_tree
An intrusive splay tree implementation that is no-std compatible and free from allocation and moves
-
trie-rs
Memory efficient trie (prefix tree) and map library based on LOUDS
-
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 -
rdf-query
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
bookfile
A container file format with chapters and an index
-
artsy
ART Tree data structure library
-
rust_cards
Simulates playing cards
-
intsplit
splitting numeric types into their binary component arrays
-
immutable-seq
Immutable sequence data structure
-
number-general
A generic number type for Rust which supports basic math and (de)serialization
-
mmap_json_file
parse, count, filter JSON files using memory mapped io library
-
hdf5-hl-sys
Bindings to HDF5 High Level API
-
plain
A small Rust library that allows users to reinterpret data of certain types safely
-
vhr_serde
A serde (de)serializer crate for the simplist possible binary format
-
destiny-pkg
Destiny 1/2 Tiger package library and tools (unpacker, verification)
-
probly-search
A lightweight full-text search engine with a fully customizable scoring function
-
stac-async
Asynchronous I/O for stac-rs
-
mstr
2-word, immutable Cow<str>
-
bipbuffer
Simon Cooke's Bip-Buffer
-
flex-alloc
Data structures with extra flexible storage
-
comfy-bounded-ints
Bounded-integer types focused on ergonomics and safety. (See README.md)
-
head
Common types with inline headers, such as HeaderVec for Vec
-
graph_process_manager_core
explore parts of a tree-like or graph-like structure that is not known in advance
-
closures
Abstraction for seperating code and state in closures
-
immutable-avl
An Immutable map and set implement for rust based on an AVL tree
-
muds
Minimalistic Data Structures and Entity-Component-System Library
-
nstree
construct branched 'namespace strings' for nested subcomponents, often for logging
-
authenticode
working with Authenticode (no-std)
-
type-pools
A data structure to store values of multiple types
-
mti
that implements type-safe, prefix-enhanced identifiers based on the TypeID Specification
-
rbl_circular_buffer
A zero-allocation, fast, circular buffer implementation in Rust
-
range_vec
Fast indexed access to a range of mostly-default values
-
dst
Data structures for DSTs
-
compacts-bits
succinct bit vector
-
bitops
Miscellaneous bit operations for any Integer
-
ebml-iterable
iterator over EBML encoded data. The items provided by the iterator are Tags as defined in EBML. The iterator is spec-agnostic and requires a specification implementing specific traits to read files…
-
graphia
graph data structure
-
bondrewd
Bit-Level field packing with proc_macros
-
gpt_disk_io
GPT (GUID Partition Table) disk IO no_std library
-
typerat
Type-level rational numbers based on
typenum -
bit-set-omnitool
A set of bits
-
lhlist
Labeled heterogeneous lists
-
fed
A sketch implementation of anonymous, tagged unions in stable Rust
-
small_vec2
Vector on the stack or heap need nightly rustc
-
structz
Anonymous struct implementation in rust
-
converge
Layered configuration, can be expressed in a single line of code. The
Convergetrait merges instances of structures into a new instance of a structure. TheConvergetrait can be derived… -
lazy_list
Lazily-populated lists, finite or infinite
-
binstring
Store binary data as a string
-
hashed
type you can convert any hashable type into and still do equality checks on
-
banyan-utils
work with banyan trees
-
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.
-
u64_array_bigints_core
Core library for
u64_array_bigints -
arrayvec
A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.
-
altdeque
An alternative deque implementation
-
bloom
Fast Bloom Filter and Counting Bloom Filter implementation
-
safer-bytes
safe, non-panicking wrappers around the 'bytes' crate
-
init_trait
A small helper trait to simplify the initialisation of 'indexable' data structures
-
array-object
Self-describing binary format for arrays of integers, real numbers, complex numbers and strings, designed for object storage, database and single file
-
vbox
type erased Box of trait object
-
pegitan
A bunch of random algorithms library
-
pasture-derive
Macro implementations for #[derive(PointType)]
-
clampf
Clamped floating-point types
-
generic-arrayvec
Interop between the arrayvec and generic_array crates
-
ordered-vecmap
Ordered map and set based on vectors and binary search
-
tapa-trait-serde
A collection of Tapalogi's reusable crates
-
dynamic-matrix
work with matrices
-
compressed_map
'Static functions': compressed maps with the keys removed
-
shine-graph
SHINE. Graph and sparse matrix module for the shine engine.
-
sorting-vec
Sorts a vector using a btreemap
-
synchronized-writer
A tiny implement for synchronously writing data
-
const_enum_map
Get const value from enum handle
-
rbtree-arena
A cache friendly red black tree where nodes live on sequential memory
-
street_index
small utility crate for working with road name / street indexing for cartographic purposes
-
shipyard
Entity Component System
-
gecs
A generated entity component system
-
csvenum
Generate code for enums with associated constants from a .csv in your command line
-
hat_trie
A hat-trie implementation that support prefix match iteration
-
dgrambuf
A fixed capacity ring buffer for datagrams (byte slices)
-
hashable_rc
Hashable wrappers for reference countings
-
delete_if_not
unsafely in-place delete function
-
aterm
Annotated Terms data structure
-
orx-self-or
Defines SoR (self-or-ref) and SoM (self-or-mut) traits that are useful in reducing code duplication and pushing forward the ownership transfer decision from the type designer to the consumer
-
len-trait
Len trait for collectons
-
char-circle
A circular buffer for strings and traits for in-place string transforms
-
open-payments-iso20022-pacs
Open Payments - Message Parsing Library - ISO20022 PACS
-
fallacy-hash
fallible hash collections
-
tdf_utils
such as tree
-
pointer_vec
The PointerVec works same as the std Vec structure except the Vec has a size of 3 usize (pointer, length, capacity). This crate provides a replacement that has a size of 1 pointer.
-
gtrie
Generic trie implementation with a support of different key and value types
-
object-merge
Traits useful for recursively merging document-like objects
-
static-bytes
Bytes for embedded devices
-
aliri_braid
Improve and strengthen your strings by making them strongly-typed with less boilerplate
-
lazy_concat
Lazy concatenation for Strings and Vecs
-
aora
Append-only random-accessed data persistence
-
ct-tilemap
help parse ClickTeam Tilemap files
-
re_string_interner
string interning library
-
fixedbitset-stack
A forked version of FixedBitSet that supports const generics
-
cycle_cursor
Cyclic cursor implementation over generic iterators
-
priority-matrix
A matrix that supports per-row, per-column and whole-matrix maximum key queries
-
embedrs-bytes
Types and traits for working with bytes
-
raw-vec
A Raw utility for managing contiguous heap allocations
-
copy-range
core::ops::Range et al, but Copy and IntoIterator
-
type-set
A set of heterogeneous types
-
merkle-search-tree
A data structure for efficient state-based CRDT replication and anti-entropy
-
ulid-generator-rs
generating ULIDs
-
sn-merkle-trie
Minimal starknet merkle patricia trie implementation
-
slots
Fixed size data structure with constant-time operations
-
bytes-expand
Types and traits for working with bytes
-
nuid
A highly performant unique identifier generator
-
libcanopy
Canopy is a lightweight tree-based data structure for Rust, optimized for reference management using Rc and Weak pointers
-
roaring-graphs
Graph data structure backed by roaring bitmaps
-
halfling
A collection of basic utilities for working with nibbles
-
calf-vec
Small copy-on-write arrays, essentially combining
SmallVecandCow -
graphstack
Graph-structured stack
-
probabilistic_data_structures
Probabilistic data structures in Rust Lang
-
ux
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…
-
indexvec
Simplified copy of rustc's index crate
-
vizz
creating GraphViz/DOT visualizations of Rust data structures
-
another_radix_trie
Rust built radix tree library
-
holodeque
Array- and slice-backed double-ended queues in 100% safe Rust
-
erasable
Type-erased thin pointers
-
persistent_rope
An immutable persistent rope data structure
-
building_blocks_partition
Acceleration structures for spatial queries on voxel data
-
hashmap_vec
A HashMap with lists a values
-
trie
An ordered map and set based on a trie
-
setting
The styles of all graphics elements
-
stable-bloom-filter
A Rust-implementation of a stable Bloom filter for filtering duplicates out of data streams
-
trailer
Store a type with an associated buffer in contiguous memory
-
rust-fp-pfds
A Functional Programming Library in Rust, Purely Functional Data Structure
-
toboggan-kv
abstraction layer over multiple KV stores
-
yuuang_dominators
null
-
vortex-mask
Vortex Mask - sorted, unique, non-negative integers
-
graph-api-lib
Core library for the graph-api ecosystem - a flexible, type-safe API for working with in-memory graphs in Rust
-
bytes_to_type
facilitate byte conversion to specified types using macro generation
-
gridava
2D coordinate systems
-
btree_monstousity
a code port of BTreeMap but with comparator functions
-
header-slice
Definitions for slices with headers, and a vec-like type with a header allocated inline
-
slotmapd
orlp/slotmap fork where serialization cycle doesn't change observable behavior
-
taganak-core
RDF types and interfaces from Taganak (Transactional, Aggregating Graph Architecture for Networking and Access to Knowledge)
-
compacts-dict
succinct dictionary
-
tensorism-gen
Multidimensional arrays with bounds included in the type system
-
sealingslice
A mutable slice that can seal its initial part off from mutability, and hand out the sealed parts as immutable references
-
flax
An ergonomic archetypical ECS
-
graph-api-test
Test utilities and property-based testing for the graph-api ecosystem
-
enum-map-derive
Macros 1.1 implementation of #[derive(Enum)]
-
judy-sys
Low-level Judy array FFI binding
-
hashindexed
A cache. A set which compares elements in a customisable way without overriding the eq() and hash() functions on the type itself.
-
docchi
A diff-based data management language to implement unlimited undo, auto-save for games, and cloud-apps which needs to retain every change
-
crossbeam-skiplist-mvcc
Support MVCC (Multiple Version Concurrent Control) for
crossbeam-skiplist -
dancing-links
Exact cover solver using dancing links technique
-
deqmap
A double-ended queue with optional keys
-
ranged_integers
An integer restricted to a compile-time defined bounds driven by const generics
-
any_handle
A thread-safe, type-safe smart pointer that can share, store and downcast a
dyn Any -
gvec
Very simple implementation of generational indexing for vectors written in Rust
-
pi_slotmap
Slotmap data structure
-
hexing
A basic Rust library to manipulate hexagonal grids
-
num-complex
Complex numbers implementation for Rust
-
ttm-rs
CLI to turn tuples into adjacency matrices
-
serde_view
Serialize views of data
-
leonardo-heap
Heap structure supporting fast in-place partial sorting
-
ibuilder
Interactive builder for Rust types
-
one-of
Macro to represent a type that can be converted either
FromorTryIntothe given types -
qt-json-rs
JSON library for QT
-
btreelist
A list data structure that has efficient insertion and removal in the middle
-
sif-rtree
immutable, flat R-tree
-
trait-based-collection
A trait-based collection library that implement different data structures using the same trait
-
asimov-core
ASIMOV Software Development Kit (SDK) for Rust
-
predicates-core
An API for boolean-valued predicate functions
-
flashtext
algorithm to search and replace keywords in given text
-
shifted_vec
A growable datastructure with positive and negative indexing built on top of
std::vec::Veccalculating the offset automatically -
ra_ap_la-arena
index-based arena without deletion
-
pagination
lib for web and database
-
generic-cursors
A generic way to mutably traverse acyclic recursive data structures
-
simple-observable
observable pointer for mutable and immutable data
-
nexum
collection of commonly used data structures
-
kudzu
concurrent, grow-only data structures
-
stack-stack
stack-allocated stack
-
tennis
data structures
-
crdt-list
Abstract CRDTs for lists
-
deferred_vector
A deferred vector implementation
-
fral
Functional random-access lists
-
map-of-indexes
A compact key-value map for unique but not dense indexes
-
fern-masking
Embedded data masking handlers for Fern proxy
-
rust_decimal_macro_impls
Shorthand macros to assist creating Decimal types. Do not depend on this directly; use rust_decimal_macros
-
doubly-linked-list
double link list
-
queue-rs
queue
-
gentrix
that adds the Matrix typed using generics that is basically a wrapper around a 2D Vector
-
ser_mapper
Mapped DTO serialzation wrapper for DBO/Model
-
native_model
A thin wrapper around serialized data which add information of identity and version
-
processing_chain
set up processing chains of large amounts of data
-
arq
manage Arq Backup data formats
-
etree
XML DOM library with XPath support
-
pi_append_vec
Only supports append vectors, lock free
-
btree_graph
A generic graph data structure
-
cdumay_result
serialize and deserialize result using serde
-
engineer
master builder!
-
enum_set2
A bit-set indexed by enum variants
-
compact-map
'Small map' optimization: store up to a small number of key-value pairs on the stack
-
flat_bit_set
有序、稀疏、节省空间的 bitset，适用于小数据量
-
const-arrayvec
A vec-like type backed by an array on the stack
-
base_custom
Use any characters as your own numeric base and convert to and from decimal
-
data-buffer
low-level data buffer type useful for IO and in homogeneous collections
-
tree-automata
Term Rewriting Systems
-
vortex-datetime-dtype
Vortex datetime extension dtype
-
m6coll
Small Smart Collections using prefix m6
-
bit_ops
Common bit-oriented operations on primitive integer types with a focus on
no_stdandconstcompatibility. Unlike other crates that provide tooling to create sophisticated high-level types with bitfields… -
suggestion_trie
A Radix trie for suggestion search, it allows to search for data indexed by a set of keywords fast
-
event-queue
crates.io için bir paket nasıl hazırlanırın ele alındığı öğrenme amaçlı modüldür
-
lighter
Macro for rewriting string matches as tries
-
stable_node_set
An ordered set with handles to values
-
bit-long-vec
Vector with fixed bit sized values stored in long
-
any_key
Dynamically typed keys for associative arrays
-
ittybitty
An itty bitty bitset to hold your itty bitty bits
-
key_set
KeySet representing concepts of All, None, Some(list), and AllExceptSome(list), with basic set calculations (intersection, difference, inverse)
-
pickledb
A lightweight and simple key-value store written in Rust, heavily inspired by Python's PickleDB (https://pythonhosted.org/pickleDB/)
-
history-buffer
A fixed capacity, write-only, ring buffer
-
keyed
Implement comparison traits by specifying a key
-
pulz-ecs
An archetype based ECS
-
base-traits
base traits (for Rust)
-
uclicious-libucl-sys
Low-level bindings to libucl
-
rusty_list
A no_std compatible, intrusive doubly linked list implementation
-
graph-arena
Collection type to store immutable graph structures efficiently
-
binary-data-schema
Meta language for raw binary serialization
-
maybe-string
newtype wrapper that represents a byte vector that may be a valid UTF-8 string
-
gloss-hecs
A wrapper over hecs for easy use with gloss
-
bitmaptrie
Bitmapped vector trie (mutable, not persistent). Word-size path-cached indexing into essentially a sparse vector. Requires rust-nightly.
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
hamst
Hash Array Mapped Shareable Trie
-
st_ring_buffer
A fixed-size String implementation using a ring buffer
-
oneoff
one-off types
-
bytey
convenient and easy to use byte storage
-
index_graph
Graph library that only stores indexes from a base array
-
explicit-discriminant
Macro for enforcing enum discriminants
-
collection
Deterministic, copy-on-write balanced search trees
-
ldtk_map
reading ldtk maps for usage in games
-
villa01-data-structures
Personal crate of me trying to implement data structures and algorithms in Rust
-
nnn
Generate your newtypes from a single macro
-
euui
An Extended Universal Unique Identifier
-
num-dual
Generalized (hyper) dual numbers for the calculation of exact (partial) derivatives
-
zipcodes
Query US zipcodes without SQLite
-
num-bigfloat
Increased precision floating point numbers implemented purely in Rust
-
slice-dst
Slice-based custom DSTs
-
roopes
Object Oriented Pattern Element System. This crate provides generic traits and implementations for typical object-oriented patterns. It is intended to be used as a cluster of utility…
-
stac-duckdb
Client for querying stac-geoparquet using DuckDB
-
mtgjson
Unofficially provided lightweight models of the data provided by MTGJSON
-
open-payments-iso20022-admi
Open Payments - Message Parsing Library - ISO20022 ADMI
-
fpdec
Decimal fixed-point arithmetic
-
unrecurse
Helper crate for rewriting your recursive code in iterative way
-
corosensei
A fast and safe implementation of stackful coroutines
-
ziku-pds
probabilist data structures
-
vhr_datatypes
data/file structures used in the computer game Valheim
-
bit-vec_serde
A vector of bits
-
simple_bitfield
Create bitfields with the same memory structure as integers using a simple macro
-
skew-forest
Skew-binary random access lists
-
kurve
Adjacency list graph data structure
-
arrsingh-lists
A test crate to test publishing
-
hashcow
HashMap implementation with copy-on-write keys and values
-
unsized-stack
Fast heterogeneous / unsized stack
-
linked_lists
Different types of linked lists
-
sliced
A segmented vector for iterating over slices
-
dimsum
multi-dimensional array library
-
egraphics
processing graphics formats in 3D space
-
tampon
Contains SAFE Rust functions, macro and trait to serialize / deserialize data structure and/or object and generate buffer
-
bitfields
Macro for generating flexible bitfields. Useful for low-level code (embedded or emulators).
-
libflow
grouping network flow data
-
valog
A lock-free, generic, lightweight value log
-
fix_float
Fixed floating types that allows useful trait implementations and datastructures on float numbers
-
graphrox
A graph library for graph compression and fast processing of graph approximations
-
nonempty_range
Range representing nonempty ranges
-
bits128
A struct to iterate over 128 bits by taking only 128 bits
-
smolbox
Like a Box, but small objects are stored on the stack
-
grid_trait
2D and 3D grids with combinators
-
svec
Dart-style list in Rust
-
nsw-types
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…
-
nonasync
A set of utilities useful for building a non-blocking non-async APIs
-
bit_range
A small library for getting bits and ranges of bits from byte collections
-
pulz-bitset
bitset implementation
-
arc-vector-rust
Rust client for Arc Vector Search Engine
-
append-only-bytes
Shareable append-only bytes
-
dimension_shiftable_buffer
A dimension shiftable buffer
-
lupine
A bloom filter using FX Hash with Kirsch and Mitzenmacher optimization
-
uberbyte
Bit manipulation for dummies
-
rdf_rs
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
zerovec
Zero-copy vector backed by a byte array
-
plum
Probabilistic data structures for rust
-
collection_traits
Collection traits & utilities; work in progress
-
power_map
A map with finite key and fixed size
-
typescript-definitions
serde support for exporting Typescript definitions
-
eitherq
Queue which support two different types
-
lsmtree
Implements a Sparse Merkle tree for a key-value store. The tree implements the same optimisations specified in the libra whitepaper, to reduce the number of hash operations required per tree operation to O(k)…
-
bigraph
Different representations with implemented operations on bigraphs
-
immutable
persistent data structures for Rust
-
disjoint-collections
Disjoint-set data structures
-
map-trait
Generic Map trait
-
zed
A minimal, Redux-like state management library for Rust with advanced features
-
graph-traits
Traits for graph data structures
-
transit_model_relations
Modeling the relations between objects
-
velect
A Vec with item / index selection
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
ptr-union
Pointer union types the size of a pointer by storing the tag in the alignment bits
-
bitwrap_extra
pack/unpack data into byte array
-
nbits_vec
Small bits value (e.g. 1,2.. bits) vector implementation.
-
typeslice
type-level slices
-
db_meta_derive
db-meta-derive is a wrapper around PostgresSOL using tokio-postgres
-
roaring_bitmap
Roaring bitmap data structure implemented in Rust
-
bloom_filter_simple
generic bloom filter implementation
-
rdf-borsh
RDF.rs is a Rust framework for working with RDF knowledge graphs
-
blfilter
Bloom filter implementation using farmhash
-
flit
Bloom filter backed by xxHash
-
num-bigint
Big integer implementation for Rust
-
atomic_swapping
An arbitrary type atomic storage with swap operations
-
vortex-ipc
IPC message format to exchange Vortex arrays across processes
-
ciborium-io
Simplified Read/Write traits for no_std usage
-
inline-xml
Embed XML data directly in your Rust code
-
brec
A flexible binary format for storing and streaming structured data as packets with CRC protection and recoverability from corruption. Built for extensibility and robustness.
-
eclectic
Experimental collection traits
-
smallbitset
series of allocation free sets capable of holding small integer values
-
graph-api-benches
Benchmarking utilities and performance tests for the graph-api ecosystem
-
fill
trait, an alternative to Extend for finite containers
-
terms
Tree terms and patterns data structures
-
generic
Higher level serialization of rust values to rust values
-
libhaystack
Haystack 4 data types, defs, filter, units, and encodings
-
either_field
Macro for generating different types off of a template struct
-
xml2arrow
Efficiently convert XML data to Apache Arrow format for high-performance data processing
-
option_vec
Vec<Option<T>>-like container
-
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 -
bit-array
A compile time sized array of bits
-
lmfu
Low Memory Footprint Utilities (String, HashMap, JSON)
-
izihawa-tantivy
Search engine library
-
cons-list
An immutable singly-linked list, as seen in basically every functional language
-
uid
creation of unique IDs
-
enum_from_variant
macro to generate From<T> trait implementations for enum variants, simplifying error conversions and enum mapping
-
simple_tables
An easy to use rust crate for creating table structures. Including macros for easily creating these table structures.
-
r-collections
Created some collection example LinkedList, Stack and Queue
-
trie-generic
A trie with generic content
-
bitwrap
pack/unpack data into byte array
-
bytebufrs
A ring buffer for bytes implementing io::Read and io::Write
-
taganak-orm
ORM (object-relational mapper) for Rust dataypes onto Taganak graphs
-
ring_queue
A double-ended queue implemented using a vector that reuses space after elements are removed
-
cursorvec
Cursored vector container
-
netplan-types
Netplan configuration types as Rust structs and enums
-
get-many-mut
Stable polyfill for slice::get_many_mut
-
healm
**He**ap **al**located **me**rkle tree
-
orx-concurrent-vec
A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations
-
bset
Fast and compact sets of bytes or ASCII characters
-
pathlink
A URL type whose path can also be used as a filesystem path, for Rust
-
stonks
Sets that allow borrowing while inserting entries
-
bit_collection
A trait for iterating over the individual bits of a collection
-
know_yaml
The Know Framework for Rust
-
rb
A thread-safe ring buffer with blocking IO
-
mmap_bytey_byte_buffer
Mmap Bytey MByteBuffer code, use Mmap Bytey instead
-
datastruct
A pure-data structure builder
-
open-payments-iso20022
Open Payments - Message Parsing Library - ISO20022
-
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.
-
wrapping
slices and arrays
-
dynvec
DynVectype that acts like a vector to store any datatype -
as-is
An abstraction over ownership
-
atlist-rs
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…
-
bagofholding
collection types. Efficient data structures that look bigger on the inside.
-
persistent-list
A singly-linked persistent thread safe list
-
vortex-expr
Vortex Expressions
-
graff
manipulating graphs
-
timed_set
timed set in Rust to store elements for a given time period
-
fixed-slice-vec
FixedSliceVecis a dynamic length Vec with runtime-determined maximum capacity backed by a slice -
querable
Quer(y)able data structure implementation
-
simple_trie
array backed trie
-
fixed_free_list
A fixed-size free-list with optional key lifetime safety and macroless unique typing
-
out-reference
out references
-
compacts
compact data structures
-
im-rope
Unicode strings backed by RRB vectors
-
bitsets
BitSet implementations: Dense, Compressed, Memory-Mapped, and Roaring
-
to-display
A trait that is Display or can be converted to Display
-
byte_trie
A compressed trie based on bytes with some weird child node bucket sizes
-
iregex-automata
Finite automata definitions for the
iregexcrate -
opt_arrayvec
Vector-like container with fixed capacity, using options instead of stored length
-
lesbar-macros
Procedural macros for string types that encode legible text
-
fp-collections
An alternate collections library for rust
-
ax_banyan_utils
work with banyan trees
-
stac-validate
Validate STAC objects with jsonschema
-
doubly
linked lists in rust
-
baffa
Generic buffer for bytes
-
jinpyok_input
My comfortable user input methods
-
known-values
Blockchain Commons Known Values
-
grafite
Range Filter
-
awint_macros
Accompanying procedural macros to
awint -
ranno
Annotations over recursive data structures
-
line-index
Maps flat
TextSizeoffsets to/from(line, column)representation -
succinct_vec
A Vec-like datastructure with less memory overhead
-
slice-deque
A double-ended queue that Deref's into a slice
-
simple-stack
linked list-based implementation of the Stack data type
-
causal-length
CRDT's based on causal length sets
-
functional_list
A functional, immutable list for Rust
-
tuco-core
Contains the Tuco trait, used by the Tuco crate
-
text-document
Text document structure and management
-
iunorm
Map normalized floating-point numbers to/from (un)signed integers
-
collectables
collections helpers for BTreeMap, BTreeSet, HashMapSet, etc. By SixArm.com.
-
passive
A trio of marker traits to classify passive data structures
-
louds
LOUDS implementation for Rust
-
nth-cons-list
The nth cons list implementation
-
prio-queue
priority queue implemented as a heap stored in a Vec
-
btree_dag
A generic DAG (undirected graph) data structure
-
generic-json
Generic JSON traits
-
evoxel
processing 3D point clouds
-
ringvec
ring buffer implementation based on a vector
-
vortex-buffer
A byte buffer implementation for Vortex
-
stacked_type_map
Compile time map of any type
-
vec-x
structure
VecXto manage fixed-length arrays, supporting numeric operations and assignment operations betweenVecXand scalar values -
pi_world
ecs world
-
eimage
processing image collections in 3D space
-
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
-
bitarray-set
A set of bits backed by bit-array
-
vortex-schema
Vortex file schema abstraction
-
littlechestnutgames-trie
A generalized trie implementation for quick prefix searching
-
do_util
Discrete Optimization utilitary library (data-structures)
-
serde-ndim
Serde support for n-dimensional arrays from self-describing formats
-
hyper-tree-router
Routing middleware for Hyper http library using Prefix tree (trie) for path finding
-
anymap3
A safe and convenient store for one value of each type
-
insert_many
optimization for vec-like structures
-
schema_generator
part of the ClimateForest project, which takes place between 01.03.2024–28.02.2027. It is funded by Interreg Aurora and supported by its contributors, including Metsäkeskus, Lapland University of Applied Sciences…
-
suffix_trie
Suffix trie for searching
-
leetcode-trees-rs
Tree Node LeetCode problems
-
drop_guard
enables you to implement the Drop trait on any type. So you can run a closure on any value running out of scope
-
structural
Field accessor traits,and emulation of structural types
-
compress-json-rs
Store JSON data in a space-efficient compressed form, with round-trip compression/decompression