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

jemallocator

allocator backed by jemalloc

sharded-slab

A lock-free concurrent slab

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

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

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

allocator-api2

Mirror of Rust's allocator API

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…

la-arena

index-based arena without deletion

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

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

stats_alloc

An allocator wrapper that allows for instrumenting global allocators

sdd

Scalable lock-free delayed memory reclaimer

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

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

rctree

A 'DOM-like' tree implemented using reference counting

vm-memory

Safe abstractions for accessing the VM physical memory

ghost-cell

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

bufsize

bytes::BufMut implementation to count buffer size

micromap

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

mbox

malloc-based box. Supports wrapping pointers or null-terminated strings returned from malloc as a Rust type, which will be free'd on drop

bump-scope

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

hwlocality

Idiomatic Rust bindings for the hwloc hardware locality library

static-alloc

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

census

Keeps an inventory of living objects

arcshift

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

jemalloc-sys

Rust FFI bindings to jemalloc

mmtk

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

pi_slotmap

Slotmap data structure

jrsonnet-gcmodule

Cyclic garbage collection inspired by CPython's gc implementation

memuse

Traits for measuring dynamic memory usage of types

lgalloc

Large object allocator

get-size2

Determine the size in bytes an object occupies inside RAM

slotmapd

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

range-alloc

Generic range 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

mini-alloc

Very simple global allocator

peak_alloc

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

gpu-alloc

agnostic memory allocator for Vulkan like APIs

memsafe

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

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!

dlmalloc

port of the dlmalloc allocator

tor-memquota

Memory use tracking and quota utilities, used by Tor software

lol_alloc

laughably simple wasm global_allocator

dumpster

A concurrent cycle-tracking garbage collector

process_vm_io

I/O access to virtual memory contents of processes

reblessive

A small runtime for running deeply nested recursive functions

stable-vec

A Vec-like collection which guarantees stable indices and features O(1) element deletion (semantically similar to Vec<Option<T>>). Useful for allocations in graphs or similar data structures.

rabuf

randome access buffer for io

qcell

Statically-checked alternatives to RefCell and RwLock

memsec

libsodium/utils

mimalloc-safe

Performance and security oriented drop-in allocator

rarena-allocator

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

checkers

A sanity checker for global allocations

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…

include_bytes_aligned

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

inplace_it

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

rustix-dlmalloc

port of the dlmalloc allocator, ported to rustix

secmem-alloc

Custom allocators for secret memory

poggers

memory lib

mappings

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

rust-cc

A cycle collector for Rust programs

stackalloc

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

tikv-jemalloc-sys

Rust FFI bindings to jemalloc

wild-linker

A very fast linker for Linux

cluFullTransmute

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

flexstr

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

offset-allocator

A port of Sebastian Aaltonen’s OffsetAllocator to Rust

refuse

incremental, multi-threaded garbage collector

pared

Projected reference counted pointers

vptr

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

shellexec

Cross-platform shellcode executor in rwx memory

lightweight-mmap

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

wdk-alloc

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

memory_set

Data structures and operations for managing memory mappings

memur

Arena storage with bells and whistles

gc

Tracing garbage collector plugin for Rust

pdf

PDF reader

thunderdome

Fast arena allocator with compact generational indices

triple_arena

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

process-image

Zero-cost abstraction for convenient access to process image tags

memflow-qemu

qemu connector for the memflow physical memory introspection framework

ra_ap_la-arena

index-based arena without deletion

rpmalloc

Cross-platform global memory allocator using rpmalloc

lifeguard

An object pool manager in Rust

slabbin

An efficient slab allocator with stable addresses

reference-counted-singleton

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

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

rallo

Rust allocator for tracking memory usage

haphazard

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

dyn_size_of

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

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

mimalloc-rspack

Performance and security oriented drop-in allocator

shared-buffer

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

weak-table

Weak hash maps and sets

mapped-file

Construct a memory mapping over any file object

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.

pi_world

ecs world

second-stack

A fast allocator for short-lived slices and large values

bitmap-allocator

Bit allocator based on segment tree algorithm

alloc_geiger

allocator which makes sound when active, like a Geiger counter

buffet

Thread-local buffer pool for the loona crate

free-list

A free-list-based page/frame allocator

generational-box

A box backed by a generational runtime

intrusive_splay_tree

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

trc

A faster Arc

sensitive

Memory allocator for sensitive information

arcslab

Slab, but with reference counted items

dynamic-provider

Dynamically request arbitrarily-typed values from providers with borrowed data

presser

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

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

blink-alloc

