Lib.rs

bumpalo

A fast bump allocation arena for Rust

memmap2

Cross-platform Rust API for memory-mapped file IO

arc-swap

Atomically swappable Arc

jemallocator

allocator backed by jemalloc

sharded-slab

A lock-free concurrent slab

tikv-jemallocator

allocator backed by jemalloc

heapless

static friendly data structures that don’t require dynamic memory allocation

arcstr

A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings

mimalloc

Performance and security oriented drop-in allocator

slab

Pre-allocated storage for a uniform data type

yoke

Abstraction allowing borrowed data to be carried along with the backing data it borrows from

typed-arena

The arena, a fast but limited type of allocator

region

Cross-platform virtual memory API

dlmalloc

port of the dlmalloc allocator

uninit

A collection of tools for a safer usage of uninitialized memory

la-arena

index-based arena without deletion

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…

talc

A fast and flexible allocator for no_std and WebAssembly

allocator-api2

Mirror of Rust's allocator API

rctree

A 'DOM-like' tree implemented using reference counting

vm-memory

Safe abstractions for accessing the VM physical memory

snmalloc-rs

rust bindings of snmalloc

static_cell

Statically allocated, initialized at runtime cell

stats_alloc

An allocator wrapper that allows for instrumenting global allocators

gbm

libgbm bindings for rust

tikv-jemalloc-sys

Rust FFI bindings to jemalloc

mem_dbg

Traits and associated procedural macros to display recursively the layout and memory usage of a value

jemalloc_pprof

Convert jemalloc heap profiles to pprof to understand memory usage, fix memory leaks, and fix OOM Kills

rarena-allocator

Lock-free ARENA allocator which can be used in both memory and on-disk

ghost-cell

Compile-time zero-cost borrow-checking of aliased references

gc-arena

safe, incrementally garbage collected arenas

gpu-alloc

agnostic memory allocator for Vulkan like APIs

bump-scope

A fast bump allocator that supports allocation scopes / checkpoints. Aka an arena for values of arbitrary types.

rustc-std-workspace-alloc

integration of crates.io crates into rust-lang/rust standard library workspace

dyn-stack

Dynamic stack wrapper for unsized allocations

aligned

A newtype with alignment of at least A bytes

tiny-fn

Type erased closures on stack

memsec

libsodium/utils

buddy_system_allocator

A bare metal allocator that uses buddy system

jemalloc-sys

Rust FFI bindings to jemalloc

bufsize

bytes::BufMut implementation to count buffer size

stak

Stak Scheme interpreter

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.

static-alloc

A bump allocator on static memory for the alloc-traits crate

lol_alloc

laughably simple wasm global_allocator

memflow

core components of the memflow physical memory introspection framework

object-pool

A thread-safe object pool with automatic return and attach/detach semantics

census

Keeps an inventory of living objects

qcell

Statically-checked alternatives to RefCell and RwLock

jrsonnet-gcmodule

Cyclic garbage collection inspired by CPython's gc implementation

hipstr

string for Rust: zero-cost borrow and slicing, inline representation for small strings, (atomic) reference counting

esp-alloc

A heap allocator for Espressif devices

offset-allocator

A port of Sebastian Aaltonen’s OffsetAllocator to Rust

micromap

The fastest alternative to HashMap, for maps smaller than 20 keys

cluFullTransmute

A more complete and extended version of data transformation with and without constraint checking

arcshift

Replacement for std::sync::Arc<T> that supports updating the value, with some caveats

slotmapd

orlp/slotmap fork where serialization cycle doesn't change observable behavior

reblessive

A small runtime for running deeply nested recursive functions

mmtk

framework for the design and implementation of high-performance and portable memory managers

rustix-dlmalloc

port of the dlmalloc allocator, ported to rustix

hyperlight-guest

build guest applications for hyperlight

lgalloc

Large object allocator

kamo

assist in the creation of an interpreter or compiler and its associated runtime

checkers

A sanity checker for global allocations

emballoc

but reliable memory allocator for embedded Rust and #![no_std]

inplace_it

Place small arrays on the stack with a low-cost!

buddy-alloc

memory allocator for no-std Rust, used for embedded environments

wdk-alloc

alloc support for binaries compiled with the Windows Development Kit (WDK)

tracy_full

Fully featured bindings for the Tracy profiler

peak_alloc

An allocator to keep track of (the max) allocated memory

