Lib.rs

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

jemallocator

allocator backed by jemalloc

stacker

A stack growth library useful when implementing deeply recursive algorithms that may accidentally blow the stack

mimalloc

Performance and security oriented drop-in allocator

heapless

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

yoke

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

slab

Pre-allocated storage for a uniform data type

v8

Rust bindings to V8

typed-arena

The arena, a fast but limited type of allocator

elsa

Append-only collections for Rust where borrows to entries can outlive insertions

region

Cross-platform virtual memory API

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

archery

Abstract over the atomicity of reference-counting pointers

talc

A fast and flexible allocator for no_std and WebAssembly

uninit

A collection of tools for a safer usage of uninitialized memory

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…

la-arena

index-based arena without deletion

tendril

Compact buffer/string type for zero-copy parsing

embedded-alloc

A heap allocator for embedded systems

mem_dbg

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

object-pool

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

boa_gc

Garbage collector for the Boa JavaScript engine

stats_alloc

An allocator wrapper that allows for instrumenting global allocators

gbm

libgbm bindings for rust

hipstr

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

gc-arena

safe, incrementally garbage collected arenas

memflow

core components of the memflow physical memory introspection framework

rctree

A 'DOM-like' tree implemented using reference counting

dyn-stack

Dynamic stack wrapper for unsized allocations

vm-memory

Safe abstractions for accessing the VM physical 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

bufsize

bytes::BufMut implementation to count buffer size

ghost-cell

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

reblessive

A small runtime for running deeply nested recursive functions

arcshift

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

static-alloc

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

bump-scope

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

census

Keeps an inventory of living objects

mmtk

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

gpu-alloc

agnostic memory allocator for Vulkan like APIs

jrsonnet-gcmodule

Cyclic garbage collection inspired by CPython's gc implementation

cluFullTransmute

A more complete and extended version of data type conversion without constraint checks

pi_slotmap

Slotmap data structure

tikv-jemalloc-sys

Rust FFI bindings to jemalloc

lgalloc

Large object allocator

dlmalloc

port of the dlmalloc allocator

mmap-rs

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

jemalloc-sys

Rust FFI bindings to jemalloc

get-size2

Determine the size in bytes an object occupies inside RAM

mini-alloc

Very simple global allocator

slotmapd

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

range-alloc

Generic range allocator

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

tor-memquota

Memory use tracking and quota utilities, used by Tor software

dumpster

A concurrent cycle-tracking garbage collector

inplace_it

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

lol_alloc

laughably simple wasm global_allocator

rarena-allocator

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

kamo

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

include_bytes_aligned

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

memur

Arena storage with bells and whistles

qcell

Statically-checked alternatives to RefCell and RwLock

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…

process_vm_io

I/O access to virtual memory contents of processes

memsec

libsodium/utils

memsafe

A Secure cross-platform Rust library for securely wrapping data in memory

secmem-alloc

Custom allocators for secret memory

checkers

A sanity checker for global allocations

mimalloc-safe

Performance and security oriented drop-in allocator

buddy-alloc

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

rust-cc

A cycle collector for Rust programs

poggers

memory lib

stats_alloc_helper

A test helper to measure memory allocations

rabuf

randome access buffer for io

stackalloc

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

flexstr

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

lightweight-mmap

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

pared

Projected reference counted pointers

offset-allocator

A port of Sebastian Aaltonen’s OffsetAllocator to Rust

ialloc

Allocator interface traits

refuse

incremental, multi-threaded garbage collector

gc

Tracing garbage collector plugin for Rust

stalloc

fast first-fit memory allocator that you can use to quickly speed up your Rust programs

vptr

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

shellexec

Cross-platform shellcode executor in rwx memory

rustix-dlmalloc

port of the dlmalloc allocator, ported to rustix

reference-counted-singleton

Reference-counted singleton whose protected data can be recreated as needed

triple_arena

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

weak-table

Weak hash maps and sets

wdk-alloc

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

thunderdome

