-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
rayon
Simple work-stealing parallelism for Rust
-
dashmap
Blazing fast concurrent HashMap for Rust
-
threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
crossbeam-queue
Concurrent queues
-
loom
Permutation testing for concurrent code
-
spin
Spin-based synchronization primitives
-
crossbeam
Tools for concurrent programming
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
crossbeam-epoch
Epoch-based garbage collection
-
flume
A blazingly fast multi-producer channel
-
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
-
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…
-
bastion
Fault-tolerant Runtime for Rust applications
-
cortex-m-rtic
Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
rustacuda
CUDA Driver API Wrapper
-
crossbeam-utils
Utilities for concurrent programming
-
atomicring
AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer
-
amadeus
Harmonious distributed data processing & analysis in Rust. parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common crawl
-
faster-rs
Rust wrapper for FASTER by Microsoft Research
-
may
Rust Stackful Coroutine Library
-
executors
A collection of high-performance task executors
-
scheduled-thread-pool
A scheduled thread pool
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
radium
Portable interfaces for maybe-atomic types
-
multiqueue2
A fast mpmc broadcast queue
-
double-checked-cell
A thread-safe lazily initialized cell using double-checked locking
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
lever
Pillars for Transactional Systems and Data Grids
-
cortex-m-rtfm-macros
Procedural macros of the cortex-m-rtfm crate
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
spinning_top
A simple spinlock crate based on the abstractions provided by
lock_api -
region
A library for manipulating memory regions
-
object-pool
A thread-safe object pool with automatic return and attach/detach semantics
-
try-lock
A lightweight atomic lock
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
rayon-core
Core APIs for Rayon
-
async-channel
Async multi-producer multi-consumer channel
-
process_control
Methods for ergonomically running processes with timeouts
-
mpi
Message Passing Interface bindings for Rust
-
rustc-rayon
Simple work-stealing parallelism for Rust - fork for rustc
-
krecik
Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL
-
arpx
Automate and relate multiple processes
-
async_nursery
Primitive for structured concurrency
-
sidekiq
Rust Sidekiq Client
-
chashmap
Fast, concurrent hash maps with extensive API
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
stateright
A model checker for implementing distributed systems
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
jod-thread
std::thread which joins on drop by default
-
state
A library for safe and effortless global and thread-local state management
-
meio
A compact actors framework for the async epoch in Rust & Tokio
-
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.
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
fast-async-mutex
It is a lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)
-
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
-
smallmap
Small byte-sized generic key-value map type
-
broadcaster
Broadcasting futures mpmc channel
-
asyncgit
allow using git2 in a asynchronous context
-
bastion-executor
Cache affine NUMA-aware executor for Rust
-
cueball-tcp-stream-connection
This is an implementation of the cueball Connection trait for TcpStream from the rust standard library
-
rtrb
A realtime-safe single-producer single-consumer ring buffer
-
scc
scalable concurrent data structures for database management systems
-
may_queue
May’s internal queue library
-
thread_io
Crate for performing I/O in background thread
-
scoped_threadpool
A library for scoped and cached threadpools
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
async-mutex
Async mutex
-
mpstthree
A library implementing Multiparty Session Types for 3 participants
-
hopper
an unbounded mpsc with bounded memory
-
thread-id
Get a unique thread ID
-
storage-map
Concurrent append-only map storage
-
crossbeam-deque
Concurrent work-stealing deque
-
desync
A hassle-free data type for asynchronous programming
-
lifetime-thread
A thread with a lifetime. Divide a value into master and slave. After the lifetime of the master value ends, the slave value will not be accessible.
-
conquer-util
utilities for concurrent and lock-free programming
-
rtic-syntax
The Real-Time Interrupt-driven Concurrency (RTIC) meta language
-
semalock
A library for concurrently writing to files in a safe and efficient manner
-
zookeeper
A minimal ZooKeeper client
-
simplelock
Simple abstractions for inter-process synchronization
-
parallel-iterator
Parallelize any iterator with ease!
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
actors-rs
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
spinning
Mutexes and SIX locks implemented by spinning
-
event-emitter-rs
Lightweight EventEmitter
-
shared-bus-rtic
Provides utilities for sharing peripheral communication buses in an RTIC application
-
thread-priority
Library for managing threads priority and schedule policies
-
swf-emitter
SWF emitter
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
try-mutex
Fast non-blocking mutex
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
atomig
Generic and convenient
stdatomics viaAtomic<T>. Can be used with many primitive types (including floats) and with custom types. -
file-lock
File locking via POSIX advisory record locks
-
remutex
Recursive mutex, adapted from Rust’s standard library
-
axiom
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka
-
ruget
Alternative to wget written in Rust
-
ev_slotmap
A lock-free, eventually consistent, concurrent slot map
-
thread_local
Per-object thread-local storage
-
slave-pool
Simple thread pool
-
global_counter
Global, thread-safe counters
-
stm
Implementation of Software transactional memory. Allows composable atomic operations.
-
thingvellir
a concurrent, shared-nothing abstraction that manages an assembly of things
-
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
-
flo_stream
Pubsub and related streams for Rust futures
-
recloser
A concurrent circuit breaker implemented with ring buffers
-
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 -
peril
Fast and safe Hazard pointers for Rust
-
namaste
Simple locks between processes
-
dynqueue
Dynamically extendable Rayon parallel iterator
-
tcb
A middleware service for delivering messages in a causal order
-
servo_arc
A fork of std::sync::Arc with some extra functionality and without weak references
-
halt
Provides functionality for pausing, stopping, and resuming iterators, readers, and writers
-
bmrng
async MPSC request-response channel for Tokio
-
locker
Simple named mutex/locker for rust-lang concurrency
-
want
Detect when another Future wants a result
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
pausable_clock
A source of time information that can be paused and resumed
-
hidefix
Concurrent HDF5 and NetCDF4 reader (experimental)
-
concurrency
This exist to prove a point
-
elysees
A fork of triomphe::Arc, now with more pointer tricks
-
tasque
A simple thread pool library
-
tlid
Thread Local ID generator by predefined range without atomics/locks/random/time
-
crossfire
channels for async and threads
-
throttle-client
Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.
-
rtfm-syntax
The Real Time for The Masses (RTFM) meta language
-
lossyq
This is a concurrent single publisher, single consumer queue with fixed length, that never blocks the writer
-
flize
non global, configurable and fast concurrent resource reclamation
-
pueue-lib
The shared library to work with the Pueue client and daemon
-
para
A dataflow/pipeline parallelization framework
-
threadstack
A more ergonomic and more flexible form of thread local storage
-
ckb-channel
Channel wrapper
-
goko
A lock-free, eventually consistent, concurrent covertree
-
skipchannel
skipchannels allow to communicate between threads, but always skip to the last sent value
-
terminate
A simple crate to abstract logic to terminate threads, coroutines and the like
-
rgraph
A task graph library
-
option-lock
A multi-purpose read/write lock for Option values
-
rayon_logs
Traces for the rayon work-stealing library
-
concurrent-hashmap
A concurrent hashmap library
-
futures-rate
This library provides easy tools to help Rust applications guide critical resources or code paths from being overwhelmed
-
cht
Lockfree resizeable concurrent hash table
-
blackhole
…to throw your threads into
-
mchprs
A multithreaded minecraft server built for redstone
-
caring
Sharing is caring: a safe library for mmap’ing memory in multiple processes
-
zonyitoo/coio
Coroutine scheduler with non-blocking I/O support
-
meio-protocol
Basic protocol traits of MEIO framework
-
atomic-shim
Atomic types for unsupported platforms
-
mula
Share expensive computation with various requesters
-
async-lock
Async synchronization primitives
-
secc
Implements a Skip-Enabled Concurrent Channel (SECC) for Rust
-
single_value_channel
Concurrent single-value update and receive channel
-
jobpool
A simple and lightweight threadpool implementation
-
managed-thread
Real fearless concurrency! Spawn threads that will be automatically destroyed when no longer needed
-
transaction-pool
Generic transaction pool
-
mkit
Tools and macros for distributed and peer-to-peer applications
-
dager
Crate to create and execute a graph of nodes
-
rsevents
Manual and auto reset events for signaling remote threads and building synchronization primitives
-
pakr-fsm
Template to implement finite-state-machines
-
amadeus-parquet
An Apache Parquet implementation in Rust
-
flurry
Rust port of Java’s ConcurrentHashMap
-
cortex-m-rtic-macros
Procedural macros of the cortex-m-rtic crate
-
slock
An async mutex that never deadlocks
-
amadeus-types
Harmonious distributed data analysis in Rust
-
apodize
simple iterators that yield generalized cosine, hanning, hamming, blackman, nuttall and triangular windows
-
bondi
Single producer, multi consumer lock-free ring buffer (experimental)
-
movie
An actor / thread orchestration library / macro / framework
-
theatre
A concise async actor model implementation
-
schedule-rs
A simple scheduling library inspired by Python’s schedule
-
node-replication
An operation-log based approach for data replication
-
rcu_cell
a lockless rcu cell implementation
-
pipe-channel
Channel implementation based on pipes
-
parallel_reader
A utility for reading from a file (or any
Readstream) and processing it by chunks, in parallel -
pflock
A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
lazy_id
A thread-safe lazily-initialized ID
-
unsafe-send-sync
Unsafe wrappers for making structs Send and/or Sync
-
signal-notify
Catch OS signals with standard mpsc channel
-
init_guard
A Synchronization Primitive for guarding against double initialization
-
ratelimit
a token bucket ratelimiter
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
update_channel
A channel for single updatable values
-
tokio-threadpool
A task scheduler backed by a work-stealing thread pool
-
lofi
Low Overhead Fibers
-
yaks
Minimalistic framework for automatic multithreading of hecs via rayon
-
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)…
-
ocl-core
A low-level OpenCL API
-
monitor
Monitor synchronization construct
-
smartpool
A very customizable, future-aware threadpool
-
stakker_log
Logging support for Stakker
-
atomic_immut
Atomic immutable value
-
revenq
A concurrent, revision-based event queue implementation
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
kademlia-dht
A simple implementation of the Kademlia DHT
-
lock_ext
Crate extending functionalities of std::sync
-
meio-connect
Set of connectors for MEIO framework
-
ping-pong-cell
An atomic cell for up to two threads
-
brutils
Some utilities for Rust
-
lockfree
This crate provides concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
throttle-timer
Throttle events and record event stats with a simple library
-
dci
DCI-Closed, a frequent closed itemset mining algorithm, implemented in Rust
-
evc
Eventually consistent synchronization primitive
-
yaar-lock
Fast, no_std synchronization primitives
-
shred-derive
Custom derive for shred
-
streamcatcher
A thread-safe, shared (asynchronous), almost-lockless stream buffer
-
task_queue
The implementation of the thread pool for Rust
-
kekbit-core
Defines the main abstractions and provides the core components required to work with kekbit channels
-
rayon_croissant
bikeshedding the name: something that is mapped folded and collected, a 🥐
-
ordered-parallel-iterator
Performs tasks in parallel returning completed tasks in order of appearance
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
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
-
rad
A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
hey_listen
An event-dispatcher-collection offering sync, parallel, and prioritised solutions!
-
hypercore-protocol
Replication protocol for Hypercore feeds
-
queuecheck
A thread-safe queue testing and benchmarking library
-
ump
Micro message passing library for threads/tasks communication
-
colosseum
A variety of arena allocators for Rust, including thread-safe arenas
-
funfsm
An FSM library where the states are functions
-
rtic-core
Core abstractions of the Real-Time Interrupt-driven Concurrency framework
-
run-down
An implementation of run-down protection in rust
-
mth_calc
Crate for demonstrating Cargo. Contains helper method for running a process in parallel on all available processors.
-
lightproc
Lightweight process abstraction for Rust
-
ppipe
An elegantly simple and lightweight library for making iterator pipelines concurrent and blazingly fast, hence the name ppipe (parallel pipe)
-
rdispatcher
Dispatcher for Rust, broadcast and subscribe many to many
-
shared-mutex
A RwLock that can be used with a Condvar
-
atomptr
A safe, dependency-less abstraction for typed atomic smart pointers
-
cuda-runtime-sys
Rust binding to CUDA Runtime APIs
-
atomic_enum
An attribute to create an atomic wrapper around a C-style enum
-
cbloom
Concurrent implementation of Bloom filters
-
coroutines
High performance coroutine library with native experience
-
async-handle
A reference-counted async RwLock
-
stoplight
Stoplight is a simple library for stoppable tasks/threads
-
simple_event_map
a simple event map based on channels, provides a receiver that is either blocking or async
-
ulock-sys
Rust bindings for Darwin’s (e.g. macOS, iOS, …) not-entirely-public ulock API, which provides futex-like functionality.
-
carboxyl
Library for functional reactive programming
-
suspend-core
Primitives for parking a thread and awaiting a notification
-
track
Track struct data modifications
-
evmap-derive
Derive macro for evmap::ShallowCopy
-
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.
-
synchronoise
Synchronization primitives that build upon the standard library
-
parking
Thread parking and unparking
-
atomic-bitvec
An atomic bit vector library
-
glock
Granular locking crate for Rust
-
shareable
Thread shareable objects using the minimal amount of synchronization
-
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.
-
atomic_prim_traits
Traits over primitive atomic types
-
borrowed-thread
thread-safe way to pass borrow to thread::spawn
-
atomic-stamped-ptr
AtomicStampedPtr for x86_64
-
cuneiform
Cache optimizations for Rust, revived from the slabs of Sumer
-
monotone
Library of counters and queues for coordination in distributed systems
-
signal-simple
Library to handle and send system signals
-
faa_array_queue
Fetch-And-Add Array Queue implementation for Rust
-
asparit
Async Parallel Iterators for Rust
-
fd-lock-rs
Like fd-lock but with a slightly different API
-
disrustor
This project is a port of the LMAX Disruptor to Rust
-
sched-clock
A timer for task scheduling
-
poolite
A lite threadpool library
-
sleepfast
Sleep for very small amounts of time quickly
-
e_book_sync_library
Synchonize e-book with your local e-library
-
once_spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
runnel
the pluggable io stream. now support: stdio, string io, in memory pipe
-
spsc-bip-buffer
A concurrent, spsc ring-buffer with sized reservations
-
rust_events
A flexible event-handling library, based on the C# delegate model
-
nfqueue
Netfilter NFQUEUE high-level bindings
-
indexed-ring-buffer
An indexed multiple readable spsc ring buffer
-
moka
A fast and concurrent cache library inspired by Caffeine (Java) and Ristretto (Go)
-
joyent/cueball
A connection pool to manage connections to a multi-node service
-
ditto
CRDTs for common data structures like maps, sets, vecs, strings, and JSON
-
bi
Simple kit for reading/writing resources
-
hurdles
Counter-based thread barrier
-
ckb-dyn-lock
ckb dyn lock lib
-
multiqueue
A fast mpmc broadcast queue
-
context
Cooperative multitasking for Rust using Boost.Context
-
hazptr
hazard pointer based concurrent memory reclamation
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
hazard
Hazard pointers
-
krecik-cli
Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL
-
semka
Semaphore implementation
-
rpool
Lock-free generic resource pool implementation
-
atomic_float
Floating point types which can be safely shared between threads
-
slottle
A throttle pool library designed for thread-based concurrency
-
rtfm-core
Core abstractions of the Real Time For the Masses framework
-
tange
Scalable Task-based Parallelism Framework
-
ocl-interop
Creates an OpenCL Context with OpenGL Interop enabled
-
delay-queue
A concurrent unbounded blocking queue where each element can only be removed when its delay expires
-
adaptive-barrier
Barrier with adaptable number of thread subsciptions
-
amadeus-serde
Harmonious distributed data analysis in Rust
-
left-right
A concurrency primitive for high concurrency reads over a single-writer data structure
-
conqueue
Yet another multi-producer, single-consumer queue (MPSC)
-
spmc
Simple SPMC channel
-
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
parc
Rust crate for cancellable time based contracts in async/await
-
tokio-executor
Future execution primitives
-
ductile
A channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface
-
redis-actor
Redis Actor
-
try-rwlock
Fast non-blocking readers-writer lock
-
contrie
Concurrent map and set