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

heapless

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

mimalloc

Performance and security oriented drop-in allocator

jemallocator

allocator backed by jemalloc

yoke

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

slab

Pre-allocated storage for a uniform data type

allocator-api2

Mirror of Rust's allocator API

typed-arena

The arena, a fast but limited type of allocator

static_init

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

elsa

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

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…

boa_gc

Garbage collector for the Boa JavaScript engine

mem_dbg

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

embedded-alloc

A heap allocator for embedded systems

rustc-std-workspace-alloc

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

stats_alloc

An allocator wrapper that allows for instrumenting global allocators

object-pool

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

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.

tendril

Compact buffer/string type for zero-copy parsing

gbm

libgbm bindings for rust

hipstr

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

dlmalloc

port of the dlmalloc allocator

gc-arena

safe, incrementally garbage collected arenas

vm-memory

Safe abstractions for accessing the VM physical memory

bump-scope

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

reblessive

A small runtime for running deeply nested recursive functions

rctree

A 'DOM-like' tree implemented using reference counting

wdk-alloc

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

weak-table

Weak hash maps and sets

jrsonnet-gcmodule

Cyclic garbage collection inspired by CPython's gc implementation

static-alloc

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

bufsize

bytes::BufMut implementation to count buffer size

cluFullTransmute

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

gpu-alloc

agnostic memory allocator for Vulkan like APIs

pi_slotmap

Slotmap data structure

mmap-rs

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

memuse

Traits for measuring dynamic memory usage of types

arcshift

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

lgalloc

Large object allocator

polkavm

A fast and secure RISC-V based virtual machine

tikv-jemalloc-sys

Rust FFI bindings to jemalloc

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

get-size2

Determine the size in bytes an object occupies inside RAM

range-alloc

Generic range allocator

mini-alloc

Very simple global allocator

buddy_system_allocator

A bare metal allocator that uses buddy system

ghost-cell

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

slabigator

A fixed-capacity linked list with stable element addressing and no dynamic allocations

tor-memquota

Memory use tracking and quota utilities, used by Tor software

typed-generational-arena

A safe arena allocator that supports deletion without suffering from the ABA problem by using generational indices. Now with typed indices and custom integer types for generations!

dumpster

A concurrent cycle-tracking garbage collector

etagere

Dynamic 2D texture atlas allocation using the shelf packing algorithm

slotmapd

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

peak_alloc

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

rarena-allocator

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

lol_alloc

laughably simple wasm global_allocator

include_bytes_aligned

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

mmtk

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

stronghold-runtime

Data structures for memory protection at runtime

process_vm_io

I/O access to virtual memory contents of processes

rabuf

randome access buffer for io

soa-rs

A Vec-like structure-of-arrays container

qcell

Statically-checked alternatives to RefCell and RwLock

secmem-alloc

Custom allocators for secret memory

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…

checkers

A sanity checker for global allocations

memsafe

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

memsec

libsodium/utils

stats_alloc_helper

A test helper to measure memory allocations

buddy-alloc

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

refuse

incremental, multi-threaded garbage collector

wild-linker

A very fast linker for Linux

graph-api-simplegraph

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

jemalloc-sys

Rust FFI bindings to jemalloc

win-wrap

用于Rust的Windows API的高级封装

accountable-refcell

A RefCell wrapper that provides actionable information for dynamic borrow failures

memur

Arena storage with bells and whistles

refbox

A Box with weak references

rustix-dlmalloc

port of the dlmalloc allocator, ported to rustix

ialloc

Allocator interface traits

pared

Projected reference counted pointers

mimalloc-safe

Performance and security oriented drop-in allocator

nunny

the definitive non-empty slice/array/vec library for Rust

gc

Tracing garbage collector plugin for Rust

rust-cc

A cycle collector for Rust programs

lightweight-mmap

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

pi_world

ecs world

memapi

A minimal, no_std-friendly memory allocation interface for raw buffers, with some error handling

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…

memory_set

Data structures and operations for managing memory mappings

offset-allocator

A port of Sebastian Aaltonen’s OffsetAllocator to Rust

triple_arena

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

vptr

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

flexstr

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

lifeguard

An object pool manager in Rust

swc_allocator

A thin wrapper for bumpalo

ra_ap_la-arena

index-based arena without deletion

id-arena

id-based arena

process-image

Zero-cost abstraction for convenient access to process image tags

slabbin

An efficient slab allocator with stable addresses

picoalloc

small and fast memory allocator

dyn_size_of

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

stalloc

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

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…

cranelift-jit

A JIT library backed by Cranelift

haphazard

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

memflow-qemu

qemu connector for the memflow physical memory introspection framework

ringal

Efficient ring allocator for short-lived buffers

thunderdome