Fast arena allocator with compact generational indices

process-image

Zero-cost abstraction for convenient access to process image tags

ra_ap_la-arena

index-based arena without deletion

graph-api-simplegraph

efficient graph implementation for the graph-api ecosystem with support for indexing

picoalloc

small and fast memory allocator

slabbin

An efficient slab allocator with stable addresses

statusinfo2

print various metrics of your system

lifeguard

An object pool manager in Rust

ringal

Efficient ring allocator for short-lived buffers

id-arena

id-based arena

libcanopy

Canopy is a lightweight tree-based data structure for Rust, optimized for reference management using Rc and Weak pointers

dyn_size_of

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

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…

haphazard

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

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

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.

shared-buffer

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

pi_atom

The global thread safe atomic string pool reduces the memory occupation of the same string and is also used for HashMap keys

recycle_vec

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

intrusive_splay_tree

An intrusive splay tree implementation that is no-std compatible and free from allocation and moves

second-stack

A fast allocator for short-lived slices and large values

mapped-file

Construct a memory mapping over any file object

alloc_geiger

allocator which makes sound when active, like a Geiger counter

generational-box

A box backed by a generational runtime

boxarray

Safe way to allocate and initialize nested arrays directly on the heap in Rust

portable-dlmalloc

Portable Fork of Doug Lea's malloc Implementation

free-list

A free-list-based page/frame allocator

rpmalloc

Cross-platform global memory allocator using rpmalloc

heap-array

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

bitmap-allocator

Bit allocator based on segment tree algorithm

trc

A faster Arc

mimalloc-rspack

Performance and security oriented drop-in allocator

deepsize

measuring the total size of object on the stack and heap

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

dynamic-provider

Dynamically request arbitrarily-typed values from providers with borrowed data

sensitive

Memory allocator for sensitive information

alloc-track

Track memory allocations by backtrace or originating thread

presser

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

pin-weak

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

aligned-buffer

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

good_memory_allocator

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

blink-alloc

Fast, concurrent, arena-based allocator with drop support

static_interner

Similar to internment crate, but with interface and performance tweaks

token-cell

A more convenient GhostCell

re_memory

Run-time memory tracking and profiling

vm-allocator

Helpers for allocating resources needed during the lifetime of a VM

emballoc

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

zeroizing-alloc

Minimal allocator wrapper to zero-on-free data for security

downstream

efficient, constant-space implementations of stream curation algorithms

swc_malloc

Configures the best memory allocator for each platforms

ferroc

A fast & lock-free memory allocator library

slimmer_box

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

alloc-from-pool

Single-threaded object pool implementation

corundum

Persistent Programming Library

compact_arena

some types to allow indexed arenas with small memory footprint

bufio

std::io::Write for your potentially uninitialized slice of memory

cache-size

finding your L1/L2/L3 cache sizes

jemalloc-ctl

A safe wrapper over jemalloc's control and introspection APIs

ndata

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

moveref

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

mockalloc

allow testing code which uses the global allocator

ocaml-boxroot-sys

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

ctoption

A compile-time option whose discriminant is elevated to compile time

graph-api-lib

Core library for the graph-api ecosystem - a flexible, type-safe API for working with in-memory graphs in Rust

baby-mimalloc

Mimalloc implemented in Rust (not a binding to the C library) with only basic features

alloc-madvise

A memory allocator for creating large aligned chunks of memory

shrink-to-fit

Recursively calls shrink_to_fit on all elements of the container

aiscript-arena

safe, incrementally garbage collected arenas

pin-cell

A pin-safe cell

lock_free_buddy_allocator

Scalable lock-free buddy system allocator

maybe-owned

MaybeOwned (and MaybeOwnedMut) type similar to std’s Cow but it implements From<T> and From<&'a T> and does not require ToOwned

pi_key_alloter

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

malloc-info

A safe wrapper around glibc's malloc_info

malloced

A malloc-ed box pointer type

shush-rs

