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

crossbeam

Tools for concurrent programming

async-lock

Async synchronization primitives

async-channel

Async multi-producer multi-consumer channel

ringbuf

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

flume

A blazingly fast multi-producer channel

threadpool

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

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

loom

Permutation testing for concurrent code

arcstr

A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings

thread-priority

managing threads priority and schedule policies

jwalk

Filesystem walk performed in parallel with streamed and sorted results

event-listener

Notify async tasks or threads

neon

A safe abstraction layer for Node.js

triomphe

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

jobserver

GNU Make jobserver for Rust

sled

Lightweight high-performance pure-rust transactional embedded database

kanal

The fast sync and async channel that Rust deserves

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

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.

rtrb

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

shared_child

using child processes from multiple threads

atomic_float

Floating point types which can be safely shared between threads

may

Rust Stackful Coroutine Library

stateright

A model checker for implementing distributed systems

rustler

Safe Rust wrappers for creating Erlang NIF functions

local-channel

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

bus

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

try-lock

A lightweight atomic lock

rayon-cond

Experimental iterator wrapper that is conditionally parallel or serial

flurry

Rust port of Java's ConcurrentHashMap

kameo

Fault-tolerant Async Actors Built on Tokio

futures-intrusive

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

throttle-server

Provide semaphores for distributed systems via an http interface

corosensei

A fast and safe implementation of stackful coroutines

radium

Portable interfaces for maybe-atomic types

shuttle

testing concurrent Rust code

ratelimit

ratelimiter that can be shared between threads

scheduled-thread-pool

A scheduled thread pool

maitake-sync

No-std async synchronization primitives from Maitake

sdd

Scalable lock-free delayed memory reclaimer

jobslot

GNU make jobserver for Rust

jod-thread

std::thread which joins on drop by default

thread-id

Get a unique thread ID

parking

Thread parking and unparking

tachyonix

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

rustc-rayon

work-stealing parallelism for Rust - fork for rustc

seize

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

mpstthree

implementing Multiparty Session Types for 2 or more participants

atomic_refcell

Threadsafe RefCell

leaky-bucket

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

shared_memory

A user friendly crate that allows you to share memory between processes

amity

Concurrency algorithms

automerge

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

surrealkv

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

executors

A collection of high-performance task executors

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

hvm

A massively parallel, optimal functional runtime in Rust

concurrent-map

a lock-free linearizable B+ tree

guardian

owned mutex guards for refcounted mutexes

dagrs

follows the concept of Flow-based Programming and is suitable for the execution of multiple tasks with graph-like dependencies. Dagrs has the characteristics of high performance and asynchronous execution…

async-condvar-fair

Condition variables for async Rust

chili

low-overhead parallelization library

process_control

Ergonomically run processes with limits

concurrent-queue

Concurrent multi-producer multi-consumer queue

gst-plugin-threadshare

GStreamer Threadshare Plugin

atomig

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

hwlocality

Idiomatic Rust bindings for the hwloc hardware locality library

television

A cross-platform, fast and extensible general purpose fuzzy finder TUI

paralight

A lightweight parallelism library for indexed structures

ppl

A structured parallel programming library for Rust

mco

Rust Coroutine Library like go

v_queue

file based queue

rclite

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

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

uid

creation of unique IDs

sea-streamer

🌊 The stream processing toolkit for Rust

clashmap

Sharded hashmap suitable for fast concurrent access

safe-lock

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

atomic-time

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

indicatif-log-bridge

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

disruptor

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

crossbeam-channel

Multi-producer multi-consumer channels for message passing

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

crossbeam-utils

concurrent programming

ringbuffer-spsc

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

fault-injection

fault injection, concurrency delay injection, and error source annotation

async_nursery

Primitive for structured concurrency

readlock

A weird alternative to Arc<RwLock<T>>

shred

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

mcslock

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

happylock

Free deadlock prevention

parallel-sh

Execute commands in parallel

pausable_clock

A source of time information that can be paused and resumed

nbio

Non-Blocking I/O

st3

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

workerpool

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

aws-sdk-s3-transfer-manager

A high performance Amazon S3 transfer manager for Rust

infinitree

Embedded, encrypted database with tiered cache

deqp-runner

A VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline

evolution

Efficiently evolve your old fixed-length data files into modern file formats