Fast arena allocator with compact generational indices

tracing-prof

Experimental library for profiling tracing spans

shared-buffer

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

trc

A faster Arc

mimalloc-rspack

Performance and security oriented drop-in allocator

second-stack

A fast allocator for short-lived slices and large values

boxarray

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

intrusive_splay_tree

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

memsecurity

Securely hold secrets in memory and protect them against cross-protection-boundary readout via microarchitectural, via attacks on physical layout, and via coldboot attacks

generational-box

A box backed by a generational runtime

alloc_geiger

allocator which makes sound when active, like a Geiger counter

slabmap

HashMap-like collection that automatically determines the key

rpmalloc

Cross-platform global memory allocator using rpmalloc

static-rc

Compile-time reference counting

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

zone

Rust bindings for Zone management

mapped-file

Construct a memory mapping over any file object

generic_singleton

allowing for generic singleton patterns

alloc-track

Track memory allocations by backtrace or originating thread

sensitive

Memory allocator for sensitive information

free-list

A free-list-based page/frame allocator

good_memory_allocator

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

to_shmem

Trait to write to a contiguous chunk of shared memory

portable-dlmalloc

Portable Fork of Doug Lea's malloc Implementation

relrc

Reference counted pointers, with relationships to other pointers

aiscript-arena

safe, incrementally garbage collected arenas

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.

presser

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

re_memory

Run-time memory tracking and profiling

creusot-contracts

contracts and logic helpers for Creusot

vm-allocator

Helpers for allocating resources needed during the lifetime of a VM

safe-allocator-api

A safe wrapper around the allocator_api’s Allocator trait

bitmap-allocator

Bit allocator based on segment tree algorithm

tlsf

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

pin-weak

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

recursive

Easy recursion without stack overflows

libcanopy

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

bufio

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

token-cell

A more convenient GhostCell

corundum

Persistent Programming Library

secbits

secure memory handling featuring

graph-api-lib

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

slimmer_box

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

orderly-allocator

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

ocaml-boxroot-sys

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

flex-alloc

Data structures with extra flexible storage

alloc-from-pool

Single-threaded object pool implementation

cbvm

Cross bytes virtual machine used for building, running and reading CBVM files

malloc-info

A safe wrapper around glibc's malloc_info

compact_arena

some types to allow indexed arenas with small memory footprint

moveref

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

blink-alloc

Fast, concurrent, arena-based allocator with drop support

hamming_rs

Computes Hamming distance and weight -- if available and beneficial, uses a highly optimized avx2 implementation

cache-size

finding your L1/L2/L3 cache sizes

baby-mimalloc

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

stack_frame_allocators

A set of allocators based off the concept of the stack and creating "Frames". Push frames onto the Stack, push values onto Frames, and pop entire Frames and their items

libmimalloc-sys

Sys crate wrapping the mimalloc allocator

quickdry

Bump-pointer arena allocator

zone-alloc

Containers for zone-based data allocation

ferroc

A fast & lock-free memory allocator library

shush-rs

designed to manage sensitive data securely by leveraging memory protection mechanisms

allocation-counter

Count the number of memory allocation of some code

malloced

A malloc-ed box pointer type

zeroizing-alloc

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

inplace_it

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

jemalloc-ctl

A safe wrapper over jemalloc's control and introspection APIs

ordered-pool-allocator

A fast and compact pool allocator with block sorting support

wasmtime-slab

Uni-typed slab with a free list for use in Wasmtime

byte-pool

Pool of byte slices, for efficient memory usage

bdwgc-alloc

impl GlobalAlloc for bdwgc

lazy-exclusive

A global type like LazyLock/LazyStatic

realloc

A re-implementation of various ::alloc features

refpool

Efficient memory pool with reference counting

ctoption

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

mmap-wrapper

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

deallocate-zeroed

An extension trait for allocators to deallocate already-zeroed memory

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…

alloc-madvise

A memory allocator for creating large aligned chunks of memory

tcmalloc2

Rust FFI bindings to tcmalloc

gpu-alloc-vulkanalia

vulkanalia backend for gpu-alloc

recycle-box

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

storage_api

Storage API, a better version of Allocator

craft-eraser

A set of simple type-erased box primitives

heapbuf

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

lock_free_buddy_allocator

Scalable lock-free buddy system allocator

mockalloc

allow testing code which uses the global allocator

relib_module

relib is a framework for reloadable dynamic libraries

moving_gc_arena

Lightweight Garbage-collectable regions using indices and explicit roots

soapy

Structure-of-arrays derive macro

contiguous-arena

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

emap

A map with a fixed capacity and integers as keys

stylo_malloc_size_of

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

rust-arc-gc

GCArc implementation for Rust

