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-lock

Async synchronization primitives

ctrlc

Easy Ctrl-C handler for Rust projects

signal-hook

Unix signal handling

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

threadpool

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

jobserver

GNU Make jobserver for Rust

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

serenity

Discord API

kanal

The fast sync and async channel that Rust deserves

sled

Lightweight high-performance pure-rust transactional embedded database

mpi

Message Passing Interface bindings for Rust

sync_wrapper

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

state

safe and effortless global and thread-local state management

lockfree-object-pool

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

rtrb

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

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

waker-fn

Convert closures into wakers

shared_child

using child processes from multiple threads

concread

Concurrently Readable Data-Structures for Rust

stateright

A model checker for implementing distributed systems

atomic_float

Floating point types which can be safely shared between threads

corosensei

A fast and safe implementation of stackful coroutines

may

Rust Stackful Coroutine Library

rayon-cond

Experimental iterator wrapper that is conditionally parallel or serial

local-channel

A non-threadsafe multi-producer, single-consumer, futures-aware, FIFO queue

bus

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

flurry

Rust port of Java's ConcurrentHashMap

try-lock

A lightweight atomic lock

radium

Portable interfaces for maybe-atomic types

shuttle

testing concurrent Rust code

fragile

wrapper types for sending non-send values to other threads

diatomic-waker

An async, lock-free synchronization primitive for task wakeup

ratelimit

ratelimiter that can be shared between threads

concurrent-queue

Concurrent multi-producer multi-consumer queue

leaky-bucket

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

sdd

Scalable lock-free delayed memory reclaimer

scheduled-thread-pool

A scheduled thread pool

jobslot

GNU make jobserver for Rust

triple_buffer

triple buffering, useful for sharing frequently updated data between threads

futures-intrusive

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

seize

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

rustc-rayon

work-stealing parallelism for Rust - fork for rustc

tachyonix

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

wasm_thread

An std thread replacement for wasm32 target

mmap-sync

package allowing sharing of data between processes in a wait-free and zero-copy fashion from mapped memory

atomic_refcell

Threadsafe RefCell

concurrent-map

a lock-free linearizable B+ tree

typedmap

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

orx-concurrent-vec

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

maitake-sync

No-std async synchronization primitives from Maitake

surrealkv

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

async-condvar-fair

Condition variables for async Rust

gix-worktree

gitoxide project for shared worktree related types and utilities

parking

Thread parking and unparking

throttle-server

Provide semaphores for distributed systems via an http interface

mpstthree

implementing Multiparty Session Types for 2 or more participants

resman

Runtime managed resource borrowing

gst-plugin-threadshare

GStreamer Threadshare Plugin

process_control

Ergonomically run processes with limits

guardian

owned mutex guards for refcounted mutexes

automerge

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

hydra

A framework for writing fault tolerant, highly scalable applications with the Rust programming language

atomig

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

crossbeam-channel

Multi-producer multi-consumer channels for message passing

twincatads-rs

Rust wrapper for TwinCAT ADS library provided with Beckhoff TwinCAT

disruptor

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

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

paralight

A lightweight parallelism library for indexed structures

executors

A collection of high-performance task executors

fdup

find duplicate files recursively and in parallel

sea-streamer

🌊 The stream processing toolkit for Rust

inline-array

efficient immutable inlinable byte array

chili

low-overhead parallelization library

ppl

A structured parallel programming library for Rust

grip-grab

A faster, more lightweight ripgrep alternative

workerpool

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

lockable

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

idr-ebr

An efficient concurrent ID to object resolver

indicatif-log-bridge

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

fault-injection

fault injection, concurrency delay injection, and error source annotation

atomic-time

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

shred

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

crossbeam-utils

concurrent programming

open-coroutine

efficient and generic stackfull-coroutine library

safe-lock

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

aws-sdk-s3-transfer-manager

A high performance Amazon S3 transfer manager for Rust

messaging_thread_pool

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

parallel-sh

Execute commands in parallel

uid

creation of unique IDs

readlock

A weird alternative to Arc<RwLock<T>>

runnel

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

happylock

Free deadlock prevention

samsa

Rust-native Kafka/Redpanda protocol and client implementation

append-only-vec

Append-only, concurrent vector

mcslock

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

pausable_clock

A source of time information that can be paused and resumed

deadqueue

Dead simple async queue

fmutex

Cross-platform mutual exclusion across processes on a file or path

infinitree

Embedded, encrypted database with tiered cache

rs-store

Redux Store for Rust

memo-map

implementing a synchronized map for memoization

oqueue

Non-interleaving multithreaded output queue

pueue

A cli tool for managing long running shell commands

rclite

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

rtsc

Real-time Synchronization Components

async_nursery

Primitive for structured concurrency

recloser

A concurrent circuit breaker implemented with ring buffers

rearch

Re-imagined approach to application design and architecture

sync_file

Files that can be read concurrently

gcra

A basic implementation of GCRA algorithm for rate limiting

gabriel2

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

oxidd-manager-index

Index-based manager implementation for OxiDD

