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

flume

A blazingly fast multi-producer channel

async-lock

Async synchronization primitives

async-channel

Async multi-producer multi-consumer channel

crossbeam

Tools for concurrent programming

dashmap

Blazing fast concurrent HashMap for Rust

thread_local

Per-object thread-local storage

threadpool

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

jobserver

GNU Make jobserver for Rust

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

triomphe

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

ringbuf

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

loom

Permutation testing for concurrent code

blake2s_simd

a pure Rust BLAKE2s implementation with dynamic SIMD

scc

High performance containers and utilities for concurrent and asynchronous programming

thread-priority

managing threads priority and schedule policies

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

state

safe and effortless global and thread-local state management

sync_wrapper

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

leaky-bucket

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

stateright

A model checker for implementing distributed systems

corosensei

A fast and safe implementation of stackful coroutines

mpi

Message Passing Interface bindings for Rust

lockfree-object-pool

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

atomic

Generic Atomic<T> wrapper type

thingbuf

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

archery

Abstract over the atomicity of reference-counting pointers

atomic_float

Floating point types which can be safely shared between threads

rtrb

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

may

Rust Stackful Coroutine Library

radium

Portable interfaces for maybe-atomic types

futures-intrusive

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

try-lock

A lightweight atomic lock

ratelimit

ratelimiter that can be shared between threads

scheduled-thread-pool

A scheduled thread pool

sled

Lightweight high-performance pure-rust transactional embedded database

throttle-server

Provide semaphores for distributed systems via an http interface

futures-channel

Channels for asynchronous communication using futures-rs

async-condvar-fair

Condition variables for async Rust

atomic_refcell

Threadsafe RefCell

shuttle

testing concurrent Rust code

mpstthree

implementing Multiparty Session Types for 2 or more participants

jobslot

GNU make jobserver for Rust

automerge

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

wasm_thread

An std thread replacement for wasm32 target

triple_buffer

triple buffering, useful for sharing frequently updated data between threads

concurrent-queue

Concurrent multi-producer multi-consumer queue

concurrent-map

a lock-free linearizable B+ tree

tachyonix

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

waker-fn

Convert closures into wakers

graph

high-performant graph algorithms

flurry

Rust port of Java's ConcurrentHashMap

yaque

disk-backed persistent queue for Rust

atomig

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

resman

Runtime managed resource borrowing

sea-streamer

🌊 The stream processing toolkit for Rust

inline-array

efficient immutable inlinable byte array

workerpool

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

diatomic-waker

An async, lock-free synchronization primitive for task wakeup

orx-concurrent-vec

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

mco

Rust Coroutine Library like go

disruptor

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

bus

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

memo-map

implementing a synchronized map for memoization

samsa

Rust-native Kafka/Redpanda protocol and client implementation

parallel-sh

Execute commands in parallel

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

typedmap

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

dispatch

Rust wrapper for Apple's Grand Central Dispatch

surrealkv

A low-level, versioned, embedded, ACID-compliant, key-value database for Rust

maitake-sync

No-std async synchronization primitives from Maitake

kanal

The fast sync and async channel that Rust deserves

gix-lock

A git-style lock-file implementation

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

sdd

Scalable lock-free delayed memory reclaimer

no_deadlocks

A Runtime Deadlock Debugger

runnel

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

recloser

A concurrent circuit breaker implemented with ring buffers

messaging_thread_pool

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

boxcar

A concurrent, append-only vector

sync_file

Files that can be read concurrently

rustix-futex-sync

Linux futex-based synchronization

callysto

Stream processing framework

lockable

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

atomic-time

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

oqueue

Non-interleaving multithreaded output queue

gst-plugin-threadshare

GStreamer Threadshare Plugin

indicatif-log-bridge

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

paralight

A lightweight parallelism library for indexed structures

async_once

async once tool for lazy_static

shred

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

safe-lock

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

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…

guardian

owned mutex guards for refcounted mutexes

rtsc

Real-time Synchronization Components

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…

rearch

Re-imagined approach to application design and architecture

signals_receipts

exfiltration of the receipt of POSIX signals