par-core

Switchable parallel execution core

oqueue

Non-interleaving multithreaded output queue

inline-array

efficient immutable inlinable byte array

irondash_run_loop

Consistent, platform-independent interface to system run loop

append-only-vec

Append-only, concurrent vector

p3-maybe-rayon

Feature-gated wrapper around rayon

mea

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

scx_loader

DBUS on-demand loader of sched-ext schedulers

rearch

Re-imagined approach to application design and architecture

mutringbuf

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

pueue

A cli tool for managing long running shell commands

grip-grab

A faster, more lightweight ripgrep alternative

atomicow

A Cow-like data structure where owned data is stored inside an Arc

recloser

A concurrent circuit breaker implemented with ring buffers

bach

Discrete-event simulation environment for async workflows

ordered-channel

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

io-reactor

Concurrent I/O resource management using reactor pattern

sync_file

Files that can be read concurrently

progress-token

tracking progress of long-running tasks

gabriel2

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

threadbound

Make any value Sync but only available on its original thread

pi_share

rc, arc, lock, atomic

fast-able

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

messaging_thread_pool

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

synchronoise

Synchronization primitives that build upon the standard library

razel

a command executor with caching for data processing pipelines

speare

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

paradis

Parallel processing with disjoint indices

botcore

Production-grade asynchronous bot engine with enterprise observability features

rsevents

Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores

aarc

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

callysto

Stream processing framework

waker-fn

Convert closures into wakers

trauma

Simplify and prettify HTTP downloads

boxcar

A concurrent, append-only vector

pumps

Eager streams for Rust

bend-lang

A high-level, massively parallel programming language

orx-concurrent-iter

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

rcu_cell

a lockless rcu cell implementation

fieldx

Procedural macro for constructing structs with lazily initialized fields, builder pattern, and serde support with a focus on declarative syntax

batch-aint-one

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

omango

Concurrency collections

pbrt-r3

pbrt-v3

leapfrog

A fast, lock-free concurrent hash map

syndicate-server

Dataspace server

pi_arr

lock-free & auto-expansion array

minstant

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

session_log

session log library for Rust

ballista-scheduler

Ballista Distributed Compute - Scheduler

krecik

Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL

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

thingvellir

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

sharded_mutex

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

sanitizers

Interfaces and FFI bindings for the sanitizers interfaces

melodium

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

atom_box

A safe idiomatic Rust implementation of Atomic Box using hazard pointers

atomptr

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

chalamet_pir

Stateful, Single-Server Private Information Retrieval for Key-Value Databases

concurrent_arena

u32 concurrent insertion/removal arena that returns ArenaArc

rustix-futex-sync

Linux futex-based synchronization

renege

Tracking cache validity using fast concurrent invalidation propogation

std-ext

Extend the standard library functionality

onering

High throughput synchronous queue

protoflow

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

task-local-extensions

Task-local container for arbitrary data

pariter

Parallel iterator processing

spinning_top

spinlock crate based on the abstractions provided by lock_api

fluxion

actor framework written in rust and designed for distributed systems

schedules

A lightweight Rust library for managing operations across multiple time scales

atomic-arena

Generational arena that allows reserving keys from other threads

async-local

For using thread locals within an async context across await points

channel

Rust advanced queue library

ostd

Rust OS framework that facilitates the development of and innovation in OS kernels

loole

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

atomic-take

Atomically take a value out of a container once

magnetic

Low-latency lock-free queues

atomic_once_cell

Thread-safe and lock-free OnceCell and Lazy

nexus-acto-rs

Actors

splaycast

Stream-specific broadcast channel

resilient-rs

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

gix-shallow

Handle files specifying the shallow boundary

mtzip

making zip archives with multithreaded compression

mutex

An abstraction over closure-based mutexes

choir

Task Orchestration Framework

find_cuda_helper

Helper crate for searching for CUDA libraries

rds_lock

asynchronous redis distributed read-write lock implementation based on tokio and redis-rs

defer-drop

Defer dropping large types to a background thread

atom

A safe abstraction around AtomicPtr

arccstr

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

range-lock

Range lock for std::vec::Vec

elysees

A fork of triomphe, now with more pointer trickery

syndicate-schema-plugin

Support for using Preserves Schema with Syndicate macros

pijul

