-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
spin
Spin-based synchronization primitives
-
crossbeam-utils
concurrent programming
-
futures-channel
Channels for asynchronous communication using futures-rs
-
crossbeam-epoch
Epoch-based garbage collection
-
thread_local
Per-object thread-local storage
-
crossbeam-deque
Concurrent work-stealing deque
-
try-lock
A lightweight atomic lock
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
rayon
work-stealing parallelism for Rust
-
sync_wrapper
enlisting the compiler's help in proving the absence of concurrency
-
jobserver
GNU Make jobserver for Rust
-
rayon-core
Core APIs for Rayon
-
async-lock
Async synchronization primitives
-
dashmap
Blazing fast concurrent HashMap for Rust
-
async-channel
Async multi-producer multi-consumer channel
-
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
crossbeam-queue
Concurrent queues
-
parking
Thread parking and unparking
-
radium
Portable interfaces for maybe-atomic types
-
flume
A blazingly fast multi-producer channel
-
waker-fn
Convert closures into wakers
-
portable-atomic
Portable atomic types including support for 128-bit atomics, atomic float, etc
-
threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
piper
Async pipes, channels, mutexes, and more
-
crossbeam
Tools for concurrent programming
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
atomic
Generic Atomic<T> wrapper type
-
scheduled-thread-pool
A scheduled thread pool
-
gix-lock
A git-style lock-file implementation
-
governor
A rate-limiting implementation in Rust
-
gix-features
integrate various capabilities using compile-time feature flags
-
moka
A fast and concurrent cache library inspired by Java Caffeine
-
blake2s_simd
a pure Rust BLAKE2s implementation with dynamic SIMD
-
fslock
files as locks
-
atomic-take
Atomically take a value out of a container once
-
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
-
state
safe and effortless global and thread-local state management
-
dispatch
Rust wrapper for Apple's Grand Central Dispatch
-
async-mutex
Async mutex
-
loom
Permutation testing for concurrent code
-
spinning_top
spinlock crate based on the abstractions provided by
lock_api
-
cache-padded
Prevent false sharing by padding and aligning to the length of a cache line
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
stateright
A model checker for implementing distributed systems
-
coarsetime
Time and duration crate optimized for speed
-
maybe-rayon
Either acts as rayon or creates a single-threaded facade
-
archery
Abstract over the atomicity of reference-counting pointers
-
file-per-thread-logger
A logging implementation that writes logs in one file per thread
-
async_once
async once tool for lazy_static
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
atomic_refcell
Threadsafe RefCell
-
sled
Lightweight high-performance pure-rust transactional embedded database
-
jwalk
Filesystem walk performed in parallel with streamed and sorted results
-
crossbeam-skiplist
A concurrent skip list
-
scc
High performance containers and utilities for concurrent and asynchronous programming
-
atomic-polyfill
Atomic polyfills, for targets where they're not available
-
corosensei
A fast and safe implementation of stackful coroutines
-
jod-thread
std::thread which joins on drop by default
-
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 -
atomic-shim
Atomic types for unsupported platforms
-
oncemutex
A mutex providing one-time synchronized access, then safe unsynchronized access
-
mintex
minimal mutex
-
atomic-counter
Atomic (thread-safe) counters for Rust
-
seqlock
A reader-writer lock that provides extremely fast read access without starving writers
-
dynamic-pool
a lock-free, thread-safe, dynamically-sized object pool
-
ratelimit
ratelimiter that can be shared between threads
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
synchronoise
Synchronization primitives that build upon the standard library
-
exit-future
Future that signals exit to many receivers
-
thread-priority
managing threads priority and schedule policies
-
quick_cache
Lightweight and high performance concurrent cache
-
cachemap2
A concurrent insert-only hashmap for caching values
-
atomic_float
Floating point types which can be safely shared between threads
-
runloop
Cancelable non-blocking polling threads (with optional timeouts)
-
kanal
The fast sync and async channel that Rust deserves
-
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 -
simple-mutex
A mutex more efficient than std and simpler than parking_lot
-
async-rwlock
Async reader-writer lock
-
antidote
Poison-free versions of the standard library Mutex and RwLock types
-
jobslot
GNU make jobserver for Rust
-
ringbuffer-spsc
A fast thread-safe single producer-single consumer ring buffer
-
sdd
Scalable lock-free memory reclaimer
-
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
-
rustc-rayon
work-stealing parallelism for Rust - fork for rustc
-
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
-
mock_instant
way to mock an std::time::Instant
-
spinning
Mutexes and SIX locks implemented by spinning
-
mini-moka
A lighter edition of Moka, a fast and concurrent cache library
-
concurrent_arena
u32 concurrent insertion/removal arena that returns ArenaArc
-
minstant
A drop-in replacement for
std::time::Instant
that measures time with high performance and high accuracy powered by TSC -
rtrb
A realtime-safe single-producer single-consumer ring buffer
-
inline-array
efficient immutable inlinable byte array
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
leaky-bucket
A token-based rate limiter based on the leaky bucket algorithm
-
shuttle
testing concurrent Rust code
-
async-condvar-fair
Condition variables for async Rust
-
thingvellir
a concurrent, shared-nothing abstraction that manages an assembly of things
-
fast-counter
A sharded concurrent counter
-
object-pool
A thread-safe object pool with automatic return and attach/detach semantics
-
memo-map
implementing a synchronized map for memoization
-
embassy-sync
no-std, no-alloc synchronization primitives with async support
-
indicatif-log-bridge
Bridge the log crate and indicatif to stop log lines from mixing up with progress bars
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
flurry
Rust port of Java's ConcurrentHashMap
-
seize
Fast, efficient, and robust memory reclamation for concurrent data structures
-
apalis-core
Core for apalis: simple, extensible multithreaded background processing for Rust
-
safe-lock
A lock struct with a
const fn
constructor and nounsafe
-
thingbuf
I'm at the buffer pool. I'm at the MPSC channel. I'm at the combination MPSC channel and buffer pool.
-
lockfree
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
packed_simd
Portable Packed SIMD vectors
-
chashmap
Fast, concurrent hash maps with extensive API
-
diatomic-waker
An async, lock-free synchronization primitive for task wakeup
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
rsevents
Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores
-
atomic_enum
An attribute to create an atomic wrapper around a C-style enum
-
reference-counted-singleton
Reference-counted singleton whose protected data can be recreated as needed
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
rtic-syntax
The Real-Time Interrupt-driven Concurrency (RTIC) meta language
-
conquer-util
concurrent and lock-free programming
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
recloser
A concurrent circuit breaker implemented with ring buffers
-
rtic-monotonic
Core abstractions of the Real-Time Interrupt-driven Concurrency Monotonic timers
-
hytra
Datastructure for fast multi-threaded updates
-
yastl
scoped threadpool library
-
svix-ksuid
A pure Rust and fully tested KSUID implementation
-
embassy-time-queue-driver
Timer queue driver trait for embassy-time
-
global_counter
Global, thread-safe counters
-
easy-parallel
Run closures in parallel
-
gzp
Parallel Compression
-
blocking-threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
rtic-core
Core abstractions of the Real-Time Interrupt-driven Concurrency framework
-
takecell
A cell type which value can only be taken once
-
cortex-m-rtic
Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems
-
atomic-arena
Generational arena allows reserving keys from other threads
-
spmc
channel
-
exclusion-set
a lock-free concurrent set
-
bmrng
async MPSC request-response channel for Tokio
-
append-only-vec
Append-only, concurrent vector
-
specs
Entity-Component-System library written in Rust
-
atomic-file-install
For atomically installing a file or a symlink
-
wasm_thread
An std thread replacement for wasm32 target
-
atomig
Generic, convenient and lock-free
std
atomics viaAtomic<T>
. Can be used with many primitive types (including floats) and with custom types. -
atomic-wait
Cross-platform atomic wait and wake (aka futex) functionality
-
watchable
RwLock-like type that is compatible with both multi-threaded and async code
-
crossfire
channels for async and threads
-
fs-lock
Locked files that can be used like normal File
-
xtensa-atomic-emulation-trap
An atomic emulation trap handler for non atomic Xtensa targets
-
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
-
left-right
A concurrency primitive for high concurrency reads over a single-writer data structure
-
gettid
Helper to get an integer ID for the current thread
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
ocl
OpenCL bindings and interfaces for Rust
-
readlock
A weird alternative to Arc<RwLock<T>>
-
cortex-m-rtic-macros
Procedural macros of the cortex-m-rtic crate
-
storage-map
Concurrent append-only map storage
-
hurdles
Counter-based thread barrier
-
process_control
Ergonomically run processes with limits
-
concurrent_lru
A concurrent LRU cache
-
wasm_sync
Synchronization primitives for both web and native
-
rattler_lock
Rust data types for conda lock
-
ordered-channel
A channel that always receives messages in the correct order, even if they were sent out of order
-
local-sync
Non-threadsafe data structure for async usage
-
rtic-time
lib TODO
-
sea-streamer-socket
🌊 SeaStreamer backend-agnostic Socket API
-
sea-streamer-file
🌊 SeaStreamer File Backend
-
sea-streamer-stdio
🌊 SeaStreamer Standard I/O Backend
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
sea-streamer-redis
🌊 SeaStreamer Redis Backend
-
sea-streamer
🌊 The stream processing toolkit for Rust
-
par-map
Parallel map and flat_map
-
atomic_once_cell
Thread-safe and lock-free OnceCell and Lazy
-
arc-cell
Helper for a simple Cell-like object containing Arc/Weak
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
piz
piz (a Parallel Implementation of Zip) is a ZIP archive reader designed to concurrently decompress files using a simple API
-
sea-streamer-kafka
🌊 SeaStreamer Kafka / Redpanda Backend
-
sea-streamer-types
🌊 SeaStreamer Traits & Types
-
roboplc
Framework for PLCs and real-time micro-services
-
swapper
Swap ownership between threads
-
packed_simd_2
Portable Packed SIMD vectors
-
sea-streamer-runtime
🌊 SeaStreamer async runtime abstraction
-
rust-releases-core
Base traits and definitions for rust-releases
-
slave-pool
thread pool
-
username
Portably retrieve the user name (and possibly other information in future versions) of the user running the current thread
-
portable_atomic_enum
An attribute to create an portable atomic wrapper around a C-style enum
-
async-semaphore
An async semaphore
-
stretto
high performance thread-safe memory-bound Rust cache
-
surrealkv
A low-level, versioned, embedded, ACID-compliant, key-value database for Rust
-
concread
Concurrently Readable Data-Structures for Rust
-
raw_sync_2
Lightweight wrapper around OS synchronization primitives
-
atomic-destructor
Atomic destructor for multi-threaded env
-
timely-communication-master
Communication layer for timely dataflow
-
async-compatibility-layer
an abstraction layer for using both async-std and tokio
-
boxcar
A concurrent, append-only vector
-
maybe_parallel_iterator
Toggle parallelism with feature flags!
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
async-liveliness-monitor
A Liveliness Monitor for your Asynchronous Runtimes
-
rayon-scan
A parallel prefix scan function for ParallelIterator
-
fslock-arti-fork
files as locks, forked for use in Arti
-
st3
A very fast lock-free, bounded, work-stealing LIFO queue
-
pariter
Parallel iterator processing
-
uid
creation of unique IDs
-
proc-lock-api
APIs for the proc-lock crate
-
colosseum
A variety of arena allocators for Rust, including thread-safe arenas
-
rtic
Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems
-
portable-atomic-util
Synchronization primitives built with portable-atomic
-
pflock
A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
systick-monotonic
RTIC Monotonic implementation based on SysTick
-
rtic-monotonics
that provides implementations of the Monotonic trait from rtic-time
-
orx-concurrent-iter
A thread-safe, ergonomic and lightweight concurrent iterator trait and efficient implementations
-
rtic-common
lib TODO
-
atomic-time
AtomicDuration
,AtomicOptionDuration
,AtomicSystemTime
,AtomicOptionSystemTime
,AtomicInstant
andAtomicOptionInstant
for Rust -
asyncgit
allow using git2 in a asynchronous context
-
mpi
Message Passing Interface bindings for Rust
-
queue-ext
The extended feature of the queue can convert the pop() function of the queue to Stream and the push() function to Sender
-
once_map
Single assignment and lazy maps
-
rtic-sync
Synchronization primitives for asynchronous contexts
-
jumphash
A Fast, Minimal Memory, Consistent Hash Algorithm
-
mpsc
mpsc channel
-
left-right-cell
A cell with lock-free concurrent read access
-
rclite
small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs
-
picokafka
Kafka library for tarantool-module based on librdkafka
-
redlock
distributed locking mechanism built on top of Redis
-
atomicring
AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer
-
loole
A safe async/sync multi-producer, multi-consumer channel
-
timedmap
A hash map with expiring key-value pairs
-
mpmc
copy-pasted from old rust stdlib
-
watch
A synchronous message passing channel that only retains the most recent value
-
htb
Hierarchical token bucket implementation
-
threadbound
Make any value Sync but only available on its original thread
-
rc_event_queue
VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue
-
disruptor
Low latency inter-thread communication via a ringbuffer (inspired by the LMAX Disruptor)
-
glommio
thread-per-core crate that makes writing highly parallel asynchronous applications in a thread-per-core architecture easier for rustaceans
-
async-events
Waiting for external task completion in asynchronous Rust code
-
yazi-scheduler
Yazi task scheduler
-
padlock
Safely acquire RwLock/Mutex locks
-
thepipelinetool_task
task package used for thepipelinetool
-
pulse
async wake signals
-
rtic-macros
Procedural macros, syntax parsing, and codegen of the RTIC crate
-
std-semaphore
A counting, blocking sempahore extracted from rust 1.7.0
-
async-stm
Asynchronous Software Transactional Memory
-
graph
high-performant graph algorithms
-
portable_atomic_enum_macros
An attribute to create an portable atomic wrapper around a C-style enum
-
thread_tryjoin
Try joining a thread