Lib.rs

parking_lot

More compact and efficient implementations of the standard synchronization primitives

spin

Spin-based synchronization primitives

rayon

work-stealing parallelism for Rust

dashmap

Blazing fast concurrent HashMap for Rust

thread_local

Per-object thread-local storage

flume

A blazingly fast multi-producer channel

async-channel

Async multi-producer multi-consumer channel

crossbeam

Tools for concurrent programming

ringbuf

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

async-lock

Async synchronization primitives

oneshot

spsc channel with (potentially) lock-free non-blocking send, and a receiver supporting both thread blocking receive operations as well as Future based async polling

threadpool

A thread pool for running a number of jobs on a fixed set of worker threads

triomphe

A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)

loom

Permutation testing for concurrent code

blake2s_simd

a pure Rust BLAKE2s implementation with dynamic SIMD

thread-priority

managing threads priority and schedule policies

jobserver

GNU Make jobserver for Rust

scc

High-performance containers and utilities for concurrent and asynchronous programming

lasso

A multithreaded and single threaded string interner that allows strings to be cached with a minimal memory footprint, associating them with a unique key that can be used to retrieve them at any time

sync_wrapper

enlisting the compiler's help in proving the absence of concurrency

mpi

Message Passing Interface bindings for Rust

state

safe and effortless global and thread-local state management

sled

Lightweight high-performance pure-rust transactional embedded database

corosensei

A fast and safe implementation of stackful coroutines

rtrb

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

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.

stateright

A model checker for implementing distributed systems

archery

Abstract over the atomicity of reference-counting pointers

atomic_float

Floating point types which can be safely shared between threads

may

Rust Stackful Coroutine Library

throttle-server

Provide semaphores for distributed systems via an http interface

radium

Portable interfaces for maybe-atomic types

try-lock

A lightweight atomic lock

maitake-sync

No-std async synchronization primitives from Maitake

diatomic-waker

An async, lock-free synchronization primitive for task wakeup

atomic_refcell

Threadsafe RefCell

scheduled-thread-pool

A scheduled thread pool

ratelimit

ratelimiter that can be shared between threads

crossbeam-channel

Multi-producer multi-consumer channels for message passing

leaky-bucket

A token-based rate limiter based on the leaky bucket algorithm

jobslot

GNU make jobserver for Rust

wasm_thread

An std thread replacement for wasm32 target

bus

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

atomic

Generic Atomic<T> wrapper type

triple_buffer

triple buffering, useful for sharing frequently updated data between threads

mpstthree

implementing Multiparty Session Types for 2 or more participants

futures-intrusive

Futures based on intrusive data structures - for std and no-std environments

async-condvar-fair

Condition variables for async Rust

executors

A collection of high-performance task executors

concurrent-map

a lock-free linearizable B+ tree

orx-concurrent-vec

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

flurry

Rust port of Java's ConcurrentHashMap

rustc-rayon

work-stealing parallelism for Rust - fork for rustc

tachyonix

A very fast asynchronous, multi-producer, single-consumer bounded channel

disruptor

Low latency inter-thread communication via a ringbuffer (inspired by the LMAX Disruptor)

typedmap

A hash map (dash map). A type of value is defined by trait implemented on key type

waker-fn

Convert closures into wakers

seize

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

resman

Runtime managed resource borrowing

shuttle

testing concurrent Rust code

yaque

disk-backed persistent queue for Rust

paralight

A lightweight parallelism library for indexed structures

inline-array

efficient immutable inlinable byte array

memo-map

implementing a synchronized map for memoization

automerge

A JSON-like data structure (a CRDT) that can be modified concurrently by different users, and merged again automatically

sdd

Scalable lock-free delayed memory reclaimer

cargo-steady-state

Code generator for steady_state projects based on a structured dot file

atomig

Generic, convenient and lock-free std atomics via Atomic<T>. Can be used with many primitive types (including floats) and with custom types.

mco

Rust Coroutine Library like go

chili

low-overhead parallelization library

futures-channel

Channels for asynchronous communication using futures-rs

sea-streamer

🌊 The stream processing toolkit for Rust

workerpool

A thread pool for running a number of jobs on a fixed set of stateful worker threads

concurrent-queue

Concurrent multi-producer multi-consumer queue

fdup

