Lib.rs

sharded-slab

A lock-free concurrent slab

crossbeam-deque

Concurrent work-stealing deque

crossbeam-epoch

Epoch-based garbage collection

crossbeam

Tools for concurrent programming

ringbuf

Lock-free SPSC FIFO ring buffer with direct access to inner data

rtrb

A realtime-safe single-producer single-consumer ring buffer

loom

Permutation testing for concurrent code

papaya

A fast and ergonomic concurrent hash-table for read-heavy workloads

crossfire

channels for async and threads

boxcar

A concurrent, append-only vector

cordyceps

Mycelium intrusive data structures

amqprs

AMQP 0-9-1 client implementation for RabbitMQ

seize

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

bbqueue

A SPSC, lockless, no_std, thread safe, queue, based on BipBuffers

sdd

Scalable lock-free delayed memory reclaimer

crossbeam-queue

Concurrent queues

lockfree-object-pool

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

thingbuf

I'm at the buffer pool. I'm at the MPSC channel. I'm at the combination MPSC channel and buffer pool.

kovan

High-performance wait-free memory reclamation for wait-free data structures. Bounded memory usage, predictable latency.

crossbeam-skiplist

A concurrent skip list

ferntree

Concurrent in-memory B+ Tree featuring optimistic lock coupling

evmap

A lock-free, eventually consistent, concurrent multi-value map

nexus-rt

Single-threaded, event-driven runtime primitives with pre-resolved dispatch

left-right

A concurrency primitive for high concurrency reads over a single-writer data structure

orx-concurrent-vec

A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations

orx-concurrent-bag

An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance concurrent collection

idr-ebr

An efficient concurrent ID to object resolver

pricelevel

high-performance, lock-free price level implementation for limit order books in Rust. This library provides the building blocks for creating efficient trading systems with support for…

hyphae

Reactive cells and runtime primitives for rship

nexus-channel

High-performance lock-free SPSC channel for low-latency systems

qubit-atomic

User-friendly atomic operations wrapper providing JDK-like atomic API

nexus-slab

A high-performance slab allocator optimized for predictable tail latency

quetzalcoatl

Lock-free ring buffers (SPSC, MPSC, SPMC, MPMC, and broadcast) for high-performance concurrent communication

concurrent-map

a lock-free linearizable B+ tree

smallring

High-performance ring buffer with automatic stack/heap optimization | 高性能环形缓冲区，支持栈/堆自动优化

inqjet

Ultra-fast, low-latency logging for Rust applications

amity

Concurrency algorithms

atomic-take

Atomically take a value out of a container once

disruptor-mp

Ultra-low-latency and high-throughput multiprocess ring-buffer substrate over SHM and mmap (LMAX Disruptor design, extended cross-process), with cross-process producer/consumer coordination…

orx-concurrent-ordered-bag

An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance and ordered concurrent collection

object-pool

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

skl

A lock-free thread-safe concurrent ARENA based (heap backend or memory map backend) skiplist implementation which helps develop MVCC memtable for LSM-Tree

nexus-id

High-performance ID generators for low-latency systems

st3

A very fast lock-free, bounded, work-stealing LIFO queue

nexus-queue

High-performance lock-free SPSC and MPSC queues for low-latency systems

atomptr

A safe copy-on-write wrapper around AtomicPtr with some extra tricks

kovan-map

Lock-free concurrent hash maps using kovan memory reclamation

nexus-rate

Rate limiting and flow control primitives for real-time systems

velocityx

A production-ready Rust crate for lock-free concurrent data structures with performance monitoring

nexus-pool

High-performance object pools for low latency systems

gil

A collection of high-performance, lock-free concurrent queues (SPSC, MPSC, MPMC, SPMC) with sync and async support

orx-pinned-concurrent-col

A core data structure with a focus to enable high performance, possibly lock-free, concurrent collections using a PinnedVec as the underlying storage