A distributed version control system

tremor-common

Tremor common functions

d-engine

A lightweight strongly-consistent Raft consensus engine for building reliable and scalable distributed systems

acts-next

a fast, tiny, extensiable workflow engine

gettid

Helper to get an integer ID for the current thread

potential

PubSub lib with sync and async API

per-thread-mutex

Synchronization lock designed for wrapping thread-unsafe C libraries

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

spring-stream

Integrate sea-streamer with spring-rs

que

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

no_deadlocks

A Runtime Deadlock Debugger

rw-cell

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

mpsc

mpsc channel

par

Session types, as an implementation of linear logic with MIX

sync42

synchronization tools

simd-itertools

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

atomic-wait

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

lever

Pillars for Transactional Systems and Data Grids

fast-stm

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

amfiteatr_core

A framework to model and simulate game theory problems with many agents

keepcalm

shared types for multi-threaded programs

mintex

minimal mutex

locktick

Automated lock accounting & profiling

asynclog

asynchronous log library

quartz

Port of the original Java Quartz Scheduler to Rust

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

sync-arena

thread-safe arena allocator

reactivate

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

lock-hierarchy

Prevent dead locks by enforcing lock hierarchies

file-per-thread-logger

A logging implementation that writes logs in one file per thread

rose_bloom

A concurrent growing element size linked list with stable pointers

ibuf

A memory buffer pool implementation

balter

A load/stress testing framework

pi_async_transaction

Asynchronous abstraction for transactions

sovran-arc

Memory management swift-isms brought to Rust

git-wait

wrapper utility around git that waits until index.lock file is no longer present running the command

batch-processing

A batch library for processing a list of items in parallel

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.

lock-free-static

Lock-free static variables

tlrepo

Thread-local git2::Repository, shareable across threads

linked

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

cfavml

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

rs-store

Redux Store for Rust

parallel_worker

A parallel worker implementation in Rust. Allows to start tasks in parallel and receive the results blocking or non-blocking.

bcast

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

slog-atomic

Atomic run-time controllable drain for slog-rs

freactor

A lightweight framework for asynchronous execution flow

namaste

lockmap

A high-performance, thread-safe HashMap implementation for Rust that provides fine-grained locking at the key level

evtcall

Rust Event Driven Framework

txn_lock

support transactional versioning

append-only-bytes

Shareable append-only bytes

atomx

Thread safe data structures based on atomic data types

round_mult

A tiny library to round a number up or down to a multiplier

ptr_cell

Thread-safe cell based on atomic pointers

winmsg-executor

Per-thread async rust executor for windows

portable_atomic_enum

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

semka

Semaphore implementation

utils-atomics

Various atomic utils

skedgy

asynchronous job scheduler

maelstrom-worker-child

Helper library for maelstrom-worker

par_slice

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

concurrent-slotmap

A lock-free concurrent slotmap

triggered

Triggers for one time events between tasks and threads

vec-belt

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

ibag

A thread-safe, immutable bag for holding any value

node-replication

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

simple_coro

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

sharded-offset-map

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

spools

Content scraping library for Instagram's Threads

command_history

managing command history in Rust applications

rc_event_queue

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

simple_spawn_blocking

spawning blocking tasks more ergonomic

replay-channel

A broadcast channel where new receivers replay all past messages before receiving new ones

sluice

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

daemonbit-lockfile

Cross-platform daemon lifecycle primitives

lock_api

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

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

stdout-channel

Write stdout to an async queue

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

ruffer

overwriting ring buffer library written in Rust

stele

An atomic Vec-like structure with no copying on allocation

stupid_utils

that provides some simple and maybe stupid or useful tools

swap-buffer-queue

A buffering MPSC queue

deno_broadcast_channel

BroadcastChannel API for Deno

svix-ksuid

A pure Rust and fully tested KSUID implementation

iterator_ilp

Iterator extensions for instruction-parallel reductions

maybe-rayon

Either acts as rayon or creates a single-threaded facade

async_once

async once tool for lazy_static

someday

Lock-free MVCC primitive

treiber_stack

A lockless, thread-safe, atomic linked-list

may_actor

Actor library based on MAY

rusturnate

A sync or async mutex, with or without timeouts

cubecl-hip-sys

Rust bindings for AMD ROCm HIP runtime libraries used by CubeCL