designed to manage sensitive data securely by leveraging memory protection mechanisms

virtual-buffer

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

hzrd

Shared mutability containers based on hazard pointers

stupidalloc

A stupid memory allocator that memory-maps allocations to files

mmap-wrapper

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

quickdry

Bump-pointer arena allocator

blur_lang

Language for JavaScript optimization

flex-alloc

Data structures with extra flexible storage

orderly-allocator

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

flatbuffers-owned

that enables a more flexible usage of FlatBuffers

ordered-pool-allocator

A fast and compact pool allocator with block sorting support

microchassis

A chassis to increase observability of services and tools

grit-data-prison

providing the struct Prison<T>, a Generational Arena that allows full interior mutability to each and every element

string-alloc

Allocator-aware no-std-compatible String implementation

heapbuf

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

refpool

Efficient memory pool with reference counting

intern-arc

An interner that deallocates unused values

relib_module

relib is a framework for reloadable dynamic libraries

mut-rc

Temporarily mutable Rc<T> that decays into Rc<T>

typed-slab

Typed wrapper for Slab

spaghetto

making double-ended data structures, like an always-contigouous double-ended queue (deque) and double-ended string

sandpit

A concurrent garbage collected arena

fixstr

fixing strings

hardened_malloc-rs

hardened_malloc rust wrapper

gpu-alloc-vulkanalia

vulkanalia backend for gpu-alloc

realloc

A re-implementation of various ::alloc features

recycle-box

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

alloc_counter

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

safe-gc

A garbage collection library with zero unsafe code and zero dependencies

tomt_atom

Basic Atom (string) registry for use with ID strings. For when an application contains and passes around many constant strings (mainly de/serialized strings), this should reduce the…

zone-alloc

Containers for zone-based data allocation

playdate-allocator

Global allocator and allocator-api implementation for Playdate

fixed-typed-arena

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

byte-pool

Pool of byte slices, for efficient memory usage

smol_buf

small-string optimized string / buffer type with O(1) clone

memflow-qemu

qemu connector for the memflow physical memory introspection framework

escoba

Useful broom to clean your RAM in Window$

tesap-std

Reimplementation of Rust's common std containers

pages-and-pages

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

mem-rs

pattern scanning and abstraction for pointers in memory of running processes

persian-rug

Framework for bringing together disparate objects with inconvenient relationships

allocation-counter

Count the number of memory allocation of some code

ralloc

An efficient alternative platform-agnostic allocator

jit-allocator

An executable code allocator

deallocate-zeroed

An extension trait for allocators to deallocate already-zeroed memory

rseal

Memory sealing operations

hipool

RUST Memory Pool

drop_arena

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

osdk-frame-allocator

The default buddy system frame allocator shipped with OSDK

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

wayrs-utils

A collection of utils and abstractions for wayrs-client

splitrc

Thread-Safe Split Reference Counts

handy

providing handles and handlemaps

vec_mem_heap

An arena allocator with reference counting

rspack_allocator

rspack allocator

ration

A shared memory library

malloc_size_of

A an allocator-agnostic crate for measuring the heap size of a value

toolshed

Arena allocator and a handful of useful data structures

microdb

A very small in-program database with cache, disk storage, etc

ps-buffer

aligned heap buffer

esl01-minibytes

Shared reference-counted bytes with zero-copy slicing support

rodeo

Fast dropping arena based on bumpalo

mimalloc-redirect

Application-wide allocator redirection to MiMalloc

scanflow

memory scanning library based on memflow

memusage

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

index_arena

id-based, heterogeneous arena allocator

roussillon-memory

Memory utility for the roussillon language

hash_cons

A type-safe hash-cons library

rsbmalloc

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

readfilez

Quite fast file to slice reading

borrow-framework

More flexible borrowing

scudo

Rust Bindings for the Scudo Hardened Allocator

capped_collections

Collections with compile-time set capacities

concat-in-place

Efficient macros for concatenation of strings and vectors

tcmalloc2