market_square

A lock-free mpmc "square"

rts-alloc

Shared memory allocator intended for small frequent allocations

cache-padded

Prevent false sharing by padding and aligning to the length of a cache line

nexus-slot

High-performance conflation slots (SPSC + SPMC) for latest-value-wins scenarios

nexus-logbuf

Lock-free SPSC and MPSC byte ring buffers for logging and archival

arena-b

Production-grade bump allocator with lock-free, slab, and virtual-memory tooling for parsers, game engines, and request-scoped services

numalloc

A blazing-fast, NUMA-aware memory allocator written in pure Rust

fixed-cache

A minimalistic, lock-free, fixed-size cache

nexus-async-net

Async WebSocket adapter for nexus-net. Tokio-compatible, zero-copy, SIMD-accelerated.

rusted-ring

LMAX inspired Lock-free ring buffers with cache-aligned memory pools for high-performance event systems

selectables

Lock-free channels with a unified select! macro for recv and send arms

async-event

An efficient async condition variable for lock-free algorithms

lock_free_hashtable

Lock-free (almost) insertion only hashtable

handler_table

A lock-free table of event handlers

nexus-stats

Fixed-memory, zero-allocation streaming statistics for real-time systems

gyre

A lock-free asynchronous ring buffer inspired by the LMAX Disruptor

enso-channel

Batch-first, bounded, lock-free ring-buffer channels (MPSC/Fan-out) for bursty, latency-sensitive systems

swmr-cell

A thread-safe single-writer multi-reader cell with wait-free reads and version-based garbage collection

ironsbe-channel

High-performance channel abstractions for IronSBE messaging

ranged-mmap

Type-safe memory-mapped file library with lock-free concurrent writes to non-overlapping ranges

opool

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

arena-alligator

Arena allocator for bytes::Bytes with a fixed-slot fast path and buddy mode

aiq

An intrusive list with lock-free insertion

feagi-state-manager

Runtime state management for FEAGI - cross-platform, RTOS-compatible

nexus-decimal

Fixed-point decimal arithmetic with compile-time precision

evno

A high-performance event bus for asynchronous tasks and event-driven systems

spmc-waker

A cached SPMC atomic waker

slotbus

Lock-free shared memory IPC with slotted request/response. Sub-microsecond wake latency, zero-copy payloads, 32 concurrent in-flight requests per worker.

lock-free-static

Lock-free static variables

phosphor-core

Audio engine, mixer, and transport for the Phosphor DAW

fluxmap

thread-safe, transactional, and concurrent in-memory key-value store for Rust. Offers ACID guarantees with Serializable Snapshot Isolation (SSI) and optional durability via a Write-Ahead Log (WAL)…

melin-pipeline

Lock-free ring buffers with dependency gating for low-latency inter-thread communication

fast-stm

Performance-focused implementation of software transactional memory. Allows composable atomic operations

bbx_core

Foundational utilities for audio DSP: lock-free SPSC, denormal handling, stack-allocated collections

nexus-async-rt

Experimental single-threaded async executor (reference implementation; tokio is the supported path for production use)

aarc

An atomically updatable Arc for lock-free concurrency

direct_ring_buffer

A high-performance, lock-free ring buffer for single-producer, single-consumer scenarios

pi_append_vec

Only supports append vectors, lock free

atomic-tagged-ptr

A platform-adaptive atomic tagged pointer implementation supporting 32-bit, 48-bit, and 52/57-bit high virtual address layouts with ABA protection

nexus-stats-regression

Online regression, learning, and estimation for nexus-stats

kovan-channel

Multi-producer multi-consumer channels using Kovan for memory reclamation

rust-tango

A lock-free, high-performance IPC channel inspired by Firedancer's Tango

virtual-buffer

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

anchormap

Lock-free concurrent hash map: elements never move after insertion, enabling lock-free reads

fastskip

Lock-free arena-backed skip list memtable for LSM-tree storage engines