find duplicate files recursively and in parallel

shred

Dispatches systems in parallel which need read access to some resources, and write access to others

parallel-sh

Execute commands in parallel

guardian

owned mutex guards for refcounted mutexes

messaging_thread_pool

aiding the creation of typed thread pool of objects that is communicated with via channels

graph

high-performant graph algorithms

idr-ebr

An efficient concurrent ID to object resolver

rusty_pool

Self growing / shrinking ThreadPool implementation based on crossbeam’s multi-producer multi-consumer channels that enables awaiting the result of a task and offers async support

uid

creation of unique IDs

loole

A safe async/sync multi-producer, multi-consumer channel

television

The revolution will be televised

botcore

Production-grade asynchronous bot engine with enterprise observability features

runnel

the pluggable io stream. now support: stdio, string io, in memory pipe

rs-store

Redux Store for Rust

ringbuffer-spsc

A fast thread-safe single producer-single consumer ring buffer

fault-injection

fault injection, concurrency delay injection, and error source annotation

lockable

offers hash map, hash set and cache data structures where individual entries can be locked

samsa

Rust-native Kafka/Redpanda protocol and client implementation

atomic-time

AtomicDuration, AtomicOptionDuration, AtomicSystemTime, AtomicOptionSystemTime, AtomicInstant and AtomicOptionInstant for Rust

gix-lock

A git-style lock-file implementation

kanal

The fast sync and async channel that Rust deserves

happylock

Free deadlock prevention

indicatif-log-bridge

Bridge the log crate and indicatif to stop log lines from mixing up with progress bars

pausable_clock

A source of time information that can be paused and resumed

nbio

Non-Blocking I/O

parking

Thread parking and unparking

session_log

session log library for Rust

mcslock

Mellor-Crummey and Scott contention-free lock for mutual exclusion, referred to as MCS lock

clashmap

Sharded hashmap suitable for fast concurrent access

append-only-vec

Append-only, concurrent vector

safe-lock

A lock struct with a const fn constructor and no unsafe - ARCHIVED

mutex

An abstraction over closure-based mutexes

async_nursery

Primitive for structured concurrency

arrayfire

high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. ArrayFire's multiple backends (CUDA…

rearch

Re-imagined approach to application design and architecture

recloser

A concurrent circuit breaker implemented with ring buffers

bindgen_cuda

Bindgen like interface to build cuda kernels to interact with within Rust

io-reactor

Concurrent I/O resource management using reactor pattern

speare

actor-like thin abstraction over tokio::task and flume channels

no_deadlocks

A Runtime Deadlock Debugger

trauma

Simplify and prettify HTTP downloads

gst-plugin-threadshare

GStreamer Threadshare Plugin

lasso2

A multithreaded and single threaded string interner that allows strings to be cached with a minimal memory footprint, associating them with a unique key that can be used to retrieve them at any time

paradis

Parallel processing with disjoint indices

st3

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

rcu_cell

a lockless rcu cell implementation

rustix-futex-sync

Linux futex-based synchronization

roboplc

Framework for PLCs and real-time micro-services

rc_event_queue

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

atomptr

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

pumps

Eager streams for Rust

qeztorncodegen

* The development of Torn's API v2 is still ongoing. * If selections remain unaltered, they will default to the API v1 version. * Unlike API v1, API v2 accepts both selections and IDs as path and query parameters…

callysto

Stream processing framework

sync_file

Files that can be read concurrently

atom

A safe abstraction around AtomicPtr

gabriel2

Indeed, an actor library based on Tokio, written in Rust

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

signals_receipts

exfiltration of the receipt of POSIX signals

renoir

Reactive Network of Operators In Rust

orx-concurrent-iter

A thread-safe and ergonomic concurrent iterator trait and efficient lock-free implementations

patrolilo

Job scheduler with integrated NTFY notifications

pueue

A cli tool for managing long running shell commands

mutringbuf

lock-free SPSC ring buffer, with in-place mutability

crossbeam-utils

concurrent programming

aarc

Atomically updatable variants of Arc and Weak for lock-free concurrency

paraseq

A minimal-copy parser for FASTA and FASTQ files built for paired parallel processing

qutex

Synchronization mechanisms that rely on lock-free and other non-(thread)blocking techniques, such as Rust futures, to guarantee mutually exclusive or shared exclusive access to data

