-
num-bigint
Big integer implementation for Rust
-
smallvec
'Small vector' optimization: store up to a small number of items on the stack
-
base64ct
Pure Rust implementation of Base64 (RFC 4648) which avoids any usages of data-dependent branches/LUTs and thereby provides portable "best effort" constant-time operation and embedded-friendly no_std support
-
der
Pure Rust embedded-friendly implementation of the Distinguished Encoding Rules (DER) for Abstract Syntax Notation One (ASN.1) as described in ITU X.690 with full support for heapless
no_std/no_alloctargets -
compact_str
A memory efficient string type that transparently stores strings on the stack, when possible
-
brotli
compressor and decompressor that with an interface avoiding the rust stdlib. This makes it suitable for embedded devices and kernels. It is designed with a pluggable allocator so that…
-
priority-queue
A Priority Queue implemented as a heap with a function to efficiently change the priority of an item
-
crypto-bigint
Pure Rust implementation of a big integer library which has been designed from the ground-up for use in cryptographic applications. Provides constant-time, no_std-friendly implementations…
-
num-format
producing string-representations of numbers, formatted according to international standards
-
tinyvec
tinyvecprovides 100% safe vec-like data structures -
rmpv
Decoding/Encoding MessagePack values without schema
-
errno
Cross-platform interface to the
errnovariable -
async-task
Task abstraction for building executors
-
mimalloc
Performance and security oriented drop-in allocator
-
heapless
staticfriendly data structures that don’t require dynamic memory allocation -
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
stacker
A stack growth library useful when implementing deeply recursive algorithms that may accidentally blow the stack
-
smol_str
small-string optimized string type with O(1) clone
-
ecow
Compact, clone-on-write vector and string
-
smoltcp
A TCP/IP stack designed for bare-metal, real-time systems without a heap
-
embassy-executor
async/await executor designed for embedded usage
-
ringbuffer
A fixed-size circular buffer
-
dhat
heap profiling and ad hoc profiling with DHAT
-
smartstring
Compact inlined strings
-
numtoa
Convert numbers into stack-allocated byte arrays
-
gpu-allocator
Memory allocator for GPU memory in Vulkan and DirectX 12
-
dary_heap
A d-ary heap
-
cordyceps
Mycelium intrusive data structures
-
jemalloc_pprof
Convert jemalloc heap profiles to pprof to understand memory usage, fix memory leaks, and fix OOM Kills
-
embedded-alloc
A heap allocator for embedded systems
-
parse-size
Parse byte size into integer accurately
-
redis-protocol
RESP2 and RESP3 protocols
-
rsruckig
Ruckig motion planning library for Rust
-
cardinality-estimator
estimating the cardinality of distinct elements in a stream or dataset
-
get-size2
Determine the size in bytes an object occupies inside RAM
-
boa_interner
String interner for the Boa JavaScript engine
-
smallbox
Small Boxoptimization: store small item on stack and fallback to heap for large item -
orx-priority-queue
Priority queue traits and high performance d-ary heap implementations
-
audio
working with audio in Rust
-
arcshift
Replacement for std::sync::Arc<T> that supports updating the value, with some caveats
-
alloc-no-stdlib
dynamic allocator that may be used with or without the stdlib. This allows a package with nostd to allocate memory dynamically and be used either with a custom allocator, items on the stack…
-
linked_list_allocator
allocator usable for no_std systems. It builds a linked list from the freed blocks and thus needs no additional data structures.
-
talc
A fast and flexible allocator for no_std and WebAssembly
-
reblessive
A small runtime for running deeply nested recursive functions
-
ijson
A more memory efficient replacement for serde_json::Value
-
smallbitvec
A bit vector optimized for size and inline storage
-
buddy_system_allocator
A bare metal allocator that uses buddy system
-
tiny-fn
Type erased closures on stack
-
libmimalloc-sys
Sys crate wrapping the mimalloc allocator
-
kstring
Key String: optimized for map keys
-
managed
An interface for logically owning objects, whether or not heap allocation is available
-
binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps
-
tendril
Compact buffer/string type for zero-copy parsing
-
small-map
An inline SIMD accelerated hashmap designed for small amount of data
-
cheetah-string
A lightweight, high-performance string manipulation library optimized for speed-sensitive applications
-
memuse
Traits for measuring dynamic memory usage of types
-
hprof-slurp
JVM heap dump hprof file analyzer
-
mimalloc-safe
Performance and security oriented drop-in allocator
-
classic-mceliece-rust
Pure rust implementation of the PQC scheme Classic McEliece
-
purl
A Package URL implementation with customizable package types
-
process_vm_io
I/O access to virtual memory contents of processes
-
inlinable_string
inlinable_stringcrate provides theInlinableStringtype – an owned, grow-able UTF-8 string that stores small strings inline and avoids heap-allocation – and theStringExttrait… -
pprof_util
various utilities for representing and manipulating profiling data
-
gpu-alloc
agnostic memory allocator for Vulkan like APIs
-
lean_string
Compact, clone-on-write string
-
byteview
Thin, immutable zero-copy slice type
-
mago-atom
A string interning library that stores and reuses identical strings efficiently, improving memory use in large codebases or tools
-
lstsq
Return the least-squares solution to a linear matrix equation
-
smallring
High-performance ring buffer with automatic stack/heap optimization | 高性能环形缓冲区，支持栈/堆自动优化
-
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
-
srt-transmit
SRT implementation in Rust
-
exn
A context-aware concrete Error type built on
core::error::Error -
compendium
A user-friendly strace for x86 Linux with HTML reports
-
auditable-extract
Extract the dependency trees embedded in binaries by
cargo auditable -
ascii-dag
Zero-dependency, no_std compatible ASCII DAG renderer. Visualize error chains, dependency trees, and graphs in the terminal.
-
osdemo
An example of combining various libraries for aarch64 OS development
-
ndata
Thread-safe, self-owned JSON-like data with manual garbage collection
-
bitwheel
High-performance fixed capacity timer wheel
-
ws2812-esp32-rmt-driver
WS2812 driver using ESP32 RMT
-
async-fuse
Helpers for fusing asynchronous computations
-
smol_bitmap
A space-efficient bitmap with inline storage optimization for small bitmaps
-
istring
A replacement for String that allows storing short strings of length up to sizeof<String>() - 1 without a heap allocation
-
alloc_cat
allocator for small-to-tiny Wasm projects in rust
-
cueue
High performance SPSC circular byte buffer with batch operations
-
nuttx-arm64-emulator
Emulate Apache NuttX RTOS for Arm64 with Unicorn Emulator (Avaota-A1 SBC)
-
css-module-lexer
Lexes CSS modules returning their dependencies metadata
-
dotscope
A high-performance, cross-platform framework for analyzing and reverse engineering .NET PE executables
-
tinyset
Size-optimized sets
-
hpm-riscv-rt
Runtime support for HPMicro RISC-V MCUs
-
splay_tree
Splay Tree based Data Structures (map, set, heap)
-
mzprof
A dataflow profiler for Materialize
-
ordinal
Format numbers as ordinals efficiently
-
lamina
High-performance compiler backend for Lamina Intermediate Representation
-
elf2tab
Compiles from ELF to TAB (a Tock Application Bundle using the Tock Binary Format)
-
weighted_path
finding shortest paths in weighted graphs using Dijkstra's algorithm with multiple heap implementations
-
profile-inspect
Analyze V8 CPU and heap profiles from Node.js/Chrome DevTools
-
qoi
VERY fast encoder/decoder for QOI (Quite Okay Image) format
-
pe-unwind-info
Parsers for PE unwind info
-
picojson
A resource-constrained JSON parser for embedded systems
-
noise-protocol
Noise Protocol Framework implementation
-
zombie-rs
Zombie - automatic memory management through lazy eviction and recomputation
-
feldera-size-of
measuring the total memory usage of an object
-
buddy-slab-allocator
Memory allocator with Buddy and Slab allocation
-
refbox
A Box with weak references
-
secure-gate
Zero-cost secure wrappers for secrets — heap for dynamic, stack for fixed
-
small_hash_map
A hash map optimized for small collections with automatic stack-to-heap transition
-
bbx_core
Foundational utilities for audio DSP: lock-free SPSC, denormal handling, stack-allocated collections
-
yangon
A high-performance, stack-allocated string type for Rust with fixed capacity and zero heap allocations
-
wordvec
A compact
SmallVec<T>-like container with onlyalign_of::<T>()overhead for small stack-only instances -
starlark
language in Rust
-
dtmf_table
A zero-heap, no_std, const-first DTMF keypad frequency table with runtime tolerance helpers. Also available in Python
-
merkletree
Light merkle tree implementation with SPV support and dependency agnostic
-
avila-atom
Atomic computational structures - Option, Result, Vec, HashMap built from nucleus
-
dynify
Add dyn compatible variant to your async trait
-
padder
A highly efficient Rust crate for padding data during runtime
-
hypnus
Memory Obfuscation in Rust
-
hvec
A Vec-like structure that can store different types of different sizes contiguous with each other in memory
-
ranged_bitmap
A high-performance bitmap library
-
stack-string
A wrapper around SmartString which adds support for various extensions
-
trame
Formally verified partial value construction for facet
-
clasp-embedded
CLASP embedded/no_std implementation - uses standard v3 protocol
-
nexus-collections
SLUB allocator backed intrusive collections for low-latency systems
-
craturn
interpretation of the 'Saturn Devouring His Son' painting
-
mimalloc-rspack
Performance and security oriented drop-in allocator
-
syslog_fmt
A formatter for the 5425 syslog protocol
-
events_once
Efficient oneshot events (channels) with support for single-threaded events, object embedding, event pools and event lakes
-
slotbus
Lock-free shared memory IPC with slotted request/response. Sub-microsecond wake latency, zero-copy payloads, 32 concurrent in-flight requests per worker.
-
dyn_size_of
report approximate amount of memory consumed by variables, including the memory allocated on heap
-
fastvec
A high-performance vector crate tuned for small data sizes
-
smox
Box that stores small objects inline and bigger objects on the heap using Box, Rc or Arc, with CoW semantic
-
d-ary-heap
Generic d-ary heap priority queue supporting min/max via comparator, with O(1) item lookup for updates. Features configurable arity, efficient priority updates, and cross-language API compatibility
-
tinybuf
Container for many types of immutable bytes, with optimisations for small arrays
-
aahc
Asynchronous, zero-allocation HTTP client that is agnostic to choice of executor
-
dma-heap
Linux DMA-Buf Heap Abstraction Library
-
dinfo
A CLI tool to analyze disk usage: shows total size, top files, and top folders
-
array-deque
Fixed-capacity circular buffer implementations: heap-allocated ArrayDeque and stack-allocated StackArrayDeque. Efficient O(1) operations, no_std support.
-
starry-smoltcp
A TCP/IP stack designed for bare-metal, real-time systems without a heap
-
ordered-channel
A channel that always receives messages in the correct order, even if they were sent out of order
-
spaa
Tools for converting profiling data to SPAA format
-
whitehole
fast, intuitive parser combinator framework for Rust
-
stack_collections
Stack-allocated collections for Rust
-
min-max-heap
An efficient, double-ended priority queue
-
lexerus
annotated lexer
-
radix-heap
Fast monotone priority queues
-
ushell_input
Core of the shell framework
-
laminar-core
Core streaming engine for LaminarDB - reactor, operators, and state management
-
lzokay
A minimal, MIT-licensed implementation of the LZO compression format
-
out
fast min and max functionality for collections
-
x-smoltcp
A TCP/IP stack designed for bare-metal, real-time systems without a heap
-
esp-alloc
A heap allocator for Espressif devices
-
fibonacci_heap
A high-performance Fibonacci Heap implementation in Rust with generic type support
-
ufotofu_queues
Infallible queues that support bulk enqueueing and dequeueing
-
moos
Memory-Optimized Objects and Strings (MOOS)
-
movingai
Benchmark Map/Scen File Parser
-
spacecurve
Space-filling curves library and visualization tools
-
perfetto_protos
Generates Rust bindings to Protocol Buffers defined by Perfetto
-
zstd-nostd
Pure Rust no_std Zstandard (zstd) compression and decompression
-
binfarce
Extremely minimal parser for ELF, Mach-O, PE and ar
-
d3d12-descriptor-heap
Descriptor heap allocator for Direct3D 12
-
boxarray
Safe way to allocate and initialize nested arrays directly on the heap in Rust
-
movable-ref
building movable self-referential types
-
combo_vec
A blazingly fast no-std vector-like ADT using the stack (and optionally heap for overflow)
-
tg-kernel-alloc
Kernel memory allocator for rCore tutorial OS using buddy allocation
-
trigivs
solving tridiagonal systems of linear equations using Givens rotations
-
ds-ext
Extensions to standard Rust data structures which provide additional capabilities
-
memtrace
A CLI tool for generation heap consumption flamegraphs
-
resource-bound
Compile-time enforcement of struct size limits and heap allocation constraints
-
datasize
A simplified heap memory size estimator
-
bounded-str
Parse, don't validate! No-std bounded string with compile-time length limits and policies
-
fixed-capacity-vec
Variable-length buffer backed by a fixed-size heap array
-
tensor_optim
A tiny tensor engine lacking compromise on portability
-
mac-addr
Lightweight, no_std compatible MAC address library
-
cfixed-string
Pass Rust strings to C with potentially not needing heap allocation
-
pprof_hyper_server
A minimal pprof server implementation using hyper without runtime dependency
-
task-heap
stack tasks and pop them randomly
-
permutohedron
Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap's algorithm.
-
generic_cache
Easy to use object caching based on defined TTL
-
dbutils
Utils for developing databases
-
mightrix
treat continous memory as a matrix
-
heapix
providing heap data structures
-
stackaroo
Swap out of the OS-provided stack
-
miniloop
The simpliest async executor without heap memory allocation
-
bpa_rs
Ball Pivot Algorithm (BPA) for 3D point cloud data
-
cranelift-bitset
Various bitset stuff for use inside Cranelift
-
clrmeta
ECMA-335 CLI/.NET metadata parsing library with read/write support
-
hunpak
PAK files of the game engine Heaps
-
oxidescan
A fast, human-friendly Rust code health checker that runs in seconds and tells you what’s risky, what’s slow, and what’s messy—so you can ship with confidence
-
ferroc
A fast & lock-free memory allocator library
-
json_size
calculate the size of a JSON object
-
sh8601-rs
driver for the SH8601 display controller
-
j1939-core
Core crate for j1939-rs
-
iso17442-types
ISO 17442 Types
-
dtmf_tones
A zero-heap, no_std, const-first DTMF keypad frequency table with runtime tolerance helpers
-
flat_rbtree
A flat, index-based Red-Black Tree with no heap allocations. Ideal for performance-critical or memory-constrained environments.
-
gc-lite
partitioned garbage collector
-
clear_on_drop
Helpers for clearing sensitive data on the stack and heap
-
german-str
small-string optimized string type with fast comparisons
-
heap-array
variable length array, with its main benefit over
Vecis taking up less space -
singlevec
Vec-like container optimized for storing only a single item
-
nexus-slot
High-performance SPSC conflation slot for latest-value-wins scenarios
-
rostl-datastructures
Oblivious data structures for secure and efficient computation
-
whitespacers
A whitespace JIT-compiler, for when your whitespace just isn't executing fast enough
-
ach-ring
Atomic Channel
-
little_weirdo
#no-std optimized wave table synthesizer for embedded devices
-
fixed_heap
A fixed-size heap structure with manually provided stateful comparison function
-
hashheap
data structures that combine a hashmap and a min/max priority heap, with main operations requiring O(1) or O(log n) time
-
noalloc-vec-rs
A no-allocation vector implementation for environment without memory allocation
-
qrcodegen-no-heap
High-quality QR Code generator library
-
ppproto
Point-to-Point Protocol (PPP) for embedded systems.
no-stdcompatible, no alloc (heap) required. -
buddy-alloc
memory allocator for no-std Rust, used for embedded environments
-
fray
A type-safe and ergonomic Rust library for working with bitfields
-
accepts
Minimal traits and blanket impls for sync/async acceptors (pipeline foundation)
-
cap_vec
A heap-allocated, fixed-capacity, variable-size array, no_std compatible
-
kaff_sso
Small-buffer-optimized generic buffer and UTF-8 string type
-
edgefirst-tensor
Zero-copy tensor memory management with DMA, shared memory, and heap backends
-
good_memory_allocator
A blazingly fast and memory efficient memory allocator to be used in
no_stdenvironments -
heap1
The simplest possible heap
-
stylo_malloc_size_of
An allocator-agnostic crate for measuring the heap size of a value
-
mheap
Flexible binary heaps
-
emballoc
but reliable memory allocator for embedded Rust and #![no_std]
-
unsized-vec
Like Vec, but for unsized values
-
caliber-pg
PostgreSQL 18+ extension for the CALIBER memory framework
-
esp-hal-wifimanager
Wifi Manager for esp-hal (bt+wifi ap)
-
redis_rocksdb
rust implement structure kv(key/value) embedded database, storage by rocksdb
-
box_closure
closure wrappers with no dependencies
-
arraystring
Fixed capacity stack based generic string
-
better_mimalloc_sys
Sys crate wrapping mimalloc (dev-branch fork for better_mimalloc_rs)
-
memusage
Small trait utility to keep track of the memory usage of structs
-
binvec
binary vector type developed in Rust to use memory efficiently. It is characterized by using the minimum memory space to store an array of bool values.
-
beap
Bi-parental heap data structure implementation in Rust
-
malloc_size_of
A an allocator-agnostic crate for measuring the heap size of a value
-
stackmap
A fast stack-only hashmap for small high-performance scenarios
-
ittybitty
An itty bitty bitset to hold your itty bitty bits
-
const-init
trait for things that are const initializable
-
arch-token-metadata-cli
CLI for interacting with Arch Token Metadata program
-
srt-c
API compatabile libsrt reimplementation using srt-tokio
-
ps-buffer
aligned heap buffer
-
re_byte_size
Calculate the heap-allocated size of values at runtime
-
rp-usb-console
Zero-heap USB CDC logging and command channel for RP2040 with Embassy async framework
-
untyped-box
A heap allocation utility when the datatype is unknown
-
osdk-heap-allocator
The default slab-based heap allocator shipped with OSDK
-
trallocator
A no_std lbrary for wrapping an existing allocator and tracking the heap usage
-
ringo-buff
Ring buffers for bytes, with heap and stack storage
-
recycle-box
A pointer type for heap-allocated objects which heap storage can be re-used, with Pin support
-
rsprof-trace
Self-instrumentation library for rsprof - captures CPU and heap traces
-
deepsize
measuring the total size of object on the stack and heap
-
memtrace-ui
A GUI tool for profiling heap memory consumption
-
default-boxed
Helper trait to help create large struct on heap directly
-
aligned_box
Allocate heap memory with user-specified alignment
-
timing-wheel
A binary-heap based timing wheel implementation
-
lazy-heap
A lazy heap allocator for Rust based on
slab_allocator_rs -
heapsz
calculating the heap usage of a data structure
-
stashmap
Zero-heap non-cryptographic hash map
-
magic-orb
thread-safe, overwrite, heap-stored, fix-sized, locking Ring buffer
-
stack-cstr
High-performance stack-to-heap C string creation for Rust with FFI support
-
pi_ext_heap
Extending the heap supports deleting and modifying the elements at the specified location. When the elements in the heap move, the callback function will be called
-
crater
Very generic containers including KD trees, fibonacci heaps, minmax heaps,
-
permute
Generate permutations of vectors and slices in a memory-efficient and deterministic manner, using Heap's algorithm
-
reap
parsing Ruby heap dumps
-
cell-gc
A fun garbage collector for that virtual machine you're writing in Rust
-
jvm-hprof
A parser for JVM hprof heap dumps
-
malloc-array
libc heap array allocator
-
mips-mcu-alloc
A heap allocator for MIPS based microcontrollers
-
priq
Array implementation of the min/max heap
-
medianheap
A median heap for keeping track of a running median
-
heapify
Convenience functions to turn slices into max-heaps
-
dotreds-binary-heap-plus
Enhanced version of std::collections::BinaryHeap that supports max, min, and custom-order heaps. Makes some previously internal function public
-
heapo
Very simple heap implementations in Rust
-
mut-binary-heap
Enhanced version of std::collections::BinaryHeap that supports increase and decrease key, max, min, and custom-order heaps
-
heapz
Heap/Priority Queue implementations
-
median-heap
A median heap implementation in Rust, used to keep track of a running median of a sequence of numbers
Try searching with DuckDuckGo or on crates.io.