Lib.rs

arc-swap

Atomically swappable Arc

slab

Pre-allocated storage for a uniform data type

bumpalo

A fast bump allocation arena for Rust

typed-arena

The arena, a fast but limited type of allocator

memmap2

Cross-platform Rust API for memory-mapped file IO

jemallocator

A Rust allocator backed by jemalloc

mimalloc

Performance and security oriented drop-in allocator

flatbuffers

Official FlatBuffers Rust runtime library

compact_str

A memory efficient string type that transparently stores strings on the stack, when possible

slotmap

Slotmap data structure

heapless

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

vm-memory

Safe abstractions for accessing the VM physical memory

static_init

Safe mutable static and non const static initialization, and code execution at program startup/exit

alloc-stdlib

A dynamic allocator example that may be used with the stdlib

linked_list_allocator

Simple allocator usable for no_std systems. It builds a linked list from the freed blocks and thus needs no additional data structures.

tendril

Compact buffer/string type for zero-copy parsing

tikv-jemallocator

A Rust allocator backed by jemalloc

snmalloc-rs

rust bindings of snmalloc

uninit

A collection of tools for a safer usage of uninitialized memory

yoke

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

memflow

core components of the memflow physical memory introspection framework

bufsize

bytes::BufMut implementation to count buffer size

rctree

A 'DOM-like' tree implemented using reference counting

checkers

A sanity checker for global allocations

stats_alloc

An allocator wrapper that allows for instrumenting global allocators

generational-arena

A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices

gpu-alloc

Implementation agnostic memory allocator for Vulkan like APIs

gc

Tracing garbage collector plugin for Rust

dlmalloc

A Rust port of the dlmalloc allocator

jemalloc-sys

Rust FFI bindings to jemalloc

seize

Fast, efficient, and robust memory reclamation for concurrent data structures

smallbox

Small Box optimization: store small item on stack and fallback to heap for large item

without-alloc

Replacements for Box, Rc, Vec, .. without alloc

ghost-cell

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

dbs-allocator

a resource allocator for virtual machine manager

memsec

Rust implementation libsodium/utils

buddy_system_allocator

A bare metal allocator that uses buddy system

regalloc2

Backtracking register allocator inspired from IonMonkey

slabmalloc

Simple 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.

cluFullTransmute

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

shared_memory

A user friendly crate that allows you to share memory between processes

alloc-no-stdlib

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

good_memory_allocator

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

rabuf

randome access buffer for io

static-alloc

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

object-pool

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

process_vm_io

I/O access to virtual memory contents of processes

ra_ap_la-arena

Simple index-based arena without deletion

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

gbm

libgbm bindings for rust

scudo

Rust Bindings for the Scudo Hardened Allocator

jrsonnet-gcmodule

Cyclic garbage collection inspired by CPython's gc implementation

rpmalloc

Cross-platform global memory allocator using rpmalloc

second-stack

A fast allocator for short-lived slices and large values

cactusref

Cycle-aware reference counting smart pointer

la-arena

Simple index-based arena without deletion

mmap-fixed-fixed

A library for 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…

qcell

Statically-checked alternatives to RefCell and RwLock

lol_alloc

lol_alloc: A laughably simple wasm global_allocator

range-alloc

Generic range allocator used by gfx-rs backends

pi_slotmap

Slotmap data structure

path_no_alloc

Provides with_paths! macro, for joining paths ergonomically and without allocation

static-rc

Compile-time reference counting

corundum

Persistent Programming Library

fixed-bump

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

haphazard

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

memflow-ffi

C bindings for the memflow physical memory introspection framework

presser

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

mmtk

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

scoped-arena

Arena allocator with optional scopes

read-process-memory

Read memory from another process

thunderdome

Fast arena allocator with compact generational indices

primordial

Low-level CPU primitives

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

id-arena

A simple, id-based arena

composable-allocators

Composable memory allocators for new allocator API

simple-chunk-allocator

A simple no_std allocator written in Rust that manages memory in fixed-size chunks/blocks. Useful for basic no_std binaries where you want to manage a heap of a few megabytes without…

onsen

Memory pool

memuse

Traits for measuring dynamic memory usage of types

mimalloc-rust

the best binding for mimalloc in rust

tikv-jemalloc-sys

Rust FFI bindings to jemalloc

token-cell

A more convenient GhostCell

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

datasize

A simplified heap memory size estimator

r-efi-alloc

UEFI Memory Allocator Integration

scope_gc

Scope GC

gomicollector

A simple mark-sweep garbage collector

mmledger

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

obj-pool

A simple object arena

jrsonnet-interner

Jrsonnet string interning

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”

ocaml-boxroot-sys

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