ordered-channel

A channel that always receives messages in the correct order, even if they were sent out of order

hexchat-unsafe-plugin

Lets you write native HexChat plugins in mostly-safe Rust

p3-maybe-rayon

Feature-gated wrapper around rayon

io-reactor

Concurrent I/O resource management using reactor pattern

atomic-maybe-uninit

Atomic operations on potentially uninitialized integers

threadbound

Make any value Sync but only available on its original thread

loole

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

pi_share

rc, arc, lock, atomic

congee

ART-OLC concurrent adaptive radix tree

ringbuffer-spsc

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

rcu_cell

a lockless rcu cell implementation

botcore

Production-grade asynchronous bot engine with enterprise observability features

mco

Rust Coroutine Library like go

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…

resilient-rs

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

st3

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

beekeeper

A full-featured worker pool library for parallelizing tasks

trauma

Simplify and prettify HTTP downloads

minstant

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

mutex

An abstraction over closure-based mutexes

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

rc_event_queue

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

clashmap

Sharded hashmap suitable for fast concurrent access

pumps

Eager streams for Rust

batch-aint-one

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

renege

Tracking cache validity using fast concurrent invalidation propogation

nbio

Non-Blocking I/O

orx-concurrent-iter

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

leapfrog

A fast, lock-free concurrent hash map

signals_receipts

exfiltration of the receipt of POSIX signals

session_log

session log library for Rust

thingvellir

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

boxcar

A concurrent, append-only vector

atomic_once_cell

Thread-safe and lock-free OnceCell and Lazy

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…

bend-lang

A high-level, massively parallel programming language

concurrent_arena

u32 concurrent insertion/removal arena that returns ArenaArc

pbrt-r3

pbrt-v3

arccstr

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

std-ext

Extend the standard library functionality

picokafka

Kafka library for tarantool-module based on librdkafka

napi-calm-down

N-API bindings

orx-parallel

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

rtic-monotonics

that provides implementations of the Monotonic trait from rtic-time

elysees

A fork of triomphe, now with more pointer trickery

schedules

A lightweight Rust library for managing operations across multiple time scales

atomic-arena

Generational arena that allows reserving keys from other threads

async-event

An efficient async condition variable for lock-free algorithms

throttle-client

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

paradis

Parallel processing with disjoint indices

onering

High throughput synchronous queue

rs-event-emitter

simulate promise implementation for rust

actify

An intutive actor model with minimal boilerplate

no_deadlocks

A Runtime Deadlock Debugger

sharded_mutex

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

sovran-arc

Memory management swift-isms brought to Rust

atom_box

A safe idiomatic Rust implementation of Atomic Box using hazard pointers

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

spinning_top

spinlock crate based on the abstractions provided by lock_api

nexus-actor-utils-rs

Nexus Actor

sanitizers

Interfaces and FFI bindings for the sanitizers interfaces

gettid

Helper to get an integer ID for the current thread

atomic-take

Atomically take a value out of a container once

choir

Task Orchestration Framework

jod-thread

std::thread which joins on drop by default

desync

A hassle-free data type for asynchronous programming

que

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

shmap

A key-value store based on linux shared-memory files (shm) for persisting state across program restarts

cargo-steady-state

Code generator for steady_state projects based on a structured dot file

async-local

For using thread locals within an async context across await points

pagetable

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

simple_coro

(ab)using async/await to write simple state-machine based coroutines

potential

PubSub lib with sync and async API

atomptr

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

pi_arr

lock-free & auto-expansion array

dispatch

Rust wrapper for Apple's Grand Central Dispatch

nebkor-maelstrom

synchronous client for creating Maelstrom distributed clients

rw-cell

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

rsvow

A Rust-like implementation of JavaScript's Promise mechanism

mintex

minimal mutex

stdin-nonblocking

Dependency-less non-blocking stdin reader using background threads. Supports streaming and immediate fallback defaults.

may_actor

Actor library based on MAY

liner_broker

Redis based message serverless broker

atomic-wait

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

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

magnetic

Low-latency lock-free queues

simd-itertools

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

sharded-offset-map

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

atomic-shim

Atomic types for unsupported platforms

pubsub-bus

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

thepipelinetool

readers used for thepipelinetool

balter

A load/stress testing framework

file-per-thread-logger

A logging implementation that writes logs in one file per thread

pi_async_transaction

Asynchronous abstraction for transactions

codas-flow

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

skipdb

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

virtual-buffer

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

crossbeam-queue

Concurrent queues

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.

aarc

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

mea

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

wdk-mutex

An idiomatic Rust mutex type for Windows kernel driver development

api-rate-limiter

rate limiter for Rust APIs

cfavml

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

haphazard

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

tatl

in-process alerting

commonware-runtime

Execute asynchronous tasks with a configurable scheduler

rearch-tokio

Re-imagined approach to application design and architecture

portable_atomic_enum

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

retry-if

A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff

spawns

Async runtime agnostic thread context task spawner for Rust

utils-atomics

Various atomic utils

paraseq

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

semka