Rust FFI bindings to tcmalloc

wraith

compiler backend

generic-vec

a vector implementation that can be used in no_std envioronments

safe-allocator-api

A safe wrapper around the allocator_api’s Allocator trait

hala-pprof-memory

A memory profile data collector for pprof

tikv-jemalloc-sys2

Rust FFI bindings to jemalloc

buffet

Thread-local buffer pool for the loona crate

kernel-alloc

Minimalistic Windows Kernel Allocator

sgx_alloc

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

contiguous-mem

A contiguous memory storage

bdwgc-alloc

impl GlobalAlloc for bdwgc

erased

Erase the type of a reference or box, retaining the lifetime

arena64

A concurrent arena providing mutually exclusive access over indexes

snap-buf

A copy on write byte buffer for efficient snapshotting

shared-buffer-rs

combines Arc and RefCell for Send and Sync

wg-utils

Personal Utility Functions

cowvert

a flexible data container supporting owned, reference-counted, and copy-on-write semantics. designed for use in interpreters

alloc-stdlib

A dynamic allocator example that may be used with the stdlib

grounded

A toolkit for managing unsafe statics

range-action-map

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

alloc-checked

Collections that don't panic on alloc failures

verity-memory

Personal memory library with some cool features

metrics-jemalloc

A small shim to provide metrics from the jemalloc runtime

snmalloc-sys

rust raw bindings of snmalloc

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”

mmap-vecdeque

A file-backed memory-mapped VecDeque with deferred commits, atomic and durable persistence

frusa

A system allocator with reclaim

arcslab

Slab, but with reference counted items

reffers

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

heapsz

calculating the heap usage of a data structure

pyembed

Embed a Python interpreter

bumpalo-herd

Support for bumpalo in scoped threads & rayon

bump-into

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

isoalloc

Security oriented allocator

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

jrsonnet-gc

Tracing garbage collector plugin for Rust

contiguous-arena

Efficient, reusable memory arena for Rust with support for contiguous memory blocks

arcstring

Atomically reference-counted thin string type with SSO

wrc

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

bulk_allocator

Implementations of GlobalAlloc holding memory cache

process-memory

that can read/write the memory of other processes

pb-atomic-linked-list

An atomic insert-only linked list

ra-ap-rustc_arena

Automatically published version of the package rustc_arena in the rust-lang/rust repository from commit 5113ed28ea1451a13eae3a05dca0dbabfd56f587 The publishing script for this crate lives at:…

vonneumann

executable memory for windows and unix

alloca

Mostly safe wrapper for alloca

fortify

convenient way to bundle owned data with a borrowing type

hirpdag

procedural macros for Hash Consed, Immutable, Reference Counted, Persistent, Directed Acyclic Graph data structures

pi_world

ecs world

reloaded-memory-buffers

Shared, Concurrent, Permanent Memory Allocator tied to Process Lifetime

storage_api

Storage API, a better version of Allocator

arc-cell

Helper for a simple Cell-like object containing Arc/Weak

composable-allocators

Composable memory allocators for new allocator API

riddance

retiring, recyclable, reservable IDs

static-rc

Compile-time reference counting

phper-alloc

Alloc related items for phper crate

opool

High-performance, lock-free local and concurrent object pool with automated allocation, cleanup, and verification

rustc-arena-modified

rustc-arena ported to stable rust with additional features

aligners

alignment guarantees for data

alloc_cat

allocator for small-to-tiny Wasm projects in rust

onsen

Memory pool

without-alloc

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

cheap

cross platform allocator which communicate over the C ABI

pstruct

procedural macro for generating pointer struct implementations with field offset access

mmap-loader

A Portable Executable manual map loader

git_fetch_concurrently

Do git fetch -p && git gc in each sub directory concurrently

obj-pool

object arena

timely-bytes-master

Disjoint mutable byte slices from a common allocation

arena-allocator

Virtual memory based linear allocator

buddyalloc