easy-pool

An easy way to reuse your objects without reallocating memory every time

typed-slab

Typed wrapper for Slab

sensitive

Memory allocator for sensitive information

yoke-derive

Custom derive for the yoke crate

triple_arena

Arena supporting non-Clone types, deletion, and more

recycle-box

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

pin-weak

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

rcsv

A non-allocating RFC 4180 compliant CSV parser

alloc-madvise

A memory allocator for creating large aligned chunks of memory

phper-alloc

Alloc related items for phper crate

alloc_counter

Count allocations, reallocations, deallocations. Allow, deny, or forbid allocations on an expression or function basis.

secmem-alloc

Custom allocators for secret memory

boa_gc

Garbage collector used in Boa

alloc-track

Track memory allocations by backtrace or originating thread

discard

Discard trait which allows for intentionally leaking memory

smallest-uint

Gets the smallest unsigned integer type that can represent a given value

customizable-buddy

A new buddy allocator that allows custom buddy finding algorithm

libmimalloc-sys

Sys crate wrapping the mimalloc allocator

broom

An ergonomic tracing garbage collector that supports mark 'n sweep garbage collection

vm-allocator

Helpers for allocating resources needed during the lifetime of a VM

tracking-allocator

global allocator that provides hooks for tracking allocation events

ijson

A more memory efficient replacement for serde_json::Value

mapped-file

Construct a memory mapping over any file object

gc_api

Generic abstractions for a multithreaded garbage collector

bacon_rajan_cc

A reference counted type with cycle collection

snmalloc-sys

rust raw bindings of snmalloc

deepsize

A crate for measuring the total size of object on the stack and heap

rb-allocator

Memorry allocator for Ruby extensions

transvec

A crate to safely transmute Vecs

viaduct

A duplex communication channel between a parent and child process, using unnamed pipes

bookcase_alloc

An arena allocator

rodeo

Fast dropping arena based on bumpalo

kernel-alloc

Minimalistic Windows Kernel Allocator

pkey_mprotect

Typed pkey_mprotect wrapper

scratchpad

Stack-like memory allocator with double-ended allocation support

sgx_alloc

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

malloced

A malloc-ed box pointer type

scudo-sys

C/FFI Bindings for the Scudo Hardened Allocator

flipperzero-alloc

Rust for Flipper Zero

moving_gc_arena

Lightweight Garbage-collectable regions using indices and explicit roots

bdwgc-alloc

impl GlobalAlloc for bdwgc

pool

A pool of reusable values

segvec

SegVec data structure for rust. Similar to Vec, but allocates memory in chunks of increasing size

drop-bin

Defer running expensive destructors until later

abin

A library for working with binaries and strings. The library tries to avoid heap-allocations / memory-copy whenever possible by automatically choosing a reasonable strategy: stack for…

buddy-alloc

Buddy-alloc is a memory allocator for no-std Rust, used for embedded environments

rendy-memory

Rendy's memory manager

bumpslab

A slab allocator with stable references

slice-pool

A library for using a slice as a memory pool

contain

A crate for defining/extending lifetimes

gbfs

A crate for reading gameboy filesystem archives, a format commonly used in GBA homebrew games

structbuf

Capacity-limited structured data buffer

easy_mmap

Strongly typed memory mapped files that allow for easy manipulation of large amounts of data

lifeguard

An object pool manager in Rust

python-oxidized-importer

A Rust-powered Python importer

elise

A concurrent GC

fixed-typed-arena

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

forgotten

globally and safely persist a value, implemented with ManuallyDrop

accountable-refcell

A RefCell wrapper that provides actionable information for dynamic borrow failures

persian-rug

Framework for bringing together disparate objects with inconvenient relationships

spi-flash

SPI flash memory interface crate

mmap-rs

A cross-platform and safe Rust API to create and manage memory mappings in the virtual address space of the calling process

polymock

A thread-safe arena bytes allocator

byte-pool

Pool of byte slices, for efficient memory usage

cache-size

A library for finding your L1/L2/L3 cache sizes

rcu-clean

Smart pointers using RCU with Deref support

jemalloc-ctl

A safe wrapper over jemalloc's control and introspection APIs

gharial

Gharial is a test tool for program to manipulate memory directly

vptr

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

wrc

A thread-safe weighted reference counting smart-pointer for Rust

wayrs-shm-alloc

A helper crate for wayrs-client for shared memory allocation

cl-generic-vec

a vector implementation that can be used in no_std envioronments

allocator_api

This is a 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

memory_units

Safe conversions between units of memory

malloc-array

libc heap array allocator

handy

A library providing handles and handlemaps

refbox

A smart pointer with a single owner and many weak references

accounting-allocator