io-pipe

A fast and thread-safe library for creating multi-writer and single-reader pipelines in Rust

latches

A downward counter (CountDownLatch) which can be used to synchronize threads or coordinate tasks

parallel-stream

Data parallelism library for async-std

affinitypool

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

orama-js-pool

Create a pool of JavaScript engines to invoke JavaScript code concurrently

progpool

Job pool with terminal progress bar

orchestrator_lock

A Mutex whose access order is managed by a separate thread

electrologica

High performance concurrent primitives for Rust

flag-bearer

Generic async semaphores

active_standby

A concurrency primitive for high concurrency reads

night

A scalable Task Queue for executing asynchronous tasks in topological order

split_channel

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

factorize_rayon

Rayon find_map_any() demonstration program

refreshable

wrapper around a value that changes over time

re_smart_channel

A channel that keeps track of latency and queue length

take-once

A thread-safe container for one-time storage and one-time consumption of a value

myriam

Actor model implementation for local and remote actors

alopt

providing efficient synchronization primitives that integrate Option into their design

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…

fast-steal

特别快的多线程库，支持超细颗粒度的任务窃取

ufotofu_queues

Infallible queues that support bulk enqueueing and dequeueing

timely_communication

Communication layer for timely dataflow

senders_receivers

Senders/Receivers implementation for Rust

pawawwewism

a wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3

k-lock

A fast mutex for short critical sections

streameroo

Compilation of mini-frameworks & utilities for data-streaming applications

EMCompute

fast , simple and cross-platform parallel computing library

amadeus

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

fastpool

This crates implements a fast object pool for Async Rust

pi_append_vec

Only supports append vectors, lock free

debugrs

logger that mimics the npm debug module

rearch-tokio

Re-imagined approach to application design and architecture

fibers

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

orx-parallel

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

orx-concurrent-bag

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

pargraph

Operator based parallel graph processing

rust_supervisor

An Erlang-inspired process supervision library for Rust

papaya

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

multipool

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

msgpass

Thin wrapper to a Message Passing Interface (MPI)

atomic_enum

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

desync

A hassle-free data type for asynchronous programming

send_cells

Safe and unsafe cells implementing Send/Sync

atomic-counter

Atomic (thread-safe) counters for Rust

atomic-destructor

Atomic destructor for multi-threaded env

pacwrap-agent

Executable agent for conducting containerized transactions

real-time

Safely share data with a real-time thread

spmc

channel

watchable

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

armc

that facilitates Mutex access to variables

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

parel

run linux commands in parallel

mm1-node

M/M/1! Queueing, do you speak it?!

skedge

Ergonomic single-process job scheduling for Rust programs

jwalk-meta

Filesystem walk performed in parallel with streamed and sorted results

swimos_sync

SwimOS Synchronization Channels

rsvow

A Rust-like implementation of JavaScript's Promise mechanism

sovran-state

state management for Rust

killswitch_std

A thread-safe kill switch using only the standard library

screeps-async

Tick-aware Async runtime for Screeps

thread_map

Types that are simple and easy-to-use alternatives to the std::thread_local macro

rust_kits

kits

hab-rs-api-client

Bindings for openHAB REST API

par-iter-sync

Parallel Iterator With Sequential Output

sync-cell-slice

Cells and slices that are accessible from multiple threads

parallel-processor

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

xstream-util

A command line tool to split a stream to child processes

antidote

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

init-once

Concurrent, non-blocking lazy initialization of values

benjamin_batchly

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

mu_uefi_tpl_mutex

Task Priority Level (TPL) mutual exclusion support

disruptor-rs

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

thread_io

performing I/O in background thread

nexus-actor-remote-rs

Remote library for Nexus Actor

spindle_rs

A distributed locking crate built on Cloud Spanner and TrueTime

tokio-agent

Agents are a simple abstraction around state, inspired by Elixir's Agent

fast-async-mutex

lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)

xstm

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

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…

shipyard_scenegraph

Scenegraph for Entity Component System

smolscale2

hitdns fork of original smolscale

datafusion-substrait

DataFusion Substrait Producer and Consumer

tc-transact

Traits and locking utilities for a TinyChain transaction

discoid

Different types of generic Circular Buffers

asyncgit

allow using git2 in a asynchronous context