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

async-lock

Async synchronization primitives

async-channel

Async multi-producer multi-consumer channel

flume

A blazingly fast multi-producer channel

ringbuf

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

crossbeam

Tools for concurrent programming

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

triomphe

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

neon

A safe abstraction layer for Node.js

loom

Permutation testing for concurrent code

jobserver

GNU Make jobserver for Rust

thread-priority

managing threads priority and schedule policies

sync_wrapper

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

arcstr

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

kanal

The fast sync and async channel that Rust deserves

corosensei

A fast and safe implementation of stackful coroutines

sled

Lightweight high-performance pure-rust transactional embedded database

mpi

Message Passing Interface bindings for Rust

parking

Thread parking and unparking

state

safe and effortless global and thread-local state management

rtrb

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

atomic_float

Floating point types which can be safely shared between threads

lockfree-object-pool

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

thingbuf

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

stateright

A model checker for implementing distributed systems

ipc-channel

A multiprocess drop-in replacement for Rust channels

may

Rust Stackful Coroutine Library

bus

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

local-channel

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

flurry

Rust port of Java's ConcurrentHashMap

rayon-cond

Experimental iterator wrapper that is conditionally parallel or serial

hwlocality

Idiomatic Rust bindings for the hwloc hardware locality library

boxcar

A concurrent, append-only vector

try-lock

A lightweight atomic lock

throttle-server

Provide semaphores for distributed systems via an http interface

scheduled-thread-pool

A scheduled thread pool

leaky-bucket

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

radium

Portable interfaces for maybe-atomic types

shuttle

testing concurrent Rust code

concurrent-queue

Concurrent multi-producer multi-consumer queue

futures-intrusive

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

ratelimit

ratelimiter that can be shared between threads

cargo-green

Cargo plugin and $RUSTC_WRAPPER to sandbox & cache cargo builds and execute jobs remotely

thread-id

Get a unique thread ID

jod-thread

std::thread which joins on drop by default

gst-plugin-threadshare

GStreamer Threadshare Plugin

tachyonix

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

amity

Concurrency algorithms

mpstthree

implementing Multiparty Session Types for 2 or more participants

rustc-rayon

work-stealing parallelism for Rust - fork for rustc

executors

A collection of high-performance task executors

once_map

Single assignment and lazy maps

typedmap

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

guardian

owned mutex guards for refcounted mutexes

surrealkv

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

orx-concurrent-vec

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

pend

do now, wait later – tiny job runner

inline-array

efficient immutable inlinable byte array

async-condvar-fair

Condition variables for async Rust

process_control

Ergonomically run processes with limits

atomig

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

sdd

Scalable lock-free delayed memory reclaimer

desync

A hassle-free data type for asynchronous programming

chili

low-overhead parallelization library

turnkeeper

An asynchronous, recurring job scheduler for Tokio with support for CRON, interval, and weekday/time schedules, plus retries, cancellation, and observability

paralight

A lightweight parallelism library for indexed structures

iroh-gossip

gossip messages over broadcast trees

crossbeam-channel

Multi-producer multi-consumer channels for message passing

ppl

A structured parallel programming library for Rust

idr-ebr

An efficient concurrent ID to object resolver

rclite

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

mco

Rust Coroutine Library like go

uid

creation of unique IDs

clashmap

Sharded hashmap suitable for fast concurrent access

fault-injection

fault injection, concurrency delay injection, and error source annotation

safe-lock

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

mutex

An abstraction over closure-based mutexes

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)

waker-fn

Convert closures into wakers

evolution

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

open-coroutine

efficient and generic stackfull-coroutine library

atomic-time

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

happylock

Free deadlock prevention

runnel

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

chorus

interacting with multiple Spacebar-compatible Instances at once

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

sea-streamer

🌊 The stream processing toolkit for Rust

synchronized

convenient macro for synchronizing code in multithreading

pausable_clock

A source of time information that can be paused and resumed

nuclei

Proactive IO & runtime system

st3

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

rtactor

An Actor framework specially designed for Real-Time constrained use cases

botcore

Production-grade asynchronous bot engine with enterprise observability features

mcslock

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

seize

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

parallel-sh

Execute commands in parallel

deqp-runner

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