io-reactor

Concurrent I/O resource management using reactor pattern

gabriel2

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

uid

creation of unique IDs

pueue

A cli tool for managing long running shell commands

seize

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

svix-ksuid

A pure Rust and fully tested KSUID implementation

append-only-vec

Append-only, concurrent vector

watchable

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

paradis

Parallel processing with disjoint indices

mutringbuf

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

urcu2

Safe API to liburcu

mcslock

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

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

concurrent_arena

u32 concurrent insertion/removal arena that returns ArenaArc

rclite

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

st3

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

skedge

Ergonomic single-process job scheduling for Rust programs

electrologica

High performance concurrent primitives for Rust

aarc

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

loole

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

rustc-rayon

work-stealing parallelism for Rust - fork for rustc

atom

A safe abstraction around AtomicPtr

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

idr-ebr

An efficient concurrent ID to object resolver

swap-buffer-queue

A buffering MPSC queue

cfavml

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

async-skipdb

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

tc-transact

Traits and locking utilities for a TinyChain transaction

open-coroutine

efficient and generic stackful-coroutine library

pumps

Eager streams for Rust

orx-concurrent-iter

A thread-safe, ergonomic and lightweight concurrent iterator trait and efficient implementations

thingvellir

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

picokafka

Kafka library for tarantool-module based on librdkafka

bindgen_cuda

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

fault-injection

fault injection, concurrency delay injection, and error source annotation

actify

An intutive actor model with minimal boilerplate

choir

Task Orchestration Framework

sharded_mutex

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

batch-aint-one

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

atom_box

A safe idiomatic Rust implementation of Atomic Box using hazard pointers

spinning_top

spinlock crate based on the abstractions provided by lock_api

threadbound

Make any value Sync but only available on its original thread

atomptr

A safe, dependency-less abstraction for typed atomic smart pointers

oxidd-manager-pointer

Pointer-based manager implementation for OxiDD

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

tsuki-scheduler

light wight, composable and extensible scheduler for every runtime

whisk

fast lockless async channels

nbio

Non-Blocking I/O

session_log

session log library for Rust

trauma

Simplify and prettify HTTP downloads

crossfire

channels for async and threads

lever

Pillars for Transactional Systems and Data Grids

rabbit-auto

Wrappers for lapin publishers and consumers

gettid

Helper to get an integer ID for the current thread

local-sync

Non-threadsafe data structure for async usage

nexus-actor-remote-rs

Remote library for Nexus Actor

supply-chain-trust-example-crate-000025

More compact and efficient implementations of the standard synchronization primitives

minstant

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

utils-atomics

Various atomic utils

mintex

minimal mutex

async-local

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

atomic-take

Atomically take a value out of a container once

cargo-steady-state

Code generator for steady_state projects based on a structured dot file

rcron

cron job scheduling for rust

fast-able

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

sluice

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

desync

A hassle-free data type for asynchronous programming

portable_atomic_enum

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

rtic-monotonics

that provides implementations of the Monotonic trait from rtic-time

melodium

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

atomic-shim

Atomic types for unsupported platforms

tasklet

An asynchronous task scheduling library

crossbeam-utils

concurrent programming

liner_broker

Redis based message serverless broker

crossbeam-skiplist-mvcc

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

cachemap2

A concurrent insert-only hashmap for caching values

someday

Lock-free MVCC primitive

omango

Concurrency collections

may_actor

Actor library based on MAY

rayon-cond

Experimental iterator wrapper that is conditionally parallel or serial

crossbeam-queue

Concurrent queues

parking

Thread parking and unparking

channel

Rust advanced queue library

timeslice

periodic time slice scheduler

jod-thread

std::thread which joins on drop by default

pagetable

Wait-free 4-level 64-bit pagetable for roughly-contiguous keys

async-stm

Asynchronous Software Transactional Memory

readlock

A weird alternative to Arc<RwLock<T>>

speare

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

happylock

Free deadlock prevention

rcu_cell

a lockless rcu cell implementation

moga

A multi-objective genetic algorithm framework

rw-cell

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

rose_bloom

