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

thread_local

Per-object thread-local storage

crossbeam

Tools for concurrent programming

async-lock

Async synchronization primitives

ringbuf

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

async-channel

Async multi-producer multi-consumer channel

dashmap

Blazing fast concurrent HashMap for Rust

triomphe

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

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

jobserver

GNU Make jobserver for Rust

threadpool

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

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

sync_wrapper

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

state

safe and effortless global and thread-local state management

stateright

A model checker for implementing distributed systems

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.

sled

Lightweight high-performance pure-rust transactional embedded database

leaky-bucket

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

mpi

Message Passing Interface bindings for Rust

archery

Abstract over the atomicity of reference-counting pointers

radium

Portable interfaces for maybe-atomic types

futures-intrusive

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

diatomic-waker

An async, lock-free synchronization primitive for task wakeup

atomic_float

Floating point types which can be safely shared between threads

try-lock

A lightweight atomic lock

scheduled-thread-pool

A scheduled thread pool

ratelimit

ratelimiter that can be shared between threads

shuttle

testing concurrent Rust code

futures-channel

Channels for asynchronous communication using futures-rs

atomic_refcell

Threadsafe RefCell

may

Rust Stackful Coroutine Library

jobslot

GNU make jobserver for Rust

triple_buffer

triple buffering, useful for sharing frequently updated data between threads

crossbeam-channel

Multi-producer multi-consumer channels for message passing

flurry

Rust port of Java's ConcurrentHashMap

async-condvar-fair

Condition variables for async Rust

bus

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

throttle-server

Provide semaphores for distributed systems via an http interface

executors

A collection of high-performance task executors

concurrent-map

a lock-free linearizable B+ tree

mpstthree

implementing Multiparty Session Types for 2 or more participants

tachyonix

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

wasm_thread

An std thread replacement for wasm32 target

orx-concurrent-vec

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

atomic

Generic Atomic<T> wrapper type

typedmap

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

automerge

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

seize

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

inline-array

efficient immutable inlinable byte array

disruptor

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

memo-map

implementing a synchronized map for memoization

sea-streamer

🌊 The stream processing toolkit for Rust

resman

Runtime managed resource borrowing

mco

Rust Coroutine Library like go

waker-fn

Convert closures into wakers

graph

high-performant graph algorithms

yaque

disk-backed persistent queue for Rust

samsa

Rust-native Kafka/Redpanda protocol and client 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

workerpool

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

atomig

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

idr-ebr

An efficient concurrent ID to object resolver

sdd

Scalable lock-free delayed memory reclaimer

trauma

Simplify and prettify HTTP downloads

paralight

A lightweight parallelism library for indexed structures

patrolilo

Job scheduler with integrated NTFY notifications

maitake-sync

No-std async synchronization primitives from Maitake

guardian

owned mutex guards for refcounted mutexes

uid

creation of unique IDs

concurrent-queue

Concurrent multi-producer multi-consumer queue

runnel

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

lockable

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

fault-injection

fault injection, concurrency delay injection, and error source annotation

loole

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

gix-lock

A git-style lock-file implementation

happylock

Free deadlock prevention

messaging_thread_pool

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

parallel-sh

Execute commands in parallel

sync_file

Files that can be read concurrently

kanal

The fast sync and async channel that Rust deserves

atomic-time

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

fdup

find duplicate files recursively and in parallel

gst-plugin-threadshare

GStreamer Threadshare Plugin

async_nursery

Primitive for structured concurrency

recloser

A concurrent circuit breaker implemented with ring buffers

rs-store

Redux Store for Rust

shred

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

no_deadlocks

A Runtime Deadlock Debugger

rearch

Re-imagined approach to application design and architecture

rustc-rayon

work-stealing parallelism for Rust - fork for rustc

io-reactor

Concurrent I/O resource management using reactor pattern

speare

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

nbio

Non-Blocking I/O

gabriel2

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

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

rcu_cell

a lockless rcu cell implementation

parking

Thread parking and unparking

safe-lock

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

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…

st3

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

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…

append-only-vec

Append-only, concurrent vector

rtsc

Real-time Synchronization Components

atomic-arena

Generational arena that allows reserving keys from other threads

ringbuffer-spsc

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

callysto

Stream processing framework

rustix-futex-sync

Linux futex-based synchronization

signals_receipts

exfiltration of the receipt of POSIX signals

indicatif-log-bridge

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

oqueue

Non-interleaving multithreaded output queue

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…

mcslock

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

paradis

Parallel processing with disjoint indices

atom

A safe abstraction around AtomicPtr

thingvellir

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

pumps

Eager streams for Rust

bindgen_cuda

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

papaya

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

aarc

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

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

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

sharded_mutex

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

swap-buffer-queue

A buffering MPSC queue

rc_event_queue

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

session_log

session log library for Rust

