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