A global memory allocator wrapper which counts allocated and deallocated bytes

shmem-ipc

Untrusted IPC with maximum performance and minimum latency on Linux

vecstorage

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

reffers

Smart pointers: ARef, that allows even further owner erasure than OwningRef. Strong is a memory efficient Rc + RefCell in one. And more!

tcmalloc

Drop-in global allocator using tcmalloc

allocator-suite

Allocator Suite for various allocation types

vec-tree

A safe tree using an arena allocator that allows deletion without suffering from the ABA problem by using generational indices

virtual-memory

Library for allocating RWX memory on Unix and Windows

rebound

Full runtime reflection for Rust, with lifetime safety

hybrid-rc

Thread-safe hybrid reference counting pointers

tracing-rc

Cycle-aware reference-counted pointers with a safe, simple api

allocators

composable memory allocators and utilities for creating more

staticinit

Safe mutable static and non const static initialization, and code execution at program startup/exit

xalloc

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

outsource-heap

Shoving your heap in random places

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.

ve

More compact Vec

symbol

Simple globally interned strings

alloc-from-pool

Single-threaded object pool implementation

default-boxed

Helper trait to help create large struct on heap directly

pipe

Synchronous Read/Write memory pipe

it-memory-traits

Defines traits that IT uses for accessing memory

zerogc-context

Handles the context of a zerogc collector

rulloc

General purpose memory allocator

tinyrand-alloc

Extensions for using tinyrand with alloc

ferris-gc

Flexible implementation of garbage collector for Rust

typed-arena-nomut

The arena, a fast but limited type of allocator

gc-arena

safe garbage collected arenas

context-allocator

cell-gc

A fun garbage collector for that virtual machine you're writing in Rust

shared_arena

A thread-safe & efficient memory pool

poule

A pool of reusable values

slotmap-fork-otter

Slotmap data structure - temporary fork for Otter

heaparray

Flexible support for dynamically-sized types, using heap-allocated array of structs

index-pool

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

rpmalloc-sys

Unsafe FFI bindings to rpmalloc C library

netbuf

The simple to use, growable, contiguous buffer object with right assumptions and interface. Tuned for using it for network buffers.

compact_arena

A crate with some types to allow indexed arenas with small memory footprint

rslab

A slab allocator for Rust

memur

Arena storage with bells and whistles

ralloc_shim

The binding layer for the rallc memory allocator

mockalloc

A crate to allow testing code which uses the global allocator

memflow-win32

win32 integration of the memflow physical memory introspection framework

heterovec

In-place vector of dynamically sized type

haz-alloc

A general-purpose allocator written in Rust

memory-cache-rs

Simple local in-memory cache for Rust

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…

dairy

A more compact, user friendly clone-on-write smart pointer

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!

mitochondria

Mitochondria is the powerhouse of the Cell

owned-alloc

A crate to help reducing manual memory management errors

jrsonnet-gc

Tracing garbage collector plugin for Rust

tikv-jemalloc-ctl

A safe wrapper over jemalloc's control and introspection APIs

maskerad_memory_allocators

custom allocators, for memory fragmentation prevention

polymorph-allocator

A simple memory allocator

fpool

Non-leased object-pooling

object-alloc

An object allocator trait for Rust

range-action-map

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

include_bytes_aligned

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

heapnotize

A smart pointer type for memory allocation on the stack

hsa

Heterogeneous System Architecture(HSA) bindings for Rust

mmapio

Cross-platform Rust API for memory-mapped file IO

cryptovec

A vector which zeroes its memory on clears and reallocations

quickdry

Bump-pointer arena allocator

nstd_alloc

NSTD memory allocation crate

ipfs-embed-cli

Cli for ipfs-embed

stable-alloc-shim

Stable shims for the Allocator API

leak-detect-allocator

Memory leak detector for nightly toolchain

maybe-std

Helper crate for writing rust libraries with an optional dependency on the standard library

crndm

Persistent Programming Library

ma_proper

A securely overwriting memory allocator

shredder

Garbage collection as a library for Rust

dreck

A safe tracing garbage collection library with minimal safety bookkeeping

sodium-alloc

Allocator type that allocates memory using Sodium's secure memory utilities

maligned

A memory alignment library

zalloc

A global allocator wrapper zeroizing memory on dealloc

aliasable_deref_trait

Marker trait for types that deref to an address that is aliasable when coerced to a raw pointer

leak_slice

leak &mut [T] in favor of NonNull<[T]>

alloc_buddy_simple2

Simple, drop-in replacement allocator for Rust running on bare metal (no_std)

co_heap

Reserved. Heap cooperation for **safe** applications & libraries.

growable

A growable, reusable box for Rust