flatbuffers-owned

that enables a more flexible usage of FlatBuffers

mem-rs

pattern scanning and abstraction for pointers in memory of running processes

flipperzero-alloc

Flipper Zero

cactusref

Cycle-aware reference counting smart pointer

alloca

Mostly safe wrapper for alloca

hipool

RUST Memory Pool

stupidalloc

A stupid memory allocator that memory-maps allocations to files

fixstr

fixing strings

stack-arena

A fast, stack-like arena allocator inspired by GNU obstack, implemented in Rust

typed-slab

Typed wrapper for Slab

tikv-jemalloc-sys2

Rust FFI bindings to jemalloc

arena-traits

Traits for arenas

libspecr

standard library for specr lang

jit-allocator

An executable code allocator

drop_arena

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

scudo

Rust Bindings for the Scudo Hardened Allocator

concat-in-place

Efficient macros for concatenation of strings and vectors

shared-buffer-rs

combines Arc and RefCell for Send and Sync

escoba

Useful broom to clean your RAM in Window$

borrow-framework

More flexible borrowing

default-boxed

Helper trait to help create large struct on heap directly

stable-arena

rustc's arena, adapted for stable Rust

rsbmalloc

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

wraith

compiler backend

use-with

resource management utilities inspired by Kotlin's 'use' function and C#'s 'using' block, ensuring proper utilization and disposal of resources in Rust

kernel-alloc

Minimalistic Windows Kernel Allocator

capped_collections

Collections with compile-time set capacities

playdate-allocator

Global allocator and allocator-api implementation for Playdate

safe-gc

A garbage collection library with zero unsafe code and zero dependencies

splitrc

Thread-Safe Split Reference Counts

snap-buf

A copy on write byte buffer for efficient snapshotting

hash_cons

A type-safe hash-cons library

roussillon-memory

Memory utility for the roussillon language

hardened_malloc-rs

hardened_malloc rust wrapper

cowvert

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

pages-and-pages

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

tcmalloc-better

wrapper over Google's TCMalloc memory allocator

contiguous-mem

A contiguous memory storage

string-alloc

Allocator-aware no-std-compatible String implementation

align_constr

Like aligned but better. Newtype whose alignment is constrained not only by the inherent alignment requirements of the underlying type but also by the alignment requirements of the “alignment constraint archetype”

persian-rug

Framework for bringing together disparate objects with inconvenient relationships

frusa

A system allocator with reclaim

ps-alloc

a reasonably safe allocator

ralloc

An efficient alternative platform-agnostic allocator

hala-pprof-memory

A memory profile data collector for pprof

verity-memory

Personal memory library with some cool features

ration

A shared memory library

defer-drop

Defer dropping large types to a background thread

opool

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

bumpalo-herd

Support for bumpalo in scoped threads & rayon

grounded

A toolkit for managing unsafe statics

handy

providing handles and handlemaps

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

alloc_cat

allocator for small-to-tiny Wasm projects in rust

hugealloc

Hugepage-aware allocator

genmap

generational map data structure with no dependencies

malloc_size_of

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

memusage

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

vonneumann

executable memory for windows and unix

pb-atomic-linked-list

An atomic insert-only linked list

hirpdag

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

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…

isoalloc

Security oriented allocator

snmalloc-sys

rust raw bindings of snmalloc

obj-pool

object arena

jrsonnet-gc

Tracing garbage collector plugin for Rust

bulk_allocator

Implementations of GlobalAlloc holding memory cache

rulloc

General purpose memory allocator

phper-alloc

Alloc related items for phper crate

mimalloc-rust

the best binding for mimalloc in rust

membarrier

Process-wide memory barrier

bysyncify

Bindings and a high-level interface to Binaryen's Asyncify

pstruct

procedural macro for generating pointer struct implementations with field offset access

composable-allocators

Composable memory allocators for new allocator API

wr_malloc_size_of

Internal utility to measure memory usage in WebRender

alloc-stdlib

A dynamic allocator example that may be used with the stdlib

rseal

Memory sealing operations

wg-utils

Personal Utility Functions

only_alloc

An allocator wrapper that disables deallocating memory within it

mmap-vecdeque

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

hexane

A columnar compression library used by automerge

wrc

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

fortify

convenient way to bundle owned data with a borrowing type

rofi-mode

High-level library for creating Rofi plugins and custom modes

owned-pin

A wrapper that both owns and pins data in memory

cabbage_collector

ready

buddyalloc

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

light_arena

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

hybrid-rc

Thread-safe hybrid reference counting pointers

asylum

A fast, lightweight string interner with automatic cleanup to prevent memory bloat

moore-common

The common core of the moore compiler framework

onsen

Memory pool

pb-arena

arena allocator for graph based operations