A concurrent growing element size linked list with stable pointers

p3-maybe-rayon

Feature-gated wrapper around rayon

thread-manager

A streamlined Rust library for efficient thread pooling and parallel job execution, designed for simplicity, flexibility, and performance

pariter

Parallel iterator processing

file-per-thread-logger

A logging implementation that writes logs in one file per thread

arccstr

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

rayon-progress-bar

work-stealing parallelism for Rust

shipyard_scenegraph

Scenegraph for Entity Component System

yazi-scheduler

Yazi task scheduler

atomic-wait

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

atomic_enum

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

reord

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

protoflow

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

amity

Concurrency algorithms

datafusion-substrait

DataFusion Substrait Producer and Consumer

myriam

Actor model implementation for local and remote actors

ptr_cell

Thread-safe cell based on atomic pointers

semka

Semaphore implementation

benjamin_batchly

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

atomic_once_cell

Thread-safe and lock-free OnceCell and Lazy

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

balter

A load/stress testing framework

slog-atomic

Atomic run-time controllable drain for slog-rs

rucron

Job Scheduling Crate

chili

low-overhead parallelization library

async-event

An efficient async condition variable for lock-free algorithms

tc-scalar

TinyChain's scalar value enum, including concurrently-resolvable op definitions and references

turbo-metrics

Toolkit to compute quality metrics fast using a GPU

node-replication

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

sharded-thread

Expirement for now

tatl

in-process alerting

armc

that facilitates Mutex access to variables

congestion-limiter

Dynamic congestion-based concurrency limits for controlling backpressure

anchor-chain

A statically typed async framework for building LLM-based applications

k-lock

A fast mutex for short critical sections

unlock

Instrumented synchronization primitives helping you to unlock performance issues

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.

namaste

kueue

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

synchronoise

Synchronization primitives that build upon the standard library

employees

A small runtime that hides all the boilerplate when using threads

roboplc

Framework for PLCs and real-time micro-services

orx-parallel

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

lockfree

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

easy-threadpool

A relatively simple thread pool which you can send jobs to

amadeus

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

tokio-cron

cron scheduler for tokio

fluxion

actor framework written in rust and designed for distributed systems

lock_ext

Extensions to std::sync::Mutex

mpvipc

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

parallel-processor

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

atomic-interval

A tiny implementation of an atomic timer

open-coroutine-hook

The syscall hook for open-coroutine

async-atomic

Atomics which can be subscribed to and asynchronously notify when updated

freezebox

deref'able lazy-initialized container

rocketmq-common

Apache rocketmq common

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…

tlrepo

Thread-local git2::Repository, shareable across threads

active_standby

A concurrency primitive for high concurrency reads

mpsc_requests

mpsc channels but with a response

txn_lock

support transactional versioning

maybe-rayon

Either acts as rayon or creates a single-threaded facade

pi_atom

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

rearch-effects

Re-imagined approach to application design and architecture

iterator_ilp

Iterator extensions for instruction-parallel reductions

miden-tx-prover

Miden rollup transaction prover

rust-lockless-slotmap

A (mostly) lockless slotmap implementation in Rust

keepcalm

shared types for multi-threaded programs

parallel-future

fluent async task experiments

treiber_stack

A lockless, thread-safe, atomic linked-list

concurrent-slotmap

A lock-free concurrent slotmap

kube-leader-election

Leader election implementations for Kubernetes workloads

disruptor-rs

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

nexus-actor-utils-rs

Nexus Actor

parcheck

Test permutations of concurrent scenarios

batch-processing

A batch library for processing a list of items in parallel

salsa

A generic framework for on-demand, incrementalized computation (experimental)

par-iter-sync

Parallel Iterator With Sequential Output

pubserve

generic observer trait

lock_api

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

split_channel

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

evtcall

Rust Event Driven Framework

sharded_queue

ShardedQueue is currently the fastest concurrent collection which can be used under highest concurrency and load

wikiwho

Fast Rust reimplementation of the WikiWho algorithm for fine-grained authorship attribution on large datasets. Optimized for easy integration in multi-threaded applications.

direct_ring_buffer

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