orx-concurrent-iter

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

minstant

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

atom_box

A safe idiomatic Rust implementation of Atomic Box using hazard pointers

svix-ksuid

A pure Rust and fully tested KSUID implementation

tsuki-scheduler

light wight, composable and extensible scheduler for every runtime

mutringbuf

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

skedge

Ergonomic single-process job scheduling for Rust programs

wdk-mutex

An idiomatic Rust mutex type for Windows kernel driver development

concurrent_arena

u32 concurrent insertion/removal arena that returns ArenaArc

pueue

A cli tool for managing long running shell commands

oxidd-manager-pointer

Pointer-based manager implementation for OxiDD

tasklet

An asynchronous task scheduling library

rush_expr_engine

The rules engine is based on the rete algorithm

atomptr

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

picokafka

Kafka library for tarantool-module based on librdkafka

rclite

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

actify

An intutive actor model with minimal boilerplate

mintex

minimal mutex

readlock

A weird alternative to Arc<RwLock<T>>

dispatch

Rust wrapper for Apple's Grand Central Dispatch

pi_arr

lock-free & auto-expansion array

leapfrog

A fast, lock-free concurrent hash map

watchable

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

batch-aint-one

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

atomic-take

Atomically take a value out of a container once

choir

Task Orchestration Framework

whisk

fast lockless async channels

myriam

Actor model implementation for local and remote actors

tokio-cadence

Tokio-based metric sinks for Cadence

async-skipdb

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

p3-maybe-rayon

Feature-gated wrapper around rayon

lever

Pillars for Transactional Systems and Data Grids

elysees

A fork of triomphe, now with more pointer trickery

chili

low-overhead parallelization library

rayon-cond

Experimental iterator wrapper that is conditionally parallel or serial

cfavml

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

async-local

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

pandora-interpreter

A command-line tool to run pandora language

gettid

Helper to get an integer ID for the current thread

jod-thread

std::thread which joins on drop by default

urcu2

Safe API to liburcu

portable_atomic_enum

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

atomic-shim

Atomic types for unsupported platforms

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

yazi-scheduler

Yazi task scheduler

async_once

async once tool for lazy_static

orx-parallel

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

rcron

cron job scheduling for rust

crossfire

channels for async and threads

spinning_top

spinlock crate based on the abstractions provided by lock_api

rw-cell

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

utils-atomics

Various atomic utils

may_actor

Actor library based on MAY

slog-atomic

Atomic run-time controllable drain for slog-rs

miyabi_scheduler

Thread pool scheduler with extra specific abilities

timeslice

periodic time slice scheduler

amity

Concurrency algorithms

rose_bloom

A concurrent growing element size linked list with stable pointers

paladin-core

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

channel

Rust advanced queue library

salsa

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

protoflow

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

crossbeam-utils

concurrent programming

roboplc

Framework for PLCs and real-time micro-services

fast-able

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

tc-scalar

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

desync

A hassle-free data type for asynchronous programming

iterator_ilp

Iterator extensions for instruction-parallel reductions

fluxion

actor framework written in rust and designed for distributed systems

arccstr

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

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…

balter

A load/stress testing framework

threadbound

Make any value Sync but only available on its original thread

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…

reord

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

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.

crossbeam-skiplist-mvcc

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

semka

Semaphore implementation

electrologica

High performance concurrent primitives for Rust

supply-chain-trust-example-crate-000025

More compact and efficient implementations of the standard synchronization primitives

file-per-thread-logger

A logging implementation that writes logs in one file per thread

async-event

An efficient async condition variable for lock-free algorithms

atomic-wait

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

omango

Concurrency collections

melodium

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

someday

Lock-free MVCC primitive

sovran-state

state management for Rust

task_scheduler_rs

A Rust-based scheduler with basic functionality, focused on adding tasks and handling actions like execute, pause, and shutdown using channels for task communication

txn_lock

support transactional versioning

tatl

in-process alerting

every

Run a command every N seconds

lock-free-static

Lock-free static variables

irondash_run_loop

Consistent, platform-independent interface to system run loop

hzrd

Shared mutability containers based on hazard pointers

boxcar

A concurrent, append-only vector

node-replication

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

mpsc_requests

mpsc channels but with a response

async-stm

Asynchronous Software Transactional Memory

lockfree

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

atomic-destructor

Atomic destructor for multi-threaded env

crossbeam-queue

Concurrent queues

cargo-steady-state

Code generator for steady_state projects based on a structured dot file

sovran-arc

Memory management swift-isms brought to Rust

atomic_enum

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

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

liner_broker

Redis based message serverless broker

parallel-processor

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

async-atomic

Atomics which can be subscribed to and asynchronously notify when updated

mpsc

mpsc channel

disruptor-rs

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

command_history

managing command history in Rust applications

sharded-vec-writer

Write parts of a Vec from different threads