system-memory

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

demikernel

Kernel-Bypass LibOS Architecture

hpt-allocator

An internal library for memory allocator for hpt

aligners

alignment guarantees for data

peakmem-alloc

An allocator wrapper that allows measuring peak memory consumption

cl-generic-vec

a vector implementation that can be used in no_std envioronments

tracking-allocator

global allocator that provides hooks for tracking allocation events

vhdl_parser

VHDL Parser

zerogc

Zero overhead tracing garbage collection for rust

heapsz

calculating the heap usage of a data structure

dotnetrawfilereader-sys

A low-level interface to a in-process dotnet runtime for Thermo Fisher's RawFileReader library

memflow-native

System call based proxy-OS for memflow

uncooked_slices

A wrapper around raw slice pointers that enables safe iteration and indexing

rco-cell

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

without-alloc

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

bookcase_alloc

An arena allocator

minedmap-default-alloc

Helper crate for target-specific selection of global allocator default

tesap-std

Reimplementation of Rust's common std containers

context-allocator

ve

More compact Vec

musli-allocator

Allocators for Müsli

fixed-typed-arena

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

cheap

cross platform allocator which communicate over the C ABI

untyped-box

A heap allocation utility when the datatype is unknown

possibly_uninit

Traits and types helping with using uninitialized memory safely

scratchpad

Stack-like memory allocator with double-ended allocation support

system-mimalloc

system's shared mimalloc library as allocator

xalloc

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

rattish

Cast between trait objects

rspe

Native Rust Reflective PE loader library

bacon_rajan_cc

A reference counted type with cycle collection

rlalloc

blazingly slow malloc replacement

erased-type-arena

A type-erased allocation arena with proper dropping

vec-tree

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

salloc

Safe C-like memory allocator for windows

haz-alloc

A general-purpose allocator written in Rust

sanitation

developing memory-safe programs while detecting and capturing possibly malicious bytes

timely-container-master

Container abstractions for Timely

alloc-tls

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

mimalloc-redirect

Application-wide allocator redirection to MiMalloc

netbuf

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

recasting

traits for one-to-one recasting of values in data structures

datatier

abstractions for byte storage pools

shared_arena

A thread-safe & efficient memory pool

virtual-memory

allocating RWX memory on Unix and Windows

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

cell-gc

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

dynamic-list

A powerful and efficient implementation of dynamic lists with versatile data structures, capable of storing any type!

osdk-heap-allocator

The default slab-based heap allocator shipped with OSDK

scx_rustland_core

Framework to implement sched_ext schedulers running in user space

shredder

Garbage collection as a library for Rust

min32

Minimal boilerplate code for targeting win32 with no-std

token-ref-cell

Interior mutability cell using an external token to synchronize accesses

generational_vector

A vector type using generational indices

fixed_heap

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

slabby

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

freeze

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

voxelis-memory

Memory utilities for the Voxelis voxel engine

pin-arc

Reference counting pointers without allocation using pinning

vecstorage

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

libisoalloc-sys

Security oriented allocator

sti

STd Improved

crndm

Persistent Programming Library

addr_of_enum

Get address of fields in enum item using stable Rust

rebound

Full runtime reflection for Rust, with lifetime safety

index_arena

id-based, heterogeneous arena allocator

tcmalloc

Drop-in global allocator using tcmalloc

dairy

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

recvmsg

Traits for receiving datagrams reliably, without truncation

rcuninit

Cyclic Rc without new_cyclic

lazy-st

Single-threaded lazy evaluation

malloc-array

libc heap array allocator

gc_api

Generic abstractions for a multithreaded garbage collector

emd-common

Various common stuff, necessary for emd

basic_allocator

A very simple global allocator written in pure Rust

shmem-ipc

Untrusted IPC with maximum performance and minimum latency on Linux

ps-mmap

Easy memory mapping

tikv-jemalloc-ctl

A safe wrapper over jemalloc's control and introspection APIs

ferris-gc

Flexible implementation of garbage collector for Rust

pseudo_pool

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

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

agentx

implementing all PDU types and encodings according to the standard

ensf594-project-mmap

Final project for the ENSF 594 course of the University of Calgary, summer 2022

obstack

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

talloc

A fast, consistant, and flexible no_std-compatible allocator

rodeo

Fast dropping arena based on bumpalo

cpr_bf

A brainfuck interpreter

refuse-pool

A string interner utilizing the Refuse garbage collector

secrecy

Wrapper types and traits for secret management which help ensure they aren't accidentally copied, logged, or otherwise exposed (as much as possible), and also ensure secrets are securely wiped from memory when dropped

regc

A garbage collector that mixes Reference counting and mark sweeping

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.

bagel

Compile-time evaluation and other tools