ph-eventing

Stack-allocated ring buffers for no-std embedded targets

ubq

Lock-free unbounded MPMC queue backed by a linked ring of fixed-size blocks

oneringbuf

A lock-free single-producer, single-consumer (SPSC) ring buffer with in-place mutability, asynchronous support, and virtual memory optimisation

cache-advisor

scan-resistant concurrent cache eviction manager

crush-core

High-performance parallel compression library core

dualcache-ff

A wait-free, high-performance concurrent cache optimized for extreme read-to-write ratios

leapfrog

A fast, lock-free concurrent hash map

pi_key_alloter

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

photon-ring

Ultra-low-latency SPMC/MPMC pub/sub using stamped ring buffers. Formally sound with atomic-slots feature. no_std compatible.

bus

A lock-free, bounded, single-producer, multi-consumer, broadcast channel

bloom_lfs

A high-performance, latch-free log-structured storage layer built for modern flash storage and multi-core systems

memlink-shm

High-performance shared memory IPC library with multi-priority messaging and lock-free ring buffers

kovan-queue

High-performance queue primitives and disruptor implementation for Kovan

swap-buffer-queue

A buffering MPSC queue

chenal

Performant channel implementations

nexus-notify

Cross-thread event queue with conflation and FIFO delivery

avila-parallel

Zero-dependency parallel library with work stealing, SIMD, lock-free operations, adaptive execution, and memory-efficient algorithms

hotswap-config

Zero-downtime configuration management with lock-free hot-reloads and atomic updates

atomic_list

Lock-free circular ring of intrusive ref-counted nodes plus shared cursors

nexus-stats-detection

Advanced change detection and signal analysis for nexus-stats

oxurack-midi

Shared MIDI message types for the oxurack ecosystem

orx-concurrent-queue

A high performance and convenient thread safe queue that can concurrently grow and shrink with push, extend, pop and pull capabilities

magnetic

Low-latency lock-free queues

local_lru

thread-safe and lock-free LRU cache based on thread local storage

once-arc

Initialize-once Arc<T> containers with zero-cost reads

renege

Tracking cache validity using fast concurrent invalidation propogation

pi_slot

lock free Slotmap data structure

ax-handler-table

A lock-free table of event handlers

lock_freedom

concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers

lophat

Lockfree Persistent Homology Algorithm Toolbox

nblf-queue

Atomic, wait-free MPMC queues based on the nblfq algorithm

nexus-net

Low-latency networking primitives: buffers, TLS codec, wire abstractions

zero-pool

High-performance thread pool with consistent low-latency task dispatch

orx-concurrent-option

ConcurrentOption is a lock-free concurrent read and write option type

ptab

Lock-free concurrent table optimized for read-heavy workloads

omega-cache

A high-performance, concurrent cache for Rust with lock-free slot management and pluggable eviction policies

lfrlock

A Lock-Free Read Lock where reads never block and writes are serialized using Mutex

concurrent-sharded-stack

A lock-free concurrent stack that shards a Treiber stack per thread and reclaims memory with epoch-based GC

tachyon-ipc

Bare-metal lock-free IPC, SPSC ring buffer over POSIX shared memory

rbuffer

Lock-free fixed-size SPSC and MPSC ring buffers for low-latency messaging

nexus-web

Low-latency WebSocket, HTTP/1.1, and REST primitives. Sans-IO, zero-copy, SIMD-accelerated.

simple-left-right

Lockfree, realtime safe and copy-free Synchronisation

jacques

High-performance lock-free MPMC queues with horizontal scaling and zero-allocation operation

horde

threads

light-qsbr

A lightweight Quiescent-State-Based Reclamation (QSBR) library for safe memory reclamation in lock-free and async runtimes

rt-history

An RT-safe history log with error checking

waitfree-sync

A collection of wait-free data structures

php-lsp

A PHP Language Server Protocol implementation