Fast, concurrent, arena-based allocator with drop support

alloc-track

Track memory allocations by backtrace or originating thread

emballoc

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

pin-weak

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

zeroizing-alloc

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

token-cell

A more convenient GhostCell

good_memory_allocator

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

vm-allocator

Helpers for allocating resources needed during the lifetime of a VM

copyvec

A contiguous growable array type, with a fixed, stack-alllocated capacity that implements Copy

slimmer_box

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

webgl-rc

WebGL wrapper with resources reference counting

alloc-from-pool

Single-threaded object pool implementation

compact_arena

some types to allow indexed arenas with small memory footprint

alloc-stdlib

A dynamic allocator example that may be used with the stdlib

sandpit

A concurrent garbage collected arena

moveref

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

corundum

Persistent Programming Library

pi_slot

lock free Slotmap data structure

ndata

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

ocaml-boxroot-sys

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

nvme

driver

cache-size

finding your L1/L2/L3 cache sizes

ctoption

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

malloc-info

A safe wrapper around glibc's malloc_info

intern-arc

An interner that deallocates unused values

hugealloc

Hugepage-aware allocator

pair

Safe API for generic self-referential pairs of owner and dependent

mockalloc

allow testing code which uses the global allocator

baby-mimalloc

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

refs

My vision of reference counting

string-alloc

Allocator-aware no-std-compatible String implementation

pin-cell

A pin-safe cell

stupidalloc

A stupid memory allocator that memory-maps allocations to files

virtual-buffer

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

capped_collections

Collections with compile-time set capacities

shush-rs

designed to manage sensitive data securely by leveraging memory protection mechanisms

flatbuffers-owned

that enables a more flexible usage of FlatBuffers

columnation

Unsafe columnar containers for native Rust types

hardened_malloc-rs

hardened_malloc rust wrapper

quickdry

Bump-pointer arena allocator

blur_lang

Language for JavaScript optimization

flex-alloc

Data structures with extra flexible storage

mmap-wrapper

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

osdk-frame-allocator

The default buddy system frame allocator shipped with OSDK

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…

orderly-allocator

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

safe-gc

A garbage collection library with zero unsafe code and zero dependencies

ferroc

A fast & lock-free memory allocator library

grit-data-prison

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

mut-rc

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

safe-allocator-api

A safe wrapper around the allocator_api’s Allocator trait

jemalloc-ctl

A safe wrapper over jemalloc's control and introspection APIs

alloc-madvise

A memory allocator for creating large aligned chunks of memory

system-memory

A small crate to get info/stats on the host's memory

refpool

Efficient memory pool with reference counting

tikv-jemalloc-sys2

Rust FFI bindings to jemalloc

tcmalloc2

Rust FFI bindings to tcmalloc

page-primer

speeds up your program by "priming" memory pages from your binary

typed-slab

Typed wrapper for Slab

malloced

A malloc-ed box pointer type

rseal

Memory sealing operations

gpu-alloc-vulkanalia

vulkanalia backend for gpu-alloc

heapbuf

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

libbz2-rs-sys-cdylib

a drop-in compatible libbz2 cdylib

bdwgc-alloc

impl GlobalAlloc for bdwgc

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…

scanflow

memory scanning library based on memflow

fastpool

This crates implements a fast object pool for Async Rust

emdumper

acquire the physical memory on linux systems (root is necessary)

allocation-counter

Count the number of memory allocation of some code

relib_module

relib is a framework for reloadable dynamic libraries

shared-buffer-rs

combines Arc and RefCell for Send and Sync

persian-rug

Framework for bringing together disparate objects with inconvenient relationships

recycle-box

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

roussillon-memory

Memory utility for the roussillon language

to_shmem

Trait to write to a contiguous chunk of shared memory

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

reloaded-memory-buffers

Shared, Concurrent, Permanent Memory Allocator tied to Process Lifetime

drop_arena

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

jit-allocator

An executable code allocator

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

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

rspack_allocator

rspack allocator

splitrc

Thread-Safe Split Reference Counts

alloc_cat

allocator for small-to-tiny Wasm projects in rust

hipool

RUST Memory Pool

freeze

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

accountable-refcell

A RefCell wrapper that provides actionable information for dynamic borrow failures

default-boxed

Helper trait to help create large struct on heap directly

hash_cons

A type-safe hash-cons library

mimalloc-redirect

Application-wide allocator redirection to MiMalloc

giputils

Some useful utilities for rust programming

rsbmalloc

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

read-process-memory

Read memory from another process

malloc_size_of

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