evident

Pub/Sub library using IDs to identify events

restd

A re-implementation of various std features

permit

A struct for cancelling operations

atomic-file-install

For atomically installing a file or a symlink

command-executor

Command Executor thread pool

windows-key-listener

Listen to arbitrary key chords on Windows

ebr

epoch-based reclamation with low cacheline ping-pong

nblock

Non-Blocking Runtime

lfchring

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

pausable_clock

A source of time information that can be paused and resumed

thread-counter

way of efficiently keeping track of active threads and waiting for them to exit

antidote

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

dynamodb_lock

Distributed lock backed by Dynamodb

incr

fast and self-contained data structures for checking whether a new value is greater than the previous maximum

thread_local_collect

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

yash-executor

single-threaded concurrent task executor

spools

Content scraping library for Instagram's Threads

circ

Efficient referenced counted pointers for non-blocking concurrency

atomicell

Multi-threaded RefCell on atomics

bastion

Fault-tolerant Runtime for Rust applications

rusturnate

A sync or async mutex, with or without timeouts

crossbeam-skiplist-pr1132

A concurrent skip list

papaya

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

thread_io

performing I/O in background thread

throttle-client

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

multithreading

in Rust

rust_kits

kits

asyncgit

allow using git2 in a asynchronous context

pi_arr

lock-free & auto-expansion array

pi_share

rc, arc, lock, atomic

datacake

A batteries included framework for building fault-tolerance distributed data systems

amfiteatr_classic

some classic game theory problems to research on

mpmc-async

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

tokio-cadence

Tokio-based metric sinks for Cadence

redlock

distributed locking mechanism built on top of Redis

with_daemon

An async client-daemon abstraction framework

rayon-scan

A parallel prefix scan function for ParallelIterator

synchronized

Convenient and simple macro for code synchronization in multithreading

threadcell

A cell whose value can only be accessed by a owning thread

television-rs

The revolution will be televised

squeue

sized queue

oxidd-rules-mtbdd

Multi-terminal decision diagrams (MTBDDs) for OxiDD

pacwrap-agent

Executable agent for conducting containerized transactions

fibers

execute a number of lightweight asynchronous tasks (a.k.a, fibers) based on futures and mio

leaklist

concurrent, lock-free, singly-linked list

chute

Lockfree mpmc/spmc multicast queue

atomicbox

Safe atomic pointers to boxed data

irondash_run_loop

Consistent, platform-independent interface to system run loop

crossbeam-channel

Multi-producer multi-consumer channels for message passing

bztree

BzTree implementation for Rust

td_rthreadpool

thread wrapper for Rust

non_blocking_mutex

NonBlockingMutex is currently the fastest way to do expensive calculations under lock, or do cheap calculations under lock when concurrency/load/contention is very high

print_queues

A print queues that can be add from different thread and print on main thread

range-lock

Range lock for std::vec::Vec

may_queue

May's internal queue library

mea

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

granite_reckoner

aggregator enabling basic statistical operations on Vec<T> in the specified number of threads. Works for all Rust's built-in numeric types.

dag-scheduler

a scheduler of dag computation graph

mogul

Agnosticly helps to manage concurrent versions of things

pargraph

Operator based parallel graph processing

mtlog

Multi-threaded logger with support for log files

stuck

Multi-threading scheduled task facility building on cooperative stackful coroutine

init-once

Concurrent, non-blocking lazy initialization of values

ring-channel

Bounded MPMC channel abstraction on top of a ring buffer

tracing-mutex

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

fork-map

running operations in a child process spawned by fork()

timedmap

A hash map with expiring key-value pairs

local_thread

A local thread management library for Rust. No more 'static functions in order to start threads!

periodically

running tasks on a schedule

zallocator

Amortizes the cost of small allocations by allocating memory in bigger chunks

left-right-cell

A cell with lock-free concurrent read access

rtic-monotonic

Core abstractions of the Real-Time Interrupt-driven Concurrency Monotonic timers

simple-semaphore

🔐 A lightweight implementation of a Semaphore in Rust

pinned-mutex

Mutex wrappers with structural pinning