saturn-ring-buffer

A high-performance ring buffer

ferroc

A fast & lock-free memory allocator library

optx-stm

Hybrid Software Transactional Memory (STM) library exploring NOrec vs TL2 tradeoffs

nexus-stats-smoothing

Advanced smoothing algorithms for nexus-stats: KAMA, Holt, Spring, Kalman1d, WindowedMedian

concurrent-pool

A concurrent object pool

tower-shot

A high-performance, atomic-backed rate limiting middleware for tower

subms-rate-limiter

submillisecond.com cookbook recipe - concurrency: subms-rate-limiter. Lock-free GCRA-style rate limiter with a single-atomic CAS-loop.

housekeeping

A concurrent memory reclaimer for periodic cleanups

ncp-engine

High performance fuzzy matcher engine

roda-state

A zero-copy, lock-free multi-threaded stage engine for ultra-low latency pipelines

nexus-stats-control

Advanced control and frequency primitives for nexus-stats

interrupt

subms-mpsc-queue

submillisecond.com cookbook recipe - concurrency: subms-mpsc-queue. Vyukov-style multi-producer single-consumer linked queue with dangling-tail handling.

listfree

lockfree prepend-only list

rc_event_queue

VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue

lowlet

Low-latency IPC library using shared memory and lock-free structures

per-thread-object

Efficient per-object thread-local storage implementation

concurrent_avl_tree

Lock-free readable AVL tree with epoch-based reclamation and background batch rebalancing

simboli_thread

Thread Pool Management

kora-observability

Per-key stats, hot-key detection, and memory attribution for Kōra

sendspin

Hyper-efficient Rust implementation of the Sendspin Protocol for synchronized multi-room audio streaming

rcu_128

RCU (Read-Copy-Update) implementation for platforms supporting atomic 128-bit operations

yring

Bounded SPSC ring with ypipe-style batched flush/prefetch

subms-spsc-ring-buffer

submillisecond.com cookbook recipe - concurrency: subms-spsc-ring-buffer. Wait-free SPSC ring buffer with cache-line padded counters and opposite-index caching; sub-50ns enqueue/dequeue on sibling cores.

fast-smr

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

shm-primitives

Lock-free primitives for shared memory IPC: BipBuffer, slot metadata, and OS-level doorbell/mmap

arena-spsc

A lock-free single-producer single-consumer byte channel backed by a flat arena

log_structured_store

A high-throughput append-oriented storage engine built in Rust using batched buffer-ring writes, direct I/O (O_DIRECT), and async io_uring dispatch

bus_queue

Lock-free Bounded non-Blocking Pub-Sub Queue

snaplock

RwLock with lock-free Reads and sequential Writes

seqmap

A blazing fast seqlock-based concurrent hashmap where every data cell is its own seqlock, suitable for thousands of concurrent readers and writers

someday

Lock-free MVCC primitive

historian

a high performance zero-config histogram implementation

loopq

An efficient SPSC lock-free ring buffer with support for no_std, Embassy, and Tokio

rarena-allocator

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

quetzal-uring

Lock-free multi-producer io_uring submission and multi-consumer completion, built on quetzalcoatl protocols and ququmatz syscalls

forge-audio

Zero-allocation, lock-free audio architecture for real-time DSP, game engines, and WebAssembly

avx-parallel

Zero-dependency parallel library with work stealing, SIMD, lock-free operations, adaptive execution, and memory-efficient algorithms

cahotic

Thread Pool Management

cyclotrace

A high-performance, wait-free ring buffer in Rust. Supports SPMC with peek-based semantics instead of destructive consumption.

atomic_once_cell

Thread-safe and lock-free OnceCell and Lazy

ttlog

High-performance lock-free tracing and logging system

atomicring

AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer

sbitmap

Fast and scalable bitmap implementation based on Linux kernel's sbitmap

ring-channel