syncpool

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

memusage

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

snmalloc-sys

rust raw bindings of snmalloc

scudo

Rust Bindings for the Scudo Hardened Allocator

contiguous-mem

A contiguous memory storage

ration

A shared memory library

metrics-jemalloc

A small shim to provide metrics from the jemalloc runtime

process-memory

that can read/write the memory of other processes

toolshed

Arena allocator and a handful of useful data structures

handy

providing handles and handlemaps

alloca

Mostly safe wrapper for alloca

escoba

Useful broom to clean your RAM in Window$

smallobjectpool

A small object pool for Rust

ralloc

An efficient alternative platform-agnostic allocator

deallocate-zeroed

An extension trait for allocators to deallocate already-zeroed memory

cowvert

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

concat-in-place

Efficient macros for concatenation of strings and vectors

ialloc

Allocator interface traits

rs-luau

Minimal overhead Luau bindings for Rust!

range-action-map

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

mimalloc-rust

the best binding for mimalloc in rust

pstruct

procedural macro for generating pointer struct implementations with field offset access

verity-memory

Personal memory library with some cool features

moving_gc_arena

Lightweight Garbage-collectable regions using indices and explicit roots

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”

luigi-rs

Rust bindings for Luigi - a simple C GUI library

fortify

convenient way to bundle owned data with a borrowing type

erased

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

reffers

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

pyembed

Embed a Python interpreter

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

heapsz

calculating the heap usage of a data structure

bumpalo-herd

Support for bumpalo in scoped threads & rayon

cactusref

Cycle-aware reference counting smart pointer

vec_mem_heap

A Vec with each element wrapped in a reference counter

snap-buf

A copy on write byte buffer for efficient snapshotting

bulk_allocator

Implementations of GlobalAlloc holding memory cache

fixed-typed-arena

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

genmap

generational map data structure with no dependencies

wrc

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

aligners

alignment guarantees for data

minedmap-default-alloc

Helper crate for target-specific selection of global allocator default

pb-atomic-linked-list

An atomic insert-only linked list

generational_token_list

A doubly-linked list backed by generational-arena

gstreamer-allocators-sys

FFI bindings to libgstallocators-1.0

vonneumann

executable memory for windows and unix

fast-smr

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

onsen

Memory pool

hirpdag

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

vec-utils

vector utilities

riddance

retiring, recyclable, reservable IDs

obj-pool

object arena

hybrid-rc

Thread-safe hybrid reference counting pointers

containers

Containers

composable-allocators

Composable memory allocators for new allocator API

ve

More compact Vec

cheap

cross platform allocator which communicate over the C ABI

phper-alloc

Alloc related items for phper crate

static-rc

Compile-time reference counting

jrsonnet-interner

Jrsonnet string interning

kernel-alloc

Minimalistic Windows Kernel Allocator

frusa

A system allocator with reclaim

slabby

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

array_pool

tiered caching array pool implementation in Rust

isoalloc

Security oriented allocator

min32

Minimal boilerplate code for targeting win32 with no-std

sodg

Surging Object DiGraph (SODG)

discard

trait which allows for intentionally leaking memory

slitter

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

owned-pin

A wrapper that both owns and pins data in memory

pb-arena

arena allocator for graph based operations

bump-into

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

kioku

A memory arena

libmimalloc-sys

Sys crate wrapping the mimalloc allocator

zone-alloc

Containers for zone-based data allocation

allocator-suite

Allocator Suite for various allocation types

mmap-loader

A Portable Executable manual map loader

azalia

🐻‍❄️🪚 Common utilities and extensions that Noelware uses in all Rust projects

ps-alloc

a reasonably safe allocator

rlalloc

blazingly slow malloc replacement

loca

memory allocation

salloc

Safe C-like memory allocator for windows

loro-thunderdome

Fork of thunderdome: Fast arena allocator with compact generational indices

rco-cell

Wrapper for Rc<RefCell<Option<T>>> and its weak variant. Includes various utilties for common operations usually performed on such a datastructure.

malloc-array

libc heap array allocator

context-allocator

bookcase_alloc

An arena allocator

bacon_rajan_cc

A reference counted type with cycle collection

peakmem-alloc

An allocator wrapper that allows measuring peak memory consumption

tracking-allocator

global allocator that provides hooks for tracking allocation events

rodeo

Fast dropping arena based on bumpalo

fixed_heap

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

refbox

A smart pointer with a single owner and many weak references

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

cl-generic-vec

a vector implementation that can be used in no_std envioronments

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

typemap-meta