atom_box

A safe idiomatic Rust implementation of Atomic Box using hazard pointers

thingvellir

a concurrent, shared-nothing abstraction that manages an assembly of things

oqueue

Non-interleaving multithreaded output queue

minstant

A drop-in replacement for std::time::Instant that measures time with high performance and high accuracy powered by TSC

orx-parallel

A performant and configurable parallel computing library for computations defined as compositions of iterator methods

protoflow-zeromq

Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages

p3-maybe-rayon

Feature-gated wrapper around rayon

leapfrog

A fast, lock-free concurrent hash map

yazi-scheduler

Yazi task scheduler

oxidd-manager-pointer

Pointer-based manager implementation for OxiDD

rtic-monotonics

that provides implementations of the Monotonic trait from rtic-time

sharded_mutex

No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.

tokio-cadence

Tokio-based metric sinks for Cadence

myriam

Actor model implementation for local and remote actors

tasklet

An asynchronous task scheduling library

atomic_once_cell

Thread-safe and lock-free OnceCell and Lazy

concurrent_arena

u32 concurrent insertion/removal arena that returns ArenaArc

sovran-arc

Memory management swift-isms brought to Rust

steady_state

Framework for building long running low latency actor based services on Linux. Provides visual telemetry to watch data flows between actors. Uses Erlang style supervisors to defend…

readlock

A weird alternative to Arc<RwLock<T>>

batch-aint-one

I got 99 problems, but a batch ain't one

boxcar

A concurrent, append-only vector

picokafka

Kafka library for tarantool-module based on librdkafka

ballista-executor

Ballista Distributed Compute - Executor

atomic-arena

Generational arena that allows reserving keys from other threads

swap-buffer-queue

A buffering MPSC queue

tsuki-scheduler

light wight, composable and extensible scheduler for every runtime

actify

An intutive actor model with minimal boilerplate

pubsub-bus

Thread-safe one-to-many publish-subscribe event system. Simple and easy to use. It just works (hopefully).

async-local

For using thread locals within an async context and across await points

skedge

Ergonomic single-process job scheduling for Rust programs

fluxion

actor framework written in rust and designed for distributed systems

pandora-interpreter

A command-line tool to run pandora language

async-skipdb

An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine

atomic-take

Atomically take a value out of a container once

rayon-cond

Experimental iterator wrapper that is conditionally parallel or serial

oneshot-uniffi

Patched version of oneshot specifically for the UniFFI project. This removes the loom target and dependency which helps with UniFFI’s downstream consumers

cfavml

CF's Accelerated Vector Math Library providing SIMD optimzied routines for vector operations

choir

Task Orchestration Framework

mintex

minimal mutex

clap-clap

CLAP plugin runtime

pariter

Parallel iterator processing

nexus-acto-rs

Actors

atomic-shim

Atomic types for unsupported platforms

gettid

Helper to get an integer ID for the current thread

jod-thread

std::thread which joins on drop by default

potential

PubSub lib with sync and async API

rtsc

Real-time Synchronization Components

dispatch

Rust wrapper for Apple's Grand Central Dispatch

spinning_top

spinlock crate based on the abstractions provided by lock_api

lever

Pillars for Transactional Systems and Data Grids

rcron

cron job scheduling for rust

portable_atomic_enum

An attribute to create an portable atomic wrapper around a C-style enum

may_actor

Actor library based on MAY

pi_arr

lock-free & auto-expansion array

reactivate

Thread Safe Reactive Data Structure. Made with ❤️ for 🦀

rw-cell

Write data to cell from anything place your application without copy, lock and reading in one place

elysees

A fork of triomphe, now with more pointer trickery

supply-chain-trust-example-crate-000025

More compact and efficient implementations of the standard synchronization primitives

liner_broker

Redis based message serverless broker

async-event

An efficient async condition variable for lock-free algorithms

rclite

small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs

whisk

fast lockless async channels

atomic-wait

Cross-platform atomic wait and wake (aka futex) functionality

async_once

async once tool for lazy_static

desync

A hassle-free data type for asynchronous programming

tetanus

A custom utils library for some common unsafe operations

par

Session types, as an implementation of linear logic with MIX

rose_bloom

