-
bumpalo
A fast bump allocation arena for Rust
-
arc-swap
Atomically swappable Arc
-
memmap2
Cross-platform Rust API for memory-mapped file IO
-
tikv-jemallocator
allocator backed by jemalloc
-
slotmap
data structure
-
sharded-slab
A lock-free concurrent slab
-
heapless
static
friendly data structures that don’t require dynamic memory allocation -
mimalloc
Performance and security oriented drop-in allocator
-
jemallocator
allocator backed by jemalloc
-
yoke
Abstraction allowing borrowed data to be carried along with the backing data it borrows from
-
slab
Pre-allocated storage for a uniform data type
-
typed-arena
The arena, a fast but limited type of allocator
-
static_init
Safe mutable static and non const static initialization, and code execution at program startup/exit
-
allocator-api2
Mirror of Rust's allocator API
-
elsa
Append-only collections for Rust where borrows to entries can outlive insertions
-
archery
Abstract over the atomicity of reference-counting pointers
-
uninit
A collection of tools for a safer usage of uninitialized memory
-
talc
A fast and flexible allocator for no_std and WebAssembly
-
snmalloc-rs
rust bindings of snmalloc
-
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…
-
tendril
Compact buffer/string type for zero-copy parsing
-
boa_gc
Garbage collector for the Boa JavaScript engine
-
mem_dbg
Traits and associated procedural macros to display recursively the layout and memory usage of a value
-
embedded-alloc
A heap allocator for embedded systems
-
rustc-std-workspace-alloc
integration of crates.io crates into rust-lang/rust standard library workspace
-
object-pool
A thread-safe object pool with automatic return and attach/detach semantics
-
gbm
libgbm bindings for rust
-
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.
-
hipstr
string for Rust: zero-cost borrow and slicing, inline representation for small strings, (atomic) reference counting
-
gc-arena
safe, incrementally garbage collected arenas
-
dlmalloc
port of the dlmalloc allocator
-
stats_alloc
An allocator wrapper that allows for instrumenting global allocators
-
vm-memory
Safe abstractions for accessing the VM physical memory
-
rctree
A 'DOM-like' tree implemented using reference counting
-
reblessive
A small runtime for running deeply nested recursive functions
-
ghost-cell
Compile-time zero-cost borrow-checking of aliased references
-
static-alloc
A bump allocator on static memory for the alloc-traits crate
-
weak-table
Weak hash maps and sets
-
bump-scope
A fast bump allocator that supports allocation scopes / checkpoints. Aka an arena for values of arbitrary types.
-
wdk-alloc
alloc support for binaries compiled with the Windows Development Kit (WDK)
-
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
-
bufsize
bytes::BufMut implementation to count buffer size
-
jrsonnet-gcmodule
Cyclic garbage collection inspired by CPython's gc implementation
-
arcshift
Replacement for std::sync::Arc<T> that supports updating the value, with some caveats
-
cluFullTransmute
A more complete and extended version of data type conversion without constraint checks
-
gpu-alloc
agnostic memory allocator for Vulkan like APIs
-
pi_slotmap
Slotmap data structure
-
lgalloc
Large object allocator
-
tikv-jemalloc-sys
Rust FFI bindings to jemalloc
-
memuse
Traits for measuring dynamic memory usage of types
-
polkavm
A fast and secure RISC-V based virtual machine
-
mmap-rs
A cross-platform and safe Rust API to create and manage memory mappings in the virtual address space of the calling process
-
get-size2
Determine the size in bytes an object occupies inside RAM
-
mini-alloc
Very simple global allocator
-
range-alloc
Generic range allocator
-
buddy_system_allocator
A bare metal allocator that uses buddy system
-
slotmapd
orlp/slotmap fork where serialization cycle doesn't change observable behavior
-
dumpster
A concurrent cycle-tracking garbage collector
-
etagere
Dynamic 2D texture atlas allocation using the shelf packing algorithm
-
tor-memquota
Memory use tracking and quota utilities, used by Tor software
-
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!
-
peak_alloc
An allocator to keep track of (the max) allocated memory
-
rarena-allocator
Lock-free ARENA allocator which can be used in both memory and on-disk
-
lol_alloc
laughably simple wasm global_allocator
-
include_bytes_aligned
macro that embeds the bytes of an external file into the executable and guarantees that they are aligned
-
mmtk
framework for the design and implementation of high-performance and portable memory managers
-
stronghold-runtime
Data structures for memory protection at runtime
-
qcell
Statically-checked alternatives to RefCell and RwLock
-
process_vm_io
I/O access to virtual memory contents of processes
-
rabuf
randome access buffer for io
-
soa-rs
A Vec-like structure-of-arrays container
-
wrapped_mono
wrapped_mono
is 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… -
secmem-alloc
Custom allocators for secret memory
-
checkers
A sanity checker for global allocations
-
rust-cc
A cycle collector for Rust programs
-
memsafe
A Secure cross-platform Rust library for securely wrapping data in memory
-
memsec
libsodium/utils
-
box_raw_ptr
providing safe wrappers for working with raw pointer. These raw pointers are
*const T
and*mut T
. These wrappers ensure memory safety by encapsulating the raw pointers in safe abstractions… -
stats_alloc_helper
A test helper to measure memory allocations
-
buddy-alloc
memory allocator for no-std Rust, used for embedded environments
-
refuse
incremental, multi-threaded garbage collector
-
jemalloc-sys
Rust FFI bindings to jemalloc
-
graph-api-simplegraph
efficient graph implementation for the graph-api ecosystem with support for indexing
-
ialloc
Allocator interface traits
-
win-wrap
用于Rust的Windows API的高级封装
-
memur
Arena storage with bells and whistles
-
refbox
A Box with weak references
-
rustix-dlmalloc
port of the dlmalloc allocator, ported to rustix
-
pared
Projected reference counted pointers
-
nunny
the definitive non-empty slice/array/vec library for Rust
-
gc
Tracing garbage collector plugin for Rust
-
lightweight-mmap
memory mapping helpers for Rust, with minimal amount of code generated
-
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…
-
pi_world
ecs world
-
memory_set
Data structures and operations for managing memory mappings
-
offset-allocator
A port of Sebastian Aaltonen’s
OffsetAllocator
to Rust -
thunderdome
Fast arena allocator with compact generational indices
-
triple_arena
Regular, Chain, Surjection, and Ordered Arenas supporting non-Clone types, deletion, and more
-
vptr
Thin references to trait objects by embedding the virtual table pointer in the struct
-
flexstr
A flexible, simple to use, immutable, clone-efficient
String
replacement for Rust -
lifeguard
An object pool manager in Rust
-
swc_allocator
A thin wrapper for bumpalo
-
ra_ap_la-arena
index-based arena without deletion
-
id-arena
id-based arena
-
process-image
Zero-cost abstraction for convenient access to process image tags
-
slabbin
An efficient slab allocator with stable addresses
-
intrusive_splay_tree
An intrusive splay tree implementation that is no-std compatible and free from allocation and moves
-
mimalloc-safe
Performance and security oriented drop-in allocator
-
haphazard
Dynamic memory management for lock-free data structures using hazard pointers
-
mimalloc-rspack
Performance and security oriented drop-in allocator
-
dyn_size_of
report approximate amount of memory consumed by variables, including the memory allocated on heap
-
stalloc
fast first-fit memory allocator that you can use to quickly speed up your Rust programs
-
memflow-qemu
qemu connector for the memflow physical memory introspection framework
-
ringal
Efficient ring allocator for short-lived buffers
-
shared-buffer
An abstraction over buffers backed by memory-mapped files or bytes in memory
-
slabmap
HashMap-like collection that automatically determines the key
-
wild-linker
A very fast linker for Linux
-
second-stack
A fast allocator for short-lived slices and large values
-
boxarray
Safe way to allocate and initialize nested arrays directly on the heap in Rust
-
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
-
generational-box
A box backed by a generational runtime
-
picoalloc
small and fast memory allocator
-
alloc_geiger
allocator which makes sound when active, like a Geiger counter
-
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.
-
rpmalloc
Cross-platform global memory allocator using rpmalloc
-
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
-
trc
A faster Arc
-
dynamic-provider
Dynamically request arbitrarily-typed values from providers with borrowed data
-
zone
Rust bindings for Zone management
-
mapped-file
Construct a memory mapping over any file object
-
alloc-track
Track memory allocations by backtrace or originating thread
-
free-list
A free-list-based page/frame allocator
-
sensitive
Memory allocator for sensitive information
-
good_memory_allocator
A blazingly fast and memory efficient memory allocator to be used in
no_std
environments -
portable-dlmalloc
Portable Fork of Doug Lea's malloc Implementation
-
pin-weak
Small wrapper around an equivalent of Pin<Weak<T>>
-
to_shmem
Trait to write to a contiguous chunk of shared memory
-
aiscript-arena
safe, incrementally garbage collected arenas
-
presser
help you copy things into raw buffers without invoking spooky action at a distance (undefined behavior)
-
re_memory
Run-time memory tracking and profiling
-
creusot-contracts
contracts and logic helpers for Creusot
-
vm-allocator
Helpers for allocating resources needed during the lifetime of a VM
-
bitmap-allocator
Bit allocator based on segment tree algorithm
-
tlsf
Two-Level Segregated Fit (TLSF) allocator with optimized memory footprint
-
recursive
Easy recursion without stack overflows
-
libcanopy
Canopy is a lightweight tree-based data structure for Rust, optimized for reference management using Rc and Weak pointers
-
bufio
std::io::Write for your potentially uninitialized slice of memory
-
token-cell
A more convenient GhostCell
-
corundum
Persistent Programming Library
-
graph-api-lib
Core library for the graph-api ecosystem - a flexible, type-safe API for working with in-memory graphs in Rust
-
slimmer_box
A packed alternative to Box<T> whose 'fat' pointer is 'slimmer'
-
orderly-allocator
A super-simple fast soft-realtime allocator for managing an external pool of memory
-
ocaml-boxroot-sys
Boxroot for OCaml: fast movable GC roots (C API)
-
flex-alloc
Data structures with extra flexible storage
-
alloc-from-pool
Single-threaded object pool implementation
-
cbvm
Cross bytes virtual machine used for building, running and reading CBVM files
-
malloc-info
A safe wrapper around glibc's malloc_info
-
zeroizing-alloc
Minimal allocator wrapper to zero-on-free data for security
-
compact_arena
some types to allow indexed arenas with small memory footprint
-
moveref
Types and traits for safe C++ style placement initialization and move semantics
-
blink-alloc
Fast, concurrent, arena-based allocator with drop support
-
hamming_rs
Computes Hamming distance and weight -- if available and beneficial, uses a highly optimized avx2 implementation
-
cache-size
finding your L1/L2/L3 cache sizes
-
baby-mimalloc
Mimalloc implemented in Rust (not a binding to the C library) with only basic features
-
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
-
libmimalloc-sys
Sys crate wrapping the mimalloc allocator
-
allocation-counter
Count the number of memory allocation of some code
-
deallocate-zeroed
An extension trait for allocators to deallocate already-zeroed memory
-
quickdry
Bump-pointer arena allocator
-
wasmtime-slab
Uni-typed slab with a free list for use in Wasmtime
-
ferroc
A fast & lock-free memory allocator library
-
shush-rs
designed to manage sensitive data securely by leveraging memory protection mechanisms
-
malloced
A malloc-ed box pointer type
-
jemalloc-ctl
A safe wrapper over jemalloc's control and introspection APIs
-
inplace_it
Place small arrays on the stack with a low-cost!
-
mockalloc
allow testing code which uses the global allocator
-
ordered-pool-allocator
A fast and compact pool allocator with block sorting support
-
bytesbox
ByteBox is a high-performance hash map implementation optimized for byte slices. It efficiently maps keys and values of type Vec<u8>, providing full ownership of the data. ByteBox uses…
-
bdwgc-alloc
impl GlobalAlloc for bdwgc
-
byte-pool
Pool of byte slices, for efficient memory usage
-
fixstr
fixing strings
-
heapbuf
Fixed size heap buffer with optional custom alignment, ref counting and custom destructor logic
-
realloc
A re-implementation of various ::alloc features
-
refpool
Efficient memory pool with reference counting
-
storage_api
Storage API, a better version of Allocator
-
ctoption
A compile-time option whose discriminant is elevated to compile time
-
mmap-wrapper
wrapper for the memmap2 crate to cast mmap backed pointers to structs
-
alloc-madvise
A memory allocator for creating large aligned chunks of memory
-
contiguous-arena
Efficient, reusable memory arena for Rust with support for contiguous memory blocks
-
gpu-alloc-vulkanalia
vulkanalia
backend forgpu-alloc
-
recycle-box
A pointer type for heap-allocated objects which heap storage can be re-used, with Pin support
-
craft-eraser
A set of simple type-erased box primitives
-
tcmalloc2
Rust FFI bindings to tcmalloc
-
lock_free_buddy_allocator
Scalable lock-free buddy system allocator
-
relib_module
relib is a framework for reloadable dynamic libraries
-
moving_gc_arena
Lightweight Garbage-collectable regions using indices and explicit roots
-
emap
A map with a fixed capacity and integers as keys
-
cactusref
Cycle-aware reference counting smart pointer
-
soapy
Structure-of-arrays derive macro
-
flatbuffers-owned
that enables a more flexible usage of FlatBuffers
-
typed-slab
Typed wrapper for Slab
-
mem-rs
pattern scanning and abstraction for pointers in memory of running processes
-
flipperzero-alloc
Flipper Zero
-
alloca
Mostly safe wrapper for alloca
-
splitrc
Thread-Safe Split Reference Counts
-
hipool
RUST Memory Pool
-
safe-gc
A garbage collection library with zero
unsafe
code and zero dependencies -
hardened_malloc-rs
hardened_malloc rust wrapper
-
stupidalloc
A stupid memory allocator that memory-maps allocations to files
-
stylo_malloc_size_of
An allocator-agnostic crate for measuring the heap size of a value
-
jit-allocator
An executable code allocator
-
tikv-jemalloc-sys2
Rust FFI bindings to jemalloc
-
arena-traits
Traits for arenas
-
concat-in-place
Efficient macros for concatenation of strings and vectors
-
playdate-allocator
Global allocator and allocator-api implementation for Playdate
-
drop_arena
A single-type allocator which permits dropping and reclaiming of individual elements
-
scudo
Rust Bindings for the Scudo Hardened Allocator
-
capped_collections
Collections with compile-time set capacities
-
shared-buffer-rs
combines Arc and RefCell for Send and Sync
-
escoba
Useful broom to clean your RAM in Window$
-
roussillon-memory
Memory utility for the roussillon language
-
pages-and-pages
Allows control over a manually allocated region of page-aligned memory with support for granular protection and locking of underlying pages
-
borrow-framework
More flexible borrowing
-
libspecr
standard library for specr lang
-
default-boxed
Helper trait to help create large struct on heap directly
-
defer-drop
Defer dropping large types to a background thread
-
rsbmalloc
but fast binned allocator for Rust. Single-threaded for no_std, multi-threaded otherwise
-
wraith
compiler backend
-
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
-
kernel-alloc
Minimalistic Windows Kernel Allocator
-
safe-allocator-api
A safe wrapper around the
allocator_api
’s Allocator trait -
snap-buf
A copy on write byte buffer for efficient snapshotting
-
hash_cons
A type-safe hash-cons library
-
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;…
-
cowvert
a flexible data container supporting owned, reference-counted, and copy-on-write semantics. designed for use in interpreters
-
ps-alloc
a reasonably safe allocator
-
rseal
Memory sealing operations
-
contiguous-mem
A contiguous memory storage
-
string-alloc
Allocator-aware no-std-compatible String implementation
-
align_constr
Like
aligned
but 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” -
persian-rug
Framework for bringing together disparate objects with inconvenient relationships
-
frusa
A system allocator with reclaim
-
ration
A shared memory library
-
ralloc
An efficient alternative platform-agnostic allocator
-
hala-pprof-memory
A memory profile data collector for pprof
-
verity-memory
Personal memory library with some cool features
-
malloc_size_of
A an allocator-agnostic crate for measuring the heap size of a value
-
opool
High-performance, lock-free local and concurrent object pool with automated allocation, cleanup, and verification
-
bumpalo-herd
Support for bumpalo in scoped threads & rayon
-
grounded
A toolkit for managing unsafe statics
-
memusage
Small trait utility to keep track of the memory usage of structs
-
handy
providing handles and handlemaps
-
alloc_cat
allocator for small-to-tiny Wasm projects in rust
-
hugealloc
Hugepage-aware allocator
-
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…
-
genmap
generational map data structure with no dependencies
-
vonneumann
executable memory for windows and unix
-
pb-atomic-linked-list
An atomic insert-only linked list
-
hybrid-rc
Thread-safe hybrid reference counting pointers
-
static-rc
Compile-time reference counting
-
cabbage_collector
ready
-
hirpdag
procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures
-
isoalloc
Security oriented allocator
-
snmalloc-sys
rust raw bindings of snmalloc
-
fixed-typed-arena
A typed arena that uses fixed-size chunks to ensure non-amortized O(1) allocations
-
obj-pool
object arena
-
jrsonnet-gc
Tracing garbage collector plugin for Rust
-
bulk_allocator
Implementations of GlobalAlloc holding memory cache
-
rulloc
General purpose memory allocator
-
osdk-frame-allocator
The default buddy system frame allocator shipped with OSDK
-
phper-alloc
Alloc related items for phper crate
-
mimalloc-rust
the best binding for mimalloc in rust
-
membarrier
Process-wide memory barrier
-
bysyncify
Bindings and a high-level interface to Binaryen's Asyncify
-
pstruct
procedural macro for generating pointer struct implementations with field offset access
-
alloc-stdlib
A dynamic allocator example that may be used with the stdlib
-
composable-allocators
Composable memory allocators for new allocator API
-
accountable-refcell
A RefCell wrapper that provides actionable information for dynamic borrow failures
-
onsen
Memory pool
-
wg-utils
Personal Utility Functions
-
zerogc
Zero overhead tracing garbage collection for rust
-
wr_malloc_size_of
Internal utility to measure memory usage in WebRender
-
mmap-vecdeque
A file-backed memory-mapped VecDeque with deferred commits, atomic and durable persistence
-
cl-generic-vec
a vector implementation that can be used in
no_std
envioronments -
wrc
A thread-safe weighted reference counting smart-pointer for Rust
-
system-mimalloc
system's shared mimalloc library as allocator
-
heapsz
calculating the heap usage of a data structure
-
rofi-mode
High-level library for creating Rofi plugins and custom modes
-
scratchpad
Stack-like memory allocator with double-ended allocation support
-
owned-pin
A wrapper that both owns and pins data in memory
-
without-alloc
Replacements for
Box
,Rc
,Vec
, .. withoutalloc
-
moore-common
The common core of the moore compiler framework
-
fortify
convenient way to bundle owned data with a borrowing type
-
light_arena
A lightweight, placement based memory arena for types which are Sized + Copy. This crate requires nightly.
-
asylum
A fast, lightweight string interner with automatic cleanup to prevent memory bloat
-
pb-arena
arena allocator for graph based operations
-
minedmap-default-alloc
Helper crate for target-specific selection of global allocator default
-
system-memory
A small crate to get info/stats on the host's memory
-
demikernel
Kernel-Bypass LibOS Architecture
-
hpt-allocator
An internal library for memory allocator for hpt
-
untyped-box
A heap allocation utility when the datatype is unknown
-
relrc
Reference counted pointers, with relationships to other pointers
-
aligners
alignment guarantees for data
-
peakmem-alloc
An allocator wrapper that allows measuring peak memory consumption
-
vhdl_parser
VHDL Parser
-
bacon_rajan_cc
A reference counted type with cycle collection
-
buddyalloc
Safe and simple drop-in allocator for Rust running on embedded or bare metal systems (no_std)
-
memflow-native
System call based proxy-OS for memflow
-
tracking-allocator
global allocator that provides hooks for tracking allocation events
-
dotnetrawfilereader-sys
A low-level interface to a in-process dotnet runtime for Thermo Fisher's RawFileReader library
-
cheap
cross platform allocator which communicate over the C ABI
-
uncooked_slices
A wrapper around raw slice pointers that enables safe iteration and indexing
-
rco-cell
Wrapper for Rc<RefCell<Option<T>>> and its weak variant. Includes various utilties for common operations usually performed on such a datastructure.
-
bookcase_alloc
An arena allocator
-
tesap-std
Reimplementation of Rust's common std containers
-
context-allocator
-
ve
More compact Vec
-
musli-allocator
Allocators for Müsli
-
possibly_uninit
Traits and types helping with using uninitialized memory safely
-
sanitation
developing memory-safe programs while detecting and capturing possibly malicious bytes
-
rodeo
Fast dropping arena based on bumpalo
-
xalloc
Suballocators for external memory (e.g., Vulkan device memory)
-
mimalloc-redirect
Application-wide allocator redirection to MiMalloc
-
rattish
Cast between trait objects
-
rspe
Native Rust Reflective PE loader library
-
generic_singleton
allowing for generic singleton patterns
-
rlalloc
blazingly slow malloc replacement
-
erased-type-arena
A type-erased allocation arena with proper dropping
-
vec-tree
A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices
-
salloc
Safe C-like memory allocator for windows
-
datatier
abstractions for byte storage pools
-
haz-alloc
A general-purpose allocator written in Rust
-
cell-gc
A fun garbage collector for that virtual machine you're writing in Rust
-
virtual-memory
allocating RWX memory on Unix and Windows
-
pin-arc
Reference counting pointers without allocation using pinning
-
timely-container-master
Container abstractions for Timely
-
alloc-tls
Thread-local storage that is safe for use in implementing global allocators
-
netbuf
growable, contiguous buffer object with right assumptions and interface. Tuned for using it for network buffers.
-
shredder
Garbage collection as a library for Rust
-
recasting
traits for one-to-one recasting of values in data structures
-
shared_arena
A thread-safe & efficient memory pool
-
slabby
Maximally efficient allocation and deallocation of a large number of instances of a type
-
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)…
-
index_arena
id-based, heterogeneous arena allocator
-
fixed_heap
A fixed-size heap structure with manually provided stateful comparison function
-
dynamic-list
A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!
-
min32
Minimal boilerplate code for targeting win32 with no-std
-
token-ref-cell
Interior mutability cell using an external token to synchronize accesses
-
generational_vector
A vector type using generational indices
-
freeze
A mmap-backed bump allocator that allows compact and zero-realloc mutability of the top vector
-
voxelis-memory
Memory utilities for the Voxelis voxel engine
-
mstak-util
Minimal Stak Scheme utilities
-
scx_rustland_core
Framework to implement sched_ext schedulers running in user space
-
vecstorage
Re-use the memory for vectors containing values with different lifetimes
-
libisoalloc-sys
Security oriented allocator
-
sti
STd Improved
-
crndm
Persistent Programming Library
-
emd-common
Various common stuff, necessary for emd
-
addr_of_enum
Get address of fields in enum item using stable Rust
-
rebound
Full runtime reflection for Rust, with lifetime safety
-
tcmalloc
Drop-in global allocator using tcmalloc
-
audio-garbage-collector
Wrapper on top of
basedrop
that provides a drop-in GC API that’ll collect reference-counted values on a background thread -
dairy
A more compact, user friendly clone-on-write smart pointer
-
recvmsg
Traits for receiving datagrams reliably, without truncation
-
lazy-st
Single-threaded lazy evaluation
-
ensf594-project-mmap
Final project for the ENSF 594 course of the University of Calgary, summer 2022
-
obstack
A fast, stack-based allocator, usable for any object
-
speedy_refs
A collection of simple and fast and useful smart pointers
-
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.
-
malloc-array
libc heap array allocator
-
gc_api
Generic abstractions for a multithreaded garbage collector
-
polkavm-derive
The derive crate for PolkaVM guest programs
-
tikv-jemalloc-ctl
A safe wrapper over jemalloc's control and introspection APIs
-
basic_allocator
A very simple global allocator written in pure Rust
-
shmem-ipc
Untrusted IPC with maximum performance and minimum latency on Linux
-
cpr_bf
A brainfuck interpreter
-
loro-thunderdome
Fork of thunderdome: Fast arena allocator with compact generational indices
-
ferris-gc
Flexible implementation of garbage collector for Rust
-
pseudo_pool
A pool-like collection that automatically returns objects to the pool & blocks when the pool is empty
-
allocator-suite
Allocator Suite for various allocation types
-
agentx
implementing all PDU types and encodings according to the standard
-
refuse-pool
A string interner utilizing the Refuse garbage collector
-
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
-
index-pool
A pool which manages allocation of unique indices. Acts like a psuedo-memory allocator.
-
regc
A garbage collector that mixes Reference counting and mark sweeping
-
ps-mmap
Easy memory mapping
-
bagel
Compile-time evaluation and other tools
-
numanji
Local-affinity first NUMA-aware allocator with optional fallback
-
forgotten
globally and safely persist a value, implemented with ManuallyDrop
-
zone-alloc
Containers for zone-based data allocation
-
talloc
A fast, consistant, and flexible
no_std
-compatible allocator -
discard
trait which allows for intentionally leaking memory
-
backdrop
Drop your large or complex objects in the background with Backdrop! (later, on another thread, or both! Fully customizable! Tokio supported!)
-
secret_mem
securely managing sensitive data in memory
-
id-alloc
An id allocator implemented by the bitmap
-
fixed-size-allocator
A fixed-size allocator
-
membank
A pool of reusable memory to prevent unnecessary deallocations
-
polymock
A thread-safe arena bytes allocator
-
memory_pages
memory_pages
provides a cross-platform memory management API which allows for acquiring memory pages from the kernel and setting permissions on them -
markable_reader
reader which can be marked in a position to be returned to after subsequent reads
-
memguar
that helps to optimize IO of large buffers in near-OOM state or with small amount of RAM
-
async-alloc-counter
measures max allocations in a future invocation
-
ashpan
RAII helpers for ash
-
card10-alloc
Dynamic memory allocation for card10 l0dables
-
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
-
heaparray
Flexible support for dynamically-sized types, using heap-allocated array of structs
-
mmap-append
Append-only memory-mapped I/O, resizable, with low lock contention
-
smallest-uint
Gets the smallest unsigned integer type that can represent a given value
-
rcu-clean
Smart pointers using RCU with Deref support
-
nstd_alloc
NSTD memory allocation crate
-
lazy-heap
A lazy heap allocator for Rust based on
slab_allocator_rs
-
insectbox
OpenSSH inspired in-memory key security
-
pool
reusable values
-
stackvec
stack-allocated Vectors (performance and/or no-std)
-
gcmodule
Cyclic garbage collection inspired by CPython's gc implementation
-
fpool
Non-leased object-pooling
-
tokengrams
Compute n-gram statistics and model language over pre-tokenized text corpora used to train large language models
-
diskallocator
For really big vectors: allocate on disk
-
rb-allocator
Memorry allocator for Ruby extensions
-
derivable-object-pool
A thread-safe derivable object pool collection with automatic reusage of objects
-
buguc
-
gomicollector
mark-sweep garbage collector
-
indexed
Convenient allocator for index-linked data structures
-
boxext
Extensions to the
Box
type -
malloc-rust
Malloc implementation using Rust allocator
-
bump_future
Type Erased Future Stored In Bump
-
sodium-alloc
Allocator type that allocates memory using Sodium's secure memory utilities
-
memory_storage
memory storage comparable to a Vec where removing items doesn't shift all the items after the removed item to the left and doesn't invalidate their IDs. It allows you to remove items…
-
silly-alloc
A collection of very basic allocators
-
virt-arena
A virtual memory bump allocator
-
pho
PHOnetic alphabet renderer
-
jrsonnet-interner
Jrsonnet string interning
-
heterovec
In-place vector of dynamically sized type
-
customizable-buddy
A new buddy allocator that allows custom buddy finding algorithm
-
aligned_box
Allocate heap memory with user-specified alignment
-
alloc-facade
Facade for std-or-alloc imports
-
zc
Self-referential zero-copy structure
-
fallible_alloc
Fallible rust stable std collections allocations
-
maybe-std
Helper crate for writing rust libraries with an optional dependency on the standard library
-
rsgc
Concurrent GC library for Rust
-
alloc_buddy_simple
drop-in replacement allocator for Rust running on bare metal (no_std)
-
lazy-cogs
Lazy Cogs is a implementation of lazy clonable data structures
-
id_allocator
ID allocator adapted from. idalloc
-
yesallocator
implemting for rust
-
maskerad_memory_allocators
custom allocators, for memory fragmentation prevention
-
acid_alloc
Bare-metal allocators
-
warlock
Arena allocation optimized collections
-
gg-alloc
A custom allocator that only returns pointers above 2G
-
rustc-arena-modified
rustc-arena ported to stable rust with additional features
-
redox-buffer-pool
A buffer pool library for Redox, featuring a general-purpose 32-bit allocator
-
la-arena
index-based arena without deletion
-
trove
arena allocator
-
cleo_redux_sdk
Rust SDK for CLEO Redux plugins
-
allocdeny
Deny the use of crate
alloc
-
shm_open_anonymous
Anonymous POSIX shared memory objects
-
fixed-bump
A bump allocator that uses fixed-size chunks to ensure non-amortized O(1) allocations
-
lockedbox
A Box-like type that prevents paging its contents to disk
-
emheap
Tiny memory manager for embedded system
-
index_alloc
A toy static allocator wich can serve as a global_allocator
-
pkey_mprotect
Typed
pkey_mprotect
wrapper -
shared_hashmap
A shared hashmap for use between processes, using shared memory
-
fallible_collections
adds fallible allocation api to std collections
-
nvpair-sys
Bindings to libnvpair.so (nvpair & nvlist)
-
cesium-allocator
Allocator pool for managing sets of allocators
-
contain
defining/extending lifetimes
-
zalloc
A global allocator wrapper zeroizing memory on dealloc
-
hato
Heterogeneous Arenas of Trait Objects
-
nalloc
An allocator wrapper that can be turned on and off
-
scoped-arena
Arena allocator with optional scopes
-
aliasable_deref_trait
Marker trait for types that deref to an address that is aliasable when coerced to a raw pointer
-
rendy-memory
Rendy's memory manager
-
unkai
set for Rust's memory allocation APIs mainly focus on tracking and conditional analyzing / limiting memory usage
-
mvcc_cell
Software-transactional memory for Rust
-
memory-layout
explicit struct layouts
-
wrapper
A trait for types that wrap other types
-
heap-ap
heap access point for anyone in rust, called to c
-
bulletproof
memory access
-
taichi-runtime
Rust language binding to the Taichi Runtime C-API
-
hirpdag_hashconsing
Various hashconsing implementations with a common interface
-
win-lookaside
Windows Lookaside Kernel Allocator
-
frond
dynamic lexicographic containers
-
noop-allocator
An
Allocator
that does nothing -
owned-alloc
help reducing manual memory management errors
-
stadium
A allocated chunk of memory populated with a fixed set of types
-
growable
reusable box for Rust
-
mos-alloc
allocator for mos architecture
-
microstack
The simplest and the fastest implementation of a fixed-size stack on stack
-
heapnotize
A smart pointer type for memory allocation on the stack
-
retry_alloc
A global allocator wrapper that will retry failed allocations
-
alleakator
leaking global allocator
-
generic_slab
Pre-allocated storage for a uniform data type
-
chunky
Abstract storage of heterogeneously-sized entity-collections
-
accounting-allocator
A global memory allocator wrapper which counts allocated and deallocated bytes
-
poule
A pool of reusable values
-
alloc-fmt
Formatting utilities safe for use in an allocator
-
binary-layout
allows type-safe, inplace, zero-copy access to structured binary data. You define a custom data layout and give it a slice of binary data, and it will allow you to read and write the…
-
soak
Transform a struct into arrays of its fields
-
soapy-shared
Custom types used by soapy macros
-
spool
object pool for upfront allocation!
-
freezie
small library that disables mutation for the contained type
-
gc_plugin
Garbage collector plugin for rust-gc
-
r-efi-alloc
UEFI Memory Allocator Integration
-
fastbuf
single-thread-oriented very fast byte buffer
-
passable
Pass a pointer around
-
memory-cache-rs
local in-memory cache for Rust
-
rslab
A slab allocator for Rust
-
staging-tracking-allocator
Tracking allocator to control the amount of memory consumed by the process
-
seckey
Use
memsec
protected secret memory -
alloc-safe
Safe memory allocation, no panic!
-
slotmap-fork-otter
Slotmap data structure - temporary fork for Otter
-
static-cow
Cow
at the type level: a framework of traits for writing types that are generic over ownership of their contents -
libcre
WIP
-
esp-idf-alloc
An allocator for the ESP32 based on the ESP-IDF
-
any_handle
A thread-safe, type-safe smart pointer that can share, store and downcast a
dyn Any
-
xsl-rs
A simple library
-
type-handle
Regular and reference-counted type handles
-
cruppers
A minimal crate to support using no_std Rust libraries in C++
-
benemalloc
WIP: A fast, general-purpose memory allocator for Rust
-
broom
An ergonomic tracing garbage collector that supports mark 'n sweep garbage collection
-
arena-allocator
Virtual memory based linear allocator
-
omniswap
swap values between possibly-overlapping references
-
mut_guard
Run a function after some data was mutably borrowed
-
cev
An expandable data array used to add data to the beginning of the array
-
malloc_buf
Structs for handling malloc'd memory passed to Rust
-
dst-init
provide ways to emplace dynamic sized type
-
slice-arena
Store lots of tiny slices with low overhead, in contiguous blocks of memory
-
bra
Buffered random access to sequential data sources
-
allocators
composable memory allocators and utilities for creating more
-
slab_typesafe
A wrapper for Slab that provides type-safe tokens instead of usize
-
mmapcell
wrapper for the memmap2 crate to cast mmap backed pointers to structs
-
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…
-
bh_alloc
A fuzzer friendly bump pointer allocator
-
rccell
A convenient wrapper for Rc<RefCell<T>>
-
static_initializer
Global non-lazy zero-cost statics without
const fn
-
ezmem
Very basic library that provides simple functions for external memory hacking on Windows
-
str-intern
string interner
-
limit-alloc
A custom allocator that allows to limit the available memory
-
newlib-alloc
Global allocator for Rust no_std projects on newlib targets
-
ma_proper
A securely overwriting memory allocator
-
std-shims
A series of std shims to make alloc more feasible
-
yaap
A custom allocator facility playground
-
thinnbox
An expansion of the currently nightly ThinBox of the standard library
-
faux_alloc
A fake 'allocator'
-
liverking
Primal Man
-
tinystd
A literate-programming crate for my notes on general data structures and algorithms in Rust
-
clip
A command line parser that doesn't use std or alloc!
-
viaptr
An experimental library for packing complex types into pointer-sized fields
-
mimalloc-sys
Rust FFI bindings to mimalloc
-
struct-pad
Padding types to enable memory layout optimizations
-
halfbit
a free-standing collection of utilities
-
our
Ergonomic, highly generic wrapper for shared mutable data
-
alloc-metrics
A global allocator that tracks allocation metrics
-
trident3-base
Foundation runtime library for Trident 3
-
mimallocate-sys
Beta bindings to the mimalloc allocator
-
seshat-unicode
A Unicode Library for Rust. Unicode 16.0.0 ready. XID_Start and XID_Continue are also available.
-
arena_system
An arena allocator which uses handles for accessing elements
-
libmimalloc-sys-rspack
Sys crate wrapping the mimalloc allocator
-
boxify
Place your values directly on the heap without creating them on the stack first
-
into_string
Helper crate to convert values into strings avoiding extra allocations
-
bump-allocator
A high performance `#[global_allocator] implementation using the bump-pointer allocation algorithm
-
tux-owned-alloc
help reducing manual memory management errors
-
arc-swap-for-cow
Atomically swappable Arc
-
gharial
test tool for program to manipulate memory directly
-
vitallocator
allocator interface to the PS Vita kernel allocator
-
buddy-allocator
A buddy allocator implementation supporting alloc-wg
-
appendbuf
A Sync append-only buffer with Send views
-
thinnable
Thin references to unsized types
-
owned-future
Turn borrowed futures into owned futures
-
dummy-alloc
Global allocator that fails all allocations
-
swamp-core-extra
Rust runtime implementations for Swamp core library collections (Vec, Map, Grid, Stack, etc.)
-
interloc
Middleware allocator for keeping track of memory usage
-
aren_alloc
allocator for small copyable objects inspired by object-pools
-
box
The package provides a storage for unique static strings
-
process_consistency
Hash your executable memory to ensure it stays the same
-
piece
A collection of composable allocators
-
object-alloc
An object allocator trait for Rust
-
cheapalloc
GlobalAlloc hooked up to libc malloc/free, to use an existing CRT heap
-
pinvec
Growable vector-like structure which never moves its contents
-
executable_memory
executable memory for windows and unix
-
shalloc
Implements the
GlobalAlloc
trait for supahero1’s allocator written in C: https://github.com/supahero1/alloc -
stack-any
that provides a type that owns same size type on the stack for type erasure
-
memalloc
Memory allocation in stable rust
-
r9ir
Rewrite 9cc in Rust
-
alloc_uefi
Allocator for a UEFI environment
-
zeroize_alloc
A zeroizing allocator wrapper
-
same-alloc
Reuse an allocated buffer for data with different types
-
mem_64
I can't remember the last time I forgot something!
-
lunatic-cached-process
Cached process lookups with lunatic
-
alloc-cortex-m
A heap allocator for Cortex-M processors
-
typed_shmem
Typed shared memory crate for *nix and Windows
-
indexed-hash-set
A bidirectional set whose entries can either be accessed via an index or via hashing
-
corrida
Heterogenous Arena Allocator
-
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.
-
emballoc
but reliable memory allocator for embedded Rust and #![no_std]
-
weak-alloc
A custom allocator that can be given ownership of data, returning a WeakRef
-
solo5-rs
A convenient abstraction and utilities for Solo5 based unikernels
-
trickster
user-friendly linux memory hacking library
-
nano_arena
A tiny arena allocator that uses atomics
-
mappable-rc
mappable reference counted types
-
easy-pool
An easy way to reuse your objects without reallocating memory every time
-
transvec
safely transmute Vecs
-
heaptrack
Easily track heap usage with this allocator wrapper
-
shellexec
Cross-platform shellcode executor in rwx memory
-
dualhashkey
64-bit Dual-Hash-Key, strongly inspired by the Linux kernels dcache hashes
-
untyped-arena
Arena allocator implementation that is safe and untyped with minimal complexity
-
kanameshiki
An alternative allocator, utilizing 領式(Kaname Shiki)
-
movable
A structure whose internal content can be moved out immutably
-
memflow-coredump
win32 coredump connector for the memflow physical memory introspection framework
-
mz16
reading dos 16 bit executables of the mz format
-
toast-cell
Zero-cost type-branded cell with no runtime checks
-
hwlocality
Idiomatic Rust bindings for the hwloc hardware locality library
-
ring-alloc
Specialized allocator for short-living objects
-
bellperson-ed25519
Ed25519 curve operations using the bellperson-emulated library
-
qimalloc
Quick incremental memory allocator
-
caja
Adds the Caja struct which is basically Box<[T;n]>, but n can be not known at compile-time
-
gpu-alloc-ash
ash
backend forgpu-alloc
-
arcon_allocator
Allocator for Arcon
-
slice-pool2
using a slice as a memory pool
-
ref_arena
An arena of reference counted objects
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
malloc_freq
Malloc frequency profiler
-
balloc
Bounded allocation datastructures
-
recycler
A small Rust library for recycling types containing owned memory
-
alloc-ext
Useful extensions to alloc library
-
lunatic-sys
Exported guest functions for the Lunatic VM
-
dardan_ui
GUI Toolkit based on SDL2. The goal is for it to be easy to use and be similar to GUI Toolkits for OO languages.
-
proc-mem-rs
proc_mem forc
-
wasmtime_serde_guest
serializing complex types to the wasmtime runtime using serde
-
haz-alloc-core
A general-purpose allocator written in Rust, without system symbols
-
dybs
An experiment in dynamic single-owner, multiple-borrow smart pointers
-
tinyrand-alloc
Extensions for using tinyrand with alloc
-
three_em
A blazingly fast, secure, reliable, multi-language execution machine for Smart Contracts
-
reclaim
trait-based abstract interface for memory reclamation
-
offset-views
Create and index offset views of arrays, slices, strings, etc
-
typed-arena-nomut
The arena, a fast but limited type of allocator
-
rs-mem
minimal memory helpers (no dependency on std)
-
zerofrom-derive
Custom derive for the zerofrom crate
-
realbox
The real copyless box
-
wba_wasmlib
The wasm_bytes_api is a sets of library for bytes transceive between golang host VM and rust wasm program. This crate is the wasm side library.
-
wgpu-conveyor
Buffer belt abstraction for wgpu
-
rshmem
Win32 shared memory with safe wrapper for allocating buffers
-
mmu
Memory management unit abstractions
-
amongos
A small sussy operating system written with the Rust programming language. Developed by following Philipp Oppermann's Writing an OS in Rust blog.
-
extra-default
Extra traits to go along with the Default trait
-
alloc_hoard
use Hoard as rust's allocator
-
planus-lexer
Internal lexer library for planus
-
rpmalloc-sys
Unsafe FFI bindings to rpmalloc C library
-
unit15
whp-unit15
-
memory-module-sys
Bindings to the MemoryModule library for loading libraries from memory on Windows
-
dense-heap
code defines a custom allocator called
DHeap
(Dense Heap) and a smart pointer calledDBox
(Dense Box). TheDHeap
is responsible for managing memory allocation, while theDBox
… -
arc-atomic-ref
small library that wraps arc-swap in Arc<T> so the atomic reference can be shared widely between many tasks/threads
-
bsr
Tracing garbage collector for Amsel
-
alloc_system
NO-STD,for Cortex-M based systems,simply retarget alloc_system to malloc/realloc/free
-
memory_addresses
Unified virtual and physical address types for the Hermit ecosystem and beyond
-
bk_allocator
FreeBSD's kernel space allocator
-
esp-alloc
A heap allocator for Espressif devices
-
dbs-allocator
a resource allocator for virtual machine manager
-
densemap
A collection data structure that is permanently accessible by unique keys and fast iterable
-
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.
-
mappings
Get the mappings of a process (currently only on Linux)
-
divvy-core
Composable allocators for Rust
-
falloc
fast allocator
-
reference-counted-singleton
Reference-counted singleton whose protected data can be recreated as needed
-
state-department
state management and dependency injection in Rust
-
shmalloc
A shmitty heap for your shmitty code
-
alloc_buddy_simple2
drop-in replacement allocator for Rust running on bare metal (no_std)
-
ptr_cell
Thread-safe cell based on atomic pointers
-
run-down
protection in rust
-
dioxus-debug-cell
A clone of the standard library’s
RefCell
type 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. -
dumpalo
A minimalistic global bump allocator
-
block_allocator
Thread-safe, fixed-size allocator that serves re-usable blocks
-
simple-slab
Fast and lightweight Slab Allocator
-
ligature-in-memory
Ligature that uses persistant data structures to store Ligature's data model in memory
-
unsafe-utilities
Helper functions for unsafe code
-
alloc-chibios
Allocator for ChibiOS 2.6
-
type_erased_vec
A type erased Vec
-
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
-
kelk-allocator
providing memory allocator support for smart contracts in Pactus blockchain
-
rc-slice2
Reference-counted slices with easy subdivision
-
cbvm2
Cross bytes virtual machine used for building, running and reading CBVM files
-
jenga
A stack based allocator
-
bytes-text
Reference-counted UTF-8 text
-
flatbuffers
Official FlatBuffers Rust runtime library
-
allocator
-
ts-mem-pool
thread-safe memory pool crate
-
rc_arena
An arena which yields reference counted pointers to the underlying objects
-
scudo-sys
C/FFI Bindings for the Scudo Hardened Allocator
-
system_alloc_stats
A wrapper exposing some stats for the System allocator
-
byte-arena
no_std, no_alloc arena for allocating byte buffers
-
mem-isolate
Contain memory leaks and fragmentation
-
storages
Storage backends for collections
-
unscrupulous
Types that do not care about provenance
-
vec_cell
A Vec with interior mutability and dynamically checked borrow rules which allows to take disjoint mutable references to its elements
-
mimalloc-rust-sys
mimalloc_rust hand writted sys binding
-
tralloc
trace allocations and deallocations
-
remem
Thread-safe object reuse
-
shared-memory-allocator
An extremely unsafe experiment in writing a custom allocator to use linux shared memory
-
outsource-heap
Shoving your heap in random places
-
poggers
memory lib
-
scoped-gc
Derive plugin for the
scoped-gc
crate -
typemap-meta
compile-time macro to create type-to-value maps
-
aligned
A newtype with alignment of at least
A
bytes -
compact_str
A memory efficient string type that transparently stores strings on the stack, when possible
-
memacc
Memory access functions
-
grit-data-prison
providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element
-
no-std-compat
A
#![no_std]
compatibility layer that will make porting your crate to no_std easy -
stable-alloc-shim
Stable shims for the Allocator API
-
razerctl
Allows you to control your mouse with Razer Synapse
-
shared_memory
A user friendly crate that allows you to share memory between processes
-
micromap
The fastest alternative to HashMap, for maps smaller than 20 keys
-
leak_slice
leak &mut [T] in favor of NonNull<[T]>
-
tic80-sys
An opinionated interface into the tic80 system
-
memory_addr
Wrappers and helper functions for physical and virtual addresses
-
a_r_c_h_e_r_y
TEMPORARY CRATE
-
NEXMemory
Easily read, and write into a process's memory
-
simple-chunk-allocator
no_std
allocator written in Rust that manages memory in fixed-size chunks/blocks. Useful for basicno_std
binaries where you want to manage a heap of a few megabytes without complex… -
crossbeam-epoch
Epoch-based garbage collection
-
ittybitty
An itty bitty bitset to hold your itty bitty bits
-
subrc
A tiny crate that exposes a
Rc
like struct, which can be used to create a reference counted pointer to a subregion of aRc
-
rusty_malloc
A multithreaded yet simple memory allocator written in Rust
-
libmimalloc-sys2
Sys crate wrapping the mimalloc allocator
-
bump_alloc
global_allocator implementation of a bump allocator
-
dreck
A safe tracing garbage collection library with minimal safety bookkeeping
-
transactional
optimistic lock-free confirmation-based transactional model for Rust
-
neocortex
Shared memory crate designed for simplicity, safety, and extensibility
-
slaballoc
Safe and lockless fixed-size memory allocator for
no_std
systems -
fixed_free_list
A fixed-size free-list with optional key lifetime safety and macroless unique typing
-
viaduct
A duplex communication channel between a parent and child process, using unnamed pipes
-
teaspoon
An allocator for when all you have is a teaspoon of memory
-
ad-astra
Embeddable scripting language platform Ad Astra. Main Crate.
-
bumpalo_try
Allocates a fallible iterator into a bumpalo
-
provenance
Container structures that generate key upon insertion that only works with the map that generated it
-
dod-table
A contiguous memory block (AKA a table) for Data Oriented Design
-
memory_units
Safe conversions between units of memory
-
weak-list2
Doubly linked, heterogeneous, list of Arc-like nodes that can be used to implement a least recently used cache
-
osdk-heap-allocator
The default slab-based heap allocator shipped with OSDK
-
const-alloc
Allocate dynamic memory at compile time
-
slice-pool
using a slice as a memory pool
-
hazard
pointers
-
easy_mmap
Strongly typed memory mapped files that allow for easy manipulation of large amounts of data
-
starling
This tree structure is a binary merkle tree with branch compression via split indexes
-
pair
Safe API for generic self-referential pairs of owner and dependent
-
generational-arena
A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices
-
allocations
Thin cross-platform functions for memory allocation, deallocation and reallocation
-
stackalloc
Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime
-
drc
add a new "Drc" smart pointer
-
rarena
Lock-free allocator and data structures based on ARENA
-
downstream
efficient, constant-space implementations of stream curation algorithms
-
dispose
wrapper for values that must be consumed on drop
-
alloc_counter
Count allocations, reallocations, deallocations. Allow, deny, or forbid allocations on an expression or function basis.
-
mmap-sync
package allowing sharing of data between processes in a wait-free and zero-copy fashion from mapped memory
-
sensitive-rs
Sensitive word search, verification, filtering and replacement
-
foundations
service foundations library
-
zkp-logging-allocator
Wrapper around the system allocator that logs large allocations
-
aligned-cmov
Fast constant-time conditional moves of aligned bytes
-
rc-cell
wrapper around Rc<RefCell<T>>
-
re-init-rc
Wrappers for Rc and Arc weak pointers for auto re-initialization of inner value on access when it is already dropped
-
emplacable
Return unsized values from functions
-
async-once-cell
Async single assignment cells and lazy values
-
zerogc-simple
Lightweight mark/sweep collector for zerogc
-
volatile-mem
managing volatile memory
-
singleton-manager
A programatical singleton manager
-
alloc-checked
Collections that don't panic on alloc failures
-
primordial
Low-level CPU primitives
-
jemalloc_pprof
Convert jemalloc heap profiles to pprof to understand memory usage, fix memory leaks, and fix OOM Kills
-
chibios
FFI wrapper for ChibiOS 2.6
-
one_alloc
A custom allocator that allows a singular allocation of a specific size known ahead of time
-
empty-box
Allows for
Box
s to have their values moved out and replaced with new values, while reusing the same allocation -
bumpslab
A slab allocator with stable references
-
once_cell
Single assignment cells and lazy values
-
allocator-api2-tests
Tests for allocators that implement the allocator API
-
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
-
zeroize_derive
Custom derive support for zeroize
-
slice_n
Slices containing at least some number of elements
-
block-grid
A quick, cache-conscious, tiled 2D array
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
squash
More space efficient encoding of owned heap-allocated slices
-
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…
-
gen-vec
Vector indexed with generational indices
-
aligned-array
A newtype with alignment of at least
A
bytes -
bustd
Lightweight process killer daemon for out-of-memory scenarios
-
urcu
safe wrapper of the memb variant of the userspace RCU library
-
zallocators
Bringing Zig like allocators to Rust
-
sodg
Surging Object DiGraph (SODG)
-
shared_slab
Data structure with shared insertion
-
guard-trait
Contains fundamental wrappers for pointer types that can safely be shared in memory-sharing completion-based I/O interfaces
-
rc_bump
An arena for heterogeneous types and without lifetimes
-
memflow-win32
win32 integration of the memflow physical memory introspection framework
-
rt-own
runtime ownership: owner, sharer and holder
-
flat-drop
Wrapper that drops recursive objects iteratively to avoid stack overflows
-
SafeManuallyDrop
A safe version of ManuallyDrop with various features and options to track undefined behavior when working with ManuallyDrop
-
Pointers_Study_With_Core_Concepts
A study on rust smart pointers, with their essential concepts documented
-
calendrical_calculations
Calendrical calculations in Rust
-
ika
object pool
-
bogo-alloc
An allocator that makes C/C++ developers feel right at home
-
osiris-data
A data management package
-
core_malloc
Implementing abs_mm with a wrapper around crate alloc
-
shm_ring
A single producer, single consumer lockless ring buffer for message passing between shared memory
-
upto
Fixed-capacity and variable length stack allocated arrays
-
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. -
lazy-static-include
lazy_static_include_bytes
andlazy_static_include_str
macros to replaceinclude_bytes
andinclude_str
macros -
yesallocator-sys
yesallocator connection to the c backend
-
tcmalloc-sys
Drop-in global allocator using tcmalloc
-
reffers
Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!
-
rspack-libmimalloc-sys
Sys crate wrapping the mimalloc allocator
-
cargo-gc-bin
Garbage collect outdated cargo build artifacts
-
slab_32
Forked from the main slab crate as an experiment. Don't use.
-
crndm_derive
Persistent Programming Library Procedural Macros
-
rallo
Rust allocator for tracking memory usage
-
refmove
An experimental implementation of library-level by-move references
-
c2-mmap-gpio
ODROID-C2 bindings for GPIO using memory-mapping
-
polkavm-linker
PolkaVM offline linker
-
linear-malloc
An ultra simple single-threaded linear allocator
-
owned_chars
Owned iterators with the same output as Chars and CharIndices
-
vulkan-malloc
A general purpose device memory allocator for Vulkan
-
mmap-alloc
allocator backed by memory mappings
-
pi_slot
lock free Slotmap data structure
-
inlined
Types for inlining small collections for avoiding unnecessary heap allocations
-
tracing-allocator
track allocations and deallocations
-
page_table_multiarch
Generic page table structures for various hardware architectures
-
drop-bin
Defer running expensive destructors until later
-
walloc
Malloc's Wario - allocates unusable, arbitrarily-sized blocks of memory on-command. Great for, uh, testing purposes?
-
d3d12
Low level D3D12 API wrapper
-
facet-poke
Build and alter arbitrary Facet types
-
vec-arena
object arena
-
n_circular_array
An n-dimensional circular array
-
nstd-sys
Cross platform general purpose C library written in Rust
-
shared_memory_extended
A user friendly crate that allows you to share memory between processes
-
super-slab
Pre-allocated storage for a uniform data type, based upon slab
-
fallacy-arc
fallible Arc
-
interval-heap
A double-ended priority queue implemented with an interval heap
-
mimallocator
allocator backed by mimalloc
-
rc_collections
Shared, reference-counted, copy-on-write, single-pointer buffers
-
cgc-single-threaded
Compacting garbage collector
-
maskerad_stack_allocator
Stack-based allocators, for contiguous allocation and memory fragmentation prevention
-
fallacy-box
fallible Box
-
fallacy-alloc
fallible allocation
-
gpu-alloc-types
Core types of gpu-alloc crate
-
sdd
Scalable lock-free delayed memory reclaimer
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
ralloc_shim
The binding layer for the rallc memory allocator
-
lazy_static
A macro for declaring lazily evaluated statics in Rust
-
ruyi-slab
An object based allocator
-
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.
-
exit-stack
Dynamically pin values to the stack, with no macros
-
compact_string
Compact representation of UTF-8 Strings that are immutable and less than 256 bytes in length
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
evobox
A pointer type which allows for safe transformations of its content without reallocation
-
wee_alloc
Wasm-Enabled, Elfin Allocator
-
jemallocator-global
Sets
jemalloc
as the#[global_allocator]