compile-time macro to create type-to-value maps

system-mimalloc

system's shared mimalloc library as allocator

possibly_uninit

Traits and types helping with using uninitialized memory safely

virtual-memory

allocating RWX memory on Unix and Windows

oco_ref

A smart pointer for storing immutable values with relatively-cheap cloning. (Like a Cow meets an Rc!)

darc

Dynamically-atomic reference-counting pointers (proof of concept)

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

xalloc

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

osdk-heap-allocator

The default slab-based heap allocator shipped with OSDK

rattish

Cast between trait objects

ps-mmap

Easy memory mapping

generic_singleton

allowing for generic singleton patterns

index_arena

id-based, heterogeneous arena allocator

vec-tree

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

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

haz-alloc

A general-purpose allocator written in Rust

talloc

A fast, consistant, and flexible no_std-compatible allocator

pool

reusable values

rebound

Full runtime reflection for Rust, with lifetime safety

ps-buffer

aligned heap buffer

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…

malloc_buf

Structs for handling malloc'd memory passed to Rust

ps-mbuf

memory buffers for memory maps

vecstorage

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

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.

musli-allocator

Allocators for Müsli

freelist

datastructure implementation providing unsafe access to backing storage

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

token-ref-cell

Interior mutability cell using an external token to synchronize accesses

gfx-memory

gfx-hal memory allocator

maskerad_memory_allocators

custom allocators, for memory fragmentation prevention

elise

A concurrent GC

columnation-master

An experimental columnar arena

pin-arc

Reference counting pointers without allocation using pinning

dairy

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

libisoalloc-sys

Security oriented allocator

redox-buffer-pool

A buffer pool library for Redox, featuring a general-purpose 32-bit allocator

refuse-pool

A string interner utilizing the Refuse garbage collector

obstack

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

yesallocator

implemting for rust

generational_vector

A vector type using generational indices

shuffling-allocator

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

addr_of_enum

Get address of fields in enum item using stable Rust

dudy-malloc

Easy way to configure best memory allocation for each platforms

rulloc

General purpose memory allocator

heapnotize

A smart pointer type for memory allocation on the stack

erased-type-arena

A type-erased allocation arena with proper dropping

allocators

composable memory allocators and utilities for creating more

josephine

using JavaScript to safely manage the lifetimes of Rust data

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

rcu-clean

Smart pointers using RCU with Deref support

crndm

Persistent Programming Library

easyrw

Easy Read and Write functions in rust, External and Internal

malloc-rust

Malloc implementation using Rust allocator

flp-framework

Floorplan, a memory layout specification language, code-generation necessities

jrsonnet-gc

Tracing garbage collector plugin for Rust

shalloc

Implements the GlobalAlloc trait for supahero1’s allocator written in C: https://github.com/supahero1/alloc

yair

A compiler framework written entirely in Rust

zerogc

Zero overhead tracing garbage collection for rust

recvmsg

Traits for receiving datagrams reliably, without truncation

tracing-rc

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

scoped-arena

Arena allocator with optional scopes

shmem-ipc

Untrusted IPC with maximum performance and minimum latency on Linux

contiguous-arena

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

mmap-append

Append-only memory-mapped I/O, resizable, with low lock contention

varstack

A call-stack based singly-linked list

memguar

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

scx_rustland_core

Framework to implement sched_ext schedulers running in user space

tram

event bus that can be cloned and shared across threads

aliasable_deref_trait

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

bustd

Lightweight process killer daemon for out-of-memory scenarios

indexed

Convenient allocator for index-linked data structures

markable_reader

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

alloc_buddy_simple

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

backdrop

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

lazy-st

Single-threaded lazy evaluation

membank

A pool of reusable memory to prevent unnecessary deallocations

netbuf

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

forgotten

globally and safely persist a value, implemented with ManuallyDrop

drop-bin

Defer running expensive destructors until later

gomicollector

mark-sweep garbage collector

cell-gc

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

pseudo_pool

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

index-pool

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

wasm-nopackage

Basic alloc and dealloc and module setup for lightweight WASM modules

fixed-size-allocator

A fixed-size allocator

flipflop

Stress-tester for double-ended iterators

virt-arena

A virtual memory bump allocator

piece

A collection of composable allocators

aligned_box

Allocate heap memory with user-specified alignment

card10-alloc

Dynamic memory allocation for card10 l0dables

smallest-uint

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

gc-sequence

a system for encoding safe points for computations running on gc-arena

arc-swap-for-cow

Atomically swappable Arc

ring-alloc

Specialized allocator for short-living objects