A concurrent growing element size linked list with stable pointers

utils-atomics

Various atomic utils

balter

A load/stress testing framework

arccstr

Thread-safe, reference-counted null-terminated immutable strings

omango

Concurrency collections

agave-thread-manager

Thread pool manager for agave

virtual-buffer

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

file-per-thread-logger

A logging implementation that writes logs in one file per thread

vec-belt

Multi-threaded bulk-append, single-threaded consume Vec<T>

rush_expr_engine

The rules engine is based on the rete algorithm

watchable

RwLock-like type that is compatible with both multi-threaded and async code

tcp-echo-benchmark

A high-performance TCP echo server benchmark tool measuring throughput using concurrent async clients. Supports configurable payload size, connection count, and test duration.

hzrd

Shared mutability containers based on hazard pointers

concurrent-slotmap

A lock-free concurrent slotmap

amity

Concurrency algorithms

slog-atomic

Atomic run-time controllable drain for slog-rs

melodium

Dataflow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely

semka

Semaphore implementation

resilient-rs

fault tolerance, including retry strategies, backoff mechanisms, and failure handling

simd-itertools

SIMD-accelerated alternatives for common operations like contains, max, find etc

atomic-maybe-uninit

Atomic operations on potentially uninitialized integers

creche

A replacement for std::process::Command and related types in the standard library. Runs single processes, and pipelines of processes, with configuration of file descriptors and environment for each child process.

threadbound

Make any value Sync but only available on its original thread

wdk-mutex

An idiomatic Rust mutex type for Windows kernel driver development

tatl

in-process alerting

sovran-state

state management for Rust

ptr_cell

Thread-safe cell based on atomic pointers

timeslice

periodic time slice scheduler

evtcall

Rust Event Driven Framework

amfiteatr_classic

some classic game theory problems to research on

rucron

Job Scheduling Crate

mea

A runtime-agnostic library providing essential synchronization primitives for asynchronous Rust programming

crossfire

channels for async and threads

node-replication

An operation-log based approach that transform single-threaded data structures into concurrent, replicated structures

idgenerator-thin