Bounded MPMC channel abstraction on top of a ring buffer

branch_allocator

A lock-free buddy allocator for no_std

nexus-smartptr

Inline smart pointers for trait objects — Flat (inline-only) and Flex (inline with heap fallback)

lambda-channel

A crossbeam-like channel concurrently executes lambda functions

lockfree

concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers

ferrilog

High-performance lock-free structured logging with sub-30ns hot-path latency

forge-manifest

Hierarchical capability manifest for Code Mode tool discovery

listener-holder

A thread-safe single-listener holder with lock-free reads for Rust

atomic-cuckoo-filter

Highly concurrent Cuckoo Filter

slotpoller

Bounded, lock-free futures collection. Faster than FuturesUnordered and other crates.

sarlacc

Thread-safe lock-free interning of data

santh-bufpool

Typed buffer recycling with fixed size classes and lock-free checkout/return

ratelock

Zero-dependency, zero-allocation, lock-free token bucket rate limiter for Rust (std + no_std)

llt-rs

Low-Latency Primitives Toolkit for Rust

rsmg-core

Core atomic pointer management and concurrent data structures for the RSMG framework

uf_rush

A lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure

genswap

Generation-tracked ArcSwap wrapper for 5-1600x faster cached reads in read-heavy workloads

stm

Software transactional memory. Allows composable atomic operations.

urcu

safe wrapper of the memb variant of the userspace RCU library

pending

lockfree worker thread responder for communicating a value back to the caller thread

codas-flow

Low-latency, high-throughput bounded queues ("data flows") for (a)synchronous and event-driven systems

real-time

Safely share data with a real-time thread

rt-ring

Lock-free SPSC ring buffer with overwrite-oldest semantics for real-time applications

transactional

optimistic lock-free confirmation-based transactional model for Rust

pithanos

Fast, lock-free probabilistic data structures for modern Rust

pi_buckets

lock-free & auto-expansion buckets

hypercounter

An atomic, lock-free, hash map-like counter structure

pinboard

A lock-free, threadsafe way to publish data, just stick it on the pinboard

concurrent-slotmap

A lock-free concurrent slotmap

sevmap

A lock-free, eventually consistent, concurrent single-value map

spragga

A scalable concurrent priority queue with relaxed ordering semantics

chute

Lockfree mpmc/spmc broadcast queue

rtrb-basedrop

A fork of the rtrb crate that uses basedrop’s Shared pointer in place of Arc

skipfree

lockfree skiplist

freezebox

deref'able lazy-initialized container

work-queue

A concurrent work-stealing queue for building schedulers

once-array

Append-only single-writer fixed-capacity vector that can be shared across threads and accessed as a slice

snowdon

A lightweight thread-safe snowflake ID implementation for Rust

kevy-ring

Lock-free bounded SPSC ring buffer. Pure Rust.

lockout-channel

Lock-free unbounded MPMC channel using hazard pointers

lfchring

Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication

carbonmap

Lock-free concurrent hash map for Rust with zero GC

ringbuf-basedrop

A fork of the ringbuf crate that uses basedrop’s Shared pointer in place of Arc

yep-coc

circular buffer. This one happens to be a zero copy, MPMC, lock free queue.

turbo-mpmc

A blazingly fast lock-free MPMC queue that beats crossbeam-channel on SPSC workloads

lock-free

High-performance lock-free data structures for Rust with zero dependencies

str_cache

A fast, lock-free, thread-safe string interning library

quid

Fast, concurrent, lock-free UID generation library

nolock

A collection of Lock-Free Datastructures

lock_free_buddy_allocator

Scalable lock-free buddy system allocator

event_queue_ggmaldo

Lock-free MPSC/SPSC event queues for DAW — UI to audio thread and back, zero allocations

lockout

A collection of lock-free utilities for Rust

mini-io-queue

Fixed-length, allocation and lock-free, async I/O oriented single-producer single-consumer queues