mea

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

skedgy

asynchronous job scheduler

maybe-rayon

Either acts as rayon or creates a single-threaded facade

multipool

A configurable thread pool with optional work-stealing support and task priority scheduling

benjamin_batchly

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

k-lock

A fast mutex for short critical sections

shipyard_scenegraph

Scenegraph for Entity Component System

evtcall

Rust Event Driven Framework

amadeus

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

armc

that facilitates Mutex access to variables

ptr_cell

Thread-safe cell based on atomic pointers

atomic-file-install

For atomically installing a file or a symlink

active_standby

A concurrency primitive for high concurrency reads

atomic-maybe-uninit

Atomic operations on potentially uninitialized integers

atomic_once_cell

Thread-safe and lock-free OnceCell and Lazy

anchor-chain

A statically typed async framework for building LLM-based applications

nexus-actor-remote-rs

Remote library for Nexus Actor

local-sync

Non-threadsafe data structure for async usage

dpc-pariter

Parallel iterator processing

rucron

Job Scheduling Crate

onering

High throughput synchronous queue

congestion-limiter

Dynamic congestion-based concurrency limits for controlling backpressure

ebr

epoch-based reclamation with low cacheline ping-pong

rtic-monotonic

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

easy-threadpool

A relatively simple thread pool which you can send jobs to

sharded-thread

Expirement for now

kube-leader-election

Leader election implementations for Kubernetes workloads

pi_atom

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

treiber_stack

A lockless, thread-safe, atomic linked-list

rearch-effects

Re-imagined approach to application design and architecture

open-coroutine-hook

The syscall hook for open-coroutine

mpvipc

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

tracing-mutex

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

sluice

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

television-utils

The revolution will be televised

rust-lockless-slotmap

A (mostly) lockless slotmap implementation in Rust

rufutex

Ulrich Drepper's mutex using futex implementation in Rust

split_channel

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

rayon-progress-bar

work-stealing parallelism for Rust

lock_ext

Extensions to std::sync::Mutex

chunklist

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

lock_api

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

keepcalm

shared types for multi-threaded programs

atomic-interval

A tiny implementation of an atomic timer

smart_channel

channel subscription system

invocation-counter

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

pubserve

generic observer trait

fasb

faceted answer set browser

moga

A multi-objective genetic algorithm framework

batch-processing

A batch library for processing a list of items in parallel

atomiq

Convenient tool for atomics in Rust

init-once

Concurrent, non-blocking lazy initialization of values

namaste

send_cells

Safe and unsafe cells implementing Send/Sync

win-kernel

windows-kernel

freezebox

deref'able lazy-initialized container

kueue

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

antidote

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

pausable_clock

A source of time information that can be paused and resumed

crossbeam-skiplist-fd

A long-term maintained forked version of the crossbeam-skiplist for supporting more flexible key comparison customization

lfchring

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

turbo-metrics

Toolkit to compute quality metrics fast using a GPU

rusturnate

A sync or async mutex, with or without timeouts

thread-manager

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

ferris-files

A CLI to find large files

thread_io

performing I/O in background thread

with_daemon

An async client-daemon abstraction framework

bcast

Low latency broadcast (SPMC) buffer designed to work with shared memory

thread_local_collect

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

asc

Atomic Strong Count

sharded-offset-map

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

sids

sample actor-model scheme providing abstraction over actor types and messages that can be sent across threads

circ

Efficient referenced counted pointers for non-blocking concurrency

spools

Content scraping library for Instagram's Threads

synchronized

Convenient and simple macro for code synchronization in multithreading

operational-transform

Operational Transformation

throttle-client

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

pyo3-utils

PyO3

restd

A re-implementation of various std features

clhlock

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

pacwrap-agent

Executable agent for conducting containerized transactions

cron_tab

A cron job library for Rust

resilience-rs

Resilience patterns in Rust

oxidd-rules-mtbdd

Multi-terminal decision diagrams (MTBDDs) for OxiDD

rayon-cancel

An adapter to interrupt rayon parallel iterators

windows-key-listener

Listen to arbitrary key chords on Windows

permit

A struct for cancelling operations

td_rthreadpool

thread wrapper for Rust

parallel_operations

perform binary operations in parallel using threads

que

A high performance channel with optional backpressure, interprocess capability, and a multiconsumer mode

par-iter-sync

Parallel Iterator With Sequential Output

concurrent-slotmap

A lock-free concurrent slotmap

simple-semaphore

🔐 A lightweight implementation of a Semaphore in Rust

async-fifo

MPMC & oneshot channels with (a)sync API

parcheck

Test permutations of concurrent scenarios

par_slice

Slices that may be accessed from multiple threads with different evels of safety

re_capabilities

Capability tokens for the Rerun code base

multithreading

in Rust

atomicbox

Safe atomic pointers to boxed data