wd_tools

tools for rust

rtthost

RTT (Real-Time Transfer) client

rearch

Re-imagined approach to application design and architecture

shred

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

messaging_thread_pool

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

ordered-channel

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

fieldx

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

sync_file

Files that can be read concurrently

par-core

Switchable parallel execution core

yazi-scheduler

Yazi task scheduler

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…

io-reactor

Concurrent I/O resource management using reactor pattern

rcu_cell

a lockless rcu cell implementation

flo_scene

Entity-messaging system for composing large programs from small programs

rs-event-emitter

simulate promise implementation for rust

threadbound

Make any value Sync but only available on its original thread

onering

High throughput synchronous queue

recloser

A concurrent circuit breaker implemented with ring buffers

infinitree-backends

Embedded, encrypted database with tiered cache -- backends

crossbeam-utils

concurrent programming

oqueue

Non-interleaving multithreaded output queue

synchronoise

Synchronization primitives that build upon the standard library

mea

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

television

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

gabriel2

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

loole

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

rsevents

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

orx-concurrent-iter

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

atomptr

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

trauma

Simplify and prettify HTTP downloads

paradis

Parallel processing with disjoint indices

pumps

Eager streams for Rust

magnetic

Low-latency lock-free queues

leapfrog

A fast, lock-free concurrent hash map

pueue

A cli tool for managing long running shell commands

callysto

Stream processing framework

ballista-scheduler

Ballista Distributed Compute - Scheduler

batch-aint-one

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

nbio

Non-Blocking I/O

atom_box

A safe idiomatic Rust implementation of Atomic Box using hazard pointers

omango

Concurrency collections

atomic-file-install

For atomically installing a file or a symlink

thingvellir

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

locktick

Automated lock accounting & profiling

razel

a command executor with caching for data processing pipelines

elysees

A fork of triomphe, now with more pointer trickery

renoir

Reactive Network of Operators In Rust

krecik

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

rtic-sync

Synchronization primitives for asynchronous contexts

sanitizers

Interfaces and FFI bindings for the sanitizers interfaces

piz

piz (a Parallel Implementation of Zip) is a ZIP archive reader designed to concurrently decompress files using a simple API

melodium

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

concurrent_arena

u32 concurrent insertion/removal arena that returns ArenaArc

atomic_once_cell

Thread-safe and lock-free OnceCell and Lazy

d-engine

A lightweight and strongly consistent Raft consensus engine written in Rust. It is a base to build reliable and scalable distributed systems.

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

openfga-client

Type-safe client SDK for OpenFGA with optional Authorization Model management and Authentication (Bearer or Client Credentials)

sharded_mutex

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

pi_arr

lock-free & auto-expansion array

myriam

Actor model implementation for local and remote actors

progress-token

tracking progress of long-running tasks

spinning_top

spinlock crate based on the abstractions provided by lock_api

atomic-arena

Generational arena that allows reserving keys from other threads

atomic

Generic Atomic<T> wrapper type

async-local

For using thread locals within an async context across await points

tc-transact

Traits and locking utilities for a TinyChain transaction

speare

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

per-thread-mutex

Synchronization lock designed for wrapping thread-unsafe C libraries

atomic-take

Atomically take a value out of a container once

threadpools

Efficient, configurable, zero-dependency thread pool implementations. Flexible and usable for a wide variety of applications.

siafu

Ergonomic job scheduling library for Rust

no_deadlocks

A Runtime Deadlock Debugger

concurrent-map

a lock-free linearizable B+ tree

nexus-acto-rs

Actors

aarc

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

pbrt-r3

pbrt-v3

ostd

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

choir

Task Orchestration Framework

splaycast

Stream-specific broadcast channel

mirai-annotations

Macros that provide source code annotations for MIRAI

transactional

optimistic lock-free confirmation-based transactional model for Rust

liner_broker

Redis based message serverless broker

wb_async_utils

working with async code

scx_bpfland

A vruntime-based sched_ext scheduler that prioritizes interactive workloads. https://github.com/sched-ext/scx/tree/main

duchess

Silky smooth Java-Rust interop

range-lock

Range lock for std::vec::Vec

channel

Rust advanced queue library

mintex

minimal mutex