istring

A replacement for String that allows storing short strings of length up to sizeof<String>() - 1 without a heap allocation

dumpster

A concurrent cycle-tracking garbage collector

secmem-alloc

Custom allocators for secret memory

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

stackalloc

Safely allocate and manipulate arbitrarily-sized slices on the stack at runtime

tor-memquota

Memory use tracking and quota utilities, used by Tor software

tendril

Compact buffer/string type for zero-copy parsing

ufotofu

Abstractions for lazily consuming and producing sequences

refuse

incremental, multi-threaded garbage collector

stats_alloc_helper

A test helper to measure memory allocations

ra_ap_la-arena

index-based arena without deletion

rabuf

randome access buffer for io

process_vm_io

I/O access to virtual memory contents of processes

haphazard

Dynamic memory management for lock-free data structures using hazard pointers

lifeguard

An object pool manager in Rust

vptr

Thin references to trait objects by embedding the virtual table pointer in the struct

id-arena

id-based arena

presser

help you copy things into raw buffers without invoking spooky action at a distance (undefined behavior)

composable-allocators

Composable memory allocators for new allocator API

mini-alloc

Very simple global allocator

include_bytes_aligned

macro that embeds the bytes of an external file into the executable and guarantees that they are aligned

lightweight-mmap

memory mapping helpers for Rust, with minimal amount of code generated

cache-size

finding your L1/L2/L3 cache sizes

vm-allocator

Helpers for allocating resources needed during the lifetime of a VM

allocation-counter

Count the number of memory allocation of some code

reloaded-memory-buffers

Shared, Concurrent, Permanent Memory Allocator tied to Process Lifetime

kernel-alloc

Minimalistic Windows Kernel Allocator

token-cell

A more convenient GhostCell

range-alloc

Generic range allocator

good_memory_allocator

A blazingly fast and memory efficient memory allocator to be used in no_std environments

boa_gc

Garbage collector for the Boa JavaScript engine

dyn_size_of

report approximate amount of memory consumed by variables, including the memory allocated on heap

timely_communication

Communication layer for timely dataflow

rust-cc

A cycle collector for Rust programs

pi_world

ecs world

shared_vector

Reference counted vector data structure

flexstr

A flexible, simple to use, immutable, clone-efficient String replacement for Rust

memory_set

Data structures and operations for managing memory mappings

wayrs-utils

A collection of utils and abstractions for wayrs-client

slimmer_box

A packed alternative to Box<T> whose 'fat' pointer is 'slimmer'

sandpit

A concurrent garbage collected arena

compact_arena

some types to allow indexed arenas with small memory footprint

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.

escoba

Useful broom to clean your RAM in Window$

safe-gc

A garbage collection library with zero unsafe code and zero dependencies

disqualified

type names more user-readable

stak-repl

Stak Scheme REPL

alloc-checked

Collections that don't panic on alloc failures

second-stack

A fast allocator for short-lived slices and large values

alloc_cat

allocator for small-to-tiny Wasm projects in rust

tlsf

Two-Level Segregated Fit (TLSF) allocator with optimized memory footprint

stele

An atomic Vec-like structure with no copying on allocation

gc

Tracing garbage collector plugin for Rust

shared-buffer

An abstraction over buffers backed by memory-mapped files or bytes in memory

pin-weak

Small wrapper around an equivalent of Pin<Weak<T>>

heap-array

variable length array, with its main benefit over Vec is taking up less space

recycle_vec

method for Vec to recycle it's backing allocation for use with another Vec of different type

datasize

A simplified heap memory size estimator

rpmalloc

Cross-platform global memory allocator using rpmalloc

metriki-jemalloc

Metriki integration for jemalloc

moveref

Types and traits for safe C++ style placement initialization and move semantics

mapped-file

Construct a memory mapping over any file object

process-image

Zero-cost abstraction for convenient access to process image tags

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

aligned-buffer

A buffer with controllable alignment, that can be sealed and shared by reference count

generational-box

A box backed by a generational runtime

slabbin

An efficient slab allocator with stable addresses

jemalloc-ctl

A safe wrapper over jemalloc's control and introspection APIs

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…

malloced

A malloc-ed box pointer type

product-os-http-body

Product OS : Http Body is a derivative of the http-body and http-body-util crates restructured for both std and no_std environments

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…

corundum

Persistent Programming Library

skiplist-rust