Shorter ID and faster generation with a new snowflake drift algorithm. The core is to shorten the ID length, but also can have a very high instantaneous concurrent processing capacity (50W/0…

command_history

managing command history in Rust applications

fastatomstruct

A Python package for the analysis of atomic structures and dynamics

lockfree

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

someday

Lock-free MVCC primitive

sharded-offset-map

A map from u64 to T that can be written from multiple threads

irondash_run_loop

Consistent, platform-independent interface to system run loop

laika

A namespace crate containing miscellaneous submodules (like an SPMC channel) of owner its-laika

svix-ksuid

A pure Rust and fully tested KSUID implementation

every

Run a command every N seconds

paladin-core

distributed algorithm toolkit. Write distributed algorithms without the complexities of distributed systems programming.

electrologica

High performance concurrent primitives for Rust

spools

Content scraping library for Instagram's Threads

skedgy

asynchronous job scheduler

anchor-chain

A statically typed async framework for building LLM-based applications

channel

Rust advanced queue library

tlrepo

Thread-local git2::Repository, shareable across threads

rusturnate

A sync or async mutex, with or without timeouts

blazemap

Implements a vector-based slab-like map with an interface similar to that of HashMap, and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map

txn_lock

support transactional versioning

maybe-rayon

Either acts as rayon or creates a single-threaded facade

local-sync

Non-threadsafe data structure for async usage

reord

Run your tests multi-threaded, but in a reproducible way

disruptor-rs

A high-performance ring buffer implementation of the LMAX Disruptor pattern

iterator_ilp

Iterator extensions for instruction-parallel reductions

td_rthreadpool

thread wrapper for Rust

cutools

atomic_enum

An attribute to create an atomic wrapper around a C-style enum

rsvow

A Rust-like implementation of JavaScript's Promise mechanism

atomic-file-install

For atomically installing a file or a symlink

lock_api

Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.

magnetic

Low-latency lock-free queues

parallel-processor

Framework to manage asynchronous execution of multiple compute units communicating using messages

atomic-destructor

Atomic destructor for multi-threaded env

mpsc

mpsc channel

lock-free-static

Lock-free static variables

tracing-mutex

Ensure deadlock-free mutexes by allocating in order, or else

active_standby

A concurrency primitive for high concurrency reads

async-stm

Asynchronous Software Transactional Memory

eventbus-tiny

A small, dependency-free crate that provides a multi-producer broadcast-consumer event bus

diskann-rs

DiskANN (Disk-based Approximate Nearest Neighbor search) featuring a 3-layer index architecture and parallel query processing. This project provides an efficient and scalable solution…

kube-leader-election

Leader election implementations for Kubernetes workloads

lazy_mut

Alternative to LazyLock<Mutex<T>>

ebr

epoch-based reclamation with low cacheline ping-pong

fast-able

The world's martial arts are fast and unbreakable; 天下武功 唯快不破

amadeus

Harmonious distributed data processing & analysis in Rust. parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common crawl

treiber_stack

A lockless, thread-safe, atomic linked-list

shipyard_scenegraph

Scenegraph for Entity Component System

mpsc_requests

mpsc channels but with a response

mpvipc

A small library which provides bindings to control existing mpv instances through sockets

sharded-vec-writer

Write parts of a Vec from different threads

win-kernel

windows-kernel

armc

that facilitates Mutex access to variables

benjamin_batchly

Low latency batching tool. Bundle lots of single concurrent operations into sequential batches of work.

gadget-std

Re-exports of core/std for Tangle Blueprints

split_channel

stream-of-messages abstraction with split send/recv channels

async-atomic

Atomics which can be subscribed to and asynchronously notify when updated

lock-hierarchy

Prevent dead locks by enforcing lock hierarchies

rust-lockless-slotmap

A (mostly) lockless slotmap implementation in Rust

atomic_pincell

Threadsafe pinnable RefCell

invocation-counter

Datastructure to answer to: how many times a function has been called in the last X minutes?

antidote

Poison-free versions of the standard library Mutex and RwLock types

ohos-sys

Bindings to the native API of OpenHarmony OS

onering

High throughput synchronous queue

crossbeam-skiplist-mvcc

Support MVCC (Multiple Version Concurrent Control) for crossbeam-skiplist

sharded-thread

Expirement for now

buf-mutex

Buffered mutexes

tc-transact

Traits and locking utilities for a TinyChain transaction

atomic-interval

A tiny implementation of an atomic timer

hydra-dashmap

A fork of dashmap for the hydra framework

congestion-limiter

Dynamic congestion-based concurrency limits for controlling backpressure

cachemap2

A concurrent insert-only hashmap for caching values

init-once

Concurrent, non-blocking lazy initialization of values

rearch-effects

Re-imagined approach to application design and architecture

mpmc-async

A multi-producer, multi-consumer async channel with reservations

lock_ext

Extensions to std::sync::Mutex

bastion

Fault-tolerant Runtime for Rust applications

easy-threadpool

A relatively simple thread pool which you can send jobs to

rayon-progress-bar

work-stealing parallelism for Rust

lfchring

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

thread_io

performing I/O in background thread

restd

A re-implementation of various std features

pi_atom

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

thread_local_collect

Supports the collection and aggregation of thread-local data across threads

rufutex

Ulrich Drepper's mutex using futex implementation in Rust

ferris-files

A CLI to find large files

nexus-actor-remote-rs

Remote library for Nexus Actor

k-lock

A fast mutex for short critical sections

ctxs

显式的代码上下文管理设施

throttle-client

Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.

oxidd-rules-mtbdd

Multi-terminal decision diagrams (MTBDDs) for OxiDD

cyclic_pipe

providing fixed-size, buffer pre-allocated cyclic pipe which support multi-producer and multi-consumer concurrent access

sluice

Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels

chunklist

A Chunk List is a new, concurrent, chunk-based data structure that is easily modifiable and allows for fast runtime operations

critical-once-cell

Thread-safe OnceCell and Lazy backed by critical section

clhlock

Craig and, indenpendently, Magnussen, Landin, and Hagersten queue lock for mutual exclusion, referred to as CLH lock

open-coroutine-hook

The syscall hook for open-coroutine

namaste

kueue

A robust, user-level, work-stealing, distributed task scheduler

thread-groups

that spawns several threads so you can wait for their completion and enjoy the silence of your life in the real world

keepcalm

shared types for multi-threaded programs