Semaphore implementation

lock-free-static

Lock-free static variables

linked

Create families of linked objects that can collaborate across threads while being internally single-threaded

forte

A low-overhead thread-pool with support for non-static async closures

gix-lock

A git-style lock-file implementation

mpsc

mpsc channel

channel

Rust advanced queue library

pi_key_alloter

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

melodium

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

torq_lang

A programming language for concurrent dataflow

timeslice

periodic time slice scheduler

sharded-vec-writer

Write parts of a Vec from different threads

par_slice

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

flag-bearer

Generic async semaphores

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

async_once

async once tool for lazy_static

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

lock-hierarchy

Prevent dead locks by enforcing lock hierarchies

spools

Content scraping library for Instagram's Threads

async-atomic

Atomics which can be subscribed to and asynchronously notify when updated

watchable

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

myriam

Actor model implementation for local and remote actors

amfiteatr_classic

some classic game theory problems to research on

rust_supervisor

An Erlang-inspired process supervision library for Rust

rush_expr_engine

The rules engine is based on the rete algorithm

limnus-default-schedulers

default schedulers for limnus. Main, Fixed and Render

orx-concurrent-bag

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

whisk

fast lockless async channels

svix-ksuid

A pure Rust and fully tested KSUID implementation

amadeus

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

rayon-progress-bar

work-stealing parallelism for Rust

rucron

Job Scheduling Crate

hecs-schedule

shedulable systems and parallel execution for hecs

rust_observer

Express telemetry rust SDK

multipool

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

stele

An atomic Vec-like structure with no copying on allocation

crossfire

channels for async and threads

drain

that supports graceful shutdown

bcast

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

notmuch

Rust interface and bindings for notmuch

orchestrator_lock

A Mutex whose access order is managed by a separate thread

sigq

Queue that signals waiting consumers about node availability

sovran-state

state management for Rust

rusturnate

A sync or async mutex, with or without timeouts

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…

easy-threadpool

A relatively simple thread pool which you can send jobs to

maybe-rayon

Either acts as rayon or creates a single-threaded facade

iterator_ilp

Iterator extensions for instruction-parallel reductions

slog-atomic

Atomic run-time controllable drain for slog-rs

crawly

A lightweight async Web crawler in Rust, optimized for concurrent scraping while respecting robots.txt rules

xstm

A Rust-implemented Software Transactional Memory (STM) library using TL2 (Transactional Locking II) algorithm

pariter

Parallel iterator processing

tetanus

A custom utils library for some common unsafe operations

concurrent-slotmap

A lock-free concurrent slotmap

evtcall

Rust Event Driven Framework

affinitypool

running blocking jobs on a dedicated thread pool with CPU core affinity

thread-manager

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

lever

Pillars for Transactional Systems and Data Grids

txn_lock

support transactional versioning

miyabi_scheduler

Thread pool scheduler with extra specific abilities

amity

Concurrency algorithms

init-once

Concurrent, non-blocking lazy initialization of values

rtic-sync

Synchronization primitives for asynchronous contexts

mpvipc

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

voxel-tiler-core

Convert point clouds to voxel data

rocketapi

Unofficial RocketAPI Rust SDK for Instagram & Threads Private API 2024

synchronoise

Synchronization primitives that build upon the standard library

msgpass

Thin wrapper to a Message Passing Interface (MPI)

parel

run linux commands in parallel

pacwrap-agent

Executable agent for conducting containerized transactions

atomic_enum

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

perthread

ThreadMap structure for accessing PerThread thread local variables form a static context

split_channel

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

blocking-threadpool

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

patrolilo

Job scheduler with integrated NTFY notifications

ltpp-output

An atomic output library based on Rust that supports output functionalities through functions, builders, and other methods. It allows customization of text and background colors.

rust-box

odd set of tools for Rust programming

mu_uefi_tpl_mutex

Task Priority Level (TPL) mutual exclusion support

spmc

channel

nexus-actor-remote-rs

Remote library for Nexus Actor

dir-lock

file-system-based mutex

locktick

Automated lock accounting & profiling

td_rthreadpool

thread wrapper for Rust

ballista-scheduler

Ballista Distributed Compute - Scheduler

pochta

Addressable channel registry

descord

A minimal discord api wrapper

parallel-stream

Data parallelism library for async-std

rt_map

Runtime managed mutable borrowing from a map

mpmc-async

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

shipyard_scenegraph

Scenegraph for Entity Component System

cocmd

cmdops tool for dev teams

benjamin_batchly

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

protoflow-zeromq

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

circuit_breaker

Circuit Breaker pattern for building resilient and fault-tolerant systems

async-stm

Asynchronous Software Transactional Memory

omango

Concurrency collections

thread_local_collect

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

parallel-processor

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

sync42

synchronization tools

armc

that facilitates Mutex access to variables

icicle-core

GPU ZK acceleration by Ingonyama

atomicell

Multi-threaded RefCell on atomics

fluxion

actor framework written in rust and designed for distributed systems

fast-stm

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

swap-buffer-queue