A lockless skiplist implementation in Rust

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

opendal_compat

Apache OpenDAL Compat

zone-alloc

Containers for zone-based data allocation

triple_arena

Regular, Chain, Surjection, and Ordered Arenas supporting non-Clone types, deletion, and more

hardened_malloc-rs

hardened_malloc rust wrapper

memflow-qemu

qemu connector for the memflow physical memory introspection framework

hash_cons

A type-safe hash-cons library

rodeo

Fast dropping arena based on bumpalo

memuse

Traits for measuring dynamic memory usage of types

arena-allocator

Virtual memory based linear allocator

byte-pool

Pool of byte slices, for efficient memory usage

olis_string

Small-string optimization for Rust, aims to replace std::string::String

mimalloc2-rust

the fork of the best binding for mimalloc in rust

free-list

A free-list-based page/frame allocator

buffet

Thread-local buffer pool for the loona crate

libmimalloc-sys

Sys crate wrapping the mimalloc allocator

fixed_heap

A fixed-size heap structure with manually provided stateful comparison function

stylish-style

Internal implementation details of stylish-core

contiguous-mem

A contiguous memory storage

mockalloc

allow testing code which uses the global allocator

mimalloc-rust

the best binding for mimalloc in rust

heapsz

calculating the heap usage of a data structure

pi_key_alloter

lock free Key(idx:u32, version:u32) alloter

hzrd

Shared mutability containers based on hazard pointers

kona-common

Common traits and system interfaces for developing client programs on top of Fault Proof VMs

parr

A C-like unknown-length array type

alloc-madvise

A memory allocator for creating large aligned chunks of memory

fixed-typed-arena

A typed arena that uses fixed-size chunks to ensure non-amortized O(1) allocations

ocaml-boxroot-sys

Boxroot for OCaml: fast movable GC roots (C API)

shush-rs

designed to manage sensitive data securely by leveraging memory protection mechanisms

heapless_matrix

efficient implementation of a matrix data structure in Rust. It offers functionality for creating, manipulating, and performing operations on matrices, such as transposition, summation, and multiplication.

mmap-wrapper

wrapper for the memmap2 crate to cast mmap backed pointers to structs

blink-alloc

Fast, concurrent, arena-based allocator with drop support

slaballoc

Safe and lockless fixed-size memory allocator for no_std systems

orderly-allocator

A super-simple fast soft-realtime allocator for managing an external pool of memory

drop_arena

A single-type allocator which permits dropping and reclaiming of individual elements

secret_mem

securely managing sensitive data in memory

resourcetrack

Basic tools for counting objects

panic-room

An experiment in panic handling with setjmp/longjmp and arenas

rsbmalloc

but fast binned allocator for Rust. Single-threaded for no_std, multi-threaded otherwise

vonneumann

executable memory for windows and unix

bitmap-allocator

Bit allocator based on segment tree algorithm

arc-swap-for-cow

Atomically swappable Arc

bbx

A robust, performant BBCode pull parser

ralloc

An efficient alternative platform-agnostic allocator

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…

unchecked-std

some methods from the Rust standard library without some checks

salloc

Safe C-like memory allocator for windows

thisenum

Assign constant literals to enum arms

unescape_zero_copy

Unescape strings without allocating memory

supply-chain-trust-example-crate-000064

Pre-allocated storage for a uniform data type

mappings

Get the mappings of a process (currently only on Linux)

jit-allocator

An executable code allocator

trc

A faster Arc

ferroc

A fast & lock-free memory allocator library

mem-rs

pattern scanning and abstraction for pointers in memory of running processes

bulk_allocator

Implementations of GlobalAlloc holding memory cache

ndata

Thread-safe, self-owned JSON-like data with manual garbage collection

gpu-alloc-vulkanalia

vulkanalia backend for gpu-alloc

ouroboros_examples

Examples for the ouroboros crate

sgx_alloc

Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language

broxus-util

A collection of utils used at Broxus

stylo_malloc_size_of

Support crate for Stylo CSS engine

deepsize

measuring the total size of object on the stack and heap

virtual-buffer

A cross-platform library for dealing with buffers backed by raw virtual memory

roussillon-memory

Memory utility for the roussillon language

ialloc

Allocator interface traits

isoalloc

Security oriented allocator

dudy-malloc

Easy way to configure best memory allocation for each platforms

generic-vec

a vector implementation that can be used in no_std envioronments

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)…