ibuf

A memory buffer pool implementation

test_cpu_parallel

Generate CPU- or memory-intensive workloads for benchmarking

arccstr

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

iterator_ilp

Iterator extensions for instruction-parallel reductions

sync42

synchronization tools

protoflow

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

stupid_utils

that provides some simple and maybe stupid or useful tools

fdup

find duplicate files recursively and in parallel

sovran-arc

Memory management swift-isms brought to Rust

gasket

Staged Event-Driven Architecture (SEDA) framework

atomic-wait

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

acts

a fast, tiny, extensiable workflow engine

schedules

A lightweight Rust library for managing operations across multiple time scales

rc_event_queue

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

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

esl01-indexedlog

Append-only on-disk storage with integrity checks and indexing support

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

bcast

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

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).

acts-next

a fast, tiny, extensiable workflow engine

rcron

cron job scheduling for rust

keepcalm

shared types for multi-threaded programs

quartz

Port of the original Java Quartz Scheduler to Rust

balter

A load/stress testing framework

irox-threading

Blocking and Asynchronous Threading Tools

testbench

Testing and benchmarking tools for concurrent Rust code

resilient-rs

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

atomic-lend-cell

lending immutable references across threads with explicit owner-borrower semantics, offering both atomic reference counting and lightweight flag-based implementations

namaste

ptr_cell

Thread-safe cell based on atomic pointers

lock-free-static

Lock-free static variables

readlock

A weird alternative to Arc<RwLock<T>>

simd-itertools

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

par_slice

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

atomx

Thread safe data structures based on atomic data types

rs-store

Redux Store for Rust

narust-158

reimplementation of OpenNARS 1.5.8

virtual-buffer

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

clave

Midi click-track generator

node-replication

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

portable_atomic_enum

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

cfavml

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

rt

A real-time operating system capable of full preemption

que

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

pi_append_vec

Only supports append vectors, lock free

swap-buffer-queue

A buffering MPSC queue

rust-releases

Find, index and obtain all officially available Rust releases

affinitypool

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

round_mult

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

lockmap

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

chalamet_pir

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

lockfree

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

lever

Pillars for Transactional Systems and Data Grids

swimos_introspection

SwimOS Agent Introspection

crosstermion

crossterm, without ties to termion

semka

Semaphore implementation

utils-atomics

Various atomic utils

lock-hierarchy

Prevent dead locks by enforcing lock hierarchies

kcr_execution_furiko_io

Kubernetes Custom Resource Bindings

pawawwewism

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

lock_api

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

linked

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

may_actor

Actor library based on MAY

rt-history

An RT-safe history log with error checking

latches

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

io-pipe

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

tlrepo

Thread-local git2::Repository, shareable across threads

svix-ksuid

A pure Rust and fully tested KSUID implementation

walle-core

OneBot lib in Rust

sigq

Queue that signals waiting consumers about node availability

rds_lock

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

opentalk-janus-client

A janus client implementation for use in OpenTalk

rocketmq-client-v4

rocket mq rust client for remote protocol. works on rocket mq V4

cubecl-hip-sys

Rust bindings for AMD ROCm HIP runtime libraries used by CubeCL

timely-master

A low-latency data-parallel dataflow system in Rust

ibag

A thread-safe, immutable bag for holding any value

orchestrator_lock

A Mutex whose access order is managed by a separate thread

someday

Lock-free MVCC primitive

sync-arena

thread-safe arena allocator

infinitree

Embedded, encrypted database with tiered cache

rusturnate

A sync or async mutex, with or without timeouts

active_standby

A concurrency primitive for high concurrency reads

nexus-actor-utils-rs

Nexus Actor

debugrs

logger that mimics the npm debug module

rex-sm

Hierarchical state machine

discord_client_rest

Undetected discord client rest API reimplementation

timeslice

periodic time slice scheduler

tether-agent

Standardised use of MQTT and MessagePack for inter-process communication

rsvow

A Rust-like implementation of JavaScript's Promise mechanism

timely_communication

Communication layer for timely dataflow

atomic-counter

Atomic (thread-safe) counters for Rust

treiber_stack

A lockless, thread-safe, atomic linked-list

gst-plugin-inter

GStreamer Inter Plugin

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

actm

Tiny async actors framework for rust

simple_coro

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

wl-client

Safe client-side libwayland wrapper

hab-rs-api-client

Bindings for openHAB REST API

kube-leader-election

Leader election implementations for Kubernetes workloads

disruptor-rs

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

rearch-tokio

Re-imagined approach to application design and architecture

blueprint-producers-extra

Additional job call producers for the Blueprint SDK

lmml

LMML Music Macro Language

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

command_history

managing command history in Rust applications

thread_io

performing I/O in background thread

visa-device-handler

handle NI-VISA connections and simplify its use

direct_ring_buffer

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

daemonbit

Cross-platform daemon lifecycle primitives

flag-bearer-mutex

Generic async semaphores

write_atomic

Write to files atomically

constellation-rs

Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs

process_anywhere

Tools for running computer processes locally and remotely via SSH

antidote

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

parallel_worker

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

EMCompute

fast , simple and cross-platform parallel computing library

dapt

serializing and unseralizing unstructured data

txn_lock

support transactional versioning

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.

pargraph

Operator based parallel graph processing

crossbeam-queue

Concurrent queues

mpsc_requests

mpsc channels but with a response

rust-lockless-slotmap

A (mostly) lockless slotmap implementation in Rust

orx-parallel

High performance, configurable and expressive parallel computation library

async_once

async once tool for lazy_static

papaya

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

k-lock

A fast mutex for short critical sections

pacwrap-agent

Executable agent for conducting containerized transactions

send_cells

Safe and unsafe cells implementing Send/Sync

congee

ART-OLC concurrent adaptive radix tree

mm1-node

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

atomicring

AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer

thread_map

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

blazingqlog

QUIC QLOG parser written in Rust

rust_kits

kits

resilient-rabbitmq-client

Easily deploy resilient RabbitMQ consumers and publishers

limqch

A channel built on top of limq

kc

Kayla's (line) counter (of code) :)

komora-sync

Synchronization structures for the komora db project

cdk-from-cfn

Turn AWS CloudFormation templates into AWS CDK applications

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

fast-steal

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

electrologica

High performance concurrent primitives for Rust

nbus

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

sync-cell-slice

Cells and slices that are accessible from multiple threads

jwalk-meta

Filesystem walk performed in parallel with streamed and sorted results

rust-pubsub

A thread-safe, in-memory publish-subscribe library for Rust with flexible subscription modes

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…

fuyu

programming language

rust_supervisor

An Erlang-inspired process supervision library for Rust

patrolilo

Job scheduler with integrated NTFY notifications

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…

crossbeam-skiplist-mvcc

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

scx_loader

DBUS on-demand loader of sched-ext schedulers

sovran-state

state management for Rust

tc-scalar

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

xstm

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

asyncgit

allow using git2 in a asynchronous context

thermal_hydraulics_rs

A Thermal Hydraulics Library with some useful traits,enums and functions for heat transfer and fluid mechanics

openmp-reducer

OpenMP-style reducers

rrddmma

RDMA

atomicbox

Safe atomic pointers to boxed data

fluxion

actor framework written in rust and designed for distributed systems

monch

Inspired by nom, but specifically for strings

atomic-server

Create, share and model Atomic Data with this graph database server. Run atomic-server without any arguments to start the server. Use --help to learn about the options.

tensr

A high-performance, cross-platform, multi-backend tensor/array library for Rust

alopt

providing efficient synchronization primitives that integrate Option into their design

shipyard_scenegraph

Scenegraph for Entity Component System

concurrent-slotmap

A lock-free concurrent slotmap

aranya-util

needed by other Aranya crates

atomic_enum

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

signals2

A thread-safe signal/slot library inspired by boost::signals2

orx-concurrent-bag

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

fast-async-mutex

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

bus_queue

Lock-free Bounded non-Blocking Pub-Sub Queue

api-rate-limiter

rate limiter for Rust APIs

conquer-once

Synchronization primitives for lazy and one-time initialization

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

drcp-format

Parse and write DRCP and literal definition files

rust_abf

reading data from Axon Binary Format (ABF) files

sync-unsafe-cell

A backport of the SyncUnsafeCell standard library type for use in older Rust versions