Safe and simple drop-in allocator for Rust running on embedded or bare metal systems (no_std)

cactusref

Cycle-aware reference counting smart pointer

slabby

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

min32

Minimal boilerplate code for targeting win32 with no-std

default-boxed

Helper trait to help create large struct on heap directly

discard

trait which allows for intentionally leaking memory

owned-pin

A wrapper that both owns and pins data in memory

maprc

Rc and Arc alternatives that allow the smart pointer to refer to just a portion of a reference-counted allocation

zerogc

Zero overhead tracing garbage collection for rust

hugealloc

Hugepage-aware allocator

light_arena

A lightweight, placement based memory arena for types which are Sized + Copy. This crate requires nightly.

kioku

A memory arena

moving_gc_arena

Lightweight Garbage-collectable regions using indices and explicit roots

cl-generic-vec

a vector implementation that can be used in no_std envioronments

system-mimalloc

system's shared mimalloc library as allocator

slitter

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

loca

memory allocation

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

hybrid-rc

Thread-safe hybrid reference counting pointers

tracking-allocator

global allocator that provides hooks for tracking allocation events

musli-allocator

Allocators for Müsli

pb-arena

arena allocator for graph based operations

context-allocator

hpt-allocator

An internal library for memory allocator for hpt

ps-alloc

a reasonably safe allocator

peakmem-alloc

An allocator wrapper that allows measuring peak memory consumption

possibly_uninit

Traits and types helping with using uninitialized memory safely

allocator-suite

Allocator Suite for various allocation types

rlalloc

blazingly slow malloc replacement

shared_arena

A thread-safe & efficient memory pool

hwlocality-sys

Low-level bindings for the hwloc hardware locality library

flatty-io

Flat message transfer

rattish

Cast between trait objects

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.

generic_singleton

allowing for generic singleton patterns

refbox

A smart pointer with a single owner and many weak references

malloc_buf

Structs for handling malloc'd memory passed to Rust

freeze

A mmap-backed bump allocator that allows compact and zero-realloc mutability of the top vector

vec-tree

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

libmimalloc-sys

Sys crate wrapping the mimalloc allocator

dynamic-arena

Dynamically typed arenas, supporting any Sized type

ps-mbuf

memory buffers for memory maps

haz-alloc

A general-purpose allocator written in Rust

fixed_heap

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

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

sodg

Surging Object DiGraph (SODG)

nstd_core

NSTD core crate

c-ffi

C FFI utilities

alloc-tls

Thread-local storage that is safe for use in implementing global allocators

salloc

Safe C-like memory allocator for windows

slotmap-fork-otter

Slotmap data structure - temporary fork for Otter

ve

More compact Vec

rust_jsc_sys

Low-level bindings to JavaScriptCore

giputils

Some useful utilities for rust programming

maskerad_memory_allocators

custom allocators, for memory fragmentation prevention

josephine

using JavaScript to safely manage the lifetimes of Rust data

ferris-gc

Flexible implementation of garbage collector for Rust

bacon_rajan_cc

A reference counted type with cycle collection

obstack

A fast, stack-based allocator, usable for any object

wr_malloc_size_of

Internal utility to measure memory usage in WebRender

talloc

A fast, consistant, and flexible no_std-compatible allocator

dairy

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

token-ref-cell

Interior mutability cell using an external token to synchronize accesses

osdk-heap-allocator

The default slab-based heap allocator shipped with OSDK

quack

Duck typing traits

shuffling-allocator

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

mimalloc-rust

the best binding for mimalloc in rust

ps-mmap

Easy memory mapping

owned_chars

Owned iterators with the same output as Chars and CharIndices

allocators

composable memory allocators and utilities for creating more

syncpool

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

scx_rustland_core

Framework to implement sched_ext schedulers running in user space

addr_of_enum

Get address of fields in enum item using stable Rust

pin-arc

Reference counting pointers without allocation using pinning

index-pool

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

typed-arena-nomut

The arena, a fast but limited type of allocator