-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
spin
Spin-based synchronization primitives
-
rayon
work-stealing parallelism for Rust
-
flume
A blazingly fast multi-producer channel
-
async-lock
Async synchronization primitives
-
async-channel
Async multi-producer multi-consumer channel
-
crossbeam
Tools for concurrent programming
-
dashmap
Blazing fast concurrent HashMap for Rust
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
thread_local
Per-object thread-local storage
-
threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
jobserver
GNU Make jobserver for Rust
-
oneshot
spsc channel with (potentially) lock-free non-blocking send, and a receiver supporting both thread blocking receive operations as well as Future based async polling
-
loom
Permutation testing for concurrent code
-
blake2s_simd
a pure Rust BLAKE2s implementation with dynamic SIMD
-
scc
High performance containers and utilities for concurrent and asynchronous programming
-
thread-priority
managing threads priority and schedule policies
-
sync_wrapper
enlisting the compiler's help in proving the absence of concurrency
-
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
-
state
safe and effortless global and thread-local state management
-
leaky-bucket
A token-based rate limiter based on the leaky bucket algorithm
-
corosensei
A fast and safe implementation of stackful coroutines
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
stateright
A model checker for implementing distributed systems
-
mpi
Message Passing Interface bindings for Rust
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
thingbuf
I'm at the buffer pool. I'm at the MPSC channel. I'm at the combination MPSC channel and buffer pool.
-
rtrb
A realtime-safe single-producer single-consumer ring buffer
-
archery
Abstract over the atomicity of reference-counting pointers
-
atomic_float
Floating point types which can be safely shared between threads
-
radium
Portable interfaces for maybe-atomic types
-
try-lock
A lightweight atomic lock
-
ratelimit
ratelimiter that can be shared between threads
-
scheduled-thread-pool
A scheduled thread pool
-
futures-channel
Channels for asynchronous communication using futures-rs
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
sled
Lightweight high-performance pure-rust transactional embedded database
-
async-condvar-fair
Condition variables for async Rust
-
atomic_refcell
Threadsafe RefCell
-
shuttle
testing concurrent Rust code
-
mpstthree
implementing Multiparty Session Types for 2 or more participants
-
may
Rust Stackful Coroutine Library
-
jobslot
GNU make jobserver for Rust
-
tachyonix
A very fast asynchronous, multi-producer, single-consumer bounded channel
-
automerge
A JSON-like data structure (a CRDT) that can be modified concurrently by different users, and merged again automatically
-
wasm_thread
An std thread replacement for wasm32 target
-
triple_buffer
triple buffering, useful for sharing frequently updated data between threads
-
flurry
Rust port of Java's ConcurrentHashMap
-
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
concurrent-map
a lock-free linearizable B+ tree
-
parallel-sh
Execute commands in parallel
-
waker-fn
Convert closures into wakers
-
atomic
Generic Atomic<T> wrapper type
-
sea-streamer
🌊 The stream processing toolkit for Rust
-
diatomic-waker
An async, lock-free synchronization primitive for task wakeup
-
graph
high-performant graph algorithms
-
yaque
disk-backed persistent queue for Rust
-
lockable
offers hash map, hash set and cache data structures where individual entries can be locked
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
resman
Runtime managed resource borrowing
-
orx-concurrent-vec
A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations
-
atomig
Generic, convenient and lock-free
std
atomics viaAtomic<T>
. Can be used with many primitive types (including floats) and with custom types. -
messaging_thread_pool
aiding the creation of typed thread pool of objects that is communicated with via channels
-
inline-array
efficient immutable inlinable byte array
-
memo-map
implementing a synchronized map for memoization
-
mco
Rust Coroutine Library like go
-
disruptor
Low latency inter-thread communication via a ringbuffer (inspired by the LMAX Disruptor)
-
samsa
Rust-native Kafka/Redpanda protocol and client implementation
-
maitake-sync
No-std async synchronization primitives from Maitake
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
trauma
Simplify and prettify HTTP downloads
-
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
-
dispatch
Rust wrapper for Apple's Grand Central Dispatch
-
sync_file
Files that can be read concurrently
-
gix-lock
A git-style lock-file implementation
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
sdd
Scalable lock-free delayed memory reclaimer
-
rusty_pool
Self growing / shrinking
ThreadPool
implementation based on crossbeam’s multi-producer multi-consumer channels that enables awaiting the result of a task and offers async support -
boxcar
A concurrent, append-only vector
-
kanal
The fast sync and async channel that Rust deserves
-
runnel
the pluggable io stream. now support: stdio, string io, in memory pipe
-
recloser
A concurrent circuit breaker implemented with ring buffers
-
paralight
A lightweight parallelism library for indexed structures
-
no_deadlocks
A Runtime Deadlock Debugger
-
guardian
owned mutex guards for refcounted mutexes
-
callysto
Stream processing framework
-
safe-lock
A lock struct with a
const fn
constructor and nounsafe
- ARCHIVED -
atomic-time
AtomicDuration
,AtomicOptionDuration
,AtomicSystemTime
,AtomicOptionSystemTime
,AtomicInstant
andAtomicOptionInstant
for Rust -
gst-plugin-threadshare
GStreamer Threadshare Plugin
-
indicatif-log-bridge
Bridge the log crate and indicatif to stop log lines from mixing up with progress bars
-
mutringbuf
lock-free SPSC ring buffer, with in-place mutability
-
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…
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
television-channels
The revolution will be televised
-
rtsc
Real-time Synchronization Components
-
oqueue
Non-interleaving multithreaded output queue
-
rearch
Re-imagined approach to application design and architecture
-
io-reactor
Concurrent I/O resource management using reactor pattern
-
uid
creation of unique IDs
-
open-coroutine
efficient and generic stackful-coroutine library
-
gabriel2
Indeed, an actor library based on Tokio, written in Rust
-
rustix-futex-sync
Linux futex-based synchronization
-
seize
Fast, efficient, and robust memory reclamation for concurrent data structures
-
append-only-vec
Append-only, concurrent vector
-
rustc-rayon
work-stealing parallelism for Rust - fork for rustc
-
rcu_cell
a lockless rcu cell implementation
-
watchable
RwLock-like type that is compatible with both multi-threaded and async code
-
orx-parallel
A performant and configurable parallel computing library for computations defined as compositions of iterator methods
-
st3
A very fast lock-free, bounded, work-stealing LIFO queue
-
signals_receipts
exfiltration of the receipt of POSIX signals
-
mcslock
Mellor-Crummey and Scott contention-free lock for mutual exclusion, referred to as MCS lock
-
concurrent_arena
u32 concurrent insertion/removal arena that returns ArenaArc
-
steady_state
Framework for building long running low latency actor based services on Linux. Provides visual telemetry to watch data flows between actors. Uses Erlang style supervisors to defend…
-
concurrency_example
program demonstrating concurrency using threads
-
rclite
small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs
-
pueue
A cli tool for managing long running shell commands
-
aarc
Atomically updatable variants of Arc and Weak for lock-free concurrency
-
async_once
async once tool for lazy_static
-
svix-ksuid
A pure Rust and fully tested KSUID implementation
-
pumps
Eager streams for Rust
-
ringbuffer-spsc
A fast thread-safe single producer-single consumer ring buffer
-
tonari-actor
A minimalist actor framework aiming for high performance and simplicity
-
paradis
Parallel processing with disjoint indices
-
idr-ebr
An efficient concurrent ID to object resolver
-
rc_event_queue
VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue
-
tasklet
An asynchronous task scheduling library
-
cfavml
CF's Accelerated Vector Math Library providing SIMD optimzied routines for vector operations
-
async-skipdb
An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine
-
fault-injection
fault injection, concurrency delay injection, and error source annotation
-
atom
A safe abstraction around AtomicPtr
-
myriam
Actor model implementation for local and remote actors
-
every
Run a command every N seconds
-
crossbeam-queue
Concurrent queues
-
picokafka
Kafka library for tarantool-module based on librdkafka
-
bindgen_cuda
Bindgen like interface to build cuda kernels to interact with within Rust
-
thingvellir
a concurrent, shared-nothing abstraction that manages an assembly of things
-
actify
An intutive actor model with minimal boilerplate
-
nbio
Non-Blocking I/O
-
skedge
Ergonomic single-process job scheduling for Rust programs
-
whisk
fast lockless async channels
-
sharded_mutex
No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.
-
swap-buffer-queue
A buffering MPSC queue
-
urcu2
Safe API to liburcu
-
batch-aint-one
I got 99 problems, but a batch ain't one
-
minstant
A drop-in replacement for
std::time::Instant
that measures time with high performance and high accuracy powered by TSC -
oxidd-manager-pointer
Pointer-based manager implementation for OxiDD
-
fast-able
The world's martial arts are fast and unbreakable; 天下武功 唯快不破
-
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
-
tsuki-scheduler
light wight, composable and extensible scheduler for every runtime
-
session_log
session log library for Rust
-
atomptr
A safe, dependency-less abstraction for typed atomic smart pointers
-
atom_box
A safe idiomatic Rust implementation of Atomic Box using hazard pointers
-
gettid
Helper to get an integer ID for the current thread
-
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 -
orx-concurrent-iter
A thread-safe, ergonomic and lightweight concurrent iterator trait and efficient implementations
-
melodium
Dataflow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely
-
nexus-acto-rs
Actors
-
supply-chain-trust-example-crate-000025
More compact and efficient implementations of the standard synchronization primitives
-
crossbeam-utils
concurrent programming
-
spinning_top
spinlock crate based on the abstractions provided by
lock_api
-
loole
A safe async/sync multi-producer, multi-consumer channel
-
lever
Pillars for Transactional Systems and Data Grids
-
electrologica
High performance concurrent primitives for Rust
-
choir
Task Orchestration Framework
-
utils-atomics
Various atomic utils
-
liner_broker
Redis based message serverless broker
-
mintex
minimal mutex
-
crossfire
channels for async and threads
-
async-local
For using thread locals within an async context and across await points
-
readlock
A weird alternative to Arc<RwLock<T>>
-
desync
A hassle-free data type for asynchronous programming
-
portable_atomic_enum
An attribute to create an portable atomic wrapper around a C-style enum
-
command_history
managing command history in Rust applications
-
timeslice
periodic time slice scheduler
-
atomic-take
Atomically take a value out of a container once
-
protoflow-zeromq
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
omango
Concurrency collections
-
threadbound
Make any value Sync but only available on its original thread
-
may_actor
Actor library based on MAY
-
crossbeam-skiplist-mvcc
Support MVCC (Multiple Version Concurrent Control) for
crossbeam-skiplist
-
tokio-cadence
Tokio-based metric sinks for Cadence
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
someday
Lock-free MVCC primitive
-
ptr_cell
Thread-safe cell based on atomic pointers
-
rcron
cron job scheduling for rust
-
jod-thread
std::thread which joins on drop by default
-
pariter
Parallel iterator processing
-
atomic-shim
Atomic types for unsupported platforms
-
iterator_ilp
Iterator extensions for instruction-parallel reductions
-
cachemap2
A concurrent insert-only hashmap for caching values
-
amity
Concurrency algorithms
-
rw-cell
Write data to cell from anything place your application without copy, lock and reading in one place
-
atomic-wait
Cross-platform atomic wait and wake (aka futex) functionality
-
sovran-state
state management for Rust
-
cargo-steady-state
Code generator for steady_state projects based on a structured dot file
-
rose_bloom
A concurrent growing element size linked list with stable pointers
-
disruptor-rs
A high-performance ring buffer implementation of the LMAX Disruptor pattern
-
async-event
An efficient async condition variable for lock-free algorithms
-
thread-manager
A streamlined Rust library for efficient thread pooling and parallel job execution, designed for simplicity, flexibility, and performance
-
hzrd
Shared mutability containers based on hazard pointers
-
sovran-arc
Memory management swift-isms brought to Rust
-
tc-scalar
TinyChain's scalar value enum, including concurrently-resolvable op definitions and references
-
rs-store
Redux Store for Rust
-
p3-maybe-rayon
Feature-gated wrapper around rayon
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
file-per-thread-logger
A logging implementation that writes logs in one file per thread
-
atomic_enum
An attribute to create an atomic wrapper around a C-style enum
-
skedgy
asynchronous job scheduler
-
moga
A multi-objective genetic algorithm framework
-
yazi-scheduler
Yazi task scheduler
-
reord
Run your tests multi-threaded, but in a reproducible way
-
channel
Rust advanced queue library
-
semka
Semaphore implementation
-
benjamin_batchly
Low latency batching tool. Bundle lots of single concurrent operations into sequential batches of work.
-
atomic_once_cell
Thread-safe and lock-free OnceCell and Lazy
-
rucron
Job Scheduling Crate
-
txn_lock
support transactional versioning
-
parking
Thread parking and unparking
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
shipyard_scenegraph
Scenegraph for Entity Component System
-
balter
A load/stress testing framework
-
fluxion
actor framework written in rust and designed for distributed systems
-
happylock
Free deadlock prevention
-
async-stm
Asynchronous Software Transactional Memory
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
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
-
local-sync
Non-threadsafe data structure for async usage
-
tlrepo
Thread-local git2::Repository, shareable across threads
-
node-replication
An operation-log based approach that transform single-threaded data structures into concurrent, replicated structures
-
chili
low-overhead parallelization library
-
tatl
in-process alerting
-
armc
that facilitates Mutex access to variables
-
namaste
-
sharded-thread
Expirement for now
-
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.
-
evtcall
Rust Event Driven Framework
-
lockfree
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
amadeus
Harmonious distributed data processing & analysis in Rust. parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common crawl
-
sids
sample actor-model scheme providing abstraction over actor types and messages that can be sent across threads
-
rtic-monotonic
Core abstractions of the Real-Time Interrupt-driven Concurrency Monotonic timers
-
rusturnate
A sync or async mutex, with or without timeouts
-
lock_ext
Extensions to std::sync::Mutex
-
rayon-progress-bar
work-stealing parallelism for Rust
-
atomic-interval
A tiny implementation of an atomic timer
-
parallel-processor
Framework to manage asynchronous execution of multiple compute units communicating using messages
-
async-atomic
Atomics which can be subscribed to and asynchronously notify when updated
-
freezebox
deref'able lazy-initialized container
-
easy-threadpool
A relatively simple thread pool which you can send jobs to
-
roboplc
Framework for PLCs and real-time micro-services
-
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…
-
active_standby
A concurrency primitive for high concurrency reads
-
maybe-rayon
Either acts as rayon or creates a single-threaded facade
-
tokio-cron
cron scheduler for tokio
-
anchor-chain
A statically typed async framework for building LLM-based applications
-
pi_atom
The global thread safe atomic string pool reduces the memory occupation of the same string and is also used for HashMap keys
-
rearch-effects
Re-imagined approach to application design and architecture
-
kueue
A robust, user-level, work-stealing, distributed task scheduler
-
turbo-metrics
Toolkit to compute quality metrics fast using a GPU
-
mpsc_requests
mpsc channels but with a response
-
mpvipc
A small library which provides bindings to control existing mpv instances through sockets
-
television-previewers
The revolution will be televised
-
treiber_stack
A lockless, thread-safe, atomic linked-list
-
congestion-limiter
Dynamic congestion-based concurrency limits for controlling backpressure
-
mongo-lock-async
Distributed mutex locks with MongoDB
-
ebr
epoch-based reclamation with low cacheline ping-pong
-
batch-processing
A batch library for processing a list of items in parallel
-
k-lock
A fast mutex for short critical sections
-
kube-leader-election
Leader election implementations for Kubernetes workloads
-
salsa
A generic framework for on-demand, incrementalized computation (experimental)
-
atomic-file-install
For atomically installing a file or a symlink
-
synchronoise
Synchronization primitives that build upon the standard library
-
redlock
distributed locking mechanism built on top of Redis
-
pubserve
generic observer trait
-
concurrent-slotmap
A lock-free concurrent slotmap
-
split_channel
stream-of-messages abstraction with split send/recv channels
-
keepcalm
shared types for multi-threaded programs
-
restd
A re-implementation of various std features
-
thread_local_collect
Supports the collection and aggregation of thread-local data across threads
-
rust-lockless-slotmap
A (mostly) lockless slotmap implementation in Rust
-
parallel_operations
perform binary operations in parallel using threads
-
init-once
Concurrent, non-blocking lazy initialization of values
-
throttle-client
Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.
-
tc-transact
Traits and locking utilities for a TinyChain transaction
-
antidote
Poison-free versions of the standard library Mutex and RwLock types
-
mpmc-async
A multi-producer, multi-consumer async channel with reservations
-
fasb
faceted answer set browser
-
windows-key-listener
Listen to arbitrary key chords on Windows
-
papaya
A fast and ergonomic concurrent hash-table for read-heavy workloads
-
nblock
Non-Blocking Runtime
-
pausable_clock
A source of time information that can be paused and resumed
-
asc
Atomic Strong Count
-
par-iter-sync
Parallel Iterator With Sequential Output
-
lfchring
Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication
-
dynamodb_lock
Distributed lock backed by Dynamodb
-
td_rthreadpool
thread wrapper for Rust
-
permit
A struct for cancelling operations
-
pargraph
Operator based parallel graph processing
-
folklore
A lock-free concurrent hash map
-
yash-executor
single-threaded concurrent task executor
-
evident
Pub/Sub library using IDs to identify events
-
hydra-dashmap
A fork of dashmap for the hydra framework
-
spools
Content scraping library for Instagram's Threads
-
command-executor
Command Executor thread pool
-
atomicell
Multi-threaded RefCell on atomics
-
incr
fast and self-contained data structures for checking whether a new value is greater than the previous maximum
-
thread_io
performing I/O in background thread
-
employees
A small runtime that hides all the boilerplate when using threads
-
openshmem-rs
Wrappers for the OpenSHMEM API
-
multithreading
in Rust
-
rust_kits
kits
-
amfiteatr_classic
some classic game theory problems to research on
-
asyncgit
allow using git2 in a asynchronous context
-
clhlock
Craig and, indenpendently, Magnussen, Landin, and Hagersten queue lock for mutual exclusion, referred to as CLH lock
-
datacake
A batteries included framework for building fault-tolerance distributed data systems
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
oxidd-rules-mtbdd
Multi-terminal decision diagrams (MTBDDs) for OxiDD
-
granite_reckoner
aggregator enabling basic statistical operations on Vec<T> in the specified number of threads. Works for all Rust's built-in numeric types.
-
parcheck
Test permutations of concurrent scenarios
-
rayon-scan
A parallel prefix scan function for ParallelIterator
-
synchronized
Convenient and simple macro for code synchronization in multithreading
-
simple-semaphore
🔐 A lightweight implementation of a Semaphore in Rust
-
pacwrap-agent
Executable agent for conducting containerized transactions
-
with_daemon
An async client-daemon abstraction framework
-
threadcell
A cell whose value can only be accessed by a owning thread
-
leaklist
concurrent, lock-free, singly-linked list
-
mea
A runtime-agnostic library providing essential synchronization primitives for asynchronous Rust programming
-
operational-transform
Operational Transformation
-
par
Session types, as an implementation of linear logic with MIX
-
topograph
A miniscule thread pool and toposort scheduler
-
stuck
Multi-threading scheduled task facility building on cooperative stackful coroutine
-
fibers
execute a number of lightweight asynchronous tasks (a.k.a, fibers) based on futures and mio
-
hylarana-common
A cross-platform screen casting library implemented by Rust
-
bztree
BzTree implementation for Rust
-
ballista-executor
Ballista Distributed Compute - Executor
-
circ
Efficient referenced counted pointers for non-blocking concurrency
-
atomicbox
Safe atomic pointers to boxed data
-
irondash_run_loop
Consistent, platform-independent interface to system run loop
-
crossbeam-skiplist-pr1132
A concurrent skip list
-
pi_share
rc, arc, lock, atomic
-
slacktor
extremely fast, bare-bones, low-overhead, supervisorless, no-std actor library
-
left-right-cell
A cell with lock-free concurrent read access
-
mogul
Agnosticly helps to manage concurrent versions of things
-
chute
Lockfree mpmc/spmc broadcast queue
-
sharded_queue
ShardedQueue is currently the fastest concurrent collection which can be used under highest concurrency and load
-
tracing-mutex
Ensure deadlock-free mutexes by allocating in order, or else
-
virtual-buffer
A cross-platform library for dealing with buffers backed by raw virtual memory
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
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
-
bastion
Fault-tolerant Runtime for Rust applications
-
EMCompute
fast , simple and cross-platform parallel computing library
-
cutools
-
pinned-mutex
Mutex wrappers with structural pinning
-
kontroli
Type checking for the lambda-Pi calculus modulo rewriting
-
dag-scheduler
a scheduler of dag computation graph
-
poll-channel
Poll on channel
-
direct_ring_buffer
A high-performance, lock-free ring buffer for single-producer, single-consumer scenarios
-
wikiwho
Fast Rust reimplementation of the WikiWho algorithm for fine-grained authorship attribution on large datasets. Optimized for easy integration in multi-threaded applications.
-
reactivate
Thread Safe Reactive Data Structure. Made with ❤️ for 🦀
-
navvy
MPSC Channel broker allowing channels of different types to be stored in a single data structure
-
parseq
Parallel sequential iterator
-
stdworld
signal-safe std replacement
-
hala-sync
Hala synchronous primitive
-
relaxed
Wrappers around Atomics that always use
Ordering::Relaxed
-
zallocator
Amortizes the cost of small allocations by allocating memory in bigger chunks
-
boomerang
Deterministic Middleware for Robotics
-
print_queues
A print queues that can be add from different thread and print on main thread
-
sharded-vec-writer
Write parts of a Vec from different threads
-
putex
process mutex
-
async_nursery
Primitive for structured concurrency
-
ump
Micro message passing library for threads/tasks communication
-
arena64
A concurrent arena providing mutually exclusive access over guarded indexes
-
task_simple
Execute functions in the background, both on desktop and web
-
nexus-actor-utils-rs
Nexus Actor
-
blocking-threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
seqlock
A reader-writer lock that provides extremely fast read access without starving writers
-
may_waiter
coroutine communication blocker
-
smolscale2
hitdns fork of original smolscale
-
crossbeam-deque
Concurrent work-stealing deque
-
atomic-maybe-uninit
Atomic operations on potentially uninitialized integers
-
mtlog-progress
A progress bar implementation working gracefully with mtlog's logger
-
fork-map
running operations in a child process spawned by
fork()
-
egui_inbox
send messages to egui views from async functions, callbacks, etc. without having to use interior mutability.
-
omango-futex
Futex for Rust
-
blaze-rs
A Rustified OpenCL Experience
-
protoflow
implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
cbloom
Concurrent implementation of Bloom filters
-
grizzly_scheduler
A scheduler for running async tasks using cron expressions. It is built on top of tokio. Tasks can be parallel or sequential. Fuzzy random offset can be added to the cron expression.
-
snowflake-rs-impl
Twitter's Snowflake ID generation algorithm
-
snowdon
A lightweight thread-safe snowflake ID implementation for Rust
-
caos
Concurrent Append Only Segment-list
-
sinner
Easy cross-thread resource sharing for Rust!
-
mutex_trait2
Generic mutex trait
-
spry
Resilient, self-healing async process hierarchies in the style of Erlang/OTP
-
halt
functionality for pausing, stopping, and resuming iterators, readers, and writers
-
persistent-scheduler
high-performance task scheduling system developed in Rust using Tokio. This system supports task persistence, repeatable tasks, Cron-based scheduling, and one-time tasks, ensuring reliability…
-
mvsync
A standalone async and worker thread library, with expandable traits and command buffers
-
commonware-runtime
Execute asynchronous tasks with a configurable scheduler
-
periodically
running tasks on a schedule
-
fast-logger
Fast logger for Rust
-
rtic-syntax
The Real-Time Interrupt-driven Concurrency (RTIC) meta language
-
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
-
sigq
Queue that signals waiting consumers about node availability
-
atomic-waitgroup
A waitgroup implementation supports async with advanced features
-
signals2
A thread-safe signal/slot library inspired by boost::signals2
-
interaction-calculus
A parallel model of computation
-
rsevents
Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores
-
per-thread-mutex
Synchronization lock designed for wrapping thread-unsafe C libraries
-
pikav
that help you send event to client with topic subscription
-
may_queue
May's internal queue library
-
cuneiform-fields
Field level [no_std] cache optimizations for Rust
-
ordered-parallel-iterator
Performs tasks in parallel returning completed tasks in order of appearance
-
flashmap
A lock-free eventually consistent concurrent hash map
-
squeue
sized queue
-
orx-concurrent-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance concurrent collection
-
stronghold-stm
Software transactional memory
-
hopper
an unbounded mpsc with bounded memory
-
ora-worker
Part of the Ora scheduler framework
-
swimming
Dive into Efficiency with Swimming: A High-Performance, No-Nonsense Connection Pool
-
omp
Rust SDK for developing open.mp gamemodes
-
tari_shutdown
A convenient shutdown signal
-
open-coroutine-hook
The syscall hook for open-coroutine
-
mlua-kafka
A Rust-native implementation of lua-kafka for mlua
-
sea-streamer-examples
🌊 The stream processing toolkit for Rust
-
nolock
A collection of Lock-Free Datastructures
-
local_thread
A local thread management library for Rust. No more 'static functions in order to start threads!
-
sparking-lot-core
parking on addresses
-
rusty-cron-scheduler
scheduler that executes function pointers following a cron string
-
mq
Message Queue
-
pi_arr
lock-free & auto-expansion array
-
concurrent-initializer
concurrent initializer to ensure initialization only once per key
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
supply-chain-trust-example-crate-000041
More compact and efficient implementations of the standard synchronization primitives
-
single_value_channel
Concurrent single-value update and receive channel
-
batch-lock
A lock manager with batch-lock support
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
lock_free_hashtable
Lock-free (almost) insertion only hashtable
-
two_phase_channel
A safe synchronisation-free parallel communication channel by statically forbidding conflicting accesses
-
vin
An ergonomic actor framework
-
arc-cell
Helper for a simple Cell-like object containing Arc/Weak
-
atomicring
AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer
-
session_types
session types in Rust
-
stm
Software transactional memory. Allows composable atomic operations.
-
rusty_junctions
Join Pattern implementation in Rust
-
concur_demo
concur multi thread samples
-
lending_thread_pool
A thread pool where workers can lend their data to their tasks
-
cron_tab
A cron job library for Rust
-
flo_stream
Pubsub and related streams for Rust futures
-
goko
A lock-free, eventually consistent, concurrent covertree
-
sea-streamer-socket
🌊 SeaStreamer backend-agnostic Socket API
-
atomic-destructor
Atomic destructor for multi-threaded env
-
left-right
A concurrency primitive for high concurrency reads over a single-writer data structure
-
leapfrog
A fast, lock-free concurrent hash map
-
concurrent_lru
A concurrent LRU cache
-
con-art-rust
ART-OLC concurrent adaptive radix tree
-
wakerset
no_std, no_alloc storage of Wakers embedded in the Future type
-
terminate-thread
terminatable thread implemented with pthread
-
bicoro
Bidirectional co-routine data structures
-
atomic-arena
Generational arena allows reserving keys from other threads
-
executors
A collection of high-performance task executors
-
moro
Experimental structured concurrency support for async Rust (similar to trio's nurseries)
-
par-dfs
Parallel, serial, and async dfs and bfs traversal
-
syncthreads
Safe thread synchronization
-
vigil
liveness checking watchdog for detecting deadlocks/livelocks/starvation etc
-
yaambo
concurrent skip lists
-
mpsc
mpsc channel
-
renege
Tracking cache validity using fast concurrent invalidation propogation
-
axka-rcu
A reference-counted read-copy-update (RCU) primitive used for protecting shared data
-
crius
hystrix-like circuit breaker
-
watch
A synchronous message passing channel that only retains the most recent value
-
mcl_sched
installable wrapper for the MCL (Minos Compute Library) Scheduler 'mcl_sched'
-
sortlock
providing ordered locking
-
mt-debug-counters
support high performance debug counters for heavy multithreaded applications
-
env-lock
Set and lock environment variables for tests
-
atomx
Thread safe data structures based on atomic data types
-
tlid
Thread Local ID generator by predefined range without atomics/locks/random/time
-
re_smart_channel
A channel that keeps track of latency and queue length
-
either-slot
An atomic slot whose senders can either place their value into the slot, or retrive all the data from the slot
-
rusty_chain
abstracts over functional processing units called
chain links
. Each link in the chain is meant to be independent, immutable, idempotent, and highly testable. -
simple-left-right
Lockfree, realtime safe and copy-free Synchronisation
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
thread-counter
way of efficiently keeping track of active threads and waiting for them to exit
-
spinout
A thread-safe clonable and mutable smart-pointer akin to
Arc<Mutex<T>>
, using spin-lock instead of system futex -
dpc-pariter
Parallel iterator processing
-
context
Cooperative multitasking for Rust using Boost.Context
-
ppl
A structured parallel programming library for Rust
-
bi
-
tagged-rendezvous
Rendezvous hashing with support for tag-based exclusions
-
sentinel-core
The flow sentinel of your microservices
-
threadalone
Make any value Send + Sync but only available on its original thread. Don't use on multi-threaded environments!
-
rly
Run shell commands concurrently with ease. Currently only a CLI tool.
-
disrustor
This project is a port of the LMAX Disruptor to Rust
-
threadling
Threads as traits
-
renoir
Network of Operators In Rust
-
hala-lockfree
Some lockfree structure for rust
-
zolegus
-
supply-chain-trust-example-crate-000051
Tools for concurrent programming
-
statman
Stat Manager
-
workpool
Distribute work to a set of threads and wait for completion
-
pulse
async wake signals
-
adaptive-barrier
Barrier with adaptable number of thread subsciptions
-
async-pipes
building concurrent data processing pipelines
-
sync_2
A little crate providing a Rust implemented Mutex and RwLock
-
blinkcast
Fast, bounded, multiple-producer, multiple-consumer, lossy, broadcast channel
-
mwcas
Multi-word CAS primitive
-
rayon-wasm
work-stealing parallelism for Rust
-
wasm_sync
Synchronization primitives for both web and native
-
arrayfire_fork
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…
-
uf_rush
A lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure
-
asparit
Async Parallel Iterators for Rust
-
cond_sync
Hides the boilerplate code needed with std::sync::Condvar
-
threadmap
WIP
-
carpet
A thread-safe, fully-parallel directed graph
-
peace-lock
A zero-cost abstraction lock that helps check contention free algorithms
-
redbus
A high-performance global message bus for concurrent applications
-
asar-snes
Rust bindings for Asar (https://github.com/RPGHacker/asar)
-
datacake-crdt
A conflict free replicated datatype based on a hybrid logical clock implementation for building eventually consistent data stores
-
dropout
Drop your objects out of main thread
-
timedmap
A hash map with expiring key-value pairs
-
protex
(Process Mutex) concurrency in process level
-
readfish-tools
Tools for analysing adaptive sampling data
-
ocl-interop
Creates an OpenCL Context with OpenGL Interop enabled
-
geph-nat
concurrent NAT thingy used throughout Geph
-
async-datachannel
Async Wrapper for datachannel
-
cooptex
Deadlock free Mutexes
-
async-cpupool
async threadpool for CPU-bound tasks
-
round_mult
A tiny library to round a number up or down to a multiplier
-
fast-counter
A sharded concurrent counter
-
latches
A downward counter (CountDownLatch) which can be used to synchronize threads or coordinate tasks
-
ligmars
Safe bindings to the LGMP C library
-
simpl_actor
tokio actors
-
ns3-parallel
A Multitask Parallel Concurrent Executor for ns-3 (network simulator)
-
yaks
Minimalistic framework for automatic multithreading of hecs via rayon
-
essential-lock
A minimal crate containing Essential's locking method that is safe to use in async code
-
norpc
Framework for in-process microservices
-
xloc
A fast, multi-threaded line counting utility written in Rust
-
acto
light-weight Actor library for Rust
-
sync-unsafe-cell
A backport of the SyncUnsafeCell standard library type for use in older Rust versions
-
crusty
Fast && scalable Broad Web Crawler developed on top of crusty-core
-
hey_listen
An event-dispatcher-collection offering async, sync, parallel, and prioritised solutions!
-
nexus-actor-remote-rs
Remote library for Nexus Actor
-
tokio-condvar
A Condition Variable for Tokio Applications
-
gpgpu
WIP GPGPU framework built on top of wgpu
-
flue
An efficient and secure actor runtime library
-
zkstate
Share a struct across multiple instances of an application using zookeeper
-
backdrop_arc
Arc which will drop its large or complex contents in the background with Backdrop! (later, on another thread, or both! Fully customizable! Tokio supported!)
-
mongo_sync
instant coding answers via the command line(just like howdoi)
-
parsli
Parallel status lines for Rust
-
ordered-channel
A channel that always receives messages in the correct order, even if they were sent out of order
-
swctx
One-shot channel with some special semantics
-
blackhole
...to throw your threads into
-
big_data
Safe Rust code for creating Erlang NIF to store big data
-
stakker_log
Logging support for Stakker
-
threadpool-executor
A threadpool executor
-
blocking_semaphore
performant blocking semaphore
-
easy-parallel
Run closures in parallel
-
hammer-cli
Hammer is a no-config cli tool for running concurrent tasks with monorepo support
-
shared-expiry-get
concurrent async get with expiration for Rust
-
lock_freedom
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
with_lock
Deadlock freedom
-
sas
Salty-and-Sweet one-line Rust Runtime Performance Optimization Library
-
talos_messenger_actions
Messenger actions for Talos
-
godwit-daemon
A daemon runner for GodWit
-
currant
spawn concurrent shell processes in rust
-
atomic-counter
Atomic (thread-safe) counters for Rust
-
cache-padded
Prevent false sharing by padding and aligning to the length of a cache line
-
hyperbridge
Fast multi-producer multi-consumer channel with async support
-
apalis-core
Core for apalis: simple, extensible multithreaded background processing for Rust
-
ampsc
async multi-producer single-consumer channel
-
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
-
anylock
Polymorphic Locks
-
evlru
An eventually consistent LRU designed for lock-free concurrent reads
-
irox-threading
Blocking and Asynchronous Threading Tools
-
surrealkv
A low-level, versioned, embedded, ACID-compliant, key-value database for Rust
-
supply-chain-trust-example-crate-000089
Spin-based synchronization primitives
-
pcat
A dead-lock free parallel cat implementation
-
flowync
multithreading a/synchronization
-
arcow
Atomically Reference-counted Copy-On-Write shared pointer
-
unlock
Instrumented synchronization primitives helping you to unlock performance issues
-
skipchannel
skipchannels allow to communicate between threads, but always skip to the last sent value
-
dremoc-sync
Synchronization utilities
-
priority
A thread/task priority type
-
real-time
Safely share data with a real-time thread
-
onetime
(aka. oneshot) async spsc channel
-
ipmpsc
Inter-process Multiple Producer, Single Consumer Channels
-
spmc
channel
-
rs-fsrs
Rust-based Scheduler for FSRS
-
ductile
A channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface
-
seda_bus
A Staged Event-Driven Architectural message bus
-
io_partition
allowing to use just a part of a Read + Seek object
-
hyaline-smr
Garbage Collector(Hyaline- Safe Memory Reclaimation) for lock free data structures
-
rcu_128
RCU (Read-Copy-Update) implementation for platforms supporting atomic 128-bit operations
-
nysa
A bus for passing messages around between independent subsystems of an application
-
tcb
A middleware service for delivering messages in a causal order
-
rcurs
An oxidized RCU implementation
-
global_counter
Global, thread-safe counters
-
job_abstrs
Abstractions for event-driven jobs
-
threadstack
A more ergonomic and more flexible form of thread local storage
-
mpi-fork-fnsp
Message Passing Interface bindings for Rust (FORK)
-
read-write-store
A concurrent, unordered collection for Rust, where each element has an internally generated ID and a read-write lock
-
cht
Lockfree resizeable concurrent hash table
-
tourniquet-tonic
Async native round-robin manager for remote services. Tonic integration.
-
rust-debugging-locks
debugging locks in Rust
-
tokio-etcd-lock
WIP
-
idle
Collection of idle strategies to be used by thread(s) when they have no work to perform
-
seckoo
A concurrent Cuckoo Hash Table
-
node-workers
A pool of long-lived nodejs workers
-
ulock-sys
Rust bindings for Darwin's (e.g. macOS, iOS, ...) not-entirely-public ulock API, which provides futex-like functionality.
-
mutex
An abstraction over closure-based mutexes
-
kademlia-dht
Kademlia DHT
-
cortexm-threads
context-switching on ARM Cortex-M ( 0, 0+, 3, 4, 4F ) micro-processors
-
maxwell-utils
Maxwell utils implementation for Rust
-
pime
Rust Python Integration Made Easy
-
dager
create and execute a graph of nodes
-
wrrm
Write-rarely-read-many wrapper
-
usync
fast, drop-in, synchronization primitives
-
takecell
A cell type which value can only be taken once
-
arl
A rate limiter to be used with tokio
-
rusty-jokes
A humorous Rust crate that brings joy and entertainment to Rust programmers with features like Laughable Lifetimes, Comedic Concurrency, and Punchline Pointers
-
potential
Borrowing for futures - Potential enables interior mutation using mutex and asynchronous borrowing (leasing) through a oneshot channel
-
hytra
Datastructure for fast multi-threaded updates
-
unknownrori-simple-thread-pool
A lighweight thread pool for networking and other stuff
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
jobsys
Lockless Work Stealing Job System
-
melodium-common
Common Mélodium elements and traits
-
lockfree-ringbuffer
A lock-free ring buffer implementation in Rust
-
swap-arc
A swappable Arc
-
priomutex
A mutex where waiting threads specify a priority
-
fragile
wrapper types for sending non-send values to other threads
-
gmtx
Mutex that grant exclusive access to a group of members
-
lockless
Composable, lock-free, allocation-light data structures
-
coarsetime
Time and duration crate optimized for speed
-
pipelines
constructing multi-threaded pipelines of execution
-
greenie
Green threads and coroutines in stable Rust
-
television-utils
The revolution will be televised
-
dycovec
A dynamically-allocated, concurrent vector
-
exclusion-set
a lock-free concurrent set
-
atomic_sibling_counter
A shared counter that allows parallel threads/tasks to check how many siblings they have. The counter is atomic and threads/tasks are not synchronized or coupled in any way.
-
base-threadpool
minimalistic threadpool implementation
-
chashmap-async
Concurrent async hash maps with key-scoped locking
-
async_ach-notify
Async Atomic Channel
-
redsync
Redlock for distributed locks with Redis
-
interval-task
Repeatedly execute a
Task
with fixed time delay. more thansetInterval
-
promise_out
promiseOut version for rust
-
rgraph
A task graph library
-
mlsp
small library for smart pointers that use both thread local and global atomic counters
-
channel-receiver
Channel Receiver
-
native-timer
Timer library which uses OS timer capabilities
-
diplomatic-bag
A wrapper type that allows you to send
!Send
types to different threads -
aramid
Synthetic fibers
-
refcell-lock-api
A single-threaded implementation of lock_api for RefCell, to alllow abstracting between single-threaded & multi-threaded code
-
rs_lockfree
a lock-Free lib based on practical Hazard Pointers algorithm
-
supermon
A set of utilities for coordinating watchers, middleware, and consumers via channels
-
managed-thread
Real fearless concurrency! Spawn threads that will be automatically destroyed when no longer needed
-
mutex_logger
logger that usess mutex for thread safty
-
ctx-thread
Cooperative, scoped threads based on crossbeam and golang’s context package
-
autoincrement
wrapper for different purposes
-
mtlog
Multi-threaded logger with support for log files
-
concread
Concurrently Readable Data-Structures for Rust
-
entropy-ecs
一个虚拟世界
-
rtfm-syntax
The Real Time for The Masses (RTFM) meta language
-
llq
Wait-free SPSC linked-list queue with individually reusable nodes
-
conquer-util
concurrent and lock-free programming
-
work-queue
A concurrent work-stealing queue for building schedulers
-
rider
bounded executor for tokio; limit the count of tasks running 🚦
-
cell-family
Cheap cells accessed through unique owners
-
thfmr-protocol
Internal control protocol encoding and decoding library for the TouHou.FM Radio project
-
swimming-pool
threadpool for running a number of jobs on a fixed number of threads
-
dci
DCI-Closed, a frequent closed itemset mining algorithm, implemented in Rust
-
revenq
A concurrent, revision-based event queue implementation
-
multithread
API for data-parallel tasks, rayon-lite
-
bursty
Test support for exarcebating contention in multi-threaded code
-
simt
compute support for rust
-
async-sema
Async semaphore library
-
toktor
A small tokio-based Actor framework
-
semaphore-key
control concurrent thread access by key using a shared semaphore
-
lightproc
Lightweight process abstraction for Rust
-
fibril
implementing distributed systems with commmunicating fibers
-
peril
Fast and safe Hazard pointers for Rust
-
proglog
Thread safe progress logging
-
concurrency-demo-benchmarks
A small utility to benchmark different approaches for building concurrent applications
-
or_poisoned
Unwrap std lock guards in a semantic way
-
rush_core
The rules engine is based on the rete algorithm
-
locklessness
Composable, lock-free, allocation-light data structures
-
protoflow-blocks
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
rt-history
An RT-safe history log with error checking
-
threadsafe_zmq
Threadsafe zeromq
-
win-events
A poor attempt to implement WaitForMultipleObjects and the ManualReset, AutoReset and Pulse types
-
threatpool
thread pool
-
refcapsule
Safely send references to other threads
-
init_guard
A Synchronization Primitive for guarding against double initialization
-
kafka_json_processor_core
The core logic for your Kafka processor, part of kafka-json-processor project
-
async-map-reduce
Fast map-reduce based on threading
-
sea-streamer-file
🌊 SeaStreamer File Backend
-
mpmc
copy-pasted from old rust stdlib
-
shared-local-state
shared local state registry for use in EBR, IO, etc
-
libblobd-direct
blobd, direct variant
-
distribuidos_sync
Sync common utils using standard library
-
ora
A scheduler framework
-
slb
Sharded load balancing text-streaming Unix tool
-
cpq
A Concurrent Priority Queue implemented in Safe Rust
-
little_raft
The lightest distributed consensus library. Run your own replicated state machine!
-
secc
Implements a Skip-Enabled Concurrent Channel (SECC) for Rust
-
tucan
fast, and multithreaded interner with loose type requirement
-
fan
Simplifies fanning-out (and eventually -in) with channels
-
parallel-iterator
Parallelize any iterator with ease!
-
fast-async-mutex
lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)
-
thread_timer
cancelable timer with no external dependencies
-
mycorrh
fast concurrent messaging system for Rust
-
no-std-async
Async synchronization primitives for #[no_std] 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.
-
persistent_stack
Concurrent persistent stack
-
elysees
A fork of triomphe, now with more pointer trickery
-
governor
A rate-limiting implementation in Rust
-
simd-itertools
SIMD-accelerated alternatives for common operations like contains, max, find etc
-
objectpool
lock-free object pool, support no_std
-
dynamic_ocl
Dynamically-loaded OpenCL bindings
-
deploy-common
Common components for the
deploy
andfabric
crates -
lockpool
offers a pool of locks where individual locks can be locked/unlocked by key
-
cogo
Rust Coroutine Library like go
-
dfmutex
Deadlock-free Mutex locks
-
orx-concurrent-option
ConcurrentOption is a lock-free concurrent read and write option type
-
navactor
A cli tool for creating and updating actors from piped input
-
lock-free-static
Lock-free static variables
-
xarc
xarc
provides atomically swappable atomically refcounted smart pointers as a safer building block for lockfree algorithms than raw atomic pointers.Xarc
is comparable toArc
but… -
sync_splitter
Safely split a mutable slice in multiple threads at the same time
-
atomicbox_nostd
Fork of the atomicbox library that works in no_std contexts
-
chex
Global exit signal library
-
nemo
Session types for asynchronous networking
-
thinkofname/think_ecs
Source code of the game Univercity: https://store.steampowered.com/app/808160/UniverCity/
-
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.
-
stewart
A minimalist, high-performance, and non-exclusive actor system
-
yanoo
Lock-free mpmc broadcast channel
-
rearch-tokio
Re-imagined approach to application design and architecture
-
linux-rtic
A Real-Time Interrupt-driven Concurrency (RTIC) implementation for Linux
-
locktick
Automated lock accounting & profiling
-
fenic
test concurrent code
-
rtrb-basedrop
A fork of the
rtrb
crate that uses basedrop’s Shared pointer in place of Arc -
lock_pool
Robust, efficient, high performance, asynchronous object pooling
-
parallel_reader
reading from a file (or any
Read
stream) and processing it by chunks, in parallel -
arrow-rayon
Use parallel iterators for Apache Arrow with rayon
-
synqueue
Internally synchronized (MPMC) queue
-
thread-control
control threads' execution/status
-
atomicslice
thread-safe shared slices that are just about as fast as possible to read while also being writable
-
microlock
waiting: Small locks and other timing things!
-
is_main_thread
A simply tool to check if current thread is the main one
-
gosh-remote
Distributed parallel computing over multiple nodes
-
object-space
An object store library for highly concurrent program written in Rust
-
simdvec
Vectors, but with the operational speedup of SIMD!
-
swapper
Swap ownership between threads
-
foco
Topic-based strongly typed pubsub for no_std rust
-
humthreads
Threads for humans
-
r3bl_core
Helper crate for r3bl_tui and r3bl_tuify crates. Used by workspace in https://github.com/r3bl-org/r3bl-open-core
-
despero-hecs-schedule
shedulable systems and parallel execution for hecs
-
discord-termview
Spawn multiple concurrent unix terminals in Discord
-
slottle
A throttle pool library designed for thread-based concurrency
-
highroller
high-level rolling index that is thread-safe and guarantees cheap runtime-unique IDs
-
grandma
A lock-free, eventually consistent, concurrent covertree
-
spinning
Mutexes and SIX locks implemented by spinning
-
sleepfast
Sleep for very small amounts of time quickly
-
runloop
Cancelable non-blocking polling threads (with optional timeouts)
-
locktree
Experimental compiler-checked deadlock-freedom
-
scrummage
Fight over OS process prioritisation
-
skippy-rs
A set of lock free, thread safe, and fast data structures implemented via a Skip List
-
voxel-tiler-core
Convert point clouds to voxel data
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
swap_channel
A safe lock-free parallel communication channel based on mem::swap
-
aide-de-camp
backend agnostic delayed job queue
-
sync-extra
Convenience functions to Mutex and RwLock
-
evolution
Efficiently evolve your old fixed-length data files into modern file formats
-
rayon-par-bridge
Process Rayon parallel processing with a traditional sequential Iterator
-
lofi
Low Overhead Fibers
-
stop-thread
Various ways of stopping threads on various platforms, without requiring the thread to poll
-
talaria
A high performance, cyclic message passing library
-
kcas
A lock-free, allocation-free multi-word compare-and-swap library
-
crosstalk
An extremely lightweight, topic-based, cross-thread, in-memory communication library
-
queued-task
concurrent queue task processing
-
ev_slotmap
A lock-free, eventually consistent, concurrent slot map
-
tokio-bichannel
Bidirectional tokio::sync::mpsc channel
-
mscheduler
Use mongodb to schedule task running
-
ballista-scheduler
Ballista Distributed Compute - Scheduler
-
PRUEBA
Colas tarea
-
piz
piz (a Parallel Implementation of Zip) is a ZIP archive reader designed to concurrently decompress files using a simple API
-
rusty_hausdorff
A parallel implementation of the directed Hausdorff distance
-
lazy_ref
Implements a non-blocking synchronization primitive for lazy-initialized immutable references
-
hwlocality
Idiomatic Rust bindings for the hwloc hardware locality library
-
rayon_logs
Traces for the rayon work-stealing library
-
tc-tensor
TinyChain's Tensor collection type
-
killable_thread
A wrapper for thread that allows it to be easily stopped cooperatively
-
concurrent-round-robin
A concurrent wrr implementation for rust
-
sever
Coerce hardlinks into new files
-
stronghold-rlu
Read-Log-Update software transactional memory like synchronization mechanism
-
status_executor
Run your work on some context (thread) and get status info back
-
stoppable_thread
A wrapper for thread that allows it to be easily stopped cooperatively
-
contrie
Concurrent map and set
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
uchan
Multi-producer single-consumer channel for message passing
-
atomicdouble
128-bit atomics for generic type
-
rewrk
HTTP benchmarking tool
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
cloudi
API
-
lazy_id
A thread-safe lazily-initialized ID
-
async-liveliness-monitor
A Liveliness Monitor for your Asynchronous Runtimes
-
libmcl-sys
This system crate provides Rust language bindings to the Minos Compute Library (MCL)
-
rayon_iter_concurrent_limit
Limit the concurrency of an individual rayon parallel iterator method with a convenient macro
-
bustle
Benchmarking harness for concurrent key-value collections
-
reactor_rs
reactor-rust is an implementation of the Reactive-Streams
-
queuingtask
queueingtask is a library for running different threads in order in Rust
-
sesh
deadlock-free session-typed communication
-
infinitree
Embedded, encrypted database with tiered cache
-
dekker
Dekker's algorithm for mutual exclusion
-
ringbuf-basedrop
A fork of the
ringbuf
crate that uses basedrop’s Shared pointer in place of Arc -
bi_channel
Manage bidirectional mpsc channels more conveniently
-
piper
Async pipes, channels, mutexes, and more
-
run-them
A CLI to launch a single command with many workers, serializing the output
-
cnr
An operation-log based approach for data replication
-
shardize
proc macro that generates code to create a sharded form of an existing container
-
range-lock
Range lock for std::vec::Vec
-
inert
lets you use non-Sync values in a Sync way
-
shared_cell
Interior mutability between concurrent tasks on the same thread
-
mp2c
A multi producer multi polling consumer library that enables multiple producers to send messages to multiple consumers completely asynchronously
-
crossbeam-epoch
Epoch-based garbage collection
-
specs-static
extension for Specs that adds custom ids
-
ringbuf-blocking
Blocking version of ringbuf
-
bmrng
async MPSC request-response channel for Tokio
-
xrm
Cross Runtime Manager
-
sanitizers
Interfaces and FFI bindings for the sanitizers interfaces
-
sublock
Variants of RwLock/RefCell that support sublocks, opened for reading if the main
RwLock
is opened for reading, opened for writing if the mainRwLock
is opened for writing -
update_channel
A channel for single updatable values
-
amfiteatr_proc_macro
Procedural macro crate for amfiteatr_* crates
-
striped-lock
Striped Lock for Rust
-
para
A dataflow/pipeline parallelization framework
-
rayon_croissant
<lqd> bikeshedding the name: something that is mapped folded and collected, a 🥐
-
open-coroutine-iouring
The io_uring support for open-coroutine
-
channel-sender
Channel Sender
-
spliter
way to implement Rayon's ParallelIterator
-
tyra
Typed Actor System
-
nvrtc
Bindings for NVIDIA® CUDA™ NVRTC in Rust
-
atomic-try-update
Primitives that make it easy to implement correct lock-free algorithms
-
simple-rw-global
GlobalContainer based on std::sync::RwLock
-
readlock-tokio
A weird alternative to Arc<RwLock<T>>, using tokio's RwLock
-
ump-ng
Micro message passing library for threads/tasks communication
-
cpu-affinity
Cross-Platform CPU affinity
-
magnetic
Low-latency lock-free queues
-
todc-utils
building and testing distributed systems
-
multichannel
A mpmc priority multi channel with dynamic channel registration and freezing
-
deqp-runner
A VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline
-
timer-rs
timer used to schedule execution of closures at a given timestamp
-
thread_lake
A very high level thread pool manager
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
android-wakelock
Safe and ergonomic Rust bindings to the Android WakeLock API
-
schedwalk
Test futures under all possible polling schedules
-
supply-chain-trust-example-crate-000031
More compact and efficient implementations of the standard synchronization primitives
-
atomic_prim_traits
Traits over primitive atomic types
-
double-checked-cell-async
A thread-safe lazily initialized cell using double-checked locking
-
amadeus-parquet
An Apache Parquet implementation in Rust
-
protoflow-syntax
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
mbarc-map
Minimally-blocking, Atomic Reference Counted Map
-
zkmq
Message Queue, backed by Zookeeper
-
std-semaphore
A counting, blocking sempahore extracted from rust 1.7.0
-
shared_channel
Multi-producer, multi-consumer FIFO queue communication primitives
-
colosseum
A variety of arena allocators for Rust, including thread-safe arenas
-
arrows
An actor framework in rust with message durability and ingestion order processing of of messages
-
single_executor
Traits for concurrent primitives
-
rdispatcher
Dispatcher for Rust, broadcast and subscribe many to many
-
classic-sync
ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems
-
async-events
Waiting for external task completion in asynchronous Rust code
-
shared_resources
shared resources container which is thread-safe, and lock-free
-
rayon-core
Core APIs for Rayon
-
barriers
A barrier spin lock implementation
-
ora-timer
Part of the Ora scheduler framework
-
paradis-demo
demo functionality for paradis, not intended for use
-
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<T> as long as T can be build statically.
-
rpools
A minimalist workerpool for rust
-
crossbeam-skiplist_piedb
A concurrent skip list
-
spsc-ringbuf-core
Heapless ring buffer
-
try-mutex
Fast non-blocking mutex
-
spin_loop
-
portable-atomic-util
Synchronization primitives built with portable-atomic
-
fused-reader
fused reader type that if writer thread dies while holding armed fuse the reader will get BrokenPipe error
-
steelmill
A resource manager (dependency injector / factory) designed for distributed systems and simulation testing
-
lariv
Linked Atomic Random Insert Vector: a thread-safe, self-memory-managed vector with no guaranteed sequential insert
-
atomic-memcpy
Byte-wise atomic memcpy
-
go-spawn
that provides macros to spawn and join threads with minimal boilerplate
-
caring
Sharing is caring: a safe library for mmap'ing memory in multiple processes
-
hadron-client
The Hadron Rust client library
-
cupchan
async overwriting channel between two threads that is wait & block free by swapping cups around
-
blobd
Blob storage designed for huge amounts of random reads and small objects with constant latency
-
async_ach-waker
Async Atomic Channel
-
async-datachannel-wasm
Async Wrapper for WebRTC datachannel in the browser environment
-
kolbold_core
memory and time metrics collection
-
coro
Stackful, first-class asymmetric coroutines
-
witty-actors
Fork of quickwit-actors, Actor framework used in quickwit
-
forkjoin
A work stealing fork-join parallelism library for Rust
-
acteur
A safe actor-like framework that just works. Simple, robust, fast, documented.
-
crossbeam-skiplist
A concurrent skip list
-
water
thread-safe distributed message sending facility supporting synchronous and asynchronous I/O across process and machine boundaries. It also uses nets which allow message broadcasts to all…
-
rapidsync
Rapid & threadsafe embedded data stores
-
consume
Memory order consume for when it's known that the compiler can't elide the dependency
-
waithandle
that makes signaling between threads a bit more ergonomic
-
snowflake-multi-threaded
The rust-lang implementation of Twitter's id generator algorithm snowflake, it thread safety | Twitter 的id生成器算法snowflake的rust-lang 实现
-
hv-guarded-borrow
Traits and implementations for generic use of "guarded" borrows
-
mth_calc
demonstrating Cargo. Contains helper method for running a process in parallel on all available processors.
-
lockmap
A high-performance, thread-safe HashMap implementation for Rust that provides fine-grained locking at the key level
-
threadgroup
Manage groups of threads as one unit, join the first one that finishes, timeout on join attempts
-
threadfin
A thread pool for running multiple tasks on a configurable group of threads
-
async-map
A rarely-locking, shared map for Rust
-
cas-lib
Core lib for CAS
-
send-cell
Immutable memory region with runtime Send checking
-
futures-dagtask
DAG-based Task Queue
-
channel_io
Reader implementation on channel of bytes
-
syncell
Sync alternative to RefCell
-
paladin-core
distributed algorithm toolkit. Write distributed algorithms without the complexities of distributed systems programming.
-
async-priority-channel
An async channel where pending messages are delivered in order of priority
-
rtfm-core
Core abstractions of the Real Time For the Masses framework
-
streambed-patterns
Patterns for working with streambed
-
hv-elastic
Safe and almost-safe abstractions for lengthening lifetimes and
'static
“loaning” of non-'static
types -
pawawwewism
a wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3
-
atomic-story
An brief overview of atomics and memory ordering on a multi-threaded context with examples
-
amadeus-postgres
Harmonious distributed data analysis in Rust
-
hv-lease-tracker
no-std compatible tracking of borrow origins, for providing better diagnostics when implementing interior mutability primitives
-
flexible-locks
Flexible Locks
-
dashmap_with_out_t_map_trait
Blazing fast concurrent HashMap for Rust
-
csplib
CSP for concurrent programming
-
rsevents-extra
Synchronization objects built on top of rsevents. Semaphore, countdown event, and more.
-
gaffer
Prioritised, parallel job scheduler with concurrent exclusion, job merging, recurring jobs and load limiting for lower priorities
-
mrogalski-looper
Clean abstraction for a single-threaded event loop. Built as a lightweight wrapper around the std::sync::mpsc package.
-
raliguard
Lazy rate limit semaphore implementation for your asynchronous code frequency execution
-
sentinel-rocket
Sentinel middleware for Rocket
-
dynqueue
Dynamically extendable Rayon parallel iterator
-
thread_reviver
A Discord bot to revive any archived threads (to counter Discord's auto-archive function)
-
thread_db
Rust wrapper for libthread_db
-
perthread
ThreadMap structure for accessing PerThread thread local variables form a static context
-
bufchan
buffered MPSC channel
-
structured_persistent_logger
A structured 'log' logger that allows for persistent fields
-
glock
Granular locking crate for Rust
-
one_at_a_time_please
For serialising calls to functions
-
shared-resource-pool-builder
Create thread pools with a shared resource
-
consumable_vec
generic approach to create a mutual database for multiple producers and consumers
-
unbounded-spsc
An unbounded spsc queue built from
bounded_spsc_queue
s -
atomic-borrow
atomic reference counter
-
slog-json-concur
JSON drain for slog-rs with concurrency
-
mini-io-queue
Fixed-length, allocation and lock-free, async I/O oriented single-producer single-consumer queues
-
lock-free-freelist
A fast lock free limited length free list for multiple producer and consumer
-
denog_runtime
denog runtime library
-
quartz_sched
Minimalistic scheduling library for Rust
-
poolio
A thread-pool
-
pflock
A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
elfmalloc
A fast, concurrent, general-purpose allocator
-
semalock
concurrently writing to files in a safe and efficient manner
-
lines-rs
⚡ A fast line counter written in rust
-
request-channel
Async MPSC request-reponse channel
-
pcp-mutex
A Priority Ceiling Protocol (PCP) mutex, based on Linux PI futex. Allows efficient and deadlock free execution.
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
try-rwlock
Fast non-blocking readers-writer lock
-
ordered-locks
Compiletime deadlock avoidance
-
geese_pool
Message-passing system for networking with Geese
-
ocl
OpenCL bindings and interfaces for Rust
-
ez_logging
dirt-cheap logging system
-
melodium-engine
Mélodium core engine and executor implementation
-
sea-streamer-stdio
🌊 SeaStreamer Standard I/O Backend
-
gemino
A multi producer multi consumer (MPMC) broadcasting channel
-
amadeus-types
Harmonious distributed data analysis in Rust
-
parking_lot_rt
Parking-lot fork for real-time applications
-
rayoff
rayon but it's map-reduce
-
atomic_pingpong
Lightweight no_std ping-pong buffer, using AtomicU8 for synchronization
-
moka2
hitdns fork of A fast and concurrent cache library inspired by Java Caffeine
-
shareable
Thread shareable objects using the minimal amount of synchronization
-
orx-concurrent-ordered-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance and ordered concurrent collection
-
task_pool
Flexible abstraction for task-based composable multithreading
-
threadbeam
specialized channel type for beaming data out of a newly spawned thread
-
concurrent_open_map
A concurrent hashmap implementation in Rust
-
ppipe
An elegantly simple and lightweight library for making iterator pipelines concurrent and blazingly fast, hence the name ppipe (parallel pipe)
-
atomic-destroy
An value which can be atomically read and destroyed; like an atomic Option
-
pacwrap-core
providing core functionality for pacwrap
-
base-coroutine
A fast and safe implementation of stackful coroutines with scheduler which supports preemptive scheduling
-
concurrency_traits
Traits for concurrent primitives
-
rush_expr_engine
The rules engine is based on the rete algorithm
-
nbchan
Highly optimized non-blocking communication channels
-
balter-runtime
A load/stress testing framework
-
rcell
A Cell which can hold either an Arc or an Weak smartpointer or be empty
-
quick_cache
Lightweight and high performance concurrent cache
-
readahead-iterator
Readahead from an iterator on a separate thread, returning items in order and synchronously
-
ste
A single-threaded executor with some tricks up its sleeve
-
todc-mem
Algorithms for shared-memory distributed systems
-
testtools
Helpers for eliminating boilerplate code in tests
-
key-rwlock
keyed asynchronous reader-writer locks
-
grip-grab
A faster, more lightweight ripgrep alternative
-
provenant
A version of Arc that can free memory while weak pointers exist by probabilistically tracking provenace
-
threads_pool
This package provides an easy way to create and manage thread pools, so you don't have to
-
context-coroutine
set of extensions to provide stackful coroutines; it is not officially associated with the context crate
-
minactor
Minimal actor framework for Rust with tokio
-
jackiechan
Bounded mpsc channel optimized for lazy bulk operations
-
terminate
abstract logic to terminate threads, coroutines and the like
-
pmpmc
A priority multi producer multi consumer channel
-
actors-rs
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
bastion-executor
Cache affine NUMA-aware executor for Rust
-
pour
Optionally consed radix tries for fast set operations
-
workerpool-rs
workerpool for rust
-
kiss-icp
Unofficial Pure Rust Implementation of kiss-icp
-
rs_taskflow
executing graphs of tasks
-
async-mutex
Async mutex
-
quinine
Atomic monotonic containers (Mono{Box,Arc})
-
stream-channel
stream in channel
-
open-coroutine-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
read-write-api
interface to unify single-threaded code and RwLocks-based code
-
spsc-buffer
Single-producer single-consumer lock-free buffer
-
movie
An actor / thread orchestration library / macro / framework
-
fiona
Concurrent runtime written against liburing
-
workctl
number of higher-level control mechanisms for concurrent work scheduling, built on standard library concurrency primatives
-
task-notify
Notify async tasks when someone mutates data they're interested in
-
verona-rt
Idiomatic binding to the verona runtime
-
simplelock
abstractions for inter-process synchronization
-
sync-cell
A collection of easier to use thread-safe types for the creation of larger thread safe systems
-
a_r_c_h_e_r_y
TEMPORARY CRATE
-
lucchetto
easily call a rust function without holding the GVL lock
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions
. -
callback_cell
Like an Atomic<Option<Box<FnOnce()>>>
-
simple_event_map
event map based on channels, provides a receiver that is either blocking or async
-
executor-service
A fast and efficient Thread Pool like Java ExecutorService
-
option-lock
mutex for Option values
-
rusty-variation
deadlock-free session-typed communication
-
jthread
Deadlock-free Mutual Exclusion locks for Rust
-
employer
Spawn worker threads and check on them later
-
infinitree-macros
Embedded, encrypted database with tiered cache
-
safenv
A thread-safe wrapper around the standard library’s
env
module -
slave-pool
thread pool
-
kik_sync_service
A synchronous threading worker channel for generating the results you want with the data you need
-
lossyq
concurrent single publisher, single consumer queue with fixed length, that never blocks the writer
-
kernel
Abstract Reactive Streams
-
fuze
A mechanism to wait for a single signal which can be checked at any time
-
bichannel
Zero dependency std::mpsc based bidirectional channel
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
wasefire-sync
Portable non-blocking mutex
-
more-sync
More synchronization utils
-
wei-scheduler
wei scheduler
-
thread-broadcaster
A SPMC (Single producer multi consumer) broadcasting channel to broadcast notifications between threads
-
waitcell
A cell type containing a value which may not yet be available
-
key-mutex
Access mutexes by key
-
mtxgroup
mutex group locks all mutexes at the same time
-
nexus-actor-core-rs
Core library for Nexus Actor
-
coroutines
High performance coroutine library with native experience
-
mrsc
mpsc with requests
-
protoflow-crossbeam
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
srmap
A lock-free, eventually consistent, concurrent multi-value map
-
maybe-async-channel
A channel which may or may not be async
-
monotone
counters and queues for coordination in distributed systems
-
parallel-event-emitter
Parallel Event Emitter for concurrent listener invocation based on futures-rs and futures-cpupool
-
malobu
Atomic MPMC Bus
-
ping-pong-cell
An atomic cell for up to two threads
-
meslin
Ergonomic messaging for Rust
-
datacake-rpc
A zero-copy, actor-like RPC framework using rkyv
-
rusty-scheduler
A single threaded closure and function scheduler
-
momen
low overhead thread pool
-
bndpresbufch
Bounds-preserving channel for passing buffers
-
refptr
Inherently reference counted structs
-
thread-lock
A wrapper that locks non-Send and non-Sync data to a specific thread
-
rt-watchdog
Real-time userspace watchdog for Rust
-
sea-streamer-redis
🌊 SeaStreamer Redis Backend
-
semaphorus
Atomic semaphores
-
sero
lightweight library for maintaining a shared store of locks
-
netcon
A collections of tools and helper functions developed for and by NetCon Unternehmensberatung GmbH
-
ach
Atomic Channel
-
sorted-channel
sorted message-based communication channel
-
c-map
Very fast concurrent hashmap
-
uppercut
Small and simple actor model implementation
-
yuki
multithreaded web archiver
-
ump-ng-server
Server message dispatch loop for ump-ng
-
mtlog-tokio
Scoped logging for tokio runtimes with support for log files
-
sentinel-actix
Sentinel middleware for Actix-Web
-
stretto
high performance thread-safe memory-bound Rust cache
-
atomic-bus
Atomic MPMC Bus
-
sea-streamer-runtime
🌊 SeaStreamer async runtime abstraction
-
queue-ext
The extended feature of the queue can convert the pop() function of the queue to Stream and the push() function to Sender
-
user-sync
user-space synchronization
-
rust-waitgroup
A Golang like WaitGroup
-
sync_cow
Thread-safe clone-on-write container for fast concurrent writing and reading
-
pipeliner
nice interface for parallel programming with iterators
-
once_mut
Safe mutable reference to static variable that can be obtained only once
-
vlock
A fast and scalable multi-version shared state lock with wait-free read access
-
taskschd
windows taskschd demo
-
bombs
Efficient single-producer multi-consumer channel types
-
bplustree
Concurrent in-memory B+ Tree featuring optimistic lock coupling
-
overdose
Fast, Row Oriented, Kotlin, Scala-like dataframe
-
sento
A lock-free, append-only atomic pool
-
tc-fs
TinyChain's transactional filesystem interface layer
-
async-once-watch
Asynchronous and shareable container which value is set once
-
proc-lock-api
APIs for the proc-lock crate
-
atomic-hyperloglog
thread-safe hyperloglog, with atomics
-
bounded-spsc-queue
A bounded SPSC queue
-
concurrency_toolkit
Easy switching between std::sync, tokio::sync and loom::sync
-
scoped-threadpool-std
scoped threadpool implementation and related tests including a password hasher
-
promissory
One-shot value exhange between threads
-
chashmap
Fast, concurrent hash maps with extensive API
-
mpmcpq
Multi-producer multi-consumer Priority Queue
-
busan
An actor implementation for Rust
-
smartpool
A very customizable, future-aware threadpool
-
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.
-
af-opencl-interop
ArrayFire is a high performance software library for parallel computing with an easy-to-use API. This crate is an addition on top of ArrayFire crate to enable users to mix RAW CUDA code in rust and ArrayFire.
-
hv-cell
A no-std port of the
atomic_refcell
crate with additionalArc
-centric functionality -
brutils
Some utilities for Rust
-
rendezvous_swap
Swap data and sync execution between a pair of threads efficiently
-
adirector
asynchronous tokio task spawner with a limited size
-
polyester
Parallel iterator adaptors that accept arbitrary iterators
-
fencing
tokens
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
lock-hierarchy
Prevent dead locks by enforcing lock hierarchies
-
minicoroutine
mini coroutine library in rust
-
hv-atom
Convenient abstractions for atomic operations on smart pointer/reference types, based on the
atom
crate -
rhythm
Rate limiter which allows VIPs, written in Rust
-
stoplight
stoppable tasks/threads
-
skipdb
An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine
-
scherben-map
Concurrent Sharded HashMap for Rust
-
orx-pinned-concurrent-col
A core data structure with a focus to enable high performance, possibly lock-free, concurrent collections using a PinnedVec as the underlying storage
-
syncmap
fast, concurrent cache library built with a focus on performance and correctness. The motivation to build syncmap comes from the sync.Map in Golang
-
hj_thread_pool
thread pool implementation in Rust
-
optimistic-cell
lock-like structure for low-overhead optimistic concurrency
-
shrink_pool
A thread pool which agressively terminates its threads as soon as they are idle
-
remutex
Recursive mutex, adapted from Rust's standard library
-
access-queue
limit the number of simultaneous accesses to a value
-
atomic_box
A struct which allows multiple threads to safely update and read from a shared non-nullable pointer to heap data
-
fibril_verifier
Verifies behavior for distributed systems implemented with the Fibril library
-
juliex
a very basic future executor
-
rework
Multi-threaded task processing in the Master-Worker pattern
-
amadeus-aws
Harmonious distributed data analysis in Rust
-
bound
Wrap lock guards and other structs along with the locks or other data they are derived by shared reference from, in a struct you can pass around and store anywhere
-
paradis-core
core functionality for paradis
-
eventbus
Safe, fast and concurrent event system, inspired by the MinecraftForge event bus
-
par-map
Parallel map and flat_map
-
rslint_rowan
threadsafe fork of rowan for the rslint project
-
chunker
Minimalistic parallel executor
-
hybrid-lock
A hybrid lock with optimistic locking
-
triex
Trivial Executor
-
tasic
Tokio, Async_STD, Smol, Interface Crate
-
slock
An async mutex that never deadlocks
-
riffy
An unbounded, wait-free, multi-producer-single-consumer queue
-
atomic_immut
Atomic immutable value
-
zestors
A fast and flexible actor-framework for building fault-tolerant Rust applications
-
std-mel
Mélodium standard library
-
ccl
Fast datastructures for use in highly concurrent systems
-
kabuki
Name reservation
-
wasserglas
A fixed size thread-safe object pool with automatic reattachment
-
pairlock
A reader-writer lock with wait-free reads
-
evelyn
event distribution library
-
open-coroutine-core
The open-coroutine is a simple, efficient and generic coroutine library
-
hurdles
Counter-based thread barrier
-
hiatus
Debug concurrent programs by choosing specific execution traces
-
laststage
fast, durable, high concurrent HashMap
-
unsync_channel
!Send/!Sync channels for Rust
-
gothack-future-parking_lot
An "as simple as possible" Future implementation for parking_lot
-
atomic_cell
Lock-free thread-safe mutable memory locations
-
membarrier
Process-wide memory barrier
-
arbalest
Like Arc<T> but where weak references don't forbid mutable access
-
ya-ring-buf
Ring Buffer. SPSC channel with direct access for bytes/Copy.
-
rtic-core
Core abstractions of the Real-Time Interrupt-driven Concurrency framework
-
bondi
Single producer, multi consumer lock-free ring buffer (experimental)
-
zsling
Rust Wrapper around a Sequentially lockign (SeqLock) Ring Buffer written in Zig
-
qrwlock
Fair queued read-write lock
-
yastl
scoped threadpool library
-
dynamic-pool
a lock-free, thread-safe, dynamically-sized object pool
-
spsc-bip-buffer
A concurrent, spsc ring-buffer with sized reservations
-
locker
named mutex/locker for rust-lang concurrency
-
boomerang_util
Boomerang
-
static_locks
The
parking_lot
locks but usable in statics and const fn -
rayon-core-wasm
Core APIs for Rayon
-
lagoon
A thread pool crate with an array of features
-
venom_log
Rust async log High-performance asynchronous logging
-
amadeus-commoncrawl
Harmonious distributed data analysis in Rust
-
linux-futex
Futex: A Linux-specific fast user-space locking primitive
-
thread-safe
Container that allows thread safety for thread-unsafe objects
-
disk_log
High Throughout, NonBlocking Disk-based logger
-
ump-server
Server message dispatch loop for ump
-
waitmap
an awaitable concurrent hash map
-
protoflow-flume
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
ach-util
Atomic Channel
-
tokio-sync-read-stream
Create a stream from a std::io::Read using Tokio blocking threads
-
waitable
A synchronized (atomic) value container implementing the Mutex+Condvar pattern for efficient blocking waits
-
namedlock
Namespaces for named locks
-
threadpool-crossbeam-channel
A fork of the threadpool create, which uses crossbeam-channel instead of std::mpsc
-
parking_monitor
Parking-lot-flavored monitor synchronization construct
-
firefly
[EXPERIMENTAL]
-
abyss-promise
[abyss] A simple promise implementation with adaptive threadpool support
-
hybridfutex
An efficient hybrid wait queue futex designed for high-contention scenarios, supporting both synchronous and asynchronous waiting and notification. It supports notify and notify_many on all targets.
-
sling
Sequentially lockign (SeqLock) Ring Buffer
-
rtic-monotonics
that provides implementations of the Monotonic trait from rtic-time
-
fixed_ring_buffer
An asynchronous SPSC fixed-capacity look-free ring buffer, which can be used to transfer data between two threads or between two asynchronous tasks
-
logmap
A concurrent hashmap using a log for buckets
-
shared-mutex
A RwLock that can be used with a Condvar
-
tange
Scalable Task-based Parallelism Framework
-
cura
arc-lock-system that should clean up the code a lot
-
countdown_latch
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes
-
dyn_object
Ergonomic and thread safe version of Box<dyn Any>
-
television
The revolution will be televised
-
clone-replace
Share mutable data by cloning and replacing a reference version
-
worker-pool
handle a set of worker threads, which need to communicate back their result to the main thread
-
horde
threads
-
thread-owned-lock
Mutex which can only be unlocked by the owning thread
-
lf-queue
A lock-free multi-producer multi-consumer unbounded queue
-
mula
Share expensive computation with various requesters