-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
crossbeam
Tools for concurrent programming
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
rayon
work-stealing parallelism for Rust
-
threadpool
thread pool for running a number of jobs on a fixed set of worker threads
-
spin
Spin-based synchronization primitives
-
dashmap
Blazing fast concurrent HashMap for Rust
-
flume
blazingly fast multi-producer channel
-
sled
Lightweight high-performance pure-rust transactional embedded database
-
sharded-slab
lock-free concurrent slab
-
simple_logger
logger that prints all messages with a readable output format
-
crossbeam-queue
Concurrent queues
-
async-lock
Async synchronization primitives
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
portable-atomic
Portable atomic types including support for 128-bit atomics, atomic float, etc
-
arcstr
better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
gix-features
integrate various capabilities using compile-time feature flags
-
triomphe
fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
thread_local
Per-object thread-local storage
-
state
safe and effortless global and thread-local state management
-
loom
Permutation testing for concurrent code
-
mpi
Message Passing Interface bindings for Rust
-
lasso
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
-
leaky-bucket
token-based rate limiter based on the leaky bucket algorithm
-
radium
Portable interfaces for maybe-atomic types
-
stateright
model checker for implementing distributed systems
-
thread-priority
managing threads priority and schedule policies
-
jobserver
GNU make jobserver for Rust
-
rskafka
minimal Rust client for Apache Kafka
-
shuttle
testing concurrent Rust code
-
atomic-take
Atomically take a value out of a container once
-
ipc-channel
multiprocess drop-in replacement for Rust channels
-
scheduled-thread-pool
scheduled thread pool
-
spinning_top
spinlock crate based on the abstractions provided by
lock_api
-
triple_buffer
triple buffering, useful for sharing frequently updated data between threads
-
thingbuf
I'm at the buffer pool. I'm at the MPSC channel. I'm at the combination MPSC channel and buffer pool.
-
archery
Abstract over the atomicity of reference-counting pointers
-
thread-id
Get a unique thread ID
-
crossbeam-deque
Concurrent work-stealing deque
-
parking
Thread parking and unparking
-
rtrb
realtime-safe single-producer single-consumer ring buffer
-
bus
lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
atomic
Generic Atomic<T> wrapper type
-
lockfree-object-pool
thread-safe object pool collection with automatic return and attach/detach semantics
-
crabz
Parallel Compression
-
deno_napi
NAPI implementation for Deno
-
corosensei
fast and safe implementation of stackful coroutines
-
kanal
fast sync and async channel that Rust deserves
-
async_once
async once tool for lazy_static
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
desync
hassle-free data type for asynchronous programming
-
rustc-rayon
work-stealing parallelism for Rust - fork for rustc
-
mpstthree
implementing Multiparty Session Types for 2 or more participants
-
may
Stackful Coroutine Library
-
st3
very fast lock-free, bounded, work-stealing LIFO queue
-
lasso-rs
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
-
try-lock
lightweight atomic lock
-
ratelimit
ratelimiter that can be shared between threads
-
rtic-monotonics
that provides implementations of the Monotonic trait from rtic-time
-
seize
Fast, efficient, and robust memory reclamation for concurrent data structures
-
sync_wrapper
enlisting the compiler’s help in proving the absence of concurrency
-
parallel-sh
Execute commands in parallel
-
crossfire
channels for async and threads
-
runnel
pluggable io stream. now support: stdio, string io, in memory pipe
-
par-iter-sync
Parallel Iterator With Sequential Output
-
vin
ergonomic actor framework
-
svix-ksuid
pure Rust and fully tested KSUID implementation
-
typedmap
hash map (dash map). A type of value is defined by trait implemented on key type
-
trauma
Simplify and prettify HTTP downloads
-
oqueue
Non-interleaving multithreaded output queue
-
sea-streamer
🌊 The stream processing toolkit for Rust
-
signals2
thread-safe signal/slot library inspired by boost::signals2
-
ppl
structured parallel programming library for Rust
-
synchronoise
Synchronization primitives that build upon the standard library
-
rsevents
Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores
-
rustup-toolchain
working with rustup toolchains
-
indicator
Abstractions for stream aggregation, we call them
Indicator
s -
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
sharded_queue
ShardedQueue is currently the fastest concurrent collection which can be used under highest concurrency and load
-
atom
safe abstraction around AtomicPtr
-
piz
(a Parallel Implementation of Zip) is a ZIP archive reader designed to concurrently decompress files using a simple API
-
once_map
Single assignment and lazy maps
-
qp2p
Peer-to-peer networking library using QUIC
-
concurrent-map
lock-free linearizable B+ tree
-
picokafka
Kafka library for tarantool-module based on librdkafka
-
choir
Task Orchestration Framework
-
crossbeam-epoch
Epoch-based garbage collection
-
may_queue
May's internal queue library
-
maitake-sync
No-std async synchronization primitives from Maitake
-
no_deadlocks
Runtime Deadlock Debugger
-
async-condvar-fair
Condition variables for async Rust
-
keepcalm
shared types for multi-threaded programs
-
file-lock
File locking via POSIX advisory record locks
-
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 -
redlock
distributed locking mechanism built on top of Redis
-
deqp-runner
VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
fault-injection
fault injection, concurrency delay injection, and error source annotation
-
process_control
Ergonomically run processes with limits
-
hypercore-protocol
Replication protocol for Hypercore feeds
-
someday
Eventually consistent, multi version concurrency
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
lever
Pillars for Transactional Systems and Data Grids
-
messaging_thread_pool
aiding the creation of typed thread pool of objects that is communicated with via channels
-
lazycell
providing a lazily filled Cell struct
-
pinboard
lock-free, threadsafe way to publish data, just stick it on the pinboard
-
thread_io
performing I/O in background thread
-
freezebox
FreezeBox: a deref'able lazy-initialized container
-
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
-
atomicring
AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer
-
dagrs
DAG engine, named dagrs, is designed to execute multiple tasks with graph-like dependencies. It offers high performance and asynchronous execution, providing a convenient programming interface for Rust developers.
-
kueue
robust, user-level, work-stealing, distributed task scheduler
-
apalis-core
Core for apalis: simple, extensible multithreaded background processing for Rust
-
wasmrs-guest
wasmRS guest implementation of the RSocket protocol for reactive streams in WebAssembly
-
rtic-syntax
Real-Time Interrupt-driven Concurrency (RTIC) meta language
-
permit
struct for cancelling operations
-
haphazard
Dynamic memory management for lock-free data structures using hazard pointers
-
threadbound
any value Sync but only available on its original thread
-
rtthost
RTT (Real-Time Transfer) client
-
rucron
Job Scheduling Crate
-
waker-fn
Convert closures into wakers
-
tc-transact
Traits and locking utilities for a TinyChain transaction
-
disruptor
Low latency inter-thread communication via a ringbuffer (inspired by the LMAX Disruptor)
-
atom_box
safe idiomatic Rust implementation of Atomic Box using hazard pointers
-
deadqueue
Dead simple async queue
-
thingvellir
concurrent, shared-nothing abstraction that manages an assembly of things
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
boxcar
concurrent, append-only vector
-
everygarf
Concurrently download every Garfield comic to date
-
fs-lock
Locked files that can be used like normal File
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
atomic_once_cell
Thread-safe and lock-free OnceCell and Lazy
-
melodium
Dataflow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely
-
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!)
-
rcron
cron job scheduling for rust
-
neon-runtime
Bindings to the Node.js native addon API, used by the Neon implementation
-
skl
lock-free thread-safe concurrent ARENA based (heap backend or memory map backend) skiplist implementation which helps develop MVCC memtable for LSM-Tree
-
uuid7
proposed UUID Version 7
-
atto
Future project
-
s3get
Download a single file from S3 using chunks
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
blocking-threadpool
thread pool for running a number of jobs on a fixed set of worker threads
-
rearch
Re-imagined approach to application design and architecture
-
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
-
watchable
RwLock-like type that is compatible with both multi-threaded and async code
-
utils-atomics
Various atomic utils
-
erldash
terminal-based Erlang dashboard
-
datacake-crdt
conflict free replicated datatype based on a hybrid logical clock implementation for building eventually consistent data stores
-
peace-lock
zero-cost abstraction lock that helps check contention free algorithms
-
owning_ref
creating references that carry their owner with them
-
kvx
Abstraction layer over various key-value store backends
-
boomphf
Scalable and Efficient Minimal Perfect Hash Functions
-
tracing-mutex
Ensure deadlock-free mutexes by allocating in order, or else
-
range-lock
Range lock for std::vec::Vec
-
throttle-client
Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.
-
local-sync
Non-threadsafe data structure for async usage
-
ringbuf-blocking
Blocking version of ringbuf
-
asyncgit
allow using git2 in a asynchronous context
-
bastion-executor
Cache affine NUMA-aware executor for Rust
-
concurrent_arena
u32 concurrent insertion/removal arena that returns ArenaArc
-
minimax
Generic implementations of Minimax
-
resman
Runtime managed resource borrowing
-
ocl-interop
Creates an OpenCL Context with OpenGL Interop enabled
-
ipc-rpc
wrapper over servo/ipc-channel which provides many high level features
-
mco
Coroutine Library like go
-
command-executor
Command Executor thread pool
-
swap-buffer-queue
buffering MPSC queue
-
genserver
Elixir inspired async actor library
-
redsync
Redlock for distributed locks with Redis
-
hyperbridge
Fast multi-producer multi-consumer channel with async support
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
jobslot
GNU make jobserver for Rust
-
rcu_cell
lockless rcu cell implementation
-
global_counter
Global, thread-safe counters
-
scoped_threadpool
scoped and cached threadpools
-
type-map
typemap container with FxHashMap
-
storyteller
focused on supporting user oriented output while supporting multiple output types (e.g. json, a progressbar, etc.)
-
semaphore-key
control concurrent thread access by key using a shared semaphore
-
amadeus
Harmonious distributed data processing & analysis in Rust. parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common crawl
-
active_standby
concurrency primitive for high concurrency reads
-
threadcell
cell whose value can only be accessed by a owning thread
-
blackhole
...to throw your threads into
-
rs-consul
access to a set of strongly typed apis to interact with consul (https://www.consul.io/)
-
sparking-lot-core
parking on addresses
-
rclite
small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs
-
lockpool
offers a pool of locks where individual locks can be locked/unlocked by key
-
pi_share
rc, arc, lock, atomic
-
lunatic-control
TBD
-
jod-thread
std::thread which joins on drop by default
-
leapfrog
fast, lock-free concurrent hash map
-
recloser
concurrent circuit breaker implemented with ring buffers
-
lrwn
encoding / decoding LoRaWAN frames
-
fuchsia-zircon
bindings for the Zircon kernel
-
round_mult
tiny library to round a number up or down to a multiplier
-
node-replication
operation-log based approach that transform single-threaded data structures into concurrent, replicated structures
-
append-only-vec
Append-only, concurrent vector
-
iotics-grpc-client
IOTICS gRPC client
-
workerpool
thread pool for running a number of jobs on a fixed set of stateful worker threads
-
atomig
Generic, convenient and lock-free
std
atomics viaAtomic<T>
. Can be used with many primitive types (including floats) and with custom types. -
work-queue
concurrent work-stealing queue for building schedulers
-
atomic-shim
Atomic types for unsupported platforms
-
sharded_mutex
Atomic Everything
-
watch
synchronous message passing channel that only retains the most recent value
-
mpsc
channel
-
atomicell
Multi-threaded RefCell on atomics
-
either-slot
atomic slot whose senders can either place their value into the slot, or retrive all the data from the slot
-
synchronized
Convenient and simple macro for code synchronization in multithreading
-
riscv-atomic-emulation-trap
atomic emulation trap handler for non atomic RISC-V targets
-
sdl-parser
SDL parser is a Rust tool designed for parsing Scenario Defined Language files
-
quartz_sched
Minimalistic scheduling library for Rust
-
snowdon
lightweight thread-safe snowflake ID implementation for Rust
-
rustix-futex-sync
Linux futex-based synchronization
-
rtic-sync
Synchronization primitives for asynchronous contexts
-
sync_file
Files that can be read concurrently
-
uid
creation of unique IDs
-
memo-map
implementing a synchronized map for memoization
-
maybe-rayon
Either acts as rayon or creates a single-threaded facade
-
hebo_codec
Packet codec for MQTT protocol
-
atomptr
safe, dependency-less abstraction for typed atomic smart pointers
-
atomic_float
Floating point types which can be safely shared between threads
-
lariv
Linked Atomic Random Insert Vector: a thread-safe, self-memory-managed vector with no guaranteed sequential insert
-
txn_lock
support transactional versioning
-
zestors
fast and flexible actor-framework for building fault-tolerant Rust applications
-
qdk_sim_experimental
Experimental simulators for use with the Quantum Development Kit
-
tlrepo
Thread-local git2::Repository, shareable across threads
-
libssh2-sys
Native bindings to the libssh2 library
-
whisk
fast lockless async channels
-
executor-service
fast and efficient Thread Pool like Java ExecutorService
-
lucchetto
easily call a rust function without holding the GVL lock
-
kube-leader-election
Leader election implementations for Kubernetes workloads
-
stm
Software transactional memory. Allows composable atomic operations.
-
scherben-map
Concurrent Sharded HashMap for Rust
-
disrustor
project is a port of the LMAX Disruptor to Rust
-
refs
My vision of reference counting
-
myriam
Remote actors on top of libp2p
-
queue-ext
extended feature of the queue can convert the pop() function of the queue to Stream and the push() function to Sender
-
stupid_utils
that provides some simple and maybe stupid or useful tools
-
iterator_ilp
Iterator extensions for instruction-parallel reductions
-
with_lock
Deadlock freedom
-
portable_atomic_enum
attribute to create an portable atomic wrapper around a C-style enum
-
async-events
Waiting for external task completion in asynchronous Rust code
-
atomx
Thread safe data structures based on atomic data types
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
basic_tcp_proxy
synchronous TCP proxy crate for forwarding TCP connections
-
shmap
key-value store based on unix shared-memory files (shm) for persisting state across program restarts
-
arl
rate limiter to be used with tokio
-
atomic-wait
Cross-platform atomic wait and wake (aka futex) functionality
-
lockfree
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
priority-inheriting-lock
priority-inheriting lock based on Linux futexes
-
mem_btree
Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
sea-streamer-examples
🌊 The stream processing toolkit for Rust
-
cdk-from-cfn
Turn AWS CloudFormation templates into AWS CDK applications
-
search-query-parser
parse complex search query into layered search conditions, so it will be easy to construct Elasticsearch query DSL or something else
-
ccd
windows simple, fast chrome_cookie_decryptor
-
kanin
RPC microservice framework for AMQP, protobuf and Rust built on lapin (https://github.com/amqp-rs/lapin)
-
loole
safe async/sync multi-producer, multi-consumer channel
-
lfchring
Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication
-
norpc
Framework for in-process microservices
-
tc-scalar
TinyChain's scalar value enum, including concurrently-resolvable op definitions and references
-
fast-async-mutex
lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)
-
color-rs
that provides types and conversions for working with various color formats. Forked from the unmuntained crate color
-
blaze-rs
Rustified OpenCL Experience
-
actix-jobs
job scheduler for Actix
-
tyra
Typed Actor System
-
datacake
batteries included framework for building fault-tolerance distributed data systems
-
agner-init-ack
actor toolkit inspired by Erlang/OTP (init-ack)
-
std-ext
Extend the standard library functionality
-
single_value_channel
Concurrent single-value update and receive channel
-
tinypointers
Pointer implementations that take 8 or 16 bits
-
scoped-thread-pool
flexible thread pool providing scoped threads. Updated fork of https://github.com/reem/rust-scoped-pool
-
pausable_clock
source of time information that can be paused and resumed
-
hopper
unbounded mpsc with bounded memory
-
derivable-object-pool
thread-safe derivable object pool collection with automatic reusage of objects
-
left-right
concurrency primitive for high concurrency reads over a single-writer data structure
-
employees
small runtime that hides all the boilerplate when using threads
-
pargraph
Operator based parallel graph processing
-
tokio-cron
cron scheduler for tokio
-
pawawwewism
wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3
-
crawly
lightweight async Web crawler in Rust, optimized for concurrent scraping while respecting
robots.txt
rules -
actix-broker
Message broker for the Actix actor framework
-
unit16
whp-unit16
-
deque
(mostly) lock-free concurrent work-stealing deque
-
kcas
lock-free, allocation-free multi-word compare-and-swap library
-
ballista-scheduler
Ballista Distributed Compute - Scheduler
-
mtxgroup
mutex group locks all mutexes at the same time
-
executors
collection of high-performance task executors
-
halt
functionality for pausing, stopping, and resuming iterators, readers, and writers
-
inline-array
efficient immutable inlinable byte array
-
bursty
Test support for exarcebating contention in multi-threaded code
-
mop
Flexible and modular single or multi-objective solver for contiguous and discrete problems
-
lock_free_hashtable
Lock-free (almost) insertion only hashtable
-
semka
Semaphore implementation
-
bustle
Benchmarking harness for concurrent key-value collections
-
session_types
session types in Rust
-
sea-streamer-redis
🌊 SeaStreamer Redis Backend
-
nolock
collection of Lock-Free Datastructures
-
hybrid-rc
Thread-safe hybrid reference counting pointers
-
geese_pool
Message-passing system for networking with Geese
-
staging-tracking-allocator
Tracking allocator to control the amount of memory consumed by the process
-
todc-mem
Algorithms for shared-memory distributed systems
-
wasm-futures-executor
Executor for asynchronous task based on wasm web workers
-
fn-store
dynamic persistent value store using closure type as key and storing its return value
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocal
type as an alternative tostd::thread_local!
that allows per-object thread-local storage, while providing a similar API… -
cloudabi
Low level interface to CloudABI. Contains all syscalls and related types.
-
mintex
minimal mutex
-
rp2040-monotonic
RTIC Monotonic implementation based on RP2040's Timer peripheral
-
uf_rush
lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure
-
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. -
test-with-tokio
attribute macro for tests using tokio with cases and async guards
-
lib-wc
Will's Programming Toolbox
-
namaste
-
mt-debug-counters
support high performance debug counters for heavy multithreaded applications
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
yaambo
concurrent skip lists
-
asyncified
small library for operating on long lived sync values in an async context
-
irox-threading
Blocking and Asynchronous Threading Tools
-
kontroli
Type checking for the lambda-Pi calculus modulo rewriting
-
datacake-rpc
zero-copy, actor-like RPC framework using rkyv
-
remutex
Recursive mutex, adapted from Rust's standard library
-
atomic_pingpong
Lightweight no_std ping-pong buffer, using AtomicU8 for synchronization
-
safe-lock
lock struct with a
const fn
constructor and nounsafe
-
sentinel-core
flow sentinel of your microservices
-
xtensa-atomic-emulation-trap
atomic emulation trap handler for non atomic Xtensa targets
-
rayon-core
Core APIs for Rayon
-
ach-cell
Atomic Channel
-
flashmap
lock-free eventually consistent concurrent hash map
-
cht
Lockfree resizeable concurrent hash table
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
treiber_stack
lockless, thread-safe, atomic linked-list
-
cache-padded
Prevent false sharing by padding and aligning to the length of a cache line
-
flo_stream
Pubsub and related streams for Rust futures
-
microamp
Asymmetric Multi-Processing on microcontrollers
-
evmap
lock-free, eventually consistent, concurrent multi-value map
-
open-coroutine
efficient and generic stackful-coroutine library
-
constellation-rs
Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs
-
no-std-async
Async synchronization primitives for #[no_std] rust
-
rsgc
Concurrent GC library for Rust
-
rgraph
task graph library
-
rudderanalytics
RudderStack Rust SDK is an analytics client to track events from your Rust application
-
cloudi
API
-
rt-history
RT-safe history log with error checking
-
fluxion
actor framework written in rust and designed for distributed systems
-
bombs
Efficient single-producer multi-consumer channel types
-
unknownrori-simple-thread-pool
lighweight thread pool for networking and other stuff
-
gbench
tools to benchmark code for further analyzation using Chrome tracing
-
read-write-api
interface to unify single-threaded code and RwLocks-based code
-
multiqueue2
fast mpmc broadcast queue
-
chunker
Minimalistic parallel executor
-
lightproc
Lightweight process abstraction for Rust
-
per-thread-object
Efficient per-object thread-local storage implementation
-
lock-free-static
Lock-free static variables
-
polymock
thread-safe arena bytes allocator
-
rsevents-extra
Synchronization objects built on top of rsevents. Semaphore, countdown event, and more.
-
mwcas
Multi-word CAS primitive
-
acto
light-weight Actor library for Rust
-
ra_ap_flycheck
TBD
-
shrink_pool
thread pool which agressively terminates its threads as soon as they are idle
-
pi_rt_file
async file 的封装,添加了多线程竞争排序。
-
shared_cell
Interior mutability between concurrent tasks on the same thread
-
readlock
weird alternative to Arc<RwLock<T>>
-
bztree
BzTree implementation for Rust
-
poolio
thread-pool
-
rt
real-time operating system capable of full preemption
-
ductile
channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface
-
rearch-tokio
Re-imagined approach to application design and architecture
-
channel-sender
Channel Sender
-
bi
kit for reading/writing resources
-
thread_lake
very high level thread pool manager
-
neuron-rs
actor system for building reactive, concurrent, and resilient distributed services
-
octoproxy-server
Server library for octoproxy
-
per-thread-mutex
Synchronization lock designed for wrapping thread-unsafe C libraries
-
ns3-parallel
Multitask Parallel Concurrent Executor for ns-3 (network simulator)
-
chashmap-serde
Fast, concurrent hash maps with extensive API and Serde support
-
spinout
thread-safe clonable and mutable smart-pointer akin to
Arc<Mutex<T>>
, using spin-lock instead of system futex -
ump
Micro message passing library for threads/tasks communication
-
proglog
Thread safe progress logging
-
stronghold-rlu
Read-Log-Update software transactional memory like synchronization mechanism
-
antidote
Poison-free versions of the standard library Mutex and RwLock types
-
try-mutex
Fast non-blocking mutex
-
jni-utils
Extra Utilities for JNI in Rust
-
minicoroutine
mini coroutine library in rust
-
rpools
minimalist workerpool for rust
-
dragonfly-api
Canonical location of the Dragonfly API definition
-
stewart
minimalist, high-performance, and non-exclusive actor system
-
mth_calc
demonstrating Cargo. Contains helper method for running a process in parallel on all available processors.
-
hey_listen
event-dispatcher-collection offering async, sync, parallel, and prioritised solutions!
-
pcp-mutex
Priority Ceiling Protocol (PCP) mutex, based on Linux PI futex. Allows efficient and deadlock free execution.
-
mycorrh
fast concurrent messaging system for Rust
-
ccl_owning_ref
creating references that carry their owner with them
-
async-datachannel
Async Wrapper for datachannel
-
conqueue
multi-producer, single-consumer queue (MPSC)
-
may_waiter
coroutine communication blocker
-
plonky2_maybe_rayon
Feature-gated wrapper around rayon
-
tlid
Thread Local ID generator by predefined range without atomics/locks/random/time
-
sync-unsafe-cell
backport of the SyncUnsafeCell standard library type for use in older Rust versions
-
shared-expiry-get
concurrent async get with expiration for Rust
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
slazy
small, no-std, macro-based lazy static library for Rust
-
rayon-wasm
work-stealing parallelism for Rust
-
atomic_enum
attribute to create an atomic wrapper around a C-style enum
-
split_channel
stream-of-messages abstraction with split send/recv channels
-
talos_messenger_actions
Messenger actions for Talos
-
rusty_junctions
Join Pattern implementation in Rust
-
concurrent_lru
concurrent LRU cache
-
client-handle
macro to generate client handles when using multithreaded / asynchronous code
-
ipmpsc
Inter-process Multiple Producer, Single Consumer Channels
-
zkstate
Share a struct across multiple instances of an application using zookeeper
-
rust-releases-core
Base traits and definitions for rust-releases
-
atomic-counter
Atomic (thread-safe) counters for Rust
-
simplelock
abstractions for inter-process synchronization
-
async-cpupool
async threadpool for CPU-bound tasks
-
pi_slot_deque
Two terminal queue based on slotmap
-
goko
lock-free, eventually consistent, concurrent covertree
-
usync
fast, drop-in, synchronization primitives
-
wishbone-bridge
control Wishbone devices
-
csplib
CSP for concurrent programming
-
cerk_runtime_threading
package for CERK. CERK is an open source CloudEvents Router written in Rust with a MicroKernel architecture.
-
graph_csr
that provides utility functions for manipulating graphs in a CSR format, used as the baseline for constructing powerful graph algorithms
-
singlyton
Safe, single-threaded global state in Rust
-
little_raft
lightest distributed consensus library. Run your own replicated state machine!
-
kademlia-dht
Kademlia DHT
-
ebr
epoch-based reclamation with low cacheline ping-pong
-
lock_freedom
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
ev_slotmap
lock-free, eventually consistent, concurrent slot map
-
para
dataflow/pipeline parallelization framework
-
todc-utils
building and testing distributed systems
-
locker
named mutex/locker for rust-lang concurrency
-
tagged-rendezvous
Rendezvous hashing with support for tag-based exclusions
-
threadpool-executor
threadpool executor
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
semalock
concurrently writing to files in a safe and efficient manner
-
lockable
offers hash map and cache data structures where individual entries can be locked
-
parking_monitor
Parking-lot-flavored monitor synchronization construct
-
nbchan
Highly optimized non-blocking communication channels
-
magnetic
Low-latency lock-free queues
-
xloc
fast, multi-threaded line counting utility written in Rust
-
menmos-std
Menmos library containing misc. reusable utilities
-
easy-parallel
Run closures in parallel
-
cogo
Coroutine Library like go
-
melodium-engine
Mélodium core engine and executor implementation
-
key-rwlock
keyed asynchronous reader-writer locks
-
fast-counter
sharded concurrent counter
-
threadpooled
Threadpool implementation
-
lofi
Low Overhead Fibers
-
nysa
bus for passing messages around between independent subsystems of an application
-
shared-mutex
RwLock that can be used with a Condvar
-
caffe2op-atomics
xxx
-
raii-counter
RAII Counter
-
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.
-
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)…
-
chyyuu/os
kernel labs based on Rust/C Lang & RISC-V 64/X86-32
-
bmrng
async MPSC request-response channel for Tokio
-
tc-fs
TinyChain's transactional filesystem interface layer
-
autoincrement
wrapper for different purposes
-
rapidsync
Rapid & threadsafe embedded data stores
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
abort_on_panic
Intercept panic! from unsafe locations and abort the process
-
pflock
phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
rtrb-basedrop
fork of the
rtrb
crate that uses basedrop’s Shared pointer in place of Arc -
vigil
liveness checking watchdog for detecting deadlocks/livelocks/starvation etc
-
amadeus-parquet
Apache Parquet implementation in Rust
-
zallocator
Amortizes the cost of small allocations by allocating memory in bigger chunks
-
glock
Granular locking crate for Rust
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
atomicbox
Safe atomic pointers to boxed data
-
chashmap
Fast, concurrent hash maps with extensive API
-
parking_lot_core
advanced API for creating custom synchronization primitives
-
hebo
Distributed MQTT broker
-
tcb
middleware service for delivering messages in a causal order
-
mongo_sync
instant coding answers via the command line(just like howdoi)
-
rad
type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
gpgpu
WIP GPGPU framework built on top of wgpu
-
novasmt
Storage-agnostic, highly ergonomic sparse Merkle trees
-
hytra
Datastructure for fast multi-threaded updates
-
crossbeam-skiplist
concurrent skip list
-
td_rthreadpool
thread wrapper for Rust
-
io_partition
allowing to use just a part of a Read + Seek object
-
parallel-iterator
Parallelize any iterator with ease!
-
godwit-daemon
daemon runner for GodWit
-
reclaim
trait-based abstract interface for memory reclamation
-
spectrusty-audio
Components of the SPECTRUSTY library for synthesizing audio samples and native audio playback
-
mutex-timeouts
let you specify a timeout on a mutex lock
-
unbounded-spsc
unbounded spsc queue built from
bounded_spsc_queue
s -
mpi-fork-fnsp
Message Passing Interface bindings for Rust (FORK)
-
logical_clock
Modern logical clocks implementation in Rust
-
crossbeam-utils
concurrent programming
-
open_proxies
fast proxy checker that include protocol validation
-
my_threadpool
threadpool
-
lock_cell
custom locking cell type written in Rust
-
mut_static
struct to help create mutable statics with lazy_static
-
mpmcpq
Multi-producer multi-consumer Priority Queue
-
nativeshell_core
NativeShell Core Rust package
-
parseq
Parallel sequential iterator
-
multi
easy way to run multiple commands in parallel
-
rose_bloom
concurrent growing element size linked list with stable pointers
-
swap-arc
swappable Arc
-
caffe2-threadpool
xxx
-
sesh
deadlock-free session-typed communication
-
async_ach-notify
Async Atomic Channel
-
ste
single-threaded executor with some tricks up its sleeve
-
datacake-node
core cluster membership system built ontop of Quickwit's chitchat
-
nvrtc
Bindings for NVIDIA® CUDA™ NVRTC in Rust
-
atomic-arena
Generational arena allows reserving keys from other threads
-
gitoxide-core
implementing all capabilities of the gitoxide CLI
-
peril
Fast and safe Hazard pointers for Rust
-
uchan
Multi-producer single-consumer channel for message passing
-
atomic_cell
Lock-free thread-safe mutable memory locations
-
node-workers
pool of long-lived nodejs workers
-
spin-seq
Fork of the
seqlock
crate that can be used on bare metal -
thread-control
control threads' execution/status
-
oma-utils
Some small-tools to help oma handle something
-
shipyard_hierarchy
Hierarchy for Shipyard Entity Component System
-
tasic
- Tokio, Async_STD, Smol, Interface Crate
-
dager
create and execute a graph of nodes
-
timed-locks
Smart pointers to
tokio::sync
locks that either panic or error after a timeout -
mp2c
multi producer multi polling consumer library that enables multiple producers to send messages to multiple consumers completely asynchronously
-
simple-rw-global
GlobalContainer based on std::sync::RwLock
-
ringbuf-basedrop
fork of the
ringbuf
crate that uses basedrop’s Shared pointer in place of Arc -
omango
Lock-free bounded SPSC and MPMC channel
-
schedule_recv
Create delayed and periodic Receivers
-
conveyor_belt
Queue and batch processing library
-
cuneiform-fields
Field level [no_std] cache optimizations for Rust
-
sea-streamer-file
🌊 SeaStreamer File Backend
-
nicompiler_backend
backend interface for National Instrument (NI) integration, offering streamlined experimental control systems with Rust's performance and safety guarantees
-
rs_lockfree
lock-Free lib based on practical Hazard Pointers algorithm
-
thread_timer
cancelable timer with no external dependencies
-
option-lock
mutex for Option values
-
rc_event_queue
VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue
-
gettid
Helper to get an integer ID for the current thread
-
maybe_parallel_iterator
Toggle parallelism with feature flags!
-
flurry
port of Java's ConcurrentHashMap
-
movie
actor / thread orchestration library / macro / framework
-
coarsetime
Time and duration crate optimized for speed
-
atomicdouble
128-bit atomics for generic type
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
brutils
Some utilities for Rust
-
spmc
channel
-
swapper
Swap ownership between threads
-
shared-resource-pool-builder
Create thread pools with a shared resource
-
async-mutex
Async mutex
-
safe_ocl
Zero-cost wrapper types for safe OpenCL
-
slb
Sharded load balancing text-streaming Unix tool
-
atomic-hyperloglog
thread-safe hyperloglog, with atomics
-
waitcell
cell type containing a value which may not yet be available
-
pakr-fsm
Template to implement finite-state-machines
-
concurrency_toolkit
Easy switching between std::sync, tokio::sync and loom::sync
-
snowflake-multi-threaded
rust-lang implementation of Twitter's id generator algorithm snowflake, it thread safety | Twitter 的id生成器算法snowflake的rust-lang 实现
-
sdcons
geo-replicated distributed consensus algorithm: SDPaxos
-
ts-breeze
multithreaded tree-sitter parsing library
-
debugit
Debug-print any value without trait bounds using specialization (Rust nightly channel)
-
open-coroutine-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
simple-task
distributed task queue for learning Rust
-
kai
My personal prelude and utilities
-
generic-session-types
Generic session types in Rust for async send recv channel
-
pipelines
constructing multi-threaded pipelines of execution
-
overdose
Fast, Row Oriented, Kotlin, Scala-like dataframe
-
cooptex
Deadlock free Mutexes
-
unblock
thread pool for isolating blocking in async programs
-
turbolift
Easy distribution interface 🚡
-
managed-thread
Real fearless concurrency! Spawn threads that will be automatically destroyed when no longer needed
-
witty-actors
Fork of quickwit-actors, Actor framework used in quickwit
-
concurrency_traits
Traits for concurrent primitives
-
multithread
API for data-parallel tasks, rayon-lite
-
mlsp
small library for smart pointers that use both thread local and global atomic counters
-
simple_event_map
event map based on channels, provides a receiver that is either blocking or async
-
vlock
fast and scalable multi-version shared state lock with wait-free read access
-
secc
Implements a Skip-Enabled Concurrent Channel (SECC) for Rust
-
membarrier
Process-wide memory barrier
-
lockless
Composable, lock-free, allocation-light data structures
-
parallel_reader
reading from a file (or any
Read
stream) and processing it by chunks, in parallel -
spinning
Mutexes and SIX locks implemented by spinning
-
rdispatcher
Dispatcher for Rust, broadcast and subscribe many to many
-
concurrent-list
append-only, single-writer multi-reader unrolled linked list
-
send-cell
Immutable memory region with runtime Send checking
-
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.
-
update_channel
channel for single updatable values
-
exec-rs
that provides utility traits for task execution and, if the sync feature is enabled, the ability to synchronise tasks based on the value of a key
-
persistent_stack
Concurrent persistent stack
-
sync_cow
Thread-safe clone-on-write container for fast concurrent writing and reading
-
stoppable_thread
wrapper for thread that allows it to be easily stopped cooperatively
-
object-space
object store library for highly concurrent program written in Rust
-
par-dfs
Parallel, serial, and async dfs and bfs traversal
-
shardize
proc macro that generates code to create a sharded form of an existing container
-
erlang_nif-sys
Create Erlang NIF modules in Rust using the C NIF API
-
employer
Spawn worker threads and check on them later
-
init_guard
Synchronization Primitive for guarding against double initialization
-
concurrent-hashmap
concurrent hashmap library
-
scrummage
Fight over OS process prioritisation
-
tc-tensor
TinyChain's Tensor collection type
-
atomption
AtomicOption implementation with no safety issue
-
fused-reader
fused reader type that if writer thread dies while holding armed fuse the reader will get BrokenPipe error
-
lock-hierarchy
Prevent dead locks by enforcing lock hierarchies
-
rcell
Cell which can hold either an Arc or an Weak smartpointer or be empty
-
namedlock
Namespaces for named locks
-
axiom
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka
-
shared_channel
Multi-producer, multi-consumer FIFO queue communication primitives
-
waker-set
waker set
-
eventual
Future & Stream abstraction
-
atomic_prim_traits
Traits over primitive atomic types
-
ulock-sys
bindings for Darwin's (e.g. macOS, iOS, ...) not-entirely-public ulock API, which provides futex-like functionality.
-
takecell
cell type which value can only be taken once
-
benjamin_batchly
Low latency batching tool. Bundle lots of single concurrent operations into sequential batches of work.
-
dekker
Dekker's algorithm for mutual exclusion
-
fisher_processor
Processor of the Fisher crate
-
barriers
barrier spin lock implementation
-
threadfin
thread pool for running multiple tasks on a configurable group of threads
-
lendable_mutex
Ergonomic wrapper over a ReentrantMutex<RefCell<T>>; a mutex you can "lend out"
-
concurrent-slice
Extend slice-type types with methods for concurrent processing
-
testtools
Helpers for eliminating boilerplate code in tests
-
throttle2
threadsafe throttle (rate limiter) that maintains fixed time intervals between ticks
-
jobsys
Lockless Work Stealing Job System
-
moka
fast and concurrent cache library inspired by Java Caffeine
-
rayon_croissant
<lqd> bikeshedding the name: something that is mapped folded and collected, a 🥐
-
threads_pool
package provides an easy way to create and manage thread pools, so you don't have to
-
driver_async
async backend for
btle
,bluetooth_mesh
andusbw
crates -
try-rwlock
Fast non-blocking readers-writer lock
-
busan
actor implementation for Rust
-
tucan
fast, and multithreaded interner with loose type requirement
-
queuingtask
queueingtask is a library for running different threads in order in Rust
-
fd
File descriptor utilities
-
refcapsule
Safely send references to other threads
-
published_value
Publish a value from one thread to other threads
-
rstorage
fast, durable, high concurrent HashMap
-
once_mut
Safe mutable reference to static variable that can be obtained only once
-
coroutines
High performance coroutine library with native experience
-
stop-thread
Various ways of stopping threads on various platforms, without requiring the thread to poll
-
zonyitoo/coio
Coroutine scheduler with non-blocking I/O support
-
fibril_verifier
Verifies behavior for distributed systems implemented with the Fibril library
-
async-datachannel-wasm
Async Wrapper for WebRTC datachannel in the browser environment
-
promise
future/promise library for rust
-
pinnable
Mutex that can be pinned
-
sleepfast
Sleep for very small amounts of time quickly
-
hq9plus
HQ9+ interpreter made using Rust
-
lock_many
Retry-based locking multiple mutexes at once
-
bi_channel
Manage bidirectional mpsc channels more conveniently
-
run-them
CLI to launch a single command with many workers, serializing the output
-
hyaline-smr
Garbage Collector(Hyaline- Safe Memory Reclaimation) for lock free data structures
-
ppipe
elegantly simple and lightweight library for making iterator pipelines concurrent and blazingly fast, hence the name ppipe (parallel pipe)
-
channel_io
Reader implementation on channel of bytes
-
read-write-store
concurrent, unordered collection for Rust, where each element has an internally generated ID and a read-write lock
-
fan
Simplifies fanning-out (and eventually -in) with channels
-
syncbuf
Append-only data structures with lock-free thread-safety and constant-time indexing
-
diplomatic-bag
wrapper type that allows you to send
!Send
types to different threads -
dwt-systick-monotonic
RTIC Monotonic implemenation based on Systick and DWT
-
vin-core
Core types and traits for vin
-
concurrent-round-robin
concurrent wrr implementation for rust
-
atomic-destroy
value which can be atomically read and destroyed; like an atomic Option
-
thread-tree
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
-
gemino
multi producer multi consumer (MPMC) broadcasting channel
-
ditto
CRDTs for common data structures like maps, sets, vecs, strings, and JSON
-
mqtt_actor
mqtt adapters (from port and adapters) to be used with actix actors
-
mogul
Agnosticly helps to manage concurrent versions of things
-
shareable
Thread shareable objects using the minimal amount of synchronization
-
busybee
synchronous/thread-pool implementations of rpc_pb
-
page-lock
reading and writing data from bytes array
-
gaffer
Prioritised, parallel job scheduler with concurrent exclusion, job merging, recurring jobs and load limiting for lower priorities
-
dynqueue
Dynamically extendable Rayon parallel iterator
-
pulse
async wake signals
-
rustpython-common
General python functions and algorithms for use in RustPython
-
theatre
concise async actor model implementation
-
eventbus
Safe, fast and concurrent event system, inspired by the MinecraftForge event bus
-
parallel-event-emitter
Parallel Event Emitter for concurrent listener invocation based on futures-rs and futures-cpupool
-
uasync
fast, safe, async executor
-
acteur
safe actor-like framework that just works. Simple, robust, fast, documented.
-
stretto
high performance thread-safe memory-bound Rust cache
-
stdin_receiver
structure to help read from stdin in a separate thread, and a method to halt execution
-
consumable_vec
generic approach to create a mutual database for multiple producers and consumers
-
left-right-cell
cell with lock-free concurrent read access
-
readahead-iterator
Readahead from an iterator on a separate thread, returning items in order and synchronously
-
storage-map
Concurrent append-only map storage
-
runloop
Cancelable non-blocking polling threads (with optional timeouts)
-
crossbeam-skiplist_piedb
concurrent skip list
-
consume
Memory order consume for when it's known that the compiler can't elide the dependency
-
linenoise
Bindings to linenoise for simple line-editing facilities
-
ordered-parallel-iterator
Performs tasks in parallel returning completed tasks in order of appearance
-
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.
-
polyester
Parallel iterator adaptors that accept arbitrary iterators
-
pond
scoped and cached threadpools that keep a state
-
fslock
files as locks
-
query-graph
concurrent incremental query dependency graph system
-
atomic-story
brief overview of atomics and memory ordering on a multi-threaded context with examples
-
slave-pool
thread pool
-
caring
Sharing is caring: a safe library for mmap'ing memory in multiple processes
-
thread-locker
Thread locker library for Rust
-
thread_reviver
Discord bot to revive any archived threads (to counter Discord's auto-archive function)
-
ligmars
Safe bindings to the LGMP C library
-
mrogalski-looper
Clean abstraction for a single-threaded event loop. Built as a lightweight wrapper around the std::sync::mpsc package.
-
threadstack
more ergonomic and more flexible form of thread local storage
-
throttle
Time-based rate-limit utility
-
rusty-variation
deadlock-free session-typed communication
-
rusty-junctions-macro
Generation and Client Macro API for rusty-junctions
-
flow-mel
Mélodium core flow control library
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
contrie
Concurrent map and set
-
killable_thread
wrapper for thread that allows it to be easily stopped cooperatively
-
par-array-init
Convenience functions for initializing arrays in parallel
-
slurm
Interface to the Slurm workload manager
-
cnr
operation-log based approach for data replication
-
liblgmp-sys
Raw bindings to the LGMP library by gnif
-
fastuuid
Fast and lightweight generation of 192-bit uuids with support for 128-bit strings
-
taskpipe
multithreaded pipeline library
-
atomic64
Atomic 64-bits types
-
threadgroup
Manage groups of threads as one unit, join the first one that finishes, timeout on join attempts
-
grandma
lock-free, eventually consistent, concurrent covertree
-
conquer-util
concurrent and lock-free programming
-
zing
fast, fiber-based job system
-
debra-common
Common types, traits and base functionality for the DEBRA reclamation scheme
-
urcu
safe wrapper of the memb variant of the userspace RCU library
-
tiny-actor
minimal actor framework for Rust
-
is_main_thread
simply tool to check if current thread is the main one
-
concurrent-biproxy
proxy that concurrent transfer message from one client to an other client
-
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 -
boomerang
'Reactors' Deterministic Actor Model
-
mechanist
framework for writing highly concurrent applications
-
triex
Trivial Executor
-
amadeus-aws
Harmonious distributed data analysis in Rust
-
async-bulkhead
async semaphore-based bulkhead implementation
-
hyena
async task pool
-
runcc
run commands concurrently with rust and cargo
-
forkjoin
work stealing fork-join parallelism library for Rust
-
double-checked-cell-async
thread-safe lazily initialized cell using double-checked locking
-
stuck
Multi-threading scheduled task facility building on cooperative stackful coroutine
-
swym-htm
Hardware transactional memory for rust
-
snarc
Sendable Non-Atomically Reference Counted
-
ocl
OpenCL bindings and interfaces for Rust
-
workctl
number of higher-level control mechanisms for concurrent work scheduling, built on standard library concurrency primatives
-
rayon_logs
Traces for the rayon work-stealing library
-
zkmq
Message Queue, backed by Zookeeper
-
lock-wrappers
Lock RAII wrappers
-
static-instance
Create mutable static instances of an object
-
parking_lot_mpsc
port of the Rust std::sync::mpsc module, using the parking_lot concurrency types rather than those in the standard library
-
crs-bind
stripped down version of qvex/vex-rt so I can do less than safe things with QUEEN's bindings for my own crassipes project. Please don't actually use this unless you need to access the bindings directly.
-
brod
wrapper library providing an API for executing Kafka producers in parallel
-
bacon-rajan-ccc
Concurrent Cycle Collection based on the work by D.F. Bacon and V.T. Rajan
-
mutex
mutual exclusive lock
-
queuecheck
thread-safe queue testing and benchmarking library
-
skipchannel
skipchannels allow to communicate between threads, but always skip to the last sent value
-
bobbytables
Atomic hashmap for incrementing integers
-
channel-drain
Drain channels with simple syntax
-
spin-locks
Intel hardware-optimized spin lock that uses Hardware Lock Elision (HLE) and a non-CAS based spin lock (an OR lock) as a fast fallback
-
bondi
Single producer, multi consumer lock-free ring buffer (experimental)
-
swctx
One-shot channel with some special semantics
-
blasoxide-mt
multithreading for blasoxide
-
elysees
fork of triomphe, now with more pointer trickery
-
threadbeam
specialized channel type for beaming data out of a newly spawned thread
-
smartpool
very customizable, future-aware threadpool
-
lazy_id
thread-safe lazily-initialized ID
-
mcs
Synchronization primitives based on Mellor-Crummey and Scott’s (MCS) queueing spinlock. This library is usable without
std
. -
arc-guard
Guard around Arc<Mutex<T>> allowing you to write less boilerplate code
-
hurdles
Counter-based thread barrier
-
indicatif-log-bridge
Bridge the log crate and indicatif to stop log lines from mixing up with progress bars
-
atomic_immut
Atomic immutable value
-
ordered-locks
Compiletime deadlock avoidance
-
evelyn
event distribution library
-
arrows
actor framework in rust with message durability and ingestion order processing of of messages
-
rendezvous_swap
Swap data and sync execution between a pair of threads efficiently
-
greenie
Green threads and coroutines in stable Rust
-
simple-mutex
mutex more efficient than std and simpler than parking_lot
-
rolock
Read Only Lock
-
srcu
为 simink 提供 rcu 读写锁机制
-
irondash_run_loop
Consistent, platform-independent interface to system run loop
-
atomicmonitor
Effeciently await a condition on atomic data
-
specs-static
extension for Specs that adds custom ids
-
governor
rate-limiting implementation in Rust
-
multiprocessing
experimental crate for POSIX-based multiprocessing
-
atomic_box
struct which allows multiple threads to safely update and read from a shared non-nullable pointer to heap data
-
countdown_latch
synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes
-
bastion-qutex
Synchronization mechanisms that rely on lock-free and other non-(thread)blocking techniques, such as Rust futures, to guarantee mutually exclusive or shared exclusive access to data
-
one_at_a_time_please
serialising calls to functions
-
critical-section
Cross-platform critical section
-
rube
Unreleased project
-
quick_cache
Lightweight and high performance concurrent cache
-
go-spawn
that provides macros to spawn and join threads with minimal boilerplate
-
npnc
Lock-free queues
-
stoplight
stoppable tasks/threads
-
oncemutex
mutex providing one-time synchronized access, then safe unsynchronized access
-
par-map
Parallel map and flat_map
-
fencing
tokens
-
sea-streamer-kafka
🌊 SeaStreamer Kafka / Redpanda Backend
-
stream-kmerge
K-way merge for streams
-
asim
Discrete Event Simluation for Async Rust
-
tasklet
task scheduling library
-
barrage
async broadcast channel
-
futex-queue
efficient MPSC queue with timer capability based on Linux futex. Suitable for real-time applications.
-
conbox
small concurrency toolbox ment for games and realtime applications
-
spsc-bip-buffer
concurrent, spsc ring-buffer with sized reservations
-
work_pool
work queue wrapped by a thread pool
-
raliguard
Lazy rate limit semaphore implementation for your asynchronous code frequency execution
-
amadeus-commoncrawl
Harmonious distributed data analysis in Rust
-
counter64
64bit increase-only atomic counter for everywhere
-
ts_static
Wrapper macro for lazy static and a struct to aid in accessing a static in a thread safe way
-
async-rwlock
Async reader-writer lock
-
quinine
Atomic monotonic containers (Mono{Box,Arc})
-
thread-broadcaster
SPMC (Single producer multi consumer) broadcasting channel to broadcast notifications between threads
-
hadron-client
Hadron Rust client library
-
open-coroutine-core
open-coroutine is a simple, efficient and generic stackful-coroutine library
-
open-coroutine-hooks
syscall hook for open-coroutine
-
thread_binder
Bind rayon pools to limit numa effects
-
seqlock
reader-writer lock that provides extremely fast read access without starving writers
-
syncell
Sync alternative to RefCell
-
basedrop
Memory-management tools for real-time audio and other latency-critical scenarios
-
spliter
way to implement Rayon's ParallelIterator
-
monotone-cli
Monotonic counter cli implemented on top of AWS DynamoDB
-
os-unfair-lock
wrapper for Darwin os_unfair_lock
-
d3-core
framework for server development -- the core layer
-
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… -
ach-ring
Atomic Channel
-
scoped-thread
scoped thread implementation
-
rtic-monotonic
Core abstractions of the Real-Time Interrupt-driven Concurrency Monotonic timers
-
microamp-tools
Build a μAMP application
-
kudzu
concurrent, grow-only data structures
-
rtfm-syntax
Real Time for The Masses (RTFM) meta language
-
cpu-affinity
Cross-Platform CPU affinity
-
ccl-crossbeam-epoch
Epoch-based garbage collection
-
sorted-channel
sorted message-based communication channel
-
shipyard_scenegraph
Scenegraph for Entity Component System
-
stm-core
Software transactional memory. STM Allows composable atomic operations. STM-core implements the bare bones of stm usage. The STM crate adds useful data structures.
-
gamozolabs/aht
Pure Rust x86_64 bootloader and kernel
-
jtp
thread pool, similar to the ThreadPoolExecutor in java
-
guardian
owned mutex guards for refcounted mutexes
-
sentinel-rocket
Sentinel middleware for Rocket
-
rayon-tlsctx
thread local contexts for rayon loops
-
scheduled-executor
Single and multi-threaded task scheduler
-
ccl
Fast datastructures for use in highly concurrent systems
-
fragile
wrapper types for sending non-send values to other threads
-
tasque
thread pool library
-
fibril
implementing distributed systems with commmunicating fibers
-
minicoro-sys
binding to minicoro
-
dontshare
Prevent false sharing between data
-
lelet-simple-lock
lelet simple lock
-
ya-ring-buf
Ring Buffer. SPSC channel with direct access for bytes/Copy.
-
hwlocality-sys
Low-level bindings for the hwloc hardware locality library
-
async-oncecell
Asynchronous versions of OnceCell and Lazy
-
ssto
(coming soon) Safe Scoped Threads Only: a small dependency for scoped threads
-
metadata-store
store for recoverable metadata that is written in atomic batches
-
task_queue
thread pool for Rust
-
taskpile
threadpool implementation
-
matrix_engine
ecs engine for "thematrix" ecosystem
-
son_of_grid_engine
Interface with son of grid engine (formerly sun grid engine) to run rust programs on clusters
-
context-coroutine
set of extensions to provide stackful coroutines; it is not officially associated with the context crate
-
rayoff
rayon but it's map-reduce
-
lock_ext
extending functionalities of std::sync
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions
. -
conv-mel
Mélodium core types conversion library
-
mpsc_requests
mpsc channels but with a response
-
progpool
Job pool with terminal progress bar
-
threadReactive
Synchronous Reactive system
-
threadalone
any value Send + Sync but only available on its original thread. Don't use on multi-threaded environments!
-
datacake-eventual-consistency
Eventually consistent state replication as a library (consensus, RPC and conflict resolution) for building your own eventually consistent databases
-
embassy-time
Instant and Duration for embedded no-std systems, with async timer support
-
rtic-time
lib TODO
-
poolter
Thread Pool implementation for Rust using JavaScript Promise like functional syntax
-
kik_sync_service
synchronous threading worker channel for generating the results you want with the data you need
-
jobpool
lightweight threadpool implementation
-
parking_method
Obtain parking_lot locks by policy objects
-
drain
that supports graceful shutdown
-
observable-btree
Reactive Observable BTree
-
wrrm
Write-rarely-read-many wrapper
-
spsc-buffer
Single-producer single-consumer lock-free buffer
-
momen
low overhead thread pool
-
pmap
parallel map for rust
-
wasserglas
fixed size thread-safe object pool with automatic reattachment
-
scoped-pool
flexible thread pool providing scoped threads
-
bastion-utils
Bastion, the highly-available, fault-tolerant, async communication oriented executor
-
rusty-junctions-client-api-macro
convenient set of declarative macros used as part of the rusty-junctions-macro Client Macro API
-
cachemap2
concurrent insert-only hashmap for caching values
-
drop_worker
Tools for worker threads
-
extra_atomics
Abstraction over atomic ptr. Such as AtomicBox and AtomicArc.
-
padlock
Safely acquire RwLock/Mutex locks
-
atomic-memcpy
Byte-wise atomic memcpy
-
concache
fast, concurrent, shared hash map
-
c-map
Very fast concurrent hashmap
-
hiatus
Debug concurrent programs by choosing specific execution traces
-
topos-tce-api
reserve for further use
-
tange
Scalable Task-based Parallelism Framework
-
arbalest
Like Arc<T> but where weak references don't forbid mutable access
-
hybridfutex
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.
-
signal-notify
Catch OS signals with standard mpsc channel
-
paladin-core
distributed algorithm toolkit. Write distributed algorithms without the complexities of distributed systems programming.
-
instrumented-mpsc
Wrapper for futures mpsc unbounded providing Prometheus metrics
-
delay-queue
concurrent unbounded blocking queue where each element can only be removed when its delay expires
-
hv-lease-tracker
no-std compatible tracking of borrow origins, for providing better diagnostics when implementing interior mutability primitives
-
dashmap_with_out_t_map_trait
Blazing fast concurrent HashMap for Rust
-
async-once-watch
Asynchronous and shareable container which value is set once
-
multi_thread
run multiple threads which optionally share data
-
scheduling
job scheduler
-
waitable
synchronized (atomic) value container implementing the Mutex+Condvar pattern for efficient blocking waits
-
llq
Wait-free SPSC linked-list queue with individually reusable nodes
-
datacake-sqlite
pre-built implementation of datacake's Storage trait using SQLite
-
stochastic-queue
Queue and MPMC channel that pops in a random order
-
gzp
Parallel Compression
-
system-graph
experimental alternative for shred's Dispatcher
-
mailbox_processor_rs
Actor abstraction inspired by the FSharp MailboxProcessor
-
asparit
Async Parallel Iterators for Rust
-
chashmap-async
Concurrent async hash maps with key-scoped locking
-
colosseum
variety of arena allocators for Rust, including thread-safe arenas
-
extensions
typemap container with FxHashMap
-
ping-pong-cell
atomic cell for up to two threads
-
rwcell
- value container which allow to simultaneously read and modify value from two separate threads
-
flexible-locks
Flexible Locks
-
lagoon
thread pool crate with an array of features
-
sea-streamer-socket
🌊 SeaStreamer backend-agnostic Socket API
-
linux-rtic
Real-Time Interrupt-driven Concurrency (RTIC) implementation for Linux
-
spin_loop
-
poolite
lite threadpool library
-
horde
threads
-
worker-pool
handle a set of worker threads, which need to communicate back their result to the main thread
-
entangled
fork-join task executor
-
rjq
Redis job queue
-
actress
actor library for Rust
-
riffy
unbounded, wait-free, multi-producer-single-consumer queue
-
terminate
abstract logic to terminate threads, coroutines and the like
-
key-message-channel
Multi-producer single-consumer queue capable of queuing messages by message key
-
mini-moka
lighter edition of Moka, a fast and concurrent cache library
-
stateful_async_worker
Asynchronous stateful worker threads utilizable as futures
-
gothack-future-parking_lot
"as simple as possible" Future implementation for parking_lot
-
sentinel-actix
Sentinel middleware for Actix-Web
-
indexed-ring-buffer
indexed multiple readable spsc ring buffer
-
fibril_core
Core types for the Fibril library
-
ump-ng
Micro message passing library for threads/tasks communication
-
ctrlc_fnonce
Wrapper for ctrlc to execute a FnOnce and exit the process upon Ctrl-C
-
adaptive-barrier
Barrier with adaptable number of thread subsciptions
-
ice-threads
Lightweight Thread pool implementation
-
ach-array
Atomic Channel
-
pmpmc
priority multi producer multi consumer channel
-
tractor
Actor system modelled after Pony's actors
-
ferrous_threads
Task runner, thread pools, multi-producer, multi-consumer queues, oh my! This is a crate with helpers for building concurrent software easily and safely
-
fuze
mechanism to wait for a single signal which can be checked at any time
-
qadapt-spin
Synchronization primitives based on spinning. They may contain data, are usable without
std
, and static initializers are available -
mula
Share expensive computation with various requesters
-
lock-free-multi-producer-single-consumer-ring-buffer
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.
-
jobsteal
work-stealing fork-join threadpool written in Rust
-
portable-atomic-util
Synchronization primitives built with portable-atomic
-
melodium-loader
Loading engine for Mélodium, with dependency resolution and retrieval
-
phoenix-tls
creating always present thread locals
-
canal
multithreaded concurrency primitives, including queues and channels
-
pipeliner
nice interface for parallel programming with iterators
-
wasm_thread
std thread replacement for wasm32 target
-
mpmc
copy-pasted from old rust stdlib
-
static_locks
parking_lot
locks but usable in statics and const fn -
liblightning
High-performance general-purpose stackful coroutine library
-
apool
Async generic pool crate for rust
-
sync_2
little crate providing a Rust implemented Mutex and RwLock
-
unsync_channel
!Send/!Sync channels for Rust
-
semaphorus
Atomic semaphores
-
cpq
Concurrent Priority Queue implemented in Safe Rust
-
lf-queue
lock-free multi-producer multi-consumer unbounded queue
-
ach-util
Atomic Channel
-
more-sync
More synchronization utils
-
ringtail
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
rtic-common
lib TODO
-
pool_barrier
barrier for blocking a main thread until the completion of work which has been offloaded to worker threads, without blocking the worker threads
-
future-parking_lot
"as simple as possible" Future implementation for parking_lot
-
yaar-lock
Fast, no_std synchronization primitives
-
tinypool
thread pool implementation in Rust
-
cache-advisor
scan-resistant concurrent cache eviction manager
-
qrwlock
Fair queued read-write lock
-
locktree
Experimental compiler-checked deadlock-freedom
-
rearch-macros
Re-imagined approach to application design and architecture
-
async-semaphore
async semaphore
-
slottle
throttle pool library designed for thread-based concurrency
-
tyractorsaur
Typed Actor System
-
rustpool
data and thread pool library for Rust
-
yastl
scoped threadpool library
-
tange-collection
Dataflow computation
-
sea-streamer-runtime
🌊 SeaStreamer async runtime abstraction
-
sea-streamer-stdio
🌊 SeaStreamer Standard I/O Backend
-
lockness
TODO
-
mpmc-map
Mpmc async map implementation for highly concurrent low-write access
-
inert
lets you use non-Sync values in a Sync way
-
may_actor
Actor library based on MAY
-
synctree
Thread-safe tree data structure
-
rtfm-core
Core abstractions of the Real Time For the Masses framework
-
piscine
pool-workers library, in Rust
-
jxl-threadpool
Internal crate of jxl-oxide to abstract over thread pool implementation
-
amadeus-types
Harmonious distributed data analysis in Rust
-
hermitdb
private decentralized database replicated over Git (or any other distributed log)
-
sync
synchronization primitives
-
objpool
Thread-safe generic object pool
-
mpmc-scheduler
multi-mpmc, cancellable, scheduler with rate limiting
-
ump-server
Server message dispatch loop for ump
-
rw_lease
Fast Reader-Writer lock with reader draining support. Based on a single (parameterisable) atomic usize.
-
hv-guarded-borrow
Traits and implementations for generic use of "guarded" borrows
-
hv-elastic
Safe and almost-safe abstractions for lengthening lifetimes and
'static
“loaning” of non-'static
types -
sentinel-tower
Sentinel middleware for Tower
-
async-barrier
async barrier
-
channel_pipes
Perform operations on broadcast queues
-
hybrid-lock
hybrid lock with optimistic locking
-
moite_moite
Split a value in two owned parts
-
user-sync
user-space synchronization
-
xtra-addons
Add-on functionality (Broker, Registry) for crate xtra
-
simple_thread_pool
thread pool
-
ops-mel
Mélodium core operations library
-
rewrk-core
HTTP benchmarking as a library made simple
-
chashmap-next
Fast, concurrent hash maps with extensive API
-
batch_queue
single-producer single-consumer Rust queue with smart batching
-
closure-future
Easily run closures on thread pools and turn their result into Futures
-
callysto
Stream processing framework
-
refptr
Inherently reference counted structs
-
csq
Concurrent Set Queue implemented in Safe Rust