-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
dashmap
Blazing fast concurrent HashMap for Rust
-
rayon
Simple work-stealing parallelism for Rust
-
flume
A blazingly fast multi-producer channel
-
spin
Spin-based synchronization primitives
-
crossbeam-queue
Concurrent queues
-
crossbeam-deque
Concurrent work-stealing deque
-
sharded-slab
A lock-free concurrent slab
-
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
-
loom
Permutation testing for concurrent code
-
async-lock
Async synchronization primitives
-
moka
A fast and concurrent cache library inspired by Caffeine (Java)
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
stretto
Stretto is a high performance thread-safe memory-bound Rust cache
-
rusty_pool
Self growing / shrinking
ThreadPoolimplementation based on crossbeam’s multi-producer multi-consumer channels that enables awaiting the result of a task and offers async support -
krecik
Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL
-
mpstthree
A library implementing Multiparty Session Types for 2 or more participants
-
threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
crossbeam-epoch
Epoch-based garbage collection
-
crossbeam
Tools for concurrent programming
-
thread-priority
Library for managing threads priority and schedule policies
-
scc
High performance containers and utilities for concurrent and asynchronous programming
-
atomig
Generic, convenient and lock-free
stdatomics viaAtomic<T>. Can be used with many primitive types (including floats) and with custom types. -
oneshot
Oneshot spsc channel with lock-free non-blocking send and a receiver supporting both thread blocking receive operations as well as Future based async polling
-
bastion
Fault-tolerant Runtime for Rust applications
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
jobserver
An implementation of the GNU make jobserver for Rust
-
flurry
Rust port of Java’s ConcurrentHashMap
-
runnel
the pluggable io stream. now support: stdio, string io, in memory pipe
-
rustc-rayon
Simple work-stealing parallelism for Rust - fork for rustc
-
may
Rust Stackful Coroutine Library
-
seize
Fast, efficient, and robust memory reclamation for concurrent data structures
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
cache-padded
Prevent false sharing by padding and aligning to the length of a cache line
-
atomicring
AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer
-
active_standby
A concurrency primitive for high concurrency reads
-
radium
Portable interfaces for maybe-atomic types
-
async_nursery
Primitive for structured concurrency
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
rtrb
A realtime-safe single-producer single-consumer ring buffer
-
spinning_top
A simple spinlock crate based on the abstractions provided by
lock_api -
lightproc
Lightweight process abstraction for Rust
-
thread_local
Per-object thread-local storage
-
bmrng
async MPSC request-response channel for Tokio
-
parallel-sh
Execute commands in parallel
-
stateright
A model checker for implementing distributed systems
-
process_control
Methods for ergonomically running processes with timeouts
-
lever
Pillars for Transactional Systems and Data Grids
-
rtic-syntax
The Real-Time Interrupt-driven Concurrency (RTIC) meta language
-
may_queue
May’s internal queue library
-
signals2
A thread-safe signal/slot library based on boost::signals2
-
region
Cross-platform virtual memory API
-
fil-rustacuda
CUDA Driver API Wrapper
-
executors
A collection of high-performance task executors
-
rc_event_queue
VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue
-
flo_stream
Pubsub and related streams for Rust futures
-
rustacuda
CUDA Driver API Wrapper
-
crossfire
channels for async and threads
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
node-replication
An operation-log based approach that transform single-threaded data structures into concurrent, replicated structures
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
mco
Rust Coroutine Library like go
-
thingbuf
I’m at the buffer pool. I’m at the MPSC channel. I’m at the combination MPSC channel and buffer pool.
-
global_counter
Global, thread-safe counters
-
cht
Lockfree resizeable concurrent hash table
-
redlock
Implementation of the distributed locking mechanism built on top of Redis
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
svix-ksuid
A pure Rust and fully tested KSUID implementation
-
multiqueue2
A fast mpmc broadcast queue
-
recloser
A concurrent circuit breaker implemented with ring buffers
-
usync
fast, drop-in, synchronization primitives
-
range-lock
Vec range lock
-
arrayfire
ArrayFire is a 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…
-
fast-async-mutex
It is a lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)
-
nolock
A collection of Lock-Free Datastructures
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
pausable_clock
A source of time information that can be paused and resumed
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
asyncgit
allow using git2 in a asynchronous context
-
stuck
Multi-threading scheduled task facility building on cooperative stackful coroutine
-
throttle-client
Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.
-
melodium
Dataflow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely
-
node-workers
A pool of long-lived nodejs workers
-
tc-transact
Traits and locking utilities for a TinyChain transaction
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
thingvellir
a concurrent, shared-nothing abstraction that manages an assembly of things
-
rtic-monotonic
Core abstractions of the Real-Time Interrupt-driven Concurrency Monotonic timers
-
shuttle
A library for testing concurrent Rust code
-
bastion-executor
Cache affine NUMA-aware executor for Rust
-
tenorite
A concurrency abstraction library. Provides a client-server model for asynchronous workers
-
mpi
Message Passing Interface bindings for Rust
-
watchable
Allows watching for value changes in both multi-threaded and asynchronous contexts
-
theatre
A concise async actor model implementation
-
shared-resource-pool-builder
Create thread pools with a shared resource
-
zkstate
Share a struct across multiple instances of an application using zookeeper
-
tracing-mutex
Ensure deadlock-free mutexes by allocating in order, or else
-
slb
Sharded load balancing text-streaming Unix tool
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
meio-protocol
Basic protocol traits of MEIO framework
-
spin-sync
Synchronization primitives using spinlock. The interface resembles std::sync. The constructors of public structs are const; i.e. it is possible to declare static Mutex as long as T can be build statically.
-
rcu_cell
a lockless rcu cell implementation
-
concurrency_toolkit
Easy switching between std::sync, tokio::sync and loom::sync
-
ballista-scheduler
Ballista Distributed Compute - Scheduler
-
freezebox
FreezeBox: a deref’able lazy-initialized container
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
scheduled-thread-pool
A scheduled thread pool
-
ratelimit
a token bucket ratelimiter
-
thread_lake
A very high level thread pool manager
-
stm
Implementation of Software transactional memory. Allows composable atomic operations.
-
st3
A very fast lock-free, bounded, work-stealing LIFO queue
-
norpc
Framework for in-process microservices
-
corosensei
A fast and safe implementation of stackful coroutines
-
async-datachannel
Async Wrapper for datachannel
-
try-lock
A lightweight atomic lock
-
leapfrog
A fast, lock-free concurrent hash map
-
atom_box
A safe idiomatic Rust implementation of Atmoic Box using hazard pointers
-
sync_wrapper
A tool for enlisting the compiler’s help in proving the absence of concurrency
-
atomptr
A safe, dependency-less abstraction for typed atomic smart pointers
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
mth_calc
Crate for demonstrating Cargo. Contains helper method for running a process in parallel on all available processors.
-
left-right
A concurrency primitive for high concurrency reads over a single-writer data structure
-
ach-util
Atomic Channel
-
trauma
Simplify and prettify HTTP downloads
-
diplomatic-bag
A wrapper type that allows you to send
!Sendtypes to different threads -
hopper
an unbounded mpsc with bounded memory
-
watch
A synchronous message passing channel that only retains the most recent value
-
rtfm-syntax
The Real Time for The Masses (RTFM) meta language
-
fault-injection
Simple fault injection, concurrency delay injection, and error source annotation
-
double-checked-cell
A thread-safe lazily initialized cell using double-checked locking
-
lightspeed_scheduler
An in-process scheduler for periodic jobs. Schedule lets you run Rust functions on a cron-like schedule.
-
amadeus-types
Harmonious distributed data analysis in Rust
-
permit
A struct for cancelling operations
-
waitcell
A cell type containing a value which may not yet be available
-
conqueue
Yet another multi-producer, single-consumer queue (MPSC)
-
thread-tree
A tree-structured thread pool for splitting jobs hierarchically on worker threads. The tree structure means that there is no contention between workers when delivering jobs
-
rtic-core
Core abstractions of the Real-Time Interrupt-driven Concurrency framework
-
nysa
A bus for passing messages around between independent subsystems of an application
-
hebo
Distributed MQTT broker
-
tc-tensor
TinyChain’s Tensor collection type
-
mpi-fork-fnsp
Message Passing Interface bindings for Rust (FORK)
-
fates
A crate for creating reactive declarations
-
crossbeam-skiplist_piedb
A concurrent skip list
-
pi_share
rc, arc, lock, atomic
-
sync_file
Files that can be read concurrently
-
cooptex
Deadlock free Mutexes
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
single_value_channel
Concurrent single-value update and receive channel
-
disrustor
This project is a port of the LMAX Disruptor to Rust
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
pcp-mutex
A Priority Ceiling Protocol (PCP) mutex, based on Linux PI futex. Allows efficient and deadlock free execution.
-
little_raft
The lightest distributed consensus library. Run your own replicated state machine!
-
gpgpu
Simple WIP GPGPU framework built on top of wgpu
-
choir
Task Orchestration Framework
-
atomicbox
Safe atomic pointers to boxed data
-
atomic_once_cell
Thread-safe and lock-free OnceCell and Lazy
-
takecell
A cell type which value can only be taken once
-
lockpool
This library offers a pool of locks where individual locks can be locked/unlocked by key
-
semka
Semaphore implementation
-
option-lock
A simple mutex for Option values
-
guardian
Provides owned mutex guards for refcounted mutexes
-
atomic-arena
Generational arena allows reserving keys from other threads
-
go-spawn
a library that provides macros to spawn and join threads with minimal boilerplate
-
lockfree
This crate provides concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
hypercore-protocol
Replication protocol for Hypercore feeds
-
hey_listen
An event-dispatcher-collection offering async, sync, parallel, and prioritised solutions!
-
stream-kmerge
K-way merge for streams
-
rgraph
A task graph library
-
peril
Fast and safe Hazard pointers for Rust
-
try-rwlock
Fast non-blocking readers-writer lock
-
threadfin
A thread pool for running multiple tasks on a configurable group of threads
-
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
meio
A compact actors framework for the async epoch in Rust & Tokio
-
ns3-parallel
A Multitask Parallel Concurrent Executor for ns-3 (network simulator)
-
safe-lock
A lock struct with a
const fnconstructor and nounsafe -
myriam
Remote actors with e2e encryption
-
jobpool
A simple and lightweight threadpool implementation
-
rcell
A Cell which can hold either an Arc or an Weak smartpointer
-
rayon-core
Core APIs for Rayon
-
shardize
proc macro that generates code to create a sharded form of an existing container
-
elysees
A fork of triomphe, now with more pointer trickery
-
deferred-reference
A deferred reference is not an actual reference, it is merely a smart pointer tied to the lifetime of the location it points to
-
semalock
A library for concurrently writing to files in a safe and efficient manner
-
sentinel-core
The flow sentinel of your microservices
-
boxcar
A concurrent, append-only vector
-
concurrent_lru
A concurrent LRU cache
-
atomic_float
Floating point types which can be safely shared between threads
-
parallel-iterator
Parallelize any iterator with ease!
-
append-only-vec
Append-only, concurrent vector
-
axiom
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka
-
try-mutex
Fast non-blocking mutex
-
whisk
A simple and fast two-way async channel
-
channel_io
Reader implementation on channel of bytes
-
multiqueue
A fast mpmc broadcast queue
-
storage-map
Concurrent append-only map storage
-
amadeus-parquet
An Apache Parquet implementation in Rust
-
fil-ocl-core
A low-level OpenCL API
-
tlid
Thread Local ID generator by predefined range without atomics/locks/random/time
-
ebr
simple epoch-based reclamation with low cacheline ping-pong
-
slave-pool
Simple thread pool
-
simplelock
Simple abstractions for inter-process synchronization
-
jod-thread
std::thread which joins on drop by default
-
concurrent_prime_sieve
Tools for generating filters and collections with primes concurrently. Rust implementation of the Sieve of Atkin. This implementation runs in O( sqrt(max_num) + section_size ) (where section_size = max_num - min_num)…
-
concurrent_arena
u32 concurrent insertion/removal arena that returns ArenaArc
-
ev_slotmap
A lock-free, eventually consistent, concurrent slot map
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
autoincrement
Autoincrement wrapper for different purposes
-
context
Cooperative multitasking for Rust using Boost.Context
-
goko
A lock-free, eventually consistent, concurrent covertree
-
quinine
Atomic monotonic containers (Mono{Box,Arc})
-
glock
Granular locking crate for Rust
-
tasque
A simple thread pool library
-
concurrent-hashmap
A concurrent hashmap library
-
namaste
Simple locks between processes
-
easy-parallel
Run closures in parallel
-
copoll
Minimalistic abstractions for the epoll linux api
-
movie
An actor / thread orchestration library / macro / framework
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
conquer-util
utilities for concurrent and lock-free programming
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
para
A dataflow/pipeline parallelization framework
-
kontroli
Type checking for the lambda-Pi calculus modulo rewriting
-
pinnable
A Mutex that can be pinned
-
halt
Provides functionality for pausing, stopping, and resuming iterators, readers, and writers
-
locker
Simple named mutex/locker for rust-lang concurrency
-
dwt-systick-monotonic
RTIC Monotonic implemenation based on Systick and DWT
-
lock_many
Retry-based locking multiple mutexes at once
-
zkmq
Simple Rust Message Queue, backed by Zookeeper
-
async-datachannel-wasm
Async Wrapper for WebRTC datachannel in the browser environment
-
gaffer
Prioritised, parallel job scheduler with concurrent exclusion, job merging, recurring jobs and load limiting for lower priorities
-
spinning
Mutexes and SIX locks implemented by spinning
-
io_partition
A library allowing to use just a part of a Read + Seek object
-
fmutex
Provides mutual exclusion on a file using flock(2)
-
lofi
Low Overhead Fibers
-
bi
Simple kit for reading/writing resources
-
local-sync
Non-threadsafe data structure for async usage
-
chashmap
Fast, concurrent hash maps with extensive API
-
uplock
A futures-aware RwLock with ref_count, upgrade, and downgrade methods
-
atomic-take
Atomically take a value out of a container once
-
crossbeam-utils
Utilities for concurrent programming
-
evc
Eventually consistent synchronization primitive
-
ocl-core
A low-level OpenCL API
-
rad
A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
stuck-macros
Macros to bootstrap stuck
-
lossyq
This is a concurrent single publisher, single consumer queue with fixed length, that never blocks the writer
-
atomx
Thread safe data structures based on atomic data types
-
rusty_junctions
Join Pattern implementation in Rust
-
kademlia-dht
A simple implementation of the Kademlia DHT
-
rusty-junctions-client-api-macro
A convenient set of declarative macros used as part of the rusty-junctions-macro Client Macro API
-
remutex
Recursive mutex, adapted from Rust’s standard library
-
stele
An atomic Vec-like structure with no copying on allocation
-
spliter
A simple way to implement Rayon’s ParallelIterator
-
simple-mutex
A mutex more efficient than std and simpler than parking_lot
-
signal-notify
Catch OS signals with standard mpsc channel
-
mpmcpq
Multi-producer multi-consumer Priority Queue
-
tcb
A middleware service for delivering messages in a causal order
-
async-events
Waiting for external task completion in asynchronous Rust code
-
threadstack
A more ergonomic and more flexible form of thread local storage
-
brutils
Some utilities for Rust
-
ach-cell
Atomic Channel
-
ductile
A channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface
-
rdispatcher
Dispatcher for Rust, broadcast and subscribe many to many
-
thread_timer
A simple, cancelable timer with no external dependencies
-
ruo
MQTT client library for Rust
-
atomic-array
Defines several array types in which elements may be updated atomically. Intended to provide atomic array types similar to those found in java.util.concurrent.atomic in Java.
-
ppipe
An elegantly simple and lightweight library for making iterator pipelines concurrent and blazingly fast, hence the name ppipe (parallel pipe)
-
shareable
Thread shareable objects using the minimal amount of synchronization
-
ecpool
Thread pool for managing executions of erasure coding
-
mwcas
Multi-word CAS primitive
-
cuneiform-fields
Field level [no_std] cache optimizations for Rust
-
rayon_croissant
bikeshedding the name: something that is mapped folded and collected, a 🥐
-
broadcaster
Broadcasting futures mpmc channel
-
shared_channel
Multi-producer, multi-consumer FIFO queue communication primitives
-
may_waiter
Simple coroutine communication blocker
-
cortex-m-rtfm-macros
Procedural macros of the cortex-m-rtfm crate
-
chashmap-async
Concurrent async hash maps with key-scoped locking
-
yaks
Minimalistic framework for automatic multithreading of hecs via rayon
-
ste
A single-threaded executor with some tricks up its sleeve
-
bombs
Efficient single-producer multi-consumer communication types
-
mongo_sync
instant coding answers via the command line(just like howdoi)
-
stoplight
Stoplight is a simple library for stoppable tasks/threads
-
consumable_vec
Consumable_Vec is a generic approach to create a mutual database for multiple producers and consumers
-
monotone
Library of counters and queues for coordination in distributed systems
-
update_channel
A channel for single updatable values
-
ya-ring-buf
Yet Another Ring Buffer. SPSC channel with direct access for bytes/Copy.
-
workctl
Provides a number of higher-level control mechanisms for concurrent work scheduling, built on standard library concurrency primatives
-
maxim
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka. A fork of the Axiom actor framework.
-
blackhole
…to throw your threads into
-
yastl
Yet another scoped threadpool library
-
dynqueue
Dynamically extendable Rayon parallel iterator
-
cogo
Rust Coroutine Library like go
-
ditto
CRDTs for common data structures like maps, sets, vecs, strings, and JSON
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
work-queue
A concurrent work-stealing queue for building schedulers
-
coroutines
High performance coroutine library with native experience
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
kik_sync_service
A synchronous threading worker channel for generating the results you want with the data you need
-
secc
Implements a Skip-Enabled Concurrent Channel (SECC) for Rust
-
colosseum
A variety of arena allocators for Rust, including thread-safe arenas
-
resources
Safe store for one value of each type, with interior mutability
-
meio-connect
Set of connectors for MEIO framework
-
scoped_threadpool
A library for scoped and cached threadpools
-
pflock
A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
skipchannel
skipchannels allow to communicate between threads, but always skip to the last sent value
-
forkjoin
A work stealing fork-join parallelism library for Rust
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions. -
synchronoise
Synchronization primitives that build upon the standard library
-
bondi
Single producer, multi consumer lock-free ring buffer (experimental)
-
consume
Memory order consume for when it’s known that the compiler can’t elide the dependency
-
clone-replace
Share mutable data by cloning and replacing a reference version
-
async-once-watch
Asynchronous and shareable container which value is set once
-
rayon_logs
Traces for the rayon work-stealing library
-
rsevents
Manual and auto reset events for signaling remote threads and building synchronization primitives
-
systick-monotonic
RTIC Monotonic implementation based on SysTick
-
terminate
A simple crate to abstract logic to terminate threads, coroutines and the like
-
read-cell
Read-only Cell counterpart
-
ump
Micro message passing library for threads/tasks communication
-
tyractorsaur
Typed Actor System
-
slottle
A throttle pool library designed for thread-based concurrency
-
futex-queue
An efficient MPSC queue with timer capability based on Linux futex. Suitable for real-time applications.
-
smartpool
A very customizable, future-aware threadpool
-
rt-history
An RT-safe history log with error checking
-
tange
Scalable Task-based Parallelism Framework
-
lockable
This library offers hash map and cache data structures where individual entries can be locked
-
spsc-bip-buffer
A concurrent, spsc ring-buffer with sized reservations
-
hazptr
hazard pointer based concurrent memory reclamation
-
amadeus-derive
Harmonious distributed data analysis in Rust
-
lf-queue
A lock-free multi-producer multi-consumer unbounded queue
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
bustle
Benchmarking harness for concurrent key-value collections
-
rayoff
rayon but it’s map-reduce
-
amadeus-serde
Harmonious distributed data analysis in Rust
-
td_rthreadpool
thread wrapper for Rust
-
delay-queue
A concurrent unbounded blocking queue where each element can only be removed when its delay expires
-
lock_ext
Crate extending functionalities of std::sync
-
zestors-codegen
Proc macros for Zestors
-
channel_pipes
Perform operations on broadcast queues
-
ringtail
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
rtfm-core
Core abstractions of the Real Time For the Masses framework
-
grandma
A lock-free, eventually consistent, concurrent covertree
-
cnr
An operation-log based approach for data replication
-
parking
Thread parking and unparking
-
mpmc
copy-pasted from old rust stdlib
-
rusty-junctions-macro
Library Generation and Client Macro API for rusty-junctions
-
rjq
Redis job queue
-
atomic_mpmc
Atomic Multi-Producer Multi-Consumer Queue