-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
rayon
Simple work-stealing parallelism for Rust
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
crossbeam-deque
Concurrent work-stealing deque
-
crossbeam-queue
Concurrent queues
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
crossbeam-utils
Utilities for concurrent programming
-
spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
cortex-m-rtfm
Real Time For the Masses (RTFM): a concurrency framework for building real time systems
-
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…
-
crossbeam
Tools for concurrent programming
-
may
Rust Stackful Coroutine Library
-
atomic
Generic Atomic wrapper type
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
dashmap
Blazing fast concurrent HashMap for Rust
-
thread_local
Per-object thread-local storage
-
region
A library for manipulating memory regions
-
rustc-rayon
Simple work-stealing parallelism for Rust - fork for rustc
-
kafka
Rust client for Apache Kafka
-
tokio-executor
Future execution primitives
-
crossbeam-epoch
Epoch-based garbage collection
-
want
Detect when another Future wants a result
-
scoped_threadpool
A library for scoped and cached threadpools
-
loom
Permutation testing for concurrent code
-
may_queue
May’s internal queue library
-
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
-
tokio-threadpool
A task scheduler backed by a work-stealing thread pool
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
chashmap
Fast, concurrent hash maps with extensive API
-
desync
A hassle-free data type for asynchronous programming
-
faster-rs
Rust wrapper for FASTER by Microsoft Research
-
executors
A collection of high-performance task executors
-
atomic_refcell
Threadsafe RefCell
-
cortex-m-rtfm-macros
Procedural macros of the cortex-m-rtfm crate
-
bastion
Fault-tolerant Runtime for Rust applications
-
rustacuda
CUDA Driver API Wrapper
-
rayon-core
Core APIs for Rayon
-
scheduled-thread-pool
A scheduled thread pool
-
session_types
An implementation of session types in Rust
-
mpi
Message Passing Interface bindings for Rust
-
double-checked-cell
A thread-safe lazily initialized cell using double-checked locking
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
rtfm-syntax
The Real Time for The Masses (RTFM) meta language
-
shred-derive
Custom derive for shred
-
bus_queue
Lock-free Bounded non-Blocking Pub-Sub Queue
-
multiqueue2
A fast mpmc broadcast queue
-
object-pool
A thread-safe object pool with automatic return and attach/detach semantics
-
axiom
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka
-
lightproc
Lightweight process abstraction for Rust
-
broadcaster
Broadcasting futures mpmc channel
-
thread-priority
Library for managing threads priority and schedule policies
-
pueue
A cli tool for managing long running shell commands
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
thread-id
Get a unique thread ID
-
runtime-fmt
Runtime-based string formatting
-
rsevents
Manual and auto reset events for signaling remote threads and building synchronization primitives
-
flo_stream
Pubsub and related streams for Rust futures
-
secc
Implements a Skip-Enabled Concurrent Channel (SECC) for Rust
-
bastion-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
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
syncpool
A thread-friendly library for recycle of heavy and heap-based objects to reduce allocation and memory pressure
-
arpx
Automate and relate multiple processes
-
stateright
A model checker for implementing distributed systems
-
atomic-counter
Atomic (thread-safe) counters for Rust
-
tokenlock
Send-able cell type whose contents can be accessed only via an inforgeable token
-
movie
An actor / thread orchestration library / macro / framework
-
bastion-executor
Cache affine NUMA-aware executor for Rust
-
lossyq
This is a concurrent single publisher, single consumer queue with fixed length, that never blocks the writer
-
hopper
an unbounded mpsc with bounded memory
-
tari_broadcast_channel
Bounded non-blocking single-producer-multi-consumer broadcast channel
-
dynpool
A thread manager that is lightweight, flexible, and rescalable
-
reclaim
trait-based abstract interface for memory reclamation
-
stm
Implementation of Software transactional memory. Allows composable atomic operations.
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
intmap
Specialized HashMap for u64 keys
-
tasque
A simple thread pool library
-
spin-sync
Synchronization primitives using spinlock. The interface resembles std::sync. rust nightly version is required so far
-
parallel-iterator
Parallelize any iterator with ease!
-
threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
storage-map
Concurrent append-only map storage
-
rtfm-core
Core abstractions of the Real Time For the Masses framework
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
lazy_transducer
Lazy, parallel, indexable, generic data iterators
-
ocl-core
A low-level OpenCL API
-
ruget
Alternative to wget written in Rust
-
pipe-channel
Channel implementation based on pipes
-
semalock
A library for concurrently writing to files in a safe and efficient manner
-
context
Cooperative multitasking for Rust using Boost.Context
-
carboxyl
Library for functional reactive programming
-
tlid
Thread Local ID generator by predefined range without atomics/locks/random/time
-
rayon_croissant
bikeshedding the name: something that is mapped folded and collected, a 🥐
-
spmc
Simple SPMC channel
-
mpmc-scheduler
multi-mpmc, cancellable, scheduler with rate limiting
-
flurry
Rust port of Java’s ConcurrentHashMap
-
concurrent-hashmap
A concurrent hashmap library
-
concurrency
This exist to prove a point
-
multiqueue
A fast mpmc broadcast queue
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
rcu_cell
a lockless rcu cell implementation
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
blackhole
…to throw your threads into
-
jobpool
A simple and lightweight threadpool implementation
-
coroutine
Coroutine Library in Rust
-
smartpool
A very customizable, future-aware threadpool
-
spsc-bip-buffer
A concurrent, spsc ring-buffer with sized reservations
-
radium
Helper traits for working with maybe-atomic values
-
single_value_channel
Concurrent single-value update and receive channel
-
ccl
Fast datastructures for use in highly concurrent systems
-
amadeus-types
Harmonious distributed data analysis in Rust
-
threadpool-crossbeam-channel
A fork of the threadpool create, which uses crossbeam-channel instead of std::mpsc
-
hazptr
hazard pointer based concurrent memory reclamation
-
hurdles
Counter-based thread barrier
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
riker-cqrs
Provides Command Query Responsibility Separation for Riker applications
-
pond
A library for scoped and cached threadpools that keep a state
-
ccl-crossbeam-epoch
Epoch-based garbage collection
-
halt
Provides functionality for pausing, stopping, and resuming iterators, readers, and writers
-
indexed-ring-buffer
An indexed multiple readable spsc ring buffer
-
shared-expiry-get
Simple concurrent async get with expiration for Rust
-
cbloom
Concurrent implementation of Bloom filters
-
ghetto-lock
Memcache backed ghetto lock implementation
-
synchronoise
Synchronization primitives that build upon the standard library
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
npnc
Lock-free queues
-
queuecheck
A thread-safe queue testing and benchmarking library
-
try-lock
A lightweight atomic lock
-
flume
A blazingly fast multi-producer channel
-
hey_listen
An event-dispatcher-collection offering sync, parallel, and prioritised solutions!
-
slave-pool
Simple thread pool
-
jobsteal
A work-stealing fork-join threadpool written in Rust
-
run-down
An implementation of run-down protection in rust
-
conqueue
Yet another multi-producer, single-consumer queue (MPSC)
-
fort
Proc macro attributes for Bastion runtime
-
namaste
Simple locks between processes
-
bastion-utils
Utilities for Bastion, the highly-available, fault-tolerant, async communication oriented executor
-
evc
Eventually consistent synchronization primitive
-
thread_tryjoin
Try joining a thread
-
swapper
Swap ownership between threads
-
cuneiform-fields
Field level [no_std] cache optimizations for Rust
-
remutex
Recursive mutex, adapted from Rust’s standard library
-
miniqueue
A minimalistic single-thread job queue based on fold/reduce
-
brutils
Some utilities for Rust
-
pipeliner
Provides a nice interface for parallel programming with iterators
-
yaar-lock
Fast, no_std synchronization primitives
-
sealrs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
future-parking_lot
An “as simple as possible” Future implementation for parking_lot
-
mpmc
copy-pasted from old rust stdlib
-
lockfree
This crate provides concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
funfsm
An FSM library where the states are functions
-
zonyitoo/coio
Coroutine scheduler with non-blocking I/O support
-
scheduler
Binding to set the linux scheduler (priority, policy, affinity, &c.)
-
stoplight
Stoplight is a simple library for stoppable tasks/threads
-
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)…
-
locker
Simple named mutex/locker for rust-lang concurrency
-
macgyver-lock
Memcache backed lock implementation
-
contrie
Concurrent map and set
-
may_actor
Simple Actor library based on MAY
-
eventual
Future & Stream abstraction
-
guardian
Provides owned mutex guards for refcounted mutexes
-
atomic_immut
Atomic immutable value
-
cuneiform
Cache optimizations for Rust, revived from the slabs of Sumer
-
refptr
Inherently reference counted structs
-
may_waiter
Simple coroutine communication blocker
-
glock
Granular locking crate for Rust
-
parallel-event-emitter
Parallel Event Emitter for concurrent listener invocation based on futures-rs and futures-cpupool
-
kekbit-core
Defines the main abstractions and provides the core components required to work with kekbit channels
-
bchannel
A better channel API
-
nfqueue
Netfilter NFQUEUE high-level bindings
-
auto-cc
A small utility to perform automatic cycle collections with bacon_rajan_cc
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
seqlock
A reader-writer lock that provides extremely fast read access without starving writers
-
forkjoin
A work stealing fork-join parallelism library for Rust
-
monitor
Monitor synchronization construct
-
cuda-runtime-sys
Rust binding to CUDA Runtime APIs
-
priomutex
A mutex where waiting threads specify a priority
-
static_locks
The
parking_lotlocks but usable in statics and const fn -
mpi-sys
Message Passing Interface bindings for Rust
-
atomig
Generic and convenient
stdatomics viaAtomic<T>. Can be used with many primitive types (including floats) and with custom types. -
rayon-join-macro
A convenience n-nary macro around
rayon::join() -
amadeus-derive
Harmonious distributed data analysis in Rust
-
syncbox
Concurrency utilities for Rust
-
poolite
A lite threadpool library
-
sched-clock
A timer for task scheduling
-
conquer-util
utilities for concurrent and lock-free programming
-
rayon-macro
Macros enabling parallelism using the rayon crate
-
shareable
Thread shareable objects using the minimal amount of synchronization
-
disrustor
This project is a port of the LMAX Disruptor to Rust
-
rad
A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
eventbus
Safe, fast and concurrent event system, inspired by the MinecraftForge event bus
-
par-map
Parallel map and flat_map
-
arbalest
Like Arc but where weak references don’t forbid mutable access
-
wait_group
golang sync.WaitGroup in Rust
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
incr
Simple, fast and self-contained data structures for checking whether a new value is greater than the previous maximum
-
amadeus-commoncrawl
Harmonious distributed data analysis in Rust
-
padlock
Safely acquire RwLock/Mutex locks
-
task_scope
asynchronous runtime extension for supporting Structured Concurrency with task spawning
-
coroutines
High performance coroutine library with native experience
-
e_book_sync_library
Synchonize e-book with your local e-library
-
magnetic
Low-latency lock-free queues
-
tange
Scalable Task-based Parallelism Framework
-
delay-queue
A concurrent unbounded blocking queue where each element can only be removed when its delay expires
-
bi
Simple kit for reading/writing resources
-
scheduled-executor
Single and multi-threaded task scheduler
-
td_rthreadpool
thread wrapper for Rust
-
ppipe
An elegantly simple and lightweight library for making iterator pipelines concurrent and blazingly fast, hence the name ppipe (parallel pipe)
-
transformable_channels
Rust channels are a convenient abstraction, but for many uses cases, they miss high-level transformations such as
map,filter, … . This crate introduces them. -
atomic-batcher
A simple batching function that allows you to atomically batch a series of operations
-
smartpool-spatial
Spatial prioritization for smartpool using manhattan trees
-
hazard
Hazard pointers
-
seal_rs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
rayon-macro-hack
Implementation details of rayon-macro
-
qadapt-spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
two-lock-queue
A MPMC channel based on the michael-scott two lock queue algorithm
-
colosseum
A variety of arena allocators for Rust, including thread-safe arenas
-
arcmutex
A convenience library for working with
Arc<Mutex<T>>s -
ringtail
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
monotone
Library of counters and queues for coordination in distributed systems
-
fused-reader
This crate provides fused reader type that if writer thread dies while holding armed fuse the reader will get BrokenPipe error
-
shared_channel
Multi-producer, multi-consumer FIFO queue communication primitives
-
bi_channel
Manage bidirectional mpsc channels more conveniently
-
inert
Inert lets you use non-Sync values in a Sync way
-
lock-free-multi-producer-single-consumer-ring-buffer
A lock-free, multi-producer, single-consumer (MPSC) ring buffer. Optimized for sending and receiving ‘bursts’ of messages. Can also be used as a ring queue. It is a Rust port of Mindaugas Rasiukevicius’s ringbuf.
-
sync_splitter
Safely split a mutable slice in multiple threads at the same time
-
tange-collection
Dataflow computation
-
greentask
Library to use coroutines as green tasks
-
ice-threads
Lightweight Thread pool implementation
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
futures-mpsc
A futures aware, bounded, MPSC channel with back pressure support
-
objpool
Thread-safe generic object pool
-
nonparallel
Rust macro for ensuring non-parallel execution of functions
-
try-mutex
Fast non-blocking mutex
-
simple_parallel
Straight-forward functions and types for basic data parallel operations, including parallel maps, for loops and thread pools
-
thread-object
Abstraction over thread-local storage allowing dynamic creation of TLS variables
-
fifo
First-in-first-out lock-free ring-buffer like kfifo in Linux
-
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.
-
arc-cell
Helper for a simple Cell-like object containing Arc/Weak
-
context-coroutine
This is a simple set of extensions to provide stackful coroutines; it is not officially associated with the context crate
-
rust_events
A flexible event-handling library, based on the C# delegate model
-
process_lock
This is process lock impl multi process for rust
-
pipelines
A tool for constructing multi-threaded pipelines of execution
-
blasoxide-mt
multithreading for blasoxide
-
fil-ocl-core
A low-level OpenCL API
-
sesh
A library for deadlock-free session-typed communication
-
sleepfast
Sleep for very small amounts of time quickly
-
context_bind
Simple M:N threading library. Should support Linux, MacOS, Free/OpenBSD, and Windows for x86/64, and aarch32/64
-
tasks-framework
Actor-like Message processing framework inspired by the work of Stepan Koltsov
-
jod-thread
std::thread which joins on drop by default
-
berghain
the hottest cache with an admisison policy based on TinyLFU
-
ordered-parallel-iterator
Performs tasks in parallel returning completed tasks in order of appearance
-
tchannel
Optimized channels for Rust
-
concache
A fast, concurrent, shared hash map
-
latest
A channel-esque type that only stores the last value that was sent
-
stm-core
Implementation of Software transactional memory. STM Allows composable atomic operations. STM-core implements the bare bones of stm usage. The STM crate adds useful data structures.
-
canal
A library for multithreaded concurrency primitives, including queues and channels
-
lockless
Composable, lock-free, allocation-light data structures
-
conc
Hazard-pointer-based concurrent memory reclamation
-
zermelo
A library that retrieves a schedule from Zermelo
-
pool_barrier
A barrier for blocking a main thread until the completion of work which has been offloaded to worker threads, without blocking the worker threads
-
simplesched
A naive coroutine based scheduler with asynchronous I/O support
-
atomic-ref2
Provides AtomicOptionRef and AtomicRef. Intended to map to java.util.concurrent.atomic.AtomicReference in Java.
-
son_of_grid_engine
Interface with son of grid engine (formerly sun grid engine) to run rust programs on clusters
-
liblightning
High-performance general-purpose stackful coroutine library
-
lock-free-stack
Lock-free (atomic-based) Collection which internally represent data as a Stack, and exposes an interface allowing to add elements, get size, and remove all giving a reverse-iterator
-
gamemap
A small 2D Map library for console games in Rust
-
async-cmd
A tool to run shell commands in parallel
-
crtq
A MPMC wait-free queue
-
lockfreehashmap
A concurrent, lock-free hash map
-
polyester
Parallel iterator adaptors that accept arbitrary iterators
-
mrogalski-looper
Clean abstraction for a single-threaded event loop. Built as a lightweight wrapper around the std::sync::mpsc package.
-
object-space
An object store library for highly concurrent program written in Rust
-
tcp-echo
This is a test project to see the feasibility of the acto-rs (Actor library) interfaces and performance
-
send-cell
Immutable memory region with runtime Send checking
-
rusty-variation
A library for deadlock-free session-typed communication
-
pairlock
A reader-writer lock with wait-free reads
-
atomic_ref
Atomic &’a T types with support for static allocation
-
slurm
Interface to the Slurm workload manager
-
thread_io
Crate for performing I/O in background thread
-
namedlock
Namespaces for named locks
-
trailing_cell
Provides wrappers for sharing a data structure where read speed is important and strict consistency is not (data can be stale)
-
moite_moite
Split a value in two owned parts
-
counting-networks
Lock-free data structures for concurrent counting
-
specs-static
specs-static is an extension for Specs that adds custom ids
-
arc_map
A Map of Arc<Mutex> that eases the access of indivdual members
-
taskpipe
A simple, multithreaded pipeline library
-
brokkr
Simple distributed task queue library for Rust
-
skipchannel
skipchannels allow to communicate between threads, but always skip to the last sent value
-
poolter
Thread Pool implementation for Rust using JavaScript Promise like functional syntax
-
atomicmonitor
Effeciently await a condition on atomic data
-
thread_binder
Bind rayon pools to limit numa effects
-
monotone-cli
Monotonic counter cli implemented on top of AWS DynamoDB
-
futures-mutex
A Mutex for the Future(s)
-
amadeus
Harmonious distributed data processing & analysis in Rust. parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common crawl
-
inert_derive
See the inert crate
-
bagpipe
A concurrent bag datastructure
-
urcu-sys
System bindings for urcu (user-space rcu)