pages-and-pages

Allows control over a manually allocated region of page-aligned memory with support for granular protection and locking of underlying pages

syncpool

A thread-friendly library for recycle of heavy and heap-based objects to reduce allocation and memory pressure

process-memory

that can read/write the memory of other processes

aligners

alignment guarantees for data

r-efi-alloc

UEFI Memory Allocator Integration

bump_future

Type Erased Future Stored In Bump

cactusref

Cycle-aware reference counting smart pointer

memusage

Small trait utility to keep track of the memory usage of structs

default-boxed

Helper trait to help create large struct on heap directly

pared

Projected reference counted pointers

teaspoon

An allocator for when all you have is a teaspoon of memory

flipflop

Stress-tester for double-ended iterators

dns-protocol

A DNS protocol implementation in Rust

persistence

A resizable, mutable array type implemented on top of mmap, providing persistence for arrays of data in memory

shard-ecs

The Shard Entity Component System

pprof_util

various utilities for representing and manipulating profiling data

pin-cell

A pin-safe cell

columnation-master

An experimental columnar arena

bump-into

a no_std bump allocator sourcing space from a user-provided slice

swap-pool

Allow objects to be stored either in RAM or on disk

thunderdome

Fast arena allocator with compact generational indices

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”

fast-smr

Toward fast, wait-free, portable, and robust memory reclamation

heapbuf

Fixed size heap buffer with optional custom alignment, ref counting and custom destructor logic

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…

easyrw

Easy Read and Write functions in rust, External and Internal

reap

parsing Ruby heap dumps

slabby

Maximally efficient allocation and deallocation of a large number of instances of a type

effective-limits

Estimate effective resource limits for a process e.g. how much RAM is available for use.

block-grid

A quick, cache-conscious, tiled 2D array

frusa

A system allocator with reclaim

recycle-box

A pointer type for heap-allocated objects which heap storage can be re-used, with Pin support

scratchpad

Stack-like memory allocator with double-ended allocation support

allocdeny

Deny the use of crate alloc

arena-traits

Traits for arenas

peakmem-alloc

An allocator wrapper that allows measuring peak memory consumption

aligned_box

Allocate heap memory with user-specified alignment

tcmalloc2

Rust FFI bindings to tcmalloc

obeli-sk-wasm-workers

Internal package of obeli-sk

build-array

Build an array dynamically without heap allocations

memguar

that helps to optimize IO of large buffers in near-OOM state or with small amount of RAM

mstak-interpret

Minimal Stak Scheme bytecode interpreter

moving_gc_arena

Lightweight Garbage-collectable regions using indices and explicit roots

core_malloc

Implementing abs_mm with a wrapper around crate alloc

dungeon-cell

Store (almost) any value as one type without dynamic memory

alloc-stdlib

A dynamic allocator example that may be used with the stdlib

sensitive

Memory allocator for sensitive information

product-os-tower

Product OS : Tower is a derivative of the tower crate restructured for both std and no_std environments

arc_slice_pool

Arcs backed by chunks of contiguous memory

sodg

Surging Object DiGraph (SODG)

containers

Containers

primordial

Low-level CPU primitives

markable_reader

reader which can be marked in a position to be returned to after subsequent reads

backdrop

Drop your large or complex objects in the background with Backdrop! (later, on another thread, or both! Fully customizable! Tokio supported!)

addr_of_enum

Get address of fields in enum item using stable Rust

async-pool

Statically allocated pool providing a std-like Box, with async functionality

pipe

Synchronous Read/Write memory pipe

pseudo_pool

A pool-like collection that automatically returns objects to the pool & blocks when the pool is empty

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

heap-slice

Basically Box<[T]> but smaller stack size

obj-pool

object arena

cheap

cross platform allocator which communicate over the C ABI

rulloc

General purpose memory allocator

tikv-jemalloc-ctl

A safe wrapper over jemalloc's control and introspection APIs

path_no_alloc

with_paths! macro, for joining paths ergonomically and without allocation

phper-alloc

Alloc related items for phper crate

kioku

A memory arena

memtable

Inmemory tables for use in Rust

musli-allocator

Allocators for Müsli

bdwgc-alloc

impl GlobalAlloc for bdwgc

index_alloc

A toy static allocator wich can serve as a global_allocator

map_box

Map the value in a Box, re-using the allocation when possible

bumpalo_try

Allocates a fallible iterator into a bumpalo

gdcm_conv

Grassroots DICOM Library wrapper

heap-ap

heap access point for anyone in rust, called to c

sparse-bitfield

Bitfield that allocates a series of small buffers

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;…

xalloc

Suballocators for external memory (e.g., Vulkan device memory)

cl-generic-vec

a vector implementation that can be used in no_std envioronments

rcu-clean

Smart pointers using RCU with Deref support

snmalloc-sys

rust raw bindings of snmalloc

timely-bytes-master

Disjoint mutable byte slices from a common allocation

bumpalo-herd

Support for bumpalo in scoped threads & rayon

slitter

A C- and Rust-callable slab allocator with a focus on safety

nimix

An allocator designed to be use by a GC

scudo

Rust Bindings for the Scudo Hardened Allocator

libload_reflective

A package to reflectively load libraries from memory

vulkanalia-vma

An integration of Vulkan Memory Allocator with vulkanalia

qwutils

some utilities

ve

More compact Vec

alloca

Mostly safe wrapper for alloca

mmledger

A ledger for confidential computing (CC) shims for tracking memory management system calls

alloc_geiger

allocator which makes sound when active, like a Geiger counter

thin-slice

An owned slice that packs the slice storage into a single word when possible

range-action-map

A range tree, offering interval operation in kernel memory management, and deliver ACTION to actual VmArea。一个区间树结构，用于提供 mmap / munmap / mprotect 时对内核中区间的操作；

hwlocality-sys

Low-level bindings for the hwloc hardware locality library

rattish

Cast between trait objects

refpool

Efficient memory pool with reference counting

allocator-suite

Allocator Suite for various allocation types

alloc-compose

Composable allocator structures for plugging together more powerful allocators

index-pool

A pool which manages allocation of unique indices. Acts like a psuedo-memory allocator.

candump-parse

parsing the output of the candump utility

tracking-allocator

global allocator that provides hooks for tracking allocation events

haz-alloc

A general-purpose allocator written in Rust

std-shims-mirror

series of std shims to make alloc more feasible. Mirrored by sneurlax from serai for downstream crate-publishing purposes until serai publishes their crates; use the versions from serai in production…

shuffling-allocator

A shuffling allocator, randomizing heap object locations; useful for avoiding accidental cache locality during benchmarking, which can obscure performance evaluation

flatty

Flat message buffers

bsr

Tracing garbage collector for Amsel

rspack_allocator

rspack allocator

talloc

A fast, consistant, and flexible no_std-compatible allocator

tarc

Transposable, type-erasable, and FFI-safe Arc

hipool

RUST Memory Pool

rebound

Full runtime reflection for Rust, with lifetime safety

rax

Rust wrapper for the ANSI C Radix Tree "rax" https://github.com/antirez/rax implementation used in Redis

aligned-buffer-pool

A buffer-pool with controllable alignment

wasm-nopackage

Basic alloc and dealloc and module setup for lightweight WASM modules

maskerad_memory_allocators

custom allocators, for memory fragmentation prevention

hyperscan-sys

Hyperscan bindings for Rust with Multiple Pattern and Streaming Scan

stack-any

that provides a type that owns same size type on the stack for type erasure

refuse-pool

A string interner utilizing the Refuse garbage collector

retry_alloc

A global allocator wrapper that will retry failed allocations

rslab

A slab allocator for Rust

refbox

A smart pointer with a single owner and many weak references

context-allocator

staging-tracking-allocator

Tracking allocator to control the amount of memory consumed by the process

piece

A collection of composable allocators

lockedbox

A Box-like type that prevents paging its contents to disk

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

vecstorage

Re-use the memory for vectors containing values with different lifetimes

box

The package provides a storage for unique static strings

loca

memory allocation

typed-slab

Typed wrapper for Slab

byte-arena

no_std, no_alloc arena for allocating byte buffers

graphannis-malloc_size_of

fork of the malloc_size_of crate, which is part of the Servo codebase, to make it available to the graphANNIS corpus search library as dependency

typed-arena-nomut

The arena, a fast but limited type of allocator

zerogc

Zero overhead tracing garbage collection for rust

discard

trait which allows for intentionally leaking memory

gpu-alloc-ash

ash backend for gpu-alloc

allocators

composable memory allocators and utilities for creating more

alloc-ext

Useful extensions to alloc library