-
bumpalo
A fast bump allocation arena for Rust
-
arc-swap
Atomically swappable Arc
-
slab
Pre-allocated storage for a uniform data type
-
memmap2
Cross-platform Rust API for memory-mapped file IO
-
tikv-jemallocator
allocator backed by jemalloc
-
sharded-slab
A lock-free concurrent slab
-
wasmtime
High-level API to expose the Wasmtime runtime
-
mimalloc
Performance and security oriented drop-in allocator
-
heapless
staticfriendly data structures that don’t require dynamic memory allocation -
yoke
Abstraction allowing borrowed data to be carried along with the backing data it borrows from
-
capnp
runtime library for Cap'n Proto data encoding
-
allocator-api2
Mirror of Rust's allocator API
-
region
Cross-platform virtual memory API
-
jemallocator
allocator backed by jemalloc
-
vm-memory
Safe abstractions for accessing the VM physical memory
-
static_cell
Statically allocated, initialized at runtime cell
-
id-arena
id-based arena
-
typed-arena
The arena, a fast but limited type of allocator
-
snmalloc-rs
rust bindings of snmalloc
-
dyn-stack
Dynamic stack wrapper for unsized allocations
-
bump-scope
A fast bump allocator that supports allocation scopes / checkpoints. Aka an arena for values of arbitrary types.
-
stable_deref_trait
An unsafe marker trait for types like Box and Rc that dereference to a stable address even when moved, and hence can be used with libraries such as owning_ref and rental
-
dlmalloc
port of the dlmalloc allocator
-
stats_alloc
An allocator wrapper that allows for instrumenting global allocators
-
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…
-
flexstr
A flexible, simple to use, clone-efficient string type for Rust
-
arcshift
Replacement for std::sync::Arc<T> that supports updating the value, with some caveats
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
stacksafe
Prevent stack overflow in deeply recursive functions with automatic stack management
-
gbm
libgbm bindings for rust
-
checkers
A sanity checker for global allocations
-
rb-sys
Rust bindings for the CRuby API
-
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
-
la-arena
index-based arena without deletion
-
reblessive
A small runtime for running deeply nested recursive functions
-
gc
Tracing garbage collector plugin for Rust
-
wdk-alloc
alloc support for binaries compiled with the Windows Development Kit (WDK)
-
blink-alloc
Fast, concurrent, arena-based allocator with drop support
-
weak-table
Weak hash maps and sets
-
mmap-rs
A cross-platform and safe Rust API to create and manage memory mappings in the virtual address space of the calling process
-
tikv-jemalloc-sys
Rust FFI bindings to jemalloc
-
memflow
core components of the memflow physical memory introspection framework
-
vm-allocator
Helpers for allocating resources needed during the lifetime of a VM
-
dumpster
A concurrent cycle-tracking garbage collector
-
r-efi-alloc
UEFI Memory Allocator Integration
-
shared_vector
Reference counted vector data structure
-
memuse
Traits for measuring dynamic memory usage of types
-
mimalloc-safe
Performance and security oriented drop-in allocator
-
calendrical_calculations
Calendrical calculations in Rust
-
process_vm_io
I/O access to virtual memory contents of processes
-
hipstr
string for Rust: zero-cost borrow and slicing, inline representation for small strings, (atomic) reference counting
-
peak_alloc
An allocator to keep track of (the max) allocated memory
-
object-pool
A thread-safe object pool with automatic return and attach/detach semantics
-
pprof_util
various utilities for representing and manipulating profiling data
-
token-cell
A more convenient GhostCell
-
smmalloc
smalloc is a very simple but performant allocator
-
opool
High-performance, lock-free local and concurrent object pool with automated allocation, cleanup, and verification
-
mbox
malloc-based box. Supports wrapping pointers or null-terminated strings returned from malloc as a Rust type, which will be free'd on drop
-
bufsize
bytes::BufMut implementation to count buffer size
-
mini-alloc
Very simple global allocator
-
infinity_pool
Offers object pooling capabilities both thread-safe and single threaded, both lifetime-managed and manual, both typed and untyped
-
thunderdome
Fast arena allocator with compact generational indices
-
typed-generational-arena
A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices. Now with typed indices and custom integer types for generations!
-
poolshark
Thread safe object pool
-
dynamo-memory
Memory management library for Dynamo
-
patina_paging
Paging library for AArch64 & X64 architectures
-
range-alloc
Generic range allocator
-
include_bytes_aligned
macro that embeds the bytes of an external file into the executable and guarantees that they are aligned
-
ghost-cell
Compile-time zero-cost borrow-checking of aliased references
-
rustc-std-workspace-alloc
integration of crates.io crates into rust-lang/rust standard library workspace
-
slabigator
A fixed-capacity linked list with stable element addressing and no dynamic allocations
-
rctree
A 'DOM-like' tree implemented using reference counting
-
inplace_it
Place small arrays on the stack with a low-cost!
-
ndata
Thread-safe, self-owned JSON-like data with manual garbage collection
-
tor-memquota
Memory use tracking and quota utilities, used by Tor software
-
sendable
Substitutes for Rc and Option that facilitate sending data between threads
-
alloc_cat
allocator for small-to-tiny Wasm projects in rust
-
rudo-gc
A garbage-collected smart pointer with automatic cycle detection using BiBOP memory layout and Mark-Sweep collection
-
shared-buffer-rs
combines Arc and RefCell for Send and Sync
-
jrsonnet-gcmodule
Cyclic garbage collection inspired by CPython's gc implementation
-
memur
Arena storage with bells and whistles
-
css-module-lexer
Lexes CSS modules returning their dependencies metadata
-
moving_gc_arena
Lightweight Garbage-collectable regions using indices and explicit roots
-
gpu-alloc
agnostic memory allocator for Vulkan like APIs
-
arena-b
Production-grade bump allocator with lock-free, slab, and virtual-memory tooling for parsers, game engines, and request-scoped services
-
zombie-rs
Zombie - automatic memory management through lazy eviction and recomputation
-
qcell
Statically-checked alternatives to RefCell and RwLock
-
openworkers-v8
Rust bindings to V8 (fork with Locker/UnenteredIsolate support for isolate pooling)
-
memvec
Memory-backed vector, not buffer. Designed for for mmap. Not MemMap, but MemVec!
-
memory_set
Data structures and operations for managing memory mappings
-
rusted-ring
LMAX inspired Lock-free ring buffers with cache-aligned memory pools for high-performance event systems
-
rts-alloc
Shared memory allocator intended for small frequent allocations
-
refbox
A Box with weak references
-
alloc_tracker
Memory allocation tracking utilities for benchmarks and performance analysis
-
small_hash_map
A hash map optimized for small collections with automatic stack-to-heap transition
-
lgalloc
Large object allocator
-
win-wrap
用于Rust的Windows API的高级封装
-
wr_malloc_size_of
Internal utility to measure memory usage in WebRender
-
relib_internal_shared
relib is a framework for reloadable dynamic libraries
-
context-mcp
MCP server for context storage, text-based retrieval, and temporal tracking with optional persistence
-
basedrop
Memory management tools for real-time audio and other latency-critical scenarios
-
metrics-lib
The fastest metrics library for Rust. Lock-free 0.6ns gauges, 18ns counters, timers, rate meters, async timing, adaptive sampling, and system health. Cross-platform with minimal dependencies.
-
memsec
libsodium/utils -
relrc
Reference counted pointers, with relationships to other pointers
-
timely_communication
Communication layer for timely dataflow
-
mmtk
framework for the design and implementation of high-performance and portable memory managers
-
buddy-slab-allocator
Memory allocator with Buddy and Slab allocation
-
sandpit
A concurrent garbage collected arena
-
std-shims
A series of std shims to make alloc more feasible
-
libmimalloc-sys
Sys crate wrapping the mimalloc allocator
-
rt-own
runtime ownership: owner, viewer and holder
-
fastvec
A high-performance vector crate tuned for small data sizes
-
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. -
rabuf
randome access buffer for io
-
shellexec
Cross-platform shellcode executor in rwx memory
-
rustix-dlmalloc
port of the dlmalloc allocator, ported to rustix
-
mem-rs
pattern scanning and abstraction for pointers in memory of running processes
-
aarc
An atomically updatable Arc for lock-free concurrency
-
fixed-bump
A bump allocator that uses fixed-size chunks to ensure non-amortized O(1) allocations
-
generational-box
A box backed by a generational runtime
-
redoubt-buffer
Page-aligned memory buffers with mlock and mprotect support
-
zeropool
High-performance buffer pool with constant-time allocation, thread-safe operations, and 5x speedup over bytes crate
-
alloc-track
Track memory allocations by backtrace or originating thread
-
swc_allocator
A thin wrapper for bumpalo
-
bitmap-allocator
Bit allocator based on segment tree algorithm
-
free-list
A free-list-based page/frame allocator
-
process-image
Zero-cost abstraction for convenient access to process image tags
-
framealloc
Intent-aware, thread-smart memory allocation for Rust game engines
-
dyn_size_of
report approximate amount of memory consumed by variables, including the memory allocated on heap
-
memsafe
A Secure cross-platform Rust library for securely wrapping data in memory
-
drying_paint
observer pattern for Rust
-
stringlet
A fast, cheap, compile-time constructible, Copy-able, kinda primitive inline string type with 4 variants
-
stable_gen_map
Single-threaded generational maps with insert(&self), stable references across growth, and smart-pointer support (Box/Rc/Arc/&T)
-
fastalloc
High-performance memory pooling library with type-safe handles, predictable latency, and zero fragmentation. Perfect for game engines, real-time systems, and high-churn workloads.
-
rpmalloc
Cross-platform global memory allocator using rpmalloc
-
alloc-checked
Collections that don't panic on alloc failures
-
rust-cc
A cycle collector for Rust programs
-
swage
Rowhammer framework
-
safe-allocator-api
A safe wrapper around the
allocator_api’s Allocator trait -
memapi
A no_std-friendly memory allocation interface for raw buffers, with improved error reporting
-
pin-weak
Small wrapper around an equivalent of Pin<Weak<T>>
-
rosu-memory-lib
read osu! memory
-
ruapc-bufpool
A high-performance memory pool using buddy memory allocation algorithm for efficient fixed-size buffer management
-
avila-cli
Ávila CLI Parser - Zero-dependency with config files, env vars, macros, completions, colors, and advanced features
-
mtb-entity-slab
Slab-style entity storage: stable IDs, internal mutability; not a full ECS
-
lite-alloc
A lightweight, single-threaded memory allocator designed for WebAssembly and embedded systems
-
picoalloc
small and fast memory allocator
-
lol_alloc
laughably simple wasm global_allocator
-
data-streams
Extension traits for reading and writing data with streams
-
lightweight-mmap
memory mapping helpers for Rust, with minimal amount of code generated
-
runmat-gc
Generational garbage collector for RunMat with optional pointer compression
-
flagged_pointer
A safe abstraction for tagged pointers using unused bits for flags
-
block-grid
A quick, cache-conscious, tiled 2D array
-
corlib
A various ideas library
-
ox_content_allocator
Arena allocator for Ox Content based on bumpalo
-
temporary-owner-rs
temporary exclusive ownership over the data which can be Send to other thread
-
slabmalloc
slab based malloc implementation in rust. Can be used stand-alone or in order to provide the necessary interface to rusts liballoc library. slabmalloc only relies on libcore.
-
gc-arena
safe, incrementally garbage collected arenas
-
secmem-alloc
Custom allocators for secret memory
-
reference-counted-singleton
Reference-counted singleton whose protected data can be recreated as needed
-
portable-dlmalloc
Portable Fork of Doug Lea's malloc Implementation
-
box_raw_ptr
providing safe wrappers for working with raw pointer. These raw pointers are
*const Tand*mut T. These wrappers ensure memory safety by encapsulating the raw pointers in safe abstractions… -
second-stack
A fast allocator for short-lived slices and large values
-
ufotofu_queues
Infallible queues that support bulk enqueueing and dequeueing
-
alloc_geiger
allocator which makes sound when active, like a Geiger counter
-
frusa
A system allocator with reclaim
-
composable-allocators
Composable memory allocators for new allocator API
-
allocated-btree
B-Tree data structures with explicit allocator control using the allocated pattern
-
boxarray
Safe way to allocate and initialize nested arrays directly on the heap in Rust
-
mozjs
Rust bindings to the Mozilla SpiderMonkey JavaScript engine
-
memory-pool-allocator
A fixed-size, thread-safe memory pool allocator for Rust, supporting custom chunk sizes and efficient allocation/deallocation
-
pin-cell
A pin-safe cell
-
re_memory
Run-time memory tracking and profiling
-
small_range
A compact range type: 50% smaller than Range<T> with zero-cost Option
-
frame_mem_utils
a few stack oriented utileties designed with unsafe in mind
-
secret-utils
Shared utilities for secret handling (wrappers, zeroization, secrecy) used across the PAKEs-Conflux workspace
-
secbits
secure memory handling featuring
-
cap
An allocator that can track and limit memory usage. This crate provides a generic allocator that wraps another allocator, tracking memory usage and enabling limits to be set
-
jemalloc-ctl
A safe wrapper over jemalloc's control and introspection APIs
-
lifeguard
An object pool manager in Rust
-
stalloc
fast first-fit memory allocator that you can use to quickly speed up your Rust programs
-
thin-cell
A compact, single-threaded smart pointer combining reference counting and interior mutability
-
trc
A faster Arc
-
generic_slab
Pre-allocated storage for a uniform data type
-
ruvector-memopt
Intelligent cross-platform memory optimizer with neural learning capabilities for smart optimization decisions
-
jemalloc-sys
Rust FFI bindings to jemalloc
-
mago-atom
A string interning library that stores and reuses identical strings efficiently, improving memory use in large codebases or tools
-
intrusive_splay_tree
An intrusive splay tree implementation that is no-std compatible and free from allocation and moves
-
malloced
A malloc-ed box pointer type
-
mimalloc-rspack
Performance and security oriented drop-in allocator
-
presser
help you copy things into raw buffers without invoking spooky action at a distance (undefined behavior)
-
rust-arc-gc
GCArc implementation for Rust
-
sanitation
developing memory-safe programs while detecting and capturing possibly malicious bytes
-
redoubt-secret
High-level Secret wrapper with automatic zeroization
-
offset-allocator
A port of Sebastian Aaltonen’s
OffsetAllocatorto Rust -
offline
Ways to make things more or less aligned
-
graph-api-simplegraph
efficient graph implementation for the graph-api ecosystem with support for indexing
-
agave-scheduler-bindings
Agave scheduler-binding message types for external pack process integration
-
slop-alloc
TODO
-
giputils
Some useful utilities for rust programming
-
spacetimedb-memory-usage
trait
MemoryUsage -
rspack_allocator
rspack allocator
-
tlsf
Two-Level Segregated Fit (TLSF) allocator with optimized memory footprint
-
refuse
incremental, multi-threaded garbage collector
-
mapped-file
Construct a memory mapping over any file object
-
memsecurity
Securely hold secrets in memory and protect them against cross-protection-boundary readout via microarchitectural, via attacks on physical layout, and via coldboot attacks
-
quarry
mining type information from the Rust standard library
-
vec64
High-performance Rust vector type with automatic 64-byte SIMD alignment
-
generational-buffer
Generational Ring Buffer
-
anathema-store
Various storage types for Anathema
-
memkit
Deterministic, intent-driven memory allocation for systems requiring predictable performance
-
wrc
A thread-safe weighted reference counting smart-pointer for Rust
-
bufio
std::io::Write for your potentially uninitialized slice of memory
-
cap_vec
A heap-allocated, fixed-capacity, variable-size array, no_std compatible
-
cubecl-hip-sys
Rust bindings for AMD ROCm HIP runtime libraries used by CubeCL
-
praborrow-logistics
Zero-copy buffer abstraction. Handles raw byte streams without allocation overhead.
-
ialloc
Allocator interface traits
-
monagement
TLSF Memory Management
-
manually-static
ManualStaticthat is a wrapper which allows to manually manage'staticlifetimes. It is unsafe but withdebug_assertionsit panics when the usage is wrong -
scion-sdk-address-manager
Address manager to allocate and manage SCION endhost addresses
-
ferroc
A fast & lock-free memory allocator library
-
interb
A high-performance, thread-safe string interner backed by a concurrent bump allocator
-
castbox
A Runtime-Typed Reference-Counted Smart Pointer and Concurrent Programming tools
-
dense-slotmap-mem
Fixed-capacity, generation-tracked dense slot map with stable handles and raw memory interface, optimized for the Swamp VM
-
heap1
The simplest possible heap
-
read-process-memory
Read memory from another process
-
emballoc
but reliable memory allocator for embedded Rust and #![no_std]
-
good_memory_allocator
A blazingly fast and memory efficient memory allocator to be used in
no_stdenvironments -
slabbin
An efficient slab allocator with stable addresses
-
arraypp
A
no_stdand noalloclibrary for more efficient array processing -
pulz
A high-performance ECS and scheduling framework for Rust applications
-
roam-shm
Shared-memory transport binding implementation
-
axiom_mem
A stable and high-performance low-level memory management library for Rust, providing fixed-capacity pools and deterministic allocation for latency-sensitive systems
-
stats_alloc_helper
A test helper to measure memory allocations
-
hook_king
Low-level automated hooking library with detours, trampolines, and memory management. Supports internal/external process hooking with optional original code preservation.
-
slice-rc
A variety of reference-counted pointers with better support for slices than std::rc::Rc
-
rocketmq-store
Storage layer for Apache RocketMQ in Rust
-
swamp-layout
Memory layout calculation for Swamp ABI types, handling size, alignment, and efficient representation of data structures
-
fixed_free_list
A fixed-size free-list with optional key lifetime safety and macroless unique typing
-
ocaml-boxroot-sys
Boxroot for OCaml: fast movable GC roots (C API)
-
deferred-cell
A single-assignment, weak reference wrapper for cyclic node graphs with late initialization
-
mappings
Get the mappings of a process (currently only on Linux)
-
range-alloc-arceos
Generic range allocator
-
thread_cell
Safe, Send + Sync access to !Send/!Sync data by isolating it on a dedicated thread and interacting with it through message passing. Perfect for Rc, RefCell, and other single-threaded types.
-
libdd-alloc
Custom memory allocators for specialized allocation patterns in profiling and signal-safe contexts
-
vptr
Thin references to trait objects by embedding the virtual table pointer in the struct
-
prefetch-index
prefetch a slice element
-
superfetch
A lib allowing to utilize the Windows superfetch magic to translate virtual addresses to physical
-
memusage
Small trait utility to keep track of the memory usage of structs
-
egglog-core-relations
egglog is a language that combines the benefits of equality saturation and datalog. It can be used for analysis, optimization, and synthesis of programs. It is the successor to the popular rust library egg.
-
stylo_malloc_size_of
An allocator-agnostic crate for measuring the heap size of a value
-
shush-rs
designed to manage sensitive data securely by leveraging memory protection mechanisms
-
kcr_slo_koordinator_sh
Kubernetes Custom Resource Bindings
-
allocation-counter
Count the number of memory allocation of some code
-
malloc_size_of
A an allocator-agnostic crate for measuring the heap size of a value
-
noop-allocator
An
Allocatorthat does nothing -
byte-pool
Pool of byte slices, for efficient memory usage
-
ephapax-proven
Safe Rust wrappers for formally verified Proven library via pure Zig FFI
-
weakref
Copy+static reference type which checks liveness at runtime
-
pwn_arena
A minimal no_std, no_alloc arena allocator with garbage collection
-
merc_unsafety
Internal MERC toolset package containing various utility functions that use unsafe code blocks
-
cactusref
Cycle-aware reference counting smart pointer
-
smol_strc
smol_str forks, replace Arc with Rc
-
poetic
parse and interpret poetic source code
-
gaia-jit
JIT execution primitives for Gaia project
-
tg-kernel-alloc
Kernel memory allocator for rCore tutorial OS using buddy allocation
-
ralloc
An efficient alternative platform-agnostic allocator
-
mirmalloc
MiMalloc Rust Bindings
-
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
-
o1heap
Rust bindings for o1heap - a constant-time deterministic memory allocator
-
static-rc
Compile-time reference counting
-
accessible
Non-trapping memory readability probes for FFI sanity checks
-
lazy-exclusive
A global type like LazyLock/LazyStatic
-
jrsonnet-interner
Jrsonnet string interning
-
alloc_counter
Count allocations, reallocations, deallocations. Allow, deny, or forbid allocations on an expression or function basis.
-
ws-framer
no-std framer for websockets (with alloc feature)
-
index_arena
id-based, heterogeneous arena allocator
-
arcslab
Slab, but with reference counted items
-
anchored-pool
Bounded and unbounded pools for generic resources or buffers
-
re_byte_size
Calculate the heap-allocated size of values at runtime
-
memapi2
A no_std/no-alloc-friendly memory allocation interface for raw buffers, with improved error reporting
-
ringal
Efficient ring allocator for short-lived buffers
-
bumpalo-herd
Support for bumpalo in scoped threads & rayon
-
jevmalloc
Rust allocator wrapping jemalloc
-
rsmemchk
Rust Memory Leak check library for global_allocator
-
dstify
safe construction of custom dynamically-sized types (DSTs)
-
zelzip_util
only intended for internal usage at the ZELZIP monorepo. Please avoid using it directly.
-
stak-primitive
Stak Scheme primitives
-
splitrc
Thread-Safe Split Reference Counts
-
cubecl-ir
Intermediate representation for CubeCL
-
libcanopy
Canopy is a lightweight tree-based data structure for Rust, optimized for reference management using Rc and Weak pointers
-
alloc-stdlib
A dynamic allocator example that may be used with the stdlib
-
caja
Adds the Caja struct which is basically Box<[T;n]>, but n can be not known at compile-time
-
cargo-fa
Static analysis tool for framealloc - detect memory intent violations before runtime
-
mmap-fixed-fixed
dealing with memory-mapped I/O This is a fork of a fork of the original rust-mmap with updated dependencies and a fix for the Windows version. This exists only because there are no other…
-
dualhashkey
64-bit Dual-Hash-Key, strongly inspired by the Linux kernels dcache hashes
-
stable-arena
rustc's arena, adapted for stable Rust
-
malloc-rust
Malloc implementation using Rust allocator
-
buddy-alloc
memory allocator for no-std Rust, used for embedded environments
-
discard
trait which allows for intentionally leaking memory
-
burncloud-service-monitor
Cross-platform system monitoring tool library for BurnCloud applications
-
haybale-pitchfork
Verifying constant-time code with symbolic execution
-
default-boxed
Helper trait to help create large struct on heap directly
-
ps-alloc
a reasonably safe allocator
-
flipperzero-alloc
Flipper Zero
-
picket
A lightweight, serde-compatible generational arena
-
reservoir-core
Core traits, types, and metrics for reservoir computing (ESN). Supports optional no_std/alloc via feature flags.
-
bump_alloc2
bump allocator using mmap
-
stackmap
A fast stack-only hashmap for small high-performance scenarios
-
reloaded-memory-buffers
Shared, Concurrent, Permanent Memory Allocator tied to Process Lifetime
-
disqualified
type names more user-readable
-
ittybitty
An itty bitty bitset to hold your itty bitty bits
-
swc_malloc
Configures the best memory allocator for each platforms
-
rsprof-trace
Self-instrumentation library for rsprof - captures CPU and heap traces
-
tcmalloc-better
wrapper over Google's TCMalloc memory allocator
-
microchassis
A chassis to increase observability of services and tools
-
orderly-allocator
A super-simple fast soft-realtime allocator for managing an external pool of memory
-
malloc-info
A safe wrapper around glibc's malloc_info
-
toolshed
Arena allocator and a handful of useful data structures
-
tagged_dispatch
Memory efficient trait dispatch using tagged pointers
-
storage_api
Storage API, a better version of Allocator
-
nimix
An allocator designed to be use by a GC
-
scudo
Rust Bindings for the Scudo Hardened Allocator
-
zombie_utils
functions and combinators for zombie-rs (bindN, sequence, zip, traverse, etc.)
-
ra_ap_la-arena
index-based arena without deletion
-
thresher
Execute a callback when a memory threshold is reached
-
bdwgc-alloc
impl GlobalAlloc for bdwgc
-
pawkit-holy-array
A small library implemnenting a freelist
-
ibuf
A memory buffer pool implementation
-
cl-arena
A less robust bump allocator for Conlang
-
cabbage_collector
ready
-
snmalloc-sys
rust raw bindings of snmalloc
-
kernel-alloc
Minimalistic Windows Kernel Allocator
-
azathoth_allocator
Main allocator used for the AzathothC2 platform
-
vec_chunked
A 2D vector-like data structure that allocates memory in chunks
-
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
-
stable-block-arena
Block-allocated arena with stable handles that survive compaction
-
wrapped_mono
wrapped_monois a safe, lightweight wrapper around the mono library. It allows embedding of the mono runtime inside a rust project. Inside this embedded runtime code written in languages supporting the… -
sapp-jsutils
Helper functions for working with js objects in miniquad based apps
-
heapbuf
Fixed size heap buffer with optional custom alignment, ref counting and custom destructor logic
-
hash_cons
A type-safe hash-cons library
-
rdvec
Raw, Dyn Vec
-
rust_beginner
A project whose codes contain i learn rust from https://kaisery.github.io/trpl-zh-cn/ch14-02-publishing-to-crates-io.html
-
bacon_rajan_cc
A reference counted type with cycle collection
-
heapsz
calculating the heap usage of a data structure
-
allocated
Abstractions for working with explicitly allocated data structures
-
bgdrop
that uses a dedicated thread and channel to reduce latency caused by memory deallocation
-
id-alloc
An id allocator implemented by the bitmap
-
rust-profanos
A lib to be able to code in rust into profanOS
-
aligned_box
Allocate heap memory with user-specified alignment
-
data_registry
An unordered data structure with immediate insertion, removal and access
-
talloc
A fast, consistant, and flexible
no_std-compatible allocator -
isoalloc
Security oriented allocator
-
memflow-qemu
qemu connector for the memflow physical memory introspection framework
-
metriki-jemalloc
Metriki integration for jemalloc
-
recycle-box
A pointer type for heap-allocated objects which heap storage can be re-used, with Pin support
-
ra-ap-rustc_arena
Automatically published version of the package
rustc_arenain the rust-lang/rust repository from commit 5113ed28ea1451a13eae3a05dca0dbabfd56f587 The publishing script for this crate lives at:… -
kotoba-memory
Advanced memory management and optimization tools for KotobaDB
-
polished_allocators
A collection of allocators for the Polished project
-
contiguous-arena
Efficient, reusable memory arena for Rust with support for contiguous memory blocks
-
uv-performance-memory-allocator
internal component crate of uv
-
osdk-heap-allocator
The default slab-based heap allocator shipped with OSDK
-
gpu-alloc-vulkanalia
vulkanaliabackend forgpu-alloc -
pyembed
Embed a Python interpreter
-
syncpool
A thread-friendly library for recycle of heavy and heap-based objects to reduce allocation and memory pressure
-
ps-mmap
Easy memory mapping
-
tor-memquota-cost
Low-level memory tracking traits, for use by Arti
-
pair
Safe API for generic self-referential pairs of owner and dependent
-
seekable-async-file
Async pread and pwrite, with optional delayed sync and metrics
-
rulloc
General purpose memory allocator
-
zerogc-context
Handles the context of a zerogc collector
-
memkit-gpu
Backend-agnostic GPU memory management for memkit
-
membarrier
Process-wide memory barrier
-
peakmem-alloc
An allocator wrapper that allows measuring peak memory consumption
-
vec_mem_heap
Fun little object pool allocator
-
sierra-vm
SierraVM
-
rodeo
Fast dropping arena based on bumpalo
-
typed-slab
Typed wrapper for Slab
-
bulk_allocator
Implementations of GlobalAlloc holding memory cache
-
align_constr
Like
alignedbut better. Newtype whose alignment is constrained not only by the inherent alignment requirements of the underlying type but also by the alignment requirements of the “alignment constraint archetype” -
quickdry
Bump-pointer arena allocator
-
owned-pin
A wrapper that both owns and pins data in memory
-
segvec
data structure for rust. Similar to Vec, but allocates memory in chunks of increasing size
-
aligners
alignment guarantees for data
-
osdk-frame-allocator
The default buddy system frame allocator shipped with OSDK
-
cargo-memlense
Static analysis tool for memkit - detect memory issues before runtime
-
vonneumann
executable memory for windows and unix
-
mmledger
A ledger for confidential computing (CC) shims for tracking memory management system calls
-
zeroizing-alloc
Minimal allocator wrapper to zero-on-free data for security
-
slimmer_box
A packed alternative to Box<T> whose 'fat' pointer is 'slimmer'
-
kioku
A memory arena
-
alloc-madvise
A memory allocator for creating large aligned chunks of memory
-
scoped-arena
Arena allocator with optional scopes
-
light-rc-arena
A lightweight arena allocator that can be cloned and shared like Rc
-
range-action-map
A range tree, offering interval operation in kernel memory management, and deliver ACTION to actual VmArea。一个区间树结构，用于提供 mmap / munmap / mprotect 时对内核中区间的操作；
-
contiguous-mem
A contiguous memory storage
-
stack-arena
A fast, stack-like arena allocator for efficient memory management, implemented in Rust
-
stupidalloc
A stupid memory allocator that memory-maps allocations to files
-
mimalloc-redirect
Application-wide allocator redirection to MiMalloc
-
dummy-alloc
Global allocator that fails all allocations
-
dotnetrawfilereader-sys
A low-level interface to a in-process dotnet runtime for Thermo Fisher's RawFileReader library
-
stack_frame_allocators
A set of allocators based off the concept of the stack and creating "Frames". Push frames onto the Stack, push values onto Frames, and pop entire Frames and their items
-
ipfs-sqlite-block-store
block store for ipfs, using sqlite
-
lazy-heap
A lazy heap allocator for Rust based on
slab_allocator_rs -
redoubt-alloc
Allocation-locked Vec that guarantees no reallocation after sealing
-
bookcase_alloc
An arena allocator
-
redoubt-util
Memory utilities for verification and testing
-
allocator_api
copy of the unstable allocator_api (https://github.com/rust-lang/rust/issues/32838) and of parts of the unstable alloc feature. Usable with stable rust, but requires 1.33
-
hipool
RUST Memory Pool
-
cell-gc
A fun garbage collector for that virtual machine you're writing in Rust
-
hybrid-rc
Thread-safe hybrid reference counting pointers
-
rarena-allocator
Lock-free ARENA allocator which can be used in both memory and on-disk
-
gc_api
Generic abstractions for a multithreaded garbage collector
-
arena-traits
Traits for arenas
-
pb-atomic-linked-list
An atomic insert-only linked list
-
compact_arena
some types to allow indexed arenas with small memory footprint
-
sparse-bitfield
Bitfield that allocates a series of small buffers
-
broxus-util
A collection of utils used at Broxus
-
api_bindium
Framework for api binding crates
-
swamp-vm-layout
Memory layout calculation for Swamp VM types, handling size, alignment, and efficient representation of data structures
-
fortify
convenient way to bundle owned data with a borrowing type
-
phper-alloc
Alloc related items for phper crate
-
fixed-typed-arena
A typed arena that uses fixed-size chunks to ensure non-amortized O(1) allocations
-
flexstr_support
Support crate for 'flexstr' and 'inline_flexstr'
-
flatty-io
Flat message transfer
-
abin
working with binaries and strings. The library tries to avoid heap-allocations / memory-copy whenever possible by automatically choosing a reasonable strategy: stack for small binaries;…
-
spsc-ringbuf-core
Heapless ring buffer
-
jrsonnet-gc
Tracing garbage collector plugin for Rust
-
kstring
Key String: optimized for map keys
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
arena-allocator
Virtual memory based linear allocator
-
flex-alloc
Data structures with extra flexible storage
-
genmap
generational map data structure with no dependencies
-
ferris-gc
Flexible implementation of garbage collector for Rust
-
wasmly
programatically build a web assembly module
-
shrex
Fast & smol hex encoding/decoding
-
index-pool
A pool which manages allocation of unique indices. Acts like a psuedo-memory allocator.
-
rebound
Full runtime reflection for Rust, with lifetime safety
-
blueprint-allocative
Inspect rust object tree and output it as flamegraph
-
rco-cell
Wrapper for Rc<RefCell<Option<T>>> and its weak variant. Includes various utilties for common operations usually performed on such a datastructure.
-
tarc
Transposable, type-erasable, and FFI-safe Arc
-
tracing-prof
Experimental library for profiling tracing spans
-
refpool
Efficient memory pool with reference counting
-
zombie_derive
Derive macros for zombie-rs (ZombieOps)
-
scratchpad
Stack-like memory allocator with double-ended allocation support
-
tram
event bus that can be cloned and shared across threads
-
rsbmalloc
but fast binned allocator for Rust. Single-threaded for no_std, multi-threaded otherwise
-
generational_vector
A vector type using generational indices
-
bump-into
a no_std bump allocator sourcing space from a user-provided slice
-
rustc-arena-modified
rustc-arena ported to stable rust with additional features
-
nstd-sys
Cross platform general purpose C library written in Rust
-
zerogc-simple
Lightweight mark/sweep collector for zerogc
-
safe-gc
A garbage collection library with zero
unsafecode and zero dependencies -
slitter
A C- and Rust-callable slab allocator with a focus on safety
-
maskerad_memory_allocators
custom allocators, for memory fragmentation prevention
-
buffet
Thread-local buffer pool for the
loonacrate -
hugealloc
Hugepage-aware allocator
-
linear_curve_fit
A
no_stdand noalloclibrary for linear curve coefficents calculation -
sodg
Surging Object DiGraph (SODG)
-
handle_rs
a lib for using handle array in rust more easier
-
shredder
Garbage collection as a library for Rust
-
mmap-wrapper
wrapper for the memmap2 crate to cast mmap backed pointers to structs
-
scx_rustland_core
Framework to implement sched_ext schedulers running in user space
-
deallocate-zeroed
An extension trait for allocators to deallocate already-zeroed memory
-
quack
Duck typing traits
-
relib_host
relib is a framework for reloadable dynamic libraries
-
moveref
Types and traits for safe C++ style placement initialization and move semantics
-
dairy
A more compact, user friendly clone-on-write smart pointer
-
alloc-compose
Composable allocator structures for plugging together more powerful allocators
-
pstruct
procedural macro for generating pointer struct implementations with field offset access
-
alloc-profiler
Alloc profiler
-
jit-allocator
An executable code allocator
-
xalloc
Suballocators for external memory (e.g., Vulkan device memory)
-
tikv-jemalloc-ctl
A safe wrapper over jemalloc's control and introspection APIs
-
lock_free_buddy_allocator
Scalable lock-free buddy system allocator
-
mimalloc-rust
the best binding for mimalloc in rust
-
sys_alloc
Low-level system allocator primitives
-
hashmapbool
The new and improved way to use boolean values in your rust code, requiring heap allocation and wasting resources on conversion
-
allocator-suite
Allocator Suite for various allocation types
-
alloca
Mostly safe wrapper for alloca
-
ma_proper
A securely overwriting memory allocator
-
lake
high-octane memory pool with direct access, checkpoints, rollback, and zero-allocation droplets. No GC. No overhead. Just you and the bytes — total control. Allocate like a cyber-samurai.
-
redox-buffer-pool
A buffer pool library for Redox, featuring a general-purpose 32-bit allocator
-
arena64
A concurrent arena providing mutually exclusive access over indexes
-
runtime-array
that provides an array, that can be allocated in runtime
-
tcmalloc
Drop-in global allocator using tcmalloc
-
yyjson-sys
low-level Rust FFI binding for yyjson, a high-performance JSON parsing library. It provides direct access to yyjson's C API. This crate is intended for building higher-level abstractions…
-
flp-framework
Floorplan, a memory layout specification language, code-generation necessities
-
thinarray
A thin alternative to Box<[T]>
-
mut-rc
Temporarily mutable
Rc<T>that decays intoRc<T> -
crndm
Persistent Programming Library
-
rsgc
Concurrent GC library for Rust
-
kolibrios-syscalls
Running KolibriOS sysfuncs/syscalls from Rust
-
escoba
Useful broom to clean your RAM in Window$
-
tikv-jemalloc-sys2
Rust FFI bindings to jemalloc
-
pool
reusable values
-
nix-bindings-bdwgc-sys
Low-level FFI bindings to the Boehm-Demers-Weiser garbage collector
-
duplicate-function-checker
determine how much of your binary is duplicate functions
-
without-alloc
Replacements for
Box,Rc,Vec, .. withoutalloc -
shared_arena
A thread-safe & efficient memory pool
-
typed-arena-nomut
The arena, a fast but limited type of allocator
-
shmem-ipc
Untrusted IPC with maximum performance and minimum latency on Linux
-
mastring
A string type that tries to minimise memory allocations
-
malloc-array
libc heap array allocator
-
cl-generic-vec
a vector implementation that can be used in
no_stdenvioronments -
craft-eraser
A set of simple type-erased box primitives
-
snap-buf
A copy on write byte buffer for efficient snapshotting
-
dynamic-arena
Dynamically typed arenas, supporting any
Sizedtype -
tcmalloc2
Rust FFI bindings to tcmalloc
-
kroos
Flexible smart pointer for ?Sized types with customizable reference counting
-
lilypads
Fun little object pool allocator
-
rcu-clean
Smart pointers using RCU with Deref support
-
drop_arena
A single-type allocator which permits dropping and reclaiming of individual elements
-
memkit-co
CPU-GPU memory coordination for the memkit ecosystem
-
tracking-allocator
global allocator that provides hooks for tracking allocation events
-
auto-allocator
Zero-configuration automatic memory allocator selection based on runtime hardware analysis and performance research
-
better_mimalloc_rs
A mimalloc wrapper that exposes tuning knobs and tracks the dev branch
-
sensitive
Memory allocator for sensitive information
-
smallest-uint
Gets the smallest unsigned integer type that can represent a given value
-
deepsize
measuring the total size of object on the stack and heap
-
context-allocator
-
mmap-append
Append-only memory-mapped I/O, resizable, with low lock contention
-
forgotten
globally and safely persist a value, implemented with ManuallyDrop
-
drop-bin
Defer running expensive destructors until later
-
gomicollector
mark-sweep garbage collector
-
idcontain
Generational (or tagged) ID-based containers
-
fast-smr
Toward fast, wait-free, portable, and robust memory reclamation
-
tmfalloc
Transactional memory-mapped file allocator
-
rblx-godot
Roblox To Godot Project, allowing you to run Roblox games inside Godot
-
hirpdag_hashconsing
Various hashconsing implementations with a common interface
-
onsen
Memory pool
-
basic_allocator
A very simple global allocator written in pure Rust
-
baby-mimalloc
Mimalloc implemented in Rust (not a binding to the C library) with only basic features
-
gcmodule
Cyclic garbage collection inspired by CPython's gc implementation
-
hcstatic-str
compact storage for short static strings
-
card10-alloc
Dynamic memory allocation for card10 l0dables
-
leak-detect-allocator
Memory leak detector for nightly toolchain
-
init_array
Initialize arrays itemwise
-
vv
A memory-contiguous
Vec<Vec<T>>with resizable inner vecs -
loro-thunderdome
Fork of thunderdome: Fast arena allocator with compact generational indices
-
secrecy
Wrapper types and traits for secret management which help ensure they aren't accidentally copied, logged, or otherwise exposed (as much as possible), and also ensure secrets are securely wiped from memory when dropped
-
sparse-mem
Fixed-capacity, generation-tracked sparse array implementation optimized for the Swamp VM
-
piece
A collection of composable allocators
-
async-alloc-counter
measures max allocations in a future invocation
-
persistence
A resizable, mutable array type implemented on top of mmap, providing persistence for arrays of data in memory
-
polymorph-allocator
memory allocator
-
hugepage-rs
wrapped allocator for linux hugepage
-
reusable-id-pool
A pool for RAII IDs
-
ref_arena
An arena of reference counted objects
-
numanji
Local-affinity first NUMA-aware allocator with optional fallback
-
pipe
Synchronous Read/Write memory pipe
-
ids
several data structures, inspired by Bagwell’s Ideal Hash Trees, with an automatic copy-on-write implementation, analogous that of Clojure, to maximize performance. It is compatible with
no_stdcode… -
rb-allocator
Memorry allocator for Ruby extensions
-
singlyton
Safe, single-threaded global state in Rust
-
josephine
using JavaScript to safely manage the lifetimes of Rust data
-
portal-solutions-id-arena
id-based arena
-
heapnotize
A smart pointer type for memory allocation on the stack
-
arc-atomic-ref
small library that wraps arc-swap in Arc<T> so the atomic reference can be shared widely between many tasks/threads
-
memory_pages
memory_pagesprovides a cross-platform memory management API which allows for acquiring memory pages from the kernel and setting permissions on them -
deepsize2
measuring the total size of object on the stack and heap
-
fixed-size-allocator
A fixed-size allocator
-
wgpu_buffer_allocator
A compact GPU memory allocator abstraction for wgpu
-
alloc-fmt
Formatting utilities safe for use in an allocator
-
heterovec
In-place vector of dynamically sized type
-
customizable-buddy
A new buddy allocator that allows custom buddy finding algorithm
-
box
The package provides a storage for unique static strings
-
mappable-rc
mappable reference counted types
-
dakv_skiplist
skiplist for dakv
-
omniswap
swap values between possibly-overlapping references
-
use-with
resource management utilities inspired by Kotlin's 'use' function and C#'s 'using' block, ensuring proper utilization and disposal of resources in Rust
-
recasting
traits for one-to-one recasting of values in data structures
-
conc
Hazard-pointer-based concurrent memory reclamation
-
alloc_buddy_simple
drop-in replacement allocator for Rust running on bare metal (no_std)
-
hardened_malloc-rs
hardened_malloc rust wrapper
-
brk_alloc
Global allocator and memory utilities for brk
-
noders
NodeJS-like event loop environment for Rust
-
markable_reader
reader which can be marked in a position to be returned to after subsequent reads
-
memory-layout
explicit struct layouts
-
speedy_refs
A collection of simple and fast and useful smart pointers
-
ssobox
A Box-like type that avoids allocations by storing small values in-place
-
bra
Buffered random access to sequential data sources
-
musli-allocator
Allocators for Müsli
-
ordered-pool-allocator
A fast and compact pool allocator with block sorting support
-
shuffling-allocator
A shuffling allocator, randomizing heap object locations; useful for avoiding accidental cache locality during benchmarking, which can obscure performance evaluation
-
heaparray
Flexible support for dynamically-sized types, using heap-allocated array of structs
-
cesium-allocator
Allocator pool for managing sets of allocators
-
disk-dlmalloc
A fork of [dlmalloc-rs] backed by a memory-mapped file, enabling support for datasets exceeding available RAM
-
cable
A cable(pointer) with a hook(header at address) at the end and a sized payload(array)
-
cleo_redux_sdk
Rust SDK for CLEO Redux plugins
-
sharedptr
Rust Sharedptr
-
boxext
Extensions to the
Boxtype -
hwlocality
Idiomatic Rust bindings for the hwloc hardware locality library
-
nalloc
An allocator wrapper that can be turned on and off
-
diskallocator
For really big vectors: allocate on disk
-
mvcc_cell
Software-transactional memory for Rust
-
addr_of_enum
Get address of fields in enum item using stable Rust
-
elise-gc
Raw GC Für Elise
-
win-lookaside
Windows Lookaside Kernel Allocator
-
relib_module
relib is a framework for reloadable dynamic libraries
-
build-array
Build an array dynamically without heap allocations
-
qbdi-sys
QBDI library rust binding (use rust bindgen)
-
seckey
Use
memsecprotected secret memory -
mmapio
Cross-platform Rust API for memory-mapped file IO
-
bronze_gc
The Bronze garbage collector for Rust. This version only includes the API for creating and using GC references; it does not actually collect anything. For experimental purposes only.
-
shared_memory
A user friendly crate that allows you to share memory between processes
-
bulletproof
memory access
-
arrcomp
Python-style list comprehension syntax for contiguous memory Rust arrays
-
gc-sequence
a system for encoding safe points for computations running on gc-arena
-
order-maintenance
Totally-ordered priorities for the order maintainence problem
-
pb-arena
arena allocator for graph based operations
-
alloc-facade
Facade for std-or-alloc imports
-
audio-garbage-collector
Wrapper on top of
basedropthat provides a drop-in GC API that’ll collect reference-counted values on a background thread -
light_arena
A lightweight, placement based memory arena for types which are Sized + Copy. This crate requires nightly.
-
get_mut_drop_weak
A function to safely get a mutable reference to an Arc and dissociate any weak references
-
toy_arena
Extensible generational arena for various uses
-
mos-alloc
allocator for mos architecture
-
reft
Ref and Mut wrappers that implement AsRef and AsMut for any given &T
-
aliasable_deref_trait
Marker trait for types that deref to an address that is aliasable when coerced to a raw pointer
-
alleakator
leaking global allocator
-
moxie-dom
TBA
-
mmap-fixed
dealing with memory-mapped I/O This is a fork of a fork of the original rust-mmap with updated dependencies and a fix for the Windows version. This exists only because there are no other…
-
ashpan
RAII helpers for ash
-
bsr
Tracing garbage collector for Amsel
-
rc-slice2
Reference-counted slices with easy subdivision
-
owned-alloc
help reducing manual memory management errors
-
emheap
Tiny memory manager for embedded system
-
microstack
The simplest and the fastest implementation of a fixed-size stack on stack
-
compact_str
A memory efficient string type that transparently stores strings on the stack, when possible
-
shared_hashmap
A shared hashmap for use between processes, using shared memory
-
cow_arc
CowArc can be useful for decreasing memory allocations by sharing immutable memory
-
dense-heap
code defines a custom allocator called
DHeap(Dense Heap) and a smart pointer calledDBox(Dense Box). TheDHeapis responsible for managing memory allocation, while theDBox… -
cowvert
a flexible data container supporting owned, reference-counted, and copy-on-write semantics. designed for use in interpreters
-
slab_allocator_rs
Slab allocator for no_std systems. Uses multiple slabs with blocks of different sizes and a buddy system allocator for blocks larger than 4096 bytes. Updated to latest nightly rust
-
chunked-buffer
A chunked buffer for memory constrained systems
-
gc_plugin
Garbage collector plugin for rust-gc
-
string-alloc
Allocator-aware no-std-compatible String implementation
-
clock-page-replacement
clock page replacement algorithm implementation
-
rpmalloc-sys
Unsafe FFI bindings to rpmalloc C library
-
hala-pprof-memory
A memory profile data collector for pprof
-
elise
A concurrent GC
-
dst-factory
Macro to implement C's flexible array members in Rust
-
accounting-allocator
A global memory allocator wrapper which counts allocated and deallocated bytes
-
libcre
WIP
-
wasm-nopackage
Basic alloc and dealloc and module setup for lightweight WASM modules
-
zerogc
Zero overhead tracing garbage collection for rust
-
memflow-registry
docker-like registry server for memflow plugins
-
pkey_mprotect
Typed
pkey_mprotectwrapper -
benemalloc
WIP: A fast, general-purpose memory allocator for Rust
-
generic-pool
A pool for recycling allocated objects for later reuse. Uses generic get/put methods so you can store (almost) any type in a single pool instance.
-
ring-alloc
Specialized allocator for short-living objects
-
freezie
small library that disables mutation for the contained type
-
allocdeny
Deny the use of crate
alloc -
malloc_freq
Malloc frequency profiler
-
obj-pool
object arena
-
pi_pointer
Pointer, similar to arc and RC, but will allocate similar objects in a continuous space
-
outsource-heap
Shoving your heap in random places
-
rusty_malloc
A multithreaded yet simple memory allocator written in Rust
-
allocator-api2-tests
Tests for allocators that implement the allocator API
-
dumballoc
A dumb (or smart?) alternative allocation strategy for reusable allocations
-
memguar
that helps to optimize IO of large buffers in near-OOM state or with small amount of RAM
-
redox_uefi_alloc
UEFI allocation support
-
bumpalo_try
Allocates a fallible iterator into a bumpalo
-
jenga
A stack based allocator
-
ferris
Hierarchical timer wheel
-
indexed
Convenient allocator for index-linked data structures
-
columnation
Unsafe columnar containers for native Rust types
-
ration
A shared memory library
-
index_alloc
A toy static allocator wich can serve as a global_allocator
-
netbuf
growable, contiguous buffer object with right assumptions and interface. Tuned for using it for network buffers.
-
cudarc
Safe and minimal CUDA bindings
-
soa
Struct-of-Array vector types
-
chromium
add some stability to your metal!
-
contain
defining/extending lifetimes
-
newlib-alloc
Global allocator for Rust no_std projects on newlib targets
-
alloc-cortex-m
A heap allocator for Cortex-M processors
-
zone-alloc
Containers for zone-based data allocation
-
faux_alloc
A fake 'allocator'
-
only_alloc
An allocator wrapper that disables deallocating memory within it
-
persian-rug
Framework for bringing together disparate objects with inconvenient relationships
-
kamo
assist in the creation of an interpreter or compiler and its associated runtime
-
alloc-from-pool
Single-threaded object pool implementation
-
rseal
Memory sealing operations
-
polymock
A thread-safe arena bytes allocator
-
alloc-metrics
A global allocator that tracks allocation metrics
-
vec_to_array
Moves a heap allocated
Vec<T>to an stack allocated array of typeTand sizeN -
zc
Self-referential zero-copy structure
-
memflow-native
System call based proxy-OS for memflow
-
memory-cache-rs
local in-memory cache for Rust
-
secret_mem
securely managing sensitive data in memory
-
rendy-memory
Rendy's memory manager
-
dy_tlsf
TLSF (Two-level segmented fit) global allocator
-
obstack
A fast, stack-based allocator, usable for any object
-
trident3-base
Foundation runtime library for Trident 3
-
struct-pad
Padding types to enable memory layout optimizations
-
object-alloc
An object allocator trait for Rust
-
mstak-util
Minimal Stak Scheme utilities
-
alloc-safe
Safe memory allocation, no panic!
-
resource-bound-core
Compile-time enforcement of struct size limits and heap allocation constraints
-
lazy-st
Single-threaded lazy evaluation
-
scope_gc
Scope GC
-
dioxus-debug-cell
A clone of the standard library’s
RefCelltype with extra debugging support in non-release builds. Whenever a borrow error happens the current locations of where known borrows were created will be printed out as well. -
lockedbox
A Box-like type that prevents paging its contents to disk
-
mut_guard
Run a function after some data was mutably borrowed
-
ctoption
A compile-time option whose discriminant is elevated to compile time
-
liverking
Primal Man
-
page-walker
A generic page table walker in Rust for operating systems, hypervisors, etc
-
bump-allocator
A high performance `#[global_allocator] implementation using the bump-pointer allocation algorithm
-
guard-trait
Contains fundamental wrappers for pointer types that can safely be shared in memory-sharing completion-based I/O interfaces
-
buddy-system
buddy system allocator for real-time usecases
-
vitallocator
allocator interface to the PS Vita kernel allocator
-
shm_open_anonymous
Anonymous POSIX shared memory objects
-
cev
An expandable data array used to add data to the beginning of the array
-
same-alloc
Reuse an allocated buffer for data with different types
-
core-allocator
help set core affinity
-
gg-alloc
A custom allocator that only returns pointers above 2G
-
ezmem
Very basic library that provides simple functions for external memory hacking on Windows
-
cpr_bfvm
A brainfuck interpreter
-
process_consistency
Hash your executable memory to ensure it stays the same
-
roussillon-memory
Memory utility for the roussillon language
-
vecstorage
Re-use the memory for vectors containing values with different lifetimes
-
str-intern
string interner
-
rapace-core
Core types and traits for rapace RPC
-
micromap
The fastest alternative to HashMap, for maps smaller than 20 keys
-
aommap
Append only lock-free memory map implementation
-
sti
STd Improved
-
interloc
Middleware allocator for keeping track of memory usage
-
mightrix
treat continous memory as a matrix
-
stable-alloc-shim
Stable shims for the Allocator API
-
jevmalloc-sys
Rust allocator wrapping jemalloc
-
tux-owned-alloc
help reducing manual memory management errors
-
libarena
Arena allocated graph implementation
-
binmod-mdk-core
Binmod MDK for Rust
-
mimalloc-rust-sys
mimalloc_rust hand writted sys binding
-
retry_alloc
A global allocator wrapper that will retry failed allocations
-
refuse-pool
A string interner utilizing the Refuse garbage collector
-
run-down
protection in rust
-
heaptrack
Easily track heap usage with this allocator wrapper
-
ve
More compact Vec
-
abs_mm
Abstract Memory Management
-
rcell
A Cell which can hold either an Arc or an Weak smartpointer or be empty
-
jscjs_sys
System crate providing bindings to the Webkit JavsScript engine, JavaScriptCore
-
pinvec
Growable vector-like structure which never moves its contents
-
system_alloc_stats
A wrapper exposing some stats for the System allocator
-
foundations
service foundations library
-
silly-alloc
A collection of very basic allocators
-
daktylos
memory-counting allocator
-
divvy-core
Composable allocators for Rust
-
storages
Storage backends for collections
-
wg-utils
Personal Utility Functions
-
corundum
Persistent Programming Library
-
executable_memory
executable memory for windows and unix
-
token-ref-cell
Interior mutability cell using an external token to synchronize accesses
-
trickster
user-friendly linux memory hacking library
-
memory_addresses
Unified virtual and physical address types for the Hermit ecosystem and beyond
-
gen-vec
Vector indexed with generational indices
-
dbs-address-space
address space manager for virtual machines
-
eko-gc
Scoped garbage collector
-
lunatic-cached-process
Cached process lookups with lunatic
-
dreck
A safe tracing garbage collection library with minimal safety bookkeeping
-
libmimalloc-sys-ms
MiMalloc Rust Bindings
-
buddy-allocator
A buddy allocator implementation supporting alloc-wg
-
duende-mlock
Memory locking for swap-critical daemons (DT-007: Swap Deadlock Prevention)
-
cannon-heap
A heap allocator suitable for Cannon MIPS executables
-
network-collections
Collections suitable for use with networking, particularly when a fixed memory usage is required to prevent out-of-memory crashes. Includes two kinds of least recently used caches, a bounded hash map…
-
better_mimalloc_sys
Sys crate wrapping mimalloc (dev-branch fork for better_mimalloc_rs)
-
get-size-derive2
Derives the GetSize trait
-
rc_arena
An arena which yields reference counted pointers to the underlying objects
-
tinyrand-alloc
Extensions for using tinyrand with alloc
-
page_table_multiarch
Generic page table structures for various hardware architectures
-
movable
A structure whose internal content can be moved out immutably
-
graph-api-lib
Core library for the graph-api ecosystem - a flexible, type-safe API for working with in-memory graphs in Rust
-
arcon_allocator
Allocator for Arcon
-
simple_games
games
-
drop_tracer
memory leak detector
-
poule
A pool of reusable values
-
haphazard
Dynamic memory management for lock-free data structures using hazard pointers
-
mmap-allocator
struct implementing trait std::alloc::GlobalAlloc for unix
-
guest_cell
Storage space for externally-owned private data
-
tesap-std
Reimplementation of Rust's common std containers
-
scoped-gc
Derive plugin for the
scoped-gccrate -
embeddenator-vsa
Vector Symbolic Architecture operations for sparse ternary representations
-
indexed-hash-set
A bidirectional set whose entries can either be accessed via an index or via hashing
-
warlock
Arena allocation optimized collections
-
zeroize_alloc
A zeroizing allocator wrapper
-
mmap-vecdeque
A file-backed memory-mapped VecDeque with deferred commits, atomic and durable persistence
-
mmu
Memory management unit abstractions
-
stwo-std-shims
Std and alloc shims for stwo
-
memapi-mimalloc-sys
FFI bindings to MiMalloc made for memapi
-
nano_arena
A tiny arena allocator that uses atomics
-
redoubt-guard
Process-level memory protection via prctl and mlock
-
alloc_hoard
use Hoard as rust's allocator
-
typesize
fetch an accurate estimate of the total memory usage of a value
-
beton
A tree-backed slab allocator
-
wgpu-conveyor
Buffer belt abstraction for wgpu
-
alloc_buddy_simple2
drop-in replacement allocator for Rust running on bare metal (no_std)
-
intrusive-containers
intrusive data structures
-
ralloc_shim
The binding layer for the rallc memory allocator
-
fpool
Non-leased object-pooling
-
gpu-alloc-ash
ashbackend forgpu-alloc -
pi_world
ecs world
-
leaktracer
allocator to trace memory allocations in Rust programs, by intercepting the allocations
-
alloc-traits
Traits to replace or supplement the alloc module in no_std
-
falloc
fast allocator
-
alloc_system
NO-STD,for Cortex-M based systems,simply retarget alloc_system to malloc/realloc/free
-
byte-arena
no_std, no_alloc arena for allocating byte buffers
-
rslab
A slab allocator for Rust
-
maybe-std
Helper crate for writing rust libraries with an optional dependency on the standard library
-
type-handle
Regular and reference-counted type handles
-
mrc
Zero-copy, zero-allocation MRC-2014 file format reader/writer for Rust
-
vmem
resource management system theorized by Jeff Bonwick and Jonathan Adams in *[Magazines and Vmem: Extending the Slab Allocator to Many CPUs and Arbitrary Resources][1]*. It provides O(1)…
-
slack-gc
A barebones utility for cleaning up old slack file uploads
-
arc-swap-for-cow
Atomically swappable Arc
-
heap-ap
heap access point for anyone in rust, called to c
-
scoped_allocator
A scoped linear allocator
-
staging-tracking-allocator
Tracking allocator to control the amount of memory consumed by the process
-
unkai
set for Rust's memory allocation APIs mainly focus on tracking and conditional analyzing / limiting memory usage
-
magic-buffer
a virtual ring buffer implementation that magically wraps around itself
-
dbs-allocator
a resource allocator for virtual machine manager
-
hft-channel
SPMC broadcast channel for HFT and real-time systems
-
fionn-pool
Tape pooling for reduced allocation overhead
-
memlib
An abstraction layer for interacting with memory
-
weak-alloc
A custom allocator that can be given ownership of data, returning a WeakRef
-
oh-snap
A thread-safe, owned, heap-allocated array which can be split and merged efficiently, i.e., without moves or memory (de-)allocations
-
memory_units
Safe conversions between units of memory
-
wrapper
A trait for types that wrap other types
-
slotmap-map
Slotmap data structure
-
columnation-master
An experimental columnar arena
-
pared
Projected reference counted pointers
-
mmap-safe
A safe wrapper around file-backed memory maps
-
bk_allocator
FreeBSD's kernel space allocator
-
memflow-coredump
win32 coredump connector for the memflow physical memory introspection framework
-
regc
A garbage collector that mixes Reference counting and mark sweeping
-
effective-limits
Estimate effective resource limits for a process e.g. how much RAM is available for use.
-
allocator
-
tralloc
trace allocations and deallocations
-
munin
A visual heap memory profiler
-
unscrupulous
Types that do not care about provenance
-
tinystd
A literate-programming crate for my notes on general data structures and algorithms in Rust
-
inplace-box
A stack-allocated container similar to Box but without heap allocation
-
dudy-malloc
Easy way to configure best memory allocation for each platforms
-
salloc
Safe C-like memory allocator for windows
-
slice-pool2
using a slice as a memory pool
-
haz-alloc-core
A general-purpose allocator written in Rust, without system symbols
-
membuf
A safe-ish wrapper for allocating and reallocating heap buffers
-
abfall
Concurrent tri-color tracing garbage collector for Rust with incremental and concurrent mark-sweep
-
scudo-sys
C/FFI Bindings for the Scudo Hardened Allocator
-
rccell
A convenient wrapper for Rc<RefCell<T>>
-
pseudo_pool
A pool-like collection that automatically returns objects to the pool & blocks when the pool is empty
-
rs-mem
minimal memory helpers (no dependency on std)
-
memory-balloon
Memory filling tool. Allocates a chunk of memory of a specified size and tries to make sure the OS keeps it in main memory, and not the swap.
-
virtual-memory
allocating RWX memory on Unix and Windows
-
trueno-zram-core
SIMD-accelerated LZ4/ZSTD compression for memory pages
-
ghost-gc
A safe garbage collected arena
-
alias-ptr
(Mostly) safe manually-freed shared pointers in Rust
-
derivable-object-pool
A thread-safe derivable object pool collection with automatic reusage of objects
-
planus-translation
Internal translation library for planus
-
wrenlet-sys
Bindings to the
WrenC library -
mockalloc
allow testing code which uses the global allocator
-
jemalloc_pprof
Convert jemalloc heap profiles to pprof to understand memory usage, fix memory leaks, and fix OOM Kills
-
linux-media-sys
providing access to the Linux Media Subsystem
-
stacked-set
Set interface, allowing stack-only implementations
-
chunked-range-alloc
generic range allocator for chunked external memory
-
malloc_buf
Structs for handling malloc'd memory passed to Rust
-
fenic
test concurrent code
-
haz-alloc
A general-purpose allocator written in Rust
-
bumpslab
A slab allocator with stable references
-
closure_attr
An attribute macro to simplify closure captures
-
remem
Thread-safe object reuse
-
easy-pool
An easy way to reuse your objects without reallocating memory every time
-
aiscript-arena
safe, incrementally garbage collected arenas
-
sdd
Scalable lock-free delayed memory reclaimer
-
async-once-cell
Async single assignment cells and lazy values
-
smart-ptr
Alternative smart pointers for Rust
-
linear-malloc
An ultra simple single-threaded linear allocator
-
hexagon
VM
-
sensitive-rs
sensitive data detection and filtering, supporting Chinese and English text with trie-based algorithms
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
rc_bump
An arena for heterogeneous types and without lifetimes
-
backdrop
Drop your large or complex objects in the background with Backdrop! (later, on another thread, or both! Fully customizable! Tokio supported!)
-
rheaper
A in-process heap profiler for rust
-
maskerad_stack_allocator
Stack-based allocators, for contiguous allocation and memory fragmentation prevention
-
bhc-arena
Arena allocators for efficient compiler data structure allocation
-
flatty-base
Flatty traits and primitives
-
fixstr
fixing strings
-
alignas
Wrapper to specify object alignment generically
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
rarena
Lock-free allocator and data structures based on ARENA
-
no_drop
wrapper type that guards against a value being automatically dropped
-
cfx-core
Core engine of WASM scripts to communicate with CitizenFX WASM Runtime
-
malloc-best-effort
wrapper over Google's TCMalloc and Microsoft's MIMalloc memory allocators
-
allocations
Thin cross-platform functions for memory allocation, deallocation and reallocation
-
pin-arc
Reference counting pointers without allocation using pinning
-
leak_slice
leak &mut [T] in favor of NonNull<[T]>
-
genref
Vale's generational references in Rust
-
bytes-text
Reference-counted UTF-8 text
-
ux-mediapipe
bindings for Google mediapipe
-
our
Ergonomic, highly generic wrapper for shared mutable data
-
cheap
cross platform allocator which communicate over the C ABI
-
rallo
Rust allocator for tracking memory usage
-
allocators
composable memory allocators and utilities for creating more
-
shmalloc
A shmitty heap for your shmitty code
-
aligned-cmov
Fast constant-time conditional moves of aligned bytes
-
managed-heap
virtual heap, inspired by VMs like the JVM. Currently supports automatic garbage collection, but no defragmentation
-
slab_allocator
Slab allocator for no_std systems. Uses multiple slabs with blocks of different sizes and a linked list for blocks larger than 4096 bytes
-
rlalloc
blazingly slow malloc replacement
-
memkit-bevy
Bevy ECS integration for memkit
-
viaduct
A duplex communication channel between a parent and child process, using unnamed pipes
-
flat-drop
Wrapper that drops recursive objects iteratively to avoid stack overflows
-
lib_malloc_freq
Use malloc frequency profiler (malloc_freq) via LD_PRELOAD
-
hirpdag
procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
rc_collections
Shared, reference-counted, copy-on-write, single-pointer buffers
-
hip-runtime-sys
Bindings for the HIP runtime
-
urcu
safe wrapper of the memb variant of the userspace RCU library
-
libisoalloc-sys
Security oriented allocator
-
corealloc
Helper CLI utility decide on core allocation on the current system
-
kcr_services_k8s_aws
Kubernetes Custom Resource Bindings
-
windows_shared_memory
Windows IPC library using shared memory. Supports 32-bit/64-bit cross-process communication
-
anycast
Allows upcasting to Any
-
counting-pointer
structs of reference counting pointers. The perforance is better than 'std::rc::Rc' and than 'std::sync::Arc' by counting only the strong references but not weak the references.
-
cgc-single-threaded
Compacting garbage collector
-
sen-plugin-sdk
SDK for creating Wasm plugins with minimal boilerplate
-
pages-and-pages
Allows control over a manually allocated region of page-aligned memory with support for granular protection and locking of underlying pages
-
slaballoc
Safe and lockless fixed-size memory allocator for
no_stdsystems -
transvec
safely transmute Vecs
-
wasefire-slice-cell
Slice with dynamic borrow checking
-
bh_alloc
A fuzzer friendly bump pointer allocator
-
mimalloc3-rs
mimalloc is a compact general purpose allocator with excellent performance
-
state-department
state management and dependency injection in Rust
-
easy_mmap
Strongly typed memory mapped files that allow for easy manipulation of large amounts of data
-
dybs
An experiment in dynamic single-owner, multiple-borrow smart pointers
-
generational-arena
A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices
-
re-init-rc
Wrappers for Rc and Arc weak pointers for auto re-initialization of inner value on access when it is already dropped
-
slice-pool
using a slice as a memory pool
-
passable
Pass a pointer around
-
deploy-temp-fringe
safe, lightweight userland context switches
-
viaptr
An experimental library for packing complex types into pointer-sized fields
-
crgc
Rust single thread GC based on reference counting + cycle removal. Inspired by QuickJS.
-
teaspoon
An allocator for when all you have is a teaspoon of memory
-
const-alloc
Allocate dynamic memory at compile time
-
imm_gc
Garbage collected pointers with immediate dropping
-
vulkan-malloc
A general purpose device memory allocator for Vulkan
-
craturn
interpretation of the 'Saturn Devouring His Son' painting
-
smallbox2
stack-preferred Box alternative
-
evobox
A pointer type which allows for safe transformations of its content without reallocation
-
subrc
A tiny crate that exposes a
Rclike struct, which can be used to create a reference counted pointer to a subregion of aRc -
toast-cell
Zero-cost type-branded cell with no runtime checks
-
rusty_winapi
Various rustified WinAPI's for pleasant and safe use with Rust
-
zerofrom-derive
Custom derive for the zerofrom crate
-
smallset
An unordered set of elements optimized for small sizes
-
memscope-rs
Advanced Rust memory analysis and visualization toolkit with custom allocator, variable tracking, and beautiful SVG reports
-
acid_alloc
Bare-metal allocators
-
hft-jobs
Allocation-free job system for HFT and real-time systems
-
ristretto_gc
JVM Garbage Collector
-
stack-any
that provides a type that owns same size type on the stack for type erasure
-
tracing-allocator
track allocations and deallocations
-
aligned
A newtype with alignment of at least
Abytes -
ika
object pool
-
redoubt-zero
Memory guards and zeroization primitives with automatic verification
-
membank
A pool of reusable memory to prevent unnecessary deallocations
-
seize
Fast, efficient, and predictable memory reclamation for concurrent data structures
-
tpuf_zerovec_0115
Zero-copy vector backed by a byte array
-
clip
A command line parser that doesn't use std or alloc!
-
static_initializer
Global non-lazy zero-cost statics without
const fn -
capped_collections
Collections with compile-time set capacities
-
sst
sorted string table abstraction
-
accountable-refcell
A RefCell wrapper that provides actionable information for dynamic borrow failures
-
static-alloc
A bump allocator on static memory for the alloc-traits crate
-
nstd_alloc
NSTD memory allocation crate
-
bbq2
A SPSC, lockless, no_std, thread safe, queue, based on BipBuffers
-
core2
The bare essentials of std::io for use in no_std. Alloc support is optional.
-
io_uring_mmap
internal crate
-
empty-box
Allows for
Boxs to have their values moved out and replaced with new values, while reusing the same allocation -
Pointers_Study_With_Core_Concepts
A study on rust smart pointers, with their essential concepts documented
-
wee_alloc
Wasm-Enabled, Elfin Allocator
-
bump_future
Type Erased Future Stored In Bump
-
ligature-in-memory
Ligature that uses persistant data structures to store Ligature's data model in memory
-
shared-data
data structures living in shared memory
-
virt-arena
A virtual memory bump allocator
-
rc-cell
wrapper around Rc<RefCell<T>>
-
memtrace
A CLI tool for generation heap consumption flamegraphs
-
shared-memory-allocator
An extremely unsafe experiment in writing a custom allocator to use linux shared memory
-
tempref
type whose value remains unchanged even when accessed through a mutable reference
-
realloc
A re-implementation of various ::alloc features
-
drc
add a new "Drc" smart pointer
-
mmslice
-
flatbuffers-owned
that enables a more flexible usage of FlatBuffers
-
block_allocator
Thread-safe, fixed-size allocator that serves re-usable blocks
-
vectorscan
wrapper for Vectorscan
-
slab_32
Forked from the main slab crate as an experiment. Don't use.
-
hato
Heterogeneous Arenas of Trait Objects
-
crndm_derive
Persistent Programming Library Procedural Macros
-
tcmalloc-sys
Drop-in global allocator using tcmalloc
-
memory_addr
Wrappers and helper functions for physical and virtual addresses
-
untyped-arena
Arena allocator implementation that is safe and untyped with minimal complexity
-
c-scape
A libc bottom-half implementation in Rust
-
hwlocality-sys
Low-level bindings for the hwloc hardware locality library
-
memapi-jemalloc-sys
FFI bindings to Jemalloc made for memapi
-
c2-mmap-gpio
ODROID-C2 bindings for GPIO using memory-mapping
-
taichi-sys
Rust language binding to the Taichi Runtime C-API
-
once_cell
Single assignment cells and lazy values
-
simple-slab
Fast and lightweight Slab Allocator
-
clone-behavior
Bound the semantic behavior and time complexity of cloning a value
-
shared_memory_extended
A user friendly crate that allows you to share memory between processes
-
wobbly
wobbly-owned reference counting pointers that mostly behave like Weak but can also keep a value alive
-
zeroize
Securely clear secrets from memory with a simple trait built on stable Rust primitives which guarantee memory is zeroed using an operation will not be 'optimized away' by the compiler…
-
bufpool
Vec<u8> pool allocator
-
corrida
Heterogenous Arena Allocator
-
slabby
Maximally efficient allocation and deallocation of a large number of instances of a type
-
maskerad_object_pool
A collection of object pools, for more efficient dynamic memory allocation
-
walloc
Malloc's Wario - allocates unusable, arbitrarily-sized blocks of memory on-command. Great for, uh, testing purposes?
-
stadium
A allocated chunk of memory populated with a fixed set of types
-
memflow-win32
win32 integration of the memflow physical memory introspection framework
-
planus-lexer
Internal lexer library for planus
-
pi_slot
lock free Slotmap data structure
-
fallible_alloc
Fallible rust stable std collections allocations
-
typed_shmem
Typed shared memory crate for *nix and Windows
-
hazard
pointers
-
limit-alloc
A custom allocator that allows to limit the available memory
-
swifer
Garbage collection for Rust-based runtimes
-
inlined
Types for inlining small collections for avoiding unnecessary heap allocations
-
vecshard
Split Vecs in constant time
-
resource-bound
Compile-time enforcement of struct size limits and heap allocation constraints
-
dumpalo
A minimalistic global bump allocator
-
secure-types
Secure data types that protect sensitive data in memory via locking and zeroization
-
alloc_uefi
Allocator for a UEFI environment
-
sodium-alloc
Allocator type that allocates memory using Sodium's secure memory utilities
-
aren_alloc
allocator for small copyable objects inspired by object-pools
-
type_erased_vec
A type erased Vec
-
slice-arena
Store lots of tiny slices with low overhead, in contiguous blocks of memory
-
squash
More space efficient encoding of owned heap-allocated slices
-
allocator_stub
custom allocator contains forward references for the
__rust_allocate,__rust_deallocate,__rust_reallocate,__rust_reallocate_inplace, and__rust_usable_sizefunctions. It… -
tendril
Compact buffer/string type for zero-copy parsing
-
tg-kernel-vm
Kernel virtual memory management for rCore tutorial OS
-
cesium-libmimalloc-sys
FFI wrapper for Microsoft's mimalloc allocator
-
flatbuffers
Official FlatBuffers Rust runtime library
-
mimalloc2
-
alloc-ext
Useful extensions to alloc library
-
gpu-alloc-types
Core types of gpu-alloc crate
-
stor
Helpers for genericising over storage types
-
mmap_buffer
(Mostly) safe wrapper for a memory-backed buffer
-
vec_cell
A Vec with interior mutability and dynamically checked borrow rules which allows to take disjoint mutable references to its elements
-
shared_slice
Thread-local and thread-safe shared slice types, like
&[T]but without lifetimes. This library depends only onallocandcore, so can be used in environments withoutstd. -
yesallocator
implemting for rust
-
memmap3
Safe, zero-copy memory-mapped I/O. Drop-in replacement for memmap2 with persistent structs and zero unsafe in user code.
-
rspack-libmimalloc-sys
Sys crate wrapping the mimalloc allocator
-
mmap-alloc
allocator backed by memory mappings
-
regalloc
Modular register allocation algorithms
-
facet-poke
Build and alter arbitrary Facet types
-
bump_alloc
global_allocator implementation of a bump allocator
-
raw-vec
A Raw utility for managing contiguous heap allocations
-
opt_vec
A wrapper around Vec<Option<T> that makes deletion fast
-
inline_flexstr
copy/clone-efficient inline string type for Rust
-
filebuffer
Fast and simple file reading
-
non-null-const
A *const equivalent of NonNull<T>
-
prat
PRetty PRint PRometheus cAT
-
fallacy-arc
fallible Arc
-
fallacy-box
fallible Box
-
zallocators
Bringing Zig like allocators to Rust
-
mimalloc-sys
Rust FFI bindings to mimalloc
-
shared_slab
Data structure with shared insertion
-
arena_system
An arena allocator which uses handles for accessing elements
-
uni_rc_lock
trait which may represent either Rc<RefCell<T>> or Arc<RwLock<T>>
-
crossbeam
Tools for concurrent programming
-
nyar-number
Numeric types with GC optimization
-
neocortex
Shared memory crate designed for simplicity, safety, and extensibility
-
slotmap-slice-fork
Fork of slotmap
-
uncooked_slices
A wrapper around raw slice pointers that enables safe iteration and indexing
-
hv-stampede
Bumpalo-based arena allocation utilities for Heavy
-
core_malloc
Implementing abs_mm with a wrapper around crate alloc
-
segmented_vector
a mutable vector type built from array segments, similar to clojure's persistent vector
-
mmapcell
wrapper for the memmap2 crate to cast mmap backed pointers to structs
-
slotmap
data structure
-
mjb_gc
Garbage collected pointers with immediate dropping
-
slot-arena
Compacted memory allocation using opaque references
-
marching-buffer
Marching buffer with resets
-
mmap-rs-with-map-from-existing
A temporary fork of mmap-rs with support for creating pages from raw memory. Will be deprecated in near future.
-
pgc
Garbage collector
-
cache-size
finding your L1/L2/L3 cache sizes
-
ruyi-slab
An object based allocator
-
segmented_string
an immutable string type built from array segments, similar to clojure's persistent vector, with unicode grapheme/width support
-
phylactery
Safe and thin wrappers around lifetime extension to allow non-static values to cross static boundaries
-
copying_gc
copying garbage collector
-
archery
Abstract over the atomicity of reference-counting pointers
-
libmimalloc3-sys
Native bindings to the mimalloc library
-
storagevec
Feature-gated heap-based/stack-based map and vector structures
-
elfmalloc
A fast, concurrent, general-purpose allocator
-
slotmap_fork_lmondada
Slotmap data structure
-
kovan
High-performance wait-free memory reclamation for lock-free data structures. Bounded memory usage, predictable latency.
-
yep-cache-line-size
A small library for retrieving cache line sizes. Forked from lovesegfault/cache-size.
-
zuffer
A mmap file based buffer implementation
-
ts-mem-pool
thread-safe memory pool crate
-
jemallocator-global
Sets
jemallocas the#[global_allocator] -
wasm-tracing-allocator
A global allocator for Wasm that traces allocations and deallocations for debugging purposes
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
tinypointers
Pointer implementations that take 8 or 16 bits
-
alloc-chibios
Allocator for ChibiOS 2.6
-
dense_bitset
A variably sized, heap allocated, dense bitset implemented using no
unsafecode -
rapace-transport-shm
Shared memory transport for rapace (performance reference implementation)
-
cheapalloc
GlobalAlloc hooked up to libc malloc/free, to use an existing CRT heap