-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
spin
Spin-based synchronization primitives
-
rayon
work-stealing parallelism for Rust
-
dashmap
Blazing fast concurrent HashMap for Rust
-
flume
A blazingly fast multi-producer channel
-
thread_local
Per-object thread-local storage
-
crossbeam
Tools for concurrent programming
-
async-channel
Async multi-producer multi-consumer channel
-
threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
async-lock
Async synchronization primitives
-
loom
Permutation testing for concurrent code
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
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
-
scc
High performance containers and utilities for concurrent and asynchronous programming
-
sled
Lightweight high-performance pure-rust transactional embedded database
-
blake2s_simd
a pure Rust BLAKE2s implementation with dynamic SIMD
-
state
safe and effortless global and thread-local state management
-
thread-priority
managing threads priority and schedule policies
-
stateright
A model checker for implementing distributed systems
-
leaky-bucket
A token-based rate limiter based on the leaky bucket algorithm
-
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
-
mpi
Message Passing Interface bindings for Rust
-
atomic_refcell
Threadsafe RefCell
-
jobserver
GNU Make jobserver for Rust
-
thingbuf
I'm at the buffer pool. I'm at the MPSC channel. I'm at the combination MPSC channel and buffer pool.
-
try-lock
A lightweight atomic lock
-
radium
Portable interfaces for maybe-atomic types
-
archery
Abstract over the atomicity of reference-counting pointers
-
async-condvar-fair
Condition variables for async Rust
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
may
Rust Stackful Coroutine Library
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
rtrb
A realtime-safe single-producer single-consumer ring buffer
-
mock_instant
way to mock an std::time::Instant
-
futures-channel
Channels for asynchronous communication using futures-rs
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
scheduled-thread-pool
A scheduled thread pool
-
shuttle
testing concurrent Rust code
-
pueue
A cli tool for managing long running shell commands
-
corosensei
A fast and safe implementation of stackful coroutines
-
atomic-take
Atomically take a value out of a container once
-
waker-fn
Convert closures into wakers
-
sea-streamer
🌊 The stream processing toolkit for Rust
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
async_once
async once tool for lazy_static
-
ratelimit
ratelimiter that can be shared between threads
-
svix-ksuid
A pure Rust and fully tested KSUID implementation
-
sync_wrapper
enlisting the compiler's help in proving the absence of concurrency
-
hwlocality
Idiomatic Rust bindings for the hwloc hardware locality library
-
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
-
spinning_top
spinlock crate based on the abstractions provided by
lock_api
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
gix-lock
A git-style lock-file implementation
-
mco
Rust Coroutine Library like go
-
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 -
picokafka
Kafka library for tarantool-module based on librdkafka
-
orx-concurrent-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance concurrent collection
-
dispatch
Rust wrapper for Apple's Grand Central Dispatch
-
messaging_thread_pool
aiding the creation of typed thread pool of objects that is communicated with via channels
-
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…
-
parallel-sh
Execute commands in parallel
-
watchable
RwLock-like type that is compatible with both multi-threaded and async code
-
runnel
the pluggable io stream. now support: stdio, string io, in memory pipe
-
atomig
Generic, convenient and lock-free
std
atomics viaAtomic<T>
. Can be used with many primitive types (including floats) and with custom types. -
jobslot
GNU make jobserver for Rust
-
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 -
ocl
OpenCL bindings and interfaces for Rust
-
crossfire
channels for async and threads
-
boxcar
A concurrent, append-only vector
-
recloser
A concurrent circuit breaker implemented with ring buffers
-
inline-array
efficient immutable inlinable byte array
-
memo-map
implementing a synchronized map for memoization
-
vin
An ergonomic actor framework
-
desync
A hassle-free data type for asynchronous programming
-
rayon-progress-bar
work-stealing parallelism for Rust
-
callysto
Stream processing framework
-
maitake-sync
No-std async synchronization primitives from Maitake
-
mpstthree
implementing Multiparty Session Types for 2 or more participants
-
lockable
offers hash map and cache data structures where individual entries can be locked
-
resman
Runtime managed resource borrowing
-
oqueue
Non-interleaving multithreaded output queue
-
mcslock
Mellor-Crummey and Scott contention-free spin-lock for mutual exclusion, referred to as MCS lock
-
idr-ebr
An efficient concurrent ID to object resolver
-
kameo
Fault-tolerant Async Actors Built on Tokio
-
indicatif-log-bridge
Bridge the log crate and indicatif to stop log lines from mixing up with progress bars
-
choir
Task Orchestration Framework
-
signals2
A thread-safe signal/slot library inspired by boost::signals2
-
st3
A very fast lock-free, bounded, work-stealing LIFO queue
-
local-sync
Non-threadsafe data structure for async usage
-
someday
Lock-free MVCC primitive
-
sharded_queue
ShardedQueue is currently the fastest concurrent collection which can be used under highest concurrency and load
-
lever
Pillars for Transactional Systems and Data Grids
-
pi_share
rc, arc, lock, atomic
-
no_deadlocks
A Runtime Deadlock Debugger
-
perthread
ThreadMap structure for accessing PerThread thread local variables form a static context
-
open-coroutine
efficient and generic stackful-coroutine library
-
everygarf
Concurrently download every Garfield comic to date
-
flurry
Rust port of Java's ConcurrentHashMap
-
orx-concurrent-iter
A thread-safe, convenient and lightweight concurrent iterator trait and efficient implementations
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
par-iter-sync
Parallel Iterator With Sequential Output
-
keepcalm
shared types for multi-threaded programs
-
thread-manager
A streamlined Rust library for efficient thread pooling and parallel job execution, designed for simplicity, flexibility, and performance
-
deqp-runner
A VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline
-
crony
cron runner that spawns another thread to run your cron jobs
-
rearch
Re-imagined approach to application design and architecture
-
surrealkv
A low-level, versioned, embedded, ACID-compliant, key-value database for Rust
-
paladin-core
distributed algorithm toolkit. Write distributed algorithms without the complexities of distributed systems programming.
-
rustc-rayon
work-stealing parallelism for Rust - fork for rustc
-
io-reactor
Concurrent I/O resource management using reactor pattern
-
mpvipc
A small library which provides bindings to control existing mpv instances through sockets
-
crossbeam-utils
concurrent programming
-
ringbuffer-spsc
A fast thread-safe single producer-single consumer ring buffer
-
infinitree
Embedded, encrypted database with tiered cache
-
timely-communication-master
Communication layer for timely dataflow
-
seize
Fast, efficient, and robust memory reclamation for concurrent data structures
-
kanal
The fast sync and async channel that Rust deserves
-
omango
Concurrency collections
-
roboplc
Framework for PLCs and real-time micro-services
-
thingvellir
a concurrent, shared-nothing abstraction that manages an assembly of things
-
atomic_once_cell
Thread-safe and lock-free OnceCell and Lazy
-
s3put
Upload a single file/stream to S3 using chunks
-
minstant
A drop-in replacement for
std::time::Instant
that measures time with high performance and high accuracy powered by TSC -
fault-injection
fault injection, concurrency delay injection, and error source annotation
-
freezebox
deref'able lazy-initialized container
-
utils-atomics
Various atomic utils
-
rw-cell
Write data to cell from anything place your application without copy, lock and reading in one place
-
latches
A downward counter (CountDownLatch) which can be used to synchronize threads or coordinate tasks
-
melodium
Dataflow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely
-
oxidd-manager-index
Index-based manager implementation for OxiDD
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
shipyard_scenegraph
Scenegraph for Entity Component System
-
async-skipdb
An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine
-
namaste
-
trauma
Simplify and prettify HTTP downloads
-
file-per-thread-logger
A logging implementation that writes logs in one file per thread
-
happylock
Free deadlock prevention
-
kueue
A robust, user-level, work-stealing, distributed task scheduler
-
atomptr
A safe, dependency-less abstraction for typed atomic smart pointers
-
ptr_cell
Thread-safe cell based on atomic pointers to externally stored data
-
salsa
A generic framework for on-demand, incrementalized computation (experimental)
-
timedmap
A hash map with expiring key-value pairs
-
tonari-actor
A minimalist actor framework aiming for high performance and simplicity
-
rtic-syntax
The Real-Time Interrupt-driven Concurrency (RTIC) meta language
-
concurrent_arena
u32 concurrent insertion/removal arena that returns ArenaArc
-
rclite
small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs
-
renoir
Network of Operators In Rust
-
mutringbuf
A very simple lock-free SPSC ring buffer, with in-place mutability
-
bastion
Fault-tolerant Runtime for Rust applications
-
ppl
A structured parallel programming library for Rust
-
async-stm
Asynchronous Software Transactional Memory
-
aarc
Atomically updatable variants of Arc and Weak for lock-free concurrency
-
append-only-vec
Append-only, concurrent vector
-
sync_file
Files that can be read concurrently
-
fiddler-cli
Data Stream processor CLI written in rust
-
thread_io
performing I/O in background thread
-
async-local
For using thread locals within an async context and across await points
-
concurrent-map
a lock-free linearizable B+ tree
-
batch-aint-one
I got 99 problems, but a batch ain't one
-
permit
A struct for cancelling operations
-
pi_atom
The global thread safe atomic string pool reduces the memory occupation of the same string and is also used for HashMap keys
-
command-executor
Command Executor thread pool
-
balter
A load/stress testing framework
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
work-queue
A concurrent work-stealing queue for building schedulers
-
swap-buffer-queue
A buffering MPSC queue
-
sdd
Scalable lock-free memory reclaimer
-
atom_box
A safe idiomatic Rust implementation of Atomic Box using hazard pointers
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
lock_ext
Extensions to std::sync::Mutex
-
rcu_cell
a lockless rcu cell implementation
-
atomic-file-install
For atomically installing a file or a symlink
-
atomic_enum
An attribute to create an atomic wrapper around a C-style enum
-
jod-thread
std::thread which joins on drop by default
-
tasklet
A task scheduling library
-
portable_atomic_enum
An attribute to create an portable atomic wrapper around a C-style enum
-
blocking-threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
evident
Pub/Sub library using IDs to identify events
-
atomic
Generic Atomic<T> wrapper type
-
timeslice
periodic time slice scheduler
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
tracing-mutex
Ensure deadlock-free mutexes by allocating in order, or else
-
atomic-time
AtomicDuration
,AtomicOptionDuration
,AtomicSystemTime
,AtomicOptionSystemTime
,AtomicInstant
andAtomicOptionInstant
for Rust -
atomic_float
Floating point types which can be safely shared between threads
-
atomic-interval
A tiny implementation of an atomic timer
-
redlock
distributed locking mechanism built on top of Redis
-
rtic-time
lib TODO
-
rsevents
Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores
-
mintex
minimal mutex
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
reactivate
Thread Safe Reactive Data Structure. Made with ❤️ for 🦀
-
maybe-rayon
Either acts as rayon or creates a single-threaded facade
-
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
-
actify
An intutive actor model with minimal boilerplate
-
incr
fast and self-contained data structures for checking whether a new value is greater than the previous maximum
-
bi
-
rose_bloom
A concurrent growing element size linked list with stable pointers
-
active_standby
A concurrency primitive for high concurrency reads
-
atomicring
AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer
-
mpsc
mpsc channel
-
print_queues
A print queues that can be add from different thread and print on main thread
-
threadbound
Make any value Sync but only available on its original thread
-
ordered-channel
A channel that always receives messages in the correct order, even if they were sent out of order
-
pariter
Parallel iterator processing
-
navactor
A cli tool for creating and updating actors from piped input
-
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…
-
pi_key_alloter
lock free Key(idx:u32, version:u32) alloter
-
parallel-processor
Framework to manage asynchronous execution of multiple compute units communicating using messages
-
synchronized
Convenient and simple macro for code synchronization in multithreading
-
amadeus
Harmonious distributed data processing & analysis in Rust. parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common crawl
-
tari_shutdown
A convenient shutdown signal
-
trc
A faster Arc
-
atomic-shim
Atomic types for unsupported platforms
-
guardian
owned mutex guards for refcounted mutexes
-
amity
Concurrency algorithms
-
fork-map
running operations in a child process spawned by
fork()
-
easy-parallel
Run closures in parallel
-
sharded-thread
Expirement for now
-
left-right-cell
A cell with lock-free concurrent read access
-
async-cpupool
async threadpool for CPU-bound tasks
-
semka
Semaphore implementation
-
dagrs
The 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.
-
reord
Run your tests multi-threaded, but in a reproducible way
-
sharded_mutex
No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.
-
async-ringbuf
Async SPSC FIFO ring buffer
-
left-right
A concurrency primitive for high concurrency reads over a single-writer data structure
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
atomic-wait
Cross-platform atomic wait and wake (aka futex) functionality
-
yazi-scheduler
Yazi task scheduler
-
rayon-scan
A parallel prefix scan function for ParallelIterator
-
arthouse
Art-Net (DMX over UDP/IP) adapter for Project Lighthouse
-
cargo-steady-state
Code generator for steady_state projects based on a structured dot file
-
asyncgit
allow using git2 in a asynchronous context
-
mpmc-async
A multi-producer, multi-consumer async channel with reservations
-
fast-logger
Fast logger for Rust
-
rust-debugging-locks
debugging locks in Rust
-
crossbeam-queue
Concurrent queues
-
pausable_clock
A source of time information that can be paused and resumed
-
blackhole
...to throw your threads into
-
watch
A synchronous message passing channel that only retains the most recent value
-
round_mult
A tiny library to round a number up or down to a multiplier
-
blaze-rs
A Rustified OpenCL Experience
-
file_rw
high-performance, memory-mapped file I/O utilities
-
myriam
Remote actors on top of libp2p
-
tatl
in-process alerting
-
sigq
Queue that signals waiting consumers about node availability
-
lfchring
Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication
-
callback_cell
Like an Atomic<Option<Box<FnOnce()>>>
-
sparking-lot-core
parking on addresses
-
gabriel2
Indeed, an actor library, not a framework, written in Rust
-
spmc
channel
-
shmap
A key-value store based on unix shared-memory files (shm) for persisting state across program restarts
-
multithreading
in Rust
-
may_waiter
coroutine communication blocker
-
leaklist
concurrent, lock-free, singly-linked list
-
lock_pool
Robust, efficient, high performance, asynchronous object pooling
-
hyperbridge
Fast multi-producer multi-consumer channel with async support
-
querent-synapse
bridge capable of handling and executing querent workflows and be able to respond to incoming events via callbacks. Acting like a synapse between querent and the outside world.
-
employees
A small runtime that hides all the boilerplate when using threads
-
arcow
Atomically Reference-counted Copy-On-Write shared pointer
-
chess_dl
Chess.com game downloader
-
stuck
Multi-threading scheduled task facility building on cooperative stackful coroutine
-
deborrow
Splits mutable references safely into their fields, and helps with reference manipulation
-
atomicell
Multi-threaded RefCell on atomics
-
semaphore-key
control concurrent thread access by key using a shared semaphore
-
node-replication
An operation-log based approach that transform single-threaded data structures into concurrent, replicated structures
-
global_counter
Global, thread-safe counters
-
retry-if
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
threadalone
Make any value Send + Sync but only available on its original thread. Don't use on multi-threaded environments!
-
async_nursery
Primitive for structured concurrency
-
tlrepo
Thread-local git2::Repository, shareable across threads
-
executor-service
A fast and efficient Thread Pool like Java ExecutorService
-
parking
Thread parking and unparking
-
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!)
-
stewart
A minimalist, high-performance, and non-exclusive actor system
-
executors
A collection of high-performance task executors
-
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
-
peace-lock
A zero-cost abstraction lock that helps check contention free algorithms
-
quartz_sched
Minimalistic scheduling library for Rust
-
task_pool
Flexible abstraction for task-based composable multithreading
-
sync42
synchronization tools
-
oxidd-manager-pointer
Pointer-based manager implementation for OxiDD
-
smolscale2
hitdns fork of original smolscale
-
rush_core
The rules engine is based on the rete algorithm
-
session_types
session types in Rust
-
wasm_sync
Synchronization primitives for both web and native
-
rayon_iter_concurrent_limit
Limit the concurrency of an individual rayon parallel iterator method with a convenient macro
-
omango-futex
Futex for Rust
-
idle
Collection of idle strategies to be used by thread(s) when they have no work to perform
-
visa
(Virtual Instrument Software Architecture) Wrapper which allows concurrent and dynamic switching between visa implementations from different vendors
-
txn_lock
support transactional versioning
-
antidote
Poison-free versions of the standard library Mutex and RwLock types
-
orx-concurrent-vec
An efficient, convenient and lightweight grow-only read & write concurrent data structure allowing high performance concurrent collection
-
lockfree
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
skipdb
An embedded, in-memory, zero-copy, ACID, MVCC, almost lock-free and serializable snapshot isolation database engine
-
jtp
thread pool, similar to the ThreadPoolExecutor in java
-
ora-worker
Part of the Ora scheduler framework
-
snowdon
A lightweight thread-safe snowflake ID implementation for Rust
-
kontroli
Type checking for the lambda-Pi calculus modulo rewriting
-
single_value_channel
Concurrent single-value update and receive channel
-
fenic
test concurrent code
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
flowync
multithreading a/synchronization
-
rpools
A minimalist workerpool for rust
-
uactor
The fastest and most modular actor system that doesn’t force you to pay for what you don’t need
-
congee
ART-OLC concurrent adaptive radix tree
-
multichannel
A multi producer single consumer bundle of channels with configurable priorities, weights and the ability to freeze specific channels
-
shrink_pool
A thread pool which agressively terminates its threads as soon as they are idle
-
crawly
A lightweight async Web crawler in Rust, optimized for concurrent scraping while respecting
robots.txt
rules -
zallocator
Amortizes the cost of small allocations by allocating memory in bigger chunks
-
stm
Software transactional memory. Allows composable atomic operations.
-
interaction-calculus
A parallel model of computation
-
libmcl-sys
This system crate provides Rust language bindings to the Minos Compute Library (MCL)
-
uf_rush
A lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure
-
uid
creation of unique IDs
-
operational-transform
Operational Transformation
-
drain
that supports graceful shutdown
-
parking_lot_rt
Parking-lot fork for real-time applications
-
rayon-wasm
work-stealing parallelism for Rust
-
gpu_rand
GPU-friendly random number generators for the Rust CUDA Project
-
app-world
A framework agnostic approach to managing frontend application state
-
chashmap-async
Concurrent async hash maps with key-scoped locking
-
swap_channel
A safe lock-free parallel communication channel based on mem::swap
-
with_lock
Deadlock freedom
-
flashmap
A lock-free eventually consistent concurrent hash map
-
rider
bounded executor for tokio; limit the count of tasks running 🚦
-
rearch-effects
Re-imagined approach to application design and architecture
-
sea-streamer-redis
🌊 SeaStreamer Redis Backend
-
crosstalk
An extremely lightweight, topic-based, cross-thread, in-memory communication library
-
parseq
Parallel sequential iterator
-
loole
A safe async/sync multi-producer, multi-consumer channel
-
synchronoise
Synchronization primitives that build upon the standard library
-
rewrk
HTTP benchmarking tool
-
ratelimit_meter
A leaky-bucket-as-a-meter rate-limiting implementation in Rust
-
hopper
an unbounded mpsc with bounded memory
-
wei-scheduler
wei scheduler
-
flue
An efficient and secure actor runtime library
-
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
-
async_logger
Asyncronous logger allows writing arbitrary slices to a memory buffer, which then processed by a writer in it's own thread
-
folklore
A lock-free concurrent hash map
-
cloudi
API
-
ump
Micro message passing library for threads/tasks communication
-
range-lock
Range lock for std::vec::Vec
-
rc_event_queue
VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue
-
may_queue
May's internal queue library
-
constellation-internal
Common components for the
constellation
framework -
threadcell
A cell whose value can only be accessed by a owning thread
-
zestors
A fast and flexible actor-framework for building fault-tolerant Rust applications
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
entropy-ecs
一个虚拟世界
-
ligmars
Safe bindings to the LGMP C library
-
todc-utils
building and testing distributed systems
-
fast-able
The world's martial arts are fast and unbreakable; 天下武功 唯快不破
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
caos
Concurrent Append Only Segment-list
-
aramid
Synthetic fibers
-
pulse
async wake signals
-
threadpool-executor
A threadpool executor
-
rusty_junctions
Join Pattern implementation in Rust
-
crius
hystrix-like circuit breaker
-
crossbeam-deque
Concurrent work-stealing deque
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
halt
functionality for pausing, stopping, and resuming iterators, readers, and writers
-
redsync
Redlock for distributed locks with Redis
-
atomic-destructor
Atomic destructor for multi-threaded env
-
throttle-client
Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.
-
radicle-node
The Radicle Node
-
thread-object
Abstraction over thread-local storage allowing dynamic creation of TLS variables
-
disrustor
This project is a port of the LMAX Disruptor to Rust
-
simt
compute support for rust
-
coroutine
in Rust
-
thread_lake
A very high level thread pool manager
-
ebr
epoch-based reclamation with low cacheline ping-pong
-
workerpool-rs
workerpool for rust
-
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…
-
sas
Salty-and-Sweet one-line Rust Runtime Performance Optimization Library
-
tc-scalar
TinyChain's scalar value enum, including concurrently-resolvable op definitions and references
-
nolock
A collection of Lock-Free Datastructures
-
rt-history
An RT-safe history log with error checking
-
simple-rw-global
GlobalContainer based on std::sync::RwLock
-
pi_arr
lock-free & auto-expansion array
-
refcell-lock-api
A single-threaded implementation of lock_api for RefCell, to alllow abstracting between single-threaded & multi-threaded code
-
sentinel-core
The flow sentinel of your microservices
-
libblobd-direct
blobd, direct variant
-
spinning
Mutexes and SIX locks implemented by spinning
-
moro
Experimental structured concurrency support for async Rust (similar to trio's nurseries)
-
fast-counter
A sharded concurrent counter
-
ductile
A channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface
-
workpool
Distribute work to a set of threads and wait for completion
-
goko
A lock-free, eventually consistent, concurrent covertree
-
hammer-cli
Hammer is a no-config cli tool for running concurrent tasks with monorepo support
-
arc-cell
Helper for a simple Cell-like object containing Arc/Weak
-
whisk
fast lockless async channels
-
tlid
Thread Local ID generator by predefined range without atomics/locks/random/time
-
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. -
async-events
Waiting for external task completion in asynchronous Rust code
-
yaambo
concurrent skip lists
-
poolio
A thread-pool
-
threatpool
thread pool
-
par-dfs
Parallel, serial, and async dfs and bfs traversal
-
read-write-api
interface to unify single-threaded code and RwLocks-based code
-
rtic-monotonic
Core abstractions of the Real-Time Interrupt-driven Concurrency Monotonic timers
-
taskschd
windows taskschd demo
-
tinypool
thread pool implementation in Rust
-
pcp-mutex
A Priority Ceiling Protocol (PCP) mutex, based on Linux PI futex. Allows efficient and deadlock free execution.
-
burstq
A multi-producer, multi-consumer channel that supports sending or receiving multiple values in a single operation
-
classic-sync
ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems
-
oxidd-rules-bdd
Binary decision diagrams (BDDs) for OxiDD
-
async-datachannel
Async Wrapper for datachannel
-
mvsync
A standalone async and worker thread library, with expandable traits and command buffers
-
winhooker
a helper for hooking functions in windows on x64
-
context
Cooperative multitasking for Rust using Boost.Context
-
atomx
Thread safe data structures based on atomic data types
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
pargraph
Operator based parallel graph processing
-
supermon
A set of utilities for coordinating watchers, middleware, and consumers via channels
-
lock-free-static
Lock-free static variables
-
datacake-crdt
A conflict free replicated datatype based on a hybrid logical clock implementation for building eventually consistent data stores
-
xtensa-atomic-emulation-trap
An atomic emulation trap handler for non atomic Xtensa targets
-
evlru
An eventually consistent LRU designed for lock-free concurrent reads
-
cuda_std
Standard library for CUDA with rustc_codegen_nvvm
-
rly
Run shell commands concurrently with ease. Currently only a CLI tool.
-
flo_stream
Pubsub and related streams for Rust futures
-
either-slot
An atomic slot whose senders can either place their value into the slot, or retrive all the data from the slot
-
leapfrog
A fast, lock-free concurrent hash map
-
txn
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
parsli
Parallel status lines for Rust
-
hey_listen
An event-dispatcher-collection offering async, sync, parallel, and prioritised solutions!
-
PRUEBA
Colas tarea
-
jthread
Deadlock-free Mutual Exclusion locks for Rust
-
ach-cell
Atomic Channel
-
potential
Borrowing for futures - Potential enables interior mutation using mutex and asynchronous borrowing (leasing) through a oneshot channel
-
shared_resources
shared resources container which is thread-safe, and lock-free
-
sync_2
A little crate providing a Rust implemented Mutex and RwLock
-
per-thread-object
Efficient per-object thread-local storage implementation
-
task-exec-queue
A asynchronous task execution queue
-
leanify-many
spawn leanify subprocesses
-
open-coroutine-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
concurrent_lru
A concurrent LRU cache
-
xloc
A fast, multi-threaded line counting utility written in Rust
-
rustodrive
Rust bindings for controlling multiple ODrives with the CAN protocol
-
yuki
multithreaded web archiver
-
tourniquet-tonic
Async native round-robin manager for remote services. Tonic integration.
-
fluxion
actor framework written in rust and designed for distributed systems
-
shared-local-state
shared local state registry for use in EBR, IO, etc
-
blinkcast
Fast, bounded, multiple-producer, multiple-consumer, lossy, broadcast channel
-
swimming
Dive into Efficiency with Swimming: A High-Performance, No-Nonsense Connection Pool
-
pawawwewism
a wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3
-
readfish-tools
Tools for analysing adaptive sampling data
-
pime
Rust Python Integration Made Easy
-
async-map-reduce
Fast map-reduce based on threading
-
lockpool
offers a pool of locks where individual locks can be locked/unlocked by key
-
ballista-scheduler
Ballista Distributed Compute - Scheduler
-
native-timer
Timer library which uses OS timer capabilities
-
stakker_log
Logging support for Stakker
-
zkstate
Share a struct across multiple instances of an application using zookeeper
-
hala-lockfree
Some lockfree structure for rust
-
cuneiform-fields
Field level [no_std] cache optimizations for Rust
-
testtools
Helpers for eliminating boilerplate code in tests
-
amfiteatr_proc_macro
Procedural macro crate for amfiteatr_* crates
-
ns3-parallel
A Multitask Parallel Concurrent Executor for ns-3 (network simulator)
-
bmrng
async MPSC request-response channel for Tokio
-
sea-streamer-examples
🌊 The stream processing toolkit for Rust
-
rgraph
A task graph library
-
yaks
Minimalistic framework for automatic multithreading of hecs via rayon
-
swimming-pool
threadpool for running a number of jobs on a fixed number of threads
-
faucet
Back-pressured MPMC queue that can be drained after signaling completion
-
tcb
A middleware service for delivering messages in a causal order
-
stronghold-rlu
Read-Log-Update software transactional memory like synchronization mechanism
-
tokio-async-utils
Async utils such as TaskHandle type that aborts task on handle drop
-
real-time
Safely share data with a real-time thread
-
pipelines
constructing multi-threaded pipelines of execution
-
tc-transact
Traits and locking utilities for a TinyChain transaction
-
verona-rt
Idiomatic binding to the verona runtime
-
frappe
Functional Reactive Programming library for Rust
-
tagged-rendezvous
Rendezvous hashing with support for tag-based exclusions
-
crusty
Fast && scalable Broad Web Crawler developed on top of crusty-core
-
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.
-
shared-resource-pool-builder
Create thread pools with a shared resource
-
cht
Lockfree resizeable concurrent hash table
-
scherben-map
Concurrent Sharded HashMap for Rust
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
gts-logger
Gts logger
-
apalis-core
Core for apalis: simple, extensible multithreaded background processing for Rust
-
thread_tryjoin
Try joining a thread
-
mtxgroup
mutex group locks all mutexes at the same time
-
seqlock
A reader-writer lock that provides extremely fast read access without starving writers
-
sig_fig_histogram
histogram type that is exponentially distributed and human-friendly
-
humthreads
Threads for humans
-
semanticsimilarity_rs
designed to compute similarity/distance metrics between embeddings
-
usync
fast, drop-in, synchronization primitives
-
despero-hecs-schedule
shedulable systems and parallel execution for hecs
-
hidefix
Concurrent HDF5 and NetCDF4 reader (experimental)
-
bastion-executor
Cache affine NUMA-aware executor for Rust
-
fast-async-mutex
lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)
-
bztree
BzTree implementation for Rust
-
big_data
Safe Rust code for creating Erlang NIF to store big data
-
condow_core
Framework for concurrent downloads
-
kcas
A lock-free, allocation-free multi-word compare-and-swap library
-
godwit-daemon
A daemon runner for GodWit
-
channel-receiver
Channel Receiver
-
coarsetime
Time and duration crate optimized for speed
-
geph-nat
concurrent NAT thingy used throughout Geph
-
tyra
Typed Actor System
-
dager
create and execute a graph of nodes
-
ocl-interop
Creates an OpenCL Context with OpenGL Interop enabled
-
parallel-iterator
Parallelize any iterator with ease!
-
async-map
A rarely-locking, shared map for Rust
-
takecell
A cell type which value can only be taken once
-
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
-
paradis
Experimental parallel processing of disjoint indices
-
tokio-etcd-lock
WIP
-
csplib
CSP for concurrent programming
-
open-coroutine-iouring
The io_uring support for open-coroutine
-
threadstack
A more ergonomic and more flexible form of thread local storage
-
currant
spawn concurrent shell processes in rust
-
vigil
liveness checking watchdog for detecting deadlocks/livelocks/starvation etc
-
unlock
Instrumented synchronization primitives helping you to unlock performance issues
-
ccd
A windows simple, fast chrome_cookie_decryptor
-
conqueue
multi-producer, single-consumer queue (MPSC)
-
mpi-fork-fnsp
Message Passing Interface bindings for Rust (FORK)
-
atomic-counter
Atomic (thread-safe) counters for Rust
-
unknownrori-simple-thread-pool
A lighweight thread pool for networking and other stuff
-
clustr
Multithreaded string clustering
-
nysa
A bus for passing messages around between independent subsystems of an application
-
sesh
deadlock-free session-typed communication
-
gts-transport
Gts transport
-
elysees
A fork of triomphe, now with more pointer trickery
-
shared-expiry-get
concurrent async get with expiration for Rust
-
timer-rs
timer used to schedule execution of closures at a given timestamp
-
slave-pool
thread pool
-
atomicbox
Safe atomic pointers to boxed data
-
per-thread-mutex
Synchronization lock designed for wrapping thread-unsafe C libraries
-
skipchannel
skipchannels allow to communicate between threads, but always skip to the last sent value
-
promise_out
promiseOut version for rust
-
autoincrement
wrapper for different purposes
-
gpgpu
WIP GPGPU framework built on top of wgpu
-
graph
high-performant graph algorithms
-
witty-actors
Fork of quickwit-actors, Actor framework used in quickwit
-
ringbuf-blocking
Blocking version of ringbuf
-
atomic_pingpong
Lightweight no_std ping-pong buffer, using AtomicU8 for synchronization
-
acto
light-weight Actor library for Rust
-
bustle
Benchmarking harness for concurrent key-value collections
-
cogo
Rust Coroutine Library like go
-
read-write-store
A concurrent, unordered collection for Rust, where each element has an internally generated ID and a read-write lock
-
orx-concurrent-ordered-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance and ordered concurrent collection
-
hala-sync
Hala synchronous primitive
-
mscheduler
Use mongodb to schedule task running
-
swap-arc
A swappable Arc
-
meslin
Ergonomic messaging for Rust
-
adirector
asynchronous tokio task spawner with a limited size
-
melodium-common
Common Mélodium elements and traits
-
status_executor
Run your work on some context (thread) and get status info back
-
cortexm-threads
context-switching on ARM Cortex-M ( 0, 0+, 3, 4, 4F ) micro-processors
-
netcon
A collections of tools and helper functions developed for and by NetCon Unternehmensberatung GmbH
-
atomicslice
thread-safe shared slices that are just about as fast as possible to read while also being writable
-
rs_lockfree
a lock-Free lib based on practical Hazard Pointers algorithm
-
cache-padded
Prevent false sharing by padding and aligning to the length of a cache line
-
threadpool-simple
Threadpool for working with many tasks easily
-
juliex
a very basic future executor
-
nbchan
Highly optimized non-blocking communication channels
-
secc
Implements a Skip-Enabled Concurrent Channel (SECC) for Rust
-
sync-unsafe-cell
A backport of the SyncUnsafeCell standard library type for use in older Rust versions
-
key-rwlock
keyed asynchronous reader-writer locks
-
bufchan
buffered MPSC channel
-
mongo_sync
instant coding answers via the command line(just like howdoi)
-
seda_bus
A Staged Event-Driven Architectural message bus
-
atomic-arena
Generational arena allows reserving keys from other threads
-
infinitree-backends
Embedded, encrypted database with tiered cache -- backends
-
pcat
A dead-lock free parallel cat implementation
-
proglog
Thread safe progress logging
-
little_raft
The lightest distributed consensus library. Run your own replicated state machine!
-
atomicdouble
128-bit atomics for generic type
-
stronghold-stm
Software transactional memory
-
thread-lock
A wrapper that locks non-Send and non-Sync data to a specific thread
-
mlsp
small library for smart pointers that use both thread local and global atomic counters
-
revenq
A concurrent, revision-based event queue implementation
-
kiss-icp
Unofficial Pure Rust Implementation of kiss-icp
-
two_phase_channel
A safe synchronisation-free parallel communication channel by statically forbidding conflicting accesses
-
brutils
Some utilities for Rust
-
peril
Fast and safe Hazard pointers for Rust
-
jobsys
Lockless Work Stealing Job System
-
glock
Granular locking crate for Rust
-
norpc
Framework for in-process microservices
-
adaptive-barrier
Barrier with adaptable number of thread subsciptions
-
scoped-threadpool-std
scoped threadpool implementation and related tests including a password hasher
-
maybe_parallel_iterator
Toggle parallelism with feature flags!
-
rtrb-basedrop
A fork of the
rtrb
crate that uses basedrop’s Shared pointer in place of Arc -
io_partition
allowing to use just a part of a Read + Seek object
-
response_channel
A bidirectional response channel
-
jobpool
lightweight threadpool implementation
-
async-mutex
Async mutex
-
oncemutex
A mutex providing one-time synchronized access, then safe unsynchronized access
-
sync-cell
A collection of easier to use thread-safe types for the creation of larger thread safe systems
-
sero
lightweight library for maintaining a shared store of locks
-
diplomatic-bag
A wrapper type that allows you to send
!Send
types to different threads -
cooptex
Deadlock free Mutexes
-
exclusion-set
a lock-free concurrent set
-
jadesrandomutil
A random util library for Rust for Jade
-
swapper
Swap ownership between threads
-
blobd
Blob storage designed for huge amounts of random reads and small objects with constant latency
-
thread-control
control threads' execution/status
-
thread_timer
cancelable timer with no external dependencies
-
rtfm-syntax
The Real Time for The Masses (RTFM) meta language
-
threadpooled
Threadpool implementation
-
priomutex
A mutex where waiting threads specify a priority
-
seckoo
A concurrent Cuckoo Hash Table
-
concurrency-demo-benchmarks
A small utility to benchmark different approaches for building concurrent applications
-
krata-runtime
Runtime for running guests on the krata hypervisor
-
shardize
proc macro that generates code to create a sharded form of an existing container
-
ctx-thread
Cooperative, scoped threads based on crossbeam and golang’s context package
-
diatomic-waker
An async, lock-free synchronization primitive for task wakeup
-
rusty-jokes
A humorous Rust crate that brings joy and entertainment to Rust programmers with features like Laughable Lifetimes, Comedic Concurrency, and Punchline Pointers
-
shared_cell
Interior mutability between concurrent tasks on the same thread
-
greenie
Green threads and coroutines in stable Rust
-
dycovec
A dynamically-allocated, concurrent vector
-
vlock
A fast and scalable multi-version shared state lock with wait-free read access
-
managed-thread
Real fearless concurrency! Spawn threads that will be automatically destroyed when no longer needed
-
rayon_logs
Traces for the rayon work-stealing library
-
dfmutex
Deadlock-free Mutex locks
-
slb
Sharded load balancing text-streaming Unix tool
-
threadbath
A minimal implementation of a thread pool
-
atomic_prim_traits
Traits over primitive atomic types
-
uppercut
Small and simple actor model implementation
-
persistent_stack
Concurrent persistent stack
-
kademlia-dht
Kademlia DHT
-
arcu
An Rcu implementation using an Arc to keep the read critical section should and handle cleanup
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
sync_splitter
Safely split a mutable slice in multiple threads at the same time
-
thfmr-protocol
Internal control protocol encoding and decoding library for the TouHou.FM Radio project
-
refcapsule
Safely send references to other threads
-
conquer-util
concurrent and lock-free programming
-
bursty
Test support for exarcebating contention in multi-threaded code
-
abyss-promise
[abyss] A simple promise implementation with adaptive threadpool support
-
stoppable_thread
A wrapper for thread that allows it to be easily stopped cooperatively
-
lariv
Linked Atomic Random Insert Vector: a thread-safe, self-memory-managed vector with no guaranteed sequential insert
-
sever
Coerce hardlinks into new files
-
std-semaphore
A counting, blocking sempahore extracted from rust 1.7.0
-
distribuidos_sync
Sync common utils using standard library
-
thread-owned-lock
Mutex which can only be unlocked by the owning thread
-
threads_pool
This package provides an easy way to create and manage thread pools, so you don't have to
-
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.
-
ordered-parallel-iterator
Performs tasks in parallel returning completed tasks in order of appearance
-
atomic-try-update
Primitives that make it easy to implement correct lock-free algorithms
-
structured_persistent_logger
A structured 'log' logger that allows for persistent fields
-
mpc-bench
Multi-party computation experimentation library
-
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)…
-
verona-rt-sys
Low level bindings to verona-rt
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
krata-xenevtchn
xen evtchn for krata
-
dci
DCI-Closed, a frequent closed itemset mining algorithm, implemented in Rust
-
rush_expr_engine
The rules engine is based on the rete algorithm
-
threadfin
A thread pool for running multiple tasks on a configurable group of threads
-
snowflake-multi-threaded
The rust-lang implementation of Twitter's id generator algorithm snowflake, it thread safety | Twitter 的id生成器算法snowflake的rust-lang 实现
-
venom_log
Rust async log High-performance asynchronous logging
-
gettid
Helper to get an integer ID for the current thread
-
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.
-
talaria
A high performance, cyclic message passing library
-
rt-watchdog
Real-time userspace watchdog for Rust
-
scrummage
Fight over OS process prioritisation
-
dekker
Dekker's algorithm for mutual exclusion
-
gix-features
integrate various capabilities using compile-time feature flags
-
sea-streamer-socket
🌊 SeaStreamer backend-agnostic Socket API
-
channel-sender
Channel Sender
-
rustls-split
A rustls TCPStream wrapper that can send and receive from separate threads
-
spsc-ringbuf-core
Heapless ring buffer
-
runloop
Cancelable non-blocking polling threads (with optional timeouts)
-
swctx
One-shot channel with some special semantics
-
rayon-tlsctx
thread local contexts for rayon loops
-
fan
Simplifies fanning-out (and eventually -in) with channels
-
paragraphs
A Parallel Graph Execution Library
-
tc-fs
TinyChain's transactional filesystem interface layer
-
steelmill
A resource manager (dependency injector / factory) designed for distributed systems and simulation testing
-
ach-util
Atomic Channel
-
npnc
Lock-free queues
-
rusty_hausdorff
A parallel implementation of the directed Hausdorff distance
-
mwcas
Multi-word CAS primitive
-
stop-thread
Various ways of stopping threads on various platforms, without requiring the thread to poll
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
node-workers
A pool of long-lived nodejs workers
-
concurrent-round-robin
A concurrent wrr implementation for rust
-
asparit
Async Parallel Iterators for Rust
-
fused-reader
fused reader type that if writer thread dies while holding armed fuse the reader will get BrokenPipe error
-
lib-wc
Will's Programming Toolbox
-
tucan
fast, and multithreaded interner with loose type requirement
-
magnetic
Low-latency lock-free queues
-
tasic
Tokio, Async_STD, Smol, Interface Crate
-
kafka_json_processor_core
The core logic for your Kafka processor, part of kafka-json-processor project
-
inert
lets you use non-Sync values in a Sync way
-
futures-dagtask
DAG-based Task Queue
-
thread_db
Rust wrapper for libthread_db
-
single_executor
Traits for concurrent primitives
-
cupchan
async overwriting channel between two threads that is wait & block free by swapping cups around
-
try-mutex
Fast non-blocking mutex
-
select-macro
Waits on multiple concurrent branches
-
quick_cache
Lightweight and high performance concurrent cache
-
safe-lock
A lock struct with a
const fn
constructor and nounsafe
-
datacake-rpc
A zero-copy, actor-like RPC framework using rkyv
-
ipmpsc
Inter-process Multiple Producer, Single Consumer Channels
-
dyn_object
Ergonomic and thread safe version of Box<dyn Any>
-
my_threadpool
threadpool
-
bi_channel
Manage bidirectional mpsc channels more conveniently
-
rapidsync
Rapid & threadsafe embedded data stores
-
dynamic_ocl
Dynamically-loaded OpenCL bindings
-
jackiechan
Bounded mpsc channel optimized for lazy bulk operations
-
rsiot-channel-utils
Вспомогательные компоненты
-
rayon_croissant
<lqd> bikeshedding the name: something that is mapped folded and collected, a 🥐
-
ora-scheduler
Part of the Ora scheduler framework
-
sleepfast
Sleep for very small amounts of time quickly
-
object-space
An object store library for highly concurrent program written in Rust
-
rcurs
An oxidized RCU implementation
-
cpq
A Concurrent Priority Queue implemented in Safe Rust
-
genserver
Elixir inspired async actor library
-
thinkofname/think_ecs
Source code of the game Univercity: https://store.steampowered.com/app/808160/UniverCity/
-
geese_pool
Message-passing system for networking with Geese
-
priority-inheriting-lock
A priority-inheriting lock based on Linux futexes
-
nemo
Session types for asynchronous networking
-
hexchat-api
API for HexChat plugin development
-
xio_jobset
XIO jobset datatypes
-
arrows
An actor framework in rust with message durability and ingestion order processing of of messages
-
foco
Topic-based strongly typed pubsub for no_std rust
-
toktor
A small tokio-based Actor framework
-
discord-termview
Spawn multiple concurrent unix terminals in Discord
-
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 -
smartpool
A very customizable, future-aware threadpool
-
queuingtask
queueingtask is a library for running different threads in order in Rust
-
ringbuf-basedrop
A fork of the
ringbuf
crate that uses basedrop’s Shared pointer in place of Arc -
reactor_rs
reactor-rust is an implementation of the Reactive-Streams
-
irox-threading
Blocking and Asynchronous Threading Tools
-
spinout
A thread-safe clonable and mutable smart-pointer akin to
Arc<Mutex<T>>
, using spin-lock instead of system futex -
barriers
A barrier spin lock implementation
-
multithread
API for data-parallel tasks, rayon-lite
-
atomicbox_nostd
Fork of the atomicbox library that works in no_std contexts
-
grandma
A lock-free, eventually consistent, concurrent covertree
-
wrrm
Write-rarely-read-many wrapper
-
mogul
Agnosticly helps to manage concurrent versions of things
-
is_main_thread
A simply tool to check if current thread is the main one
-
locktree
Experimental compiler-checked deadlock-freedom
-
poolter
Thread Pool implementation for Rust using JavaScript Promise like functional syntax
-
bombs
Efficient single-producer multi-consumer channel types
-
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…
-
wasm_thread
An std thread replacement for wasm32 target
-
mt-kahypar-sys
Rust bindings to Mt-KaHyPar
-
drive-server
Exchange files locally using mDNS
-
killable_thread
A wrapper for thread that allows it to be easily stopped cooperatively
-
shared_channel
Multi-producer, multi-consumer FIFO queue communication primitives
-
simple_event_map
event map based on channels, provides a receiver that is either blocking or async
-
gosh-remote
Distributed parallel computing over multiple nodes
-
send-cell
Immutable memory region with runtime Send checking
-
minicoroutine
mini coroutine library in rust
-
raliguard
Lazy rate limit semaphore implementation for your asynchronous code frequency execution
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
lofi
Low Overhead Fibers
-
skippy-rs
A set of lock free, thread safe, and fast data structures implemented via a Skip List
-
par-array-init
Convenience functions for initializing arrays in parallel
-
slottle
A throttle pool library designed for thread-based concurrency
-
parallel_reader
reading from a file (or any
Read
stream) and processing it by chunks, in parallel -
cell-family
Cheap cells accessed through unique owners
-
membarrier
Process-wide memory barrier
-
cnr
An operation-log based approach for data replication
-
gemino
A multi producer multi consumer (MPMC) broadcasting channel
-
schedwalk
Test futures under all possible polling schedules
-
process_control
Ergonomically run processes with limits
-
benjamin_batchly
Low latency batching tool. Bundle lots of single concurrent operations into sequential batches of work.
-
lazy_id
A thread-safe lazily-initialized ID
-
atomic-memcpy
Byte-wise atomic memcpy
-
rdispatcher
Dispatcher for Rust, broadcast and subscribe many to many
-
rearch-tokio
Re-imagined approach to application design and architecture
-
talos_messenger_actions
Messenger actions for Talos
-
specs-static
extension for Specs that adds custom ids
-
fibril
implementing distributed systems with commmunicating fibers
-
piper
Async pipes, channels, mutexes, and more
-
one_at_a_time_please
For serialising calls to functions
-
ulock-sys
Rust bindings for Darwin's (e.g. macOS, iOS, ...) not-entirely-public ulock API, which provides futex-like functionality.
-
mp2c
A multi producer multi polling consumer library that enables multiple producers to send messages to multiple consumers completely asynchronously
-
synqueue
Internally synchronized (MPMC) queue
-
scoped-pool
A flexible thread pool providing scoped threads
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
rsevents-extra
Synchronization objects built on top of rsevents. Semaphore, countdown event, and more.
-
lines-rs
⚡ A fast line counter written in rust
-
key-mutex
Access mutexes by key
-
std-threadpool
Threadpool implementation
-
rayon-core
Core APIs for Rayon
-
crossbeam-skiplist_piedb
A concurrent skip list
-
lossyq
concurrent single publisher, single consumer queue with fixed length, that never blocks the writer
-
ev_slotmap
A lock-free, eventually consistent, concurrent slot map
-
mbarc-map
Minimally-blocking, Atomic Reference Counted Map
-
td_rthreadpool
thread wrapper for Rust
-
no-std-async
Async synchronization primitives for #[no_std] rust
-
pi_slot_deque
Two terminal queue based on slotmap
-
thread-local-panic-hook
Panic hooks that work per thread
-
parallel-event-emitter
Parallel Event Emitter for concurrent listener invocation based on futures-rs and futures-cpupool
-
parking_lot_mpsc
A port of the Rust std::sync::mpsc module, using the parking_lot concurrency types rather than those in the standard library
-
proc-lock
cross-process locking API
-
yastl
scoped threadpool library
-
acteur
A safe actor-like framework that just works. Simple, robust, fast, documented.
-
time_sigil
task scheduler
-
crossbeam-epoch
Epoch-based garbage collection
-
gaffer
Prioritised, parallel job scheduler with concurrent exclusion, job merging, recurring jobs and load limiting for lower priorities
-
governor
A rate-limiting implementation in Rust
-
denog_runtime
denog runtime library
-
chunker
Minimalistic parallel executor
-
rtfm-core
Core abstractions of the Real Time For the Masses framework
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
captain-workflow-manager
Run and manage jobs that depend on each other on a variety of backends.s
-
crossbeam-skiplist
A concurrent skip list
-
caring
Sharing is caring: a safe library for mmap'ing memory in multiple processes
-
async-datachannel-wasm
Async Wrapper for WebRTC datachannel in the browser environment
-
overdose
Fast, Row Oriented, Kotlin, Scala-like dataframe
-
tenorite
A concurrency abstraction library. Provides a client-server model for asynchronous workers
-
key-message-channel
Multi-producer single-consumer queue capable of queuing messages by message key
-
taski
async task DAG execution
-
queue-ext
The extended feature of the queue can convert the pop() function of the queue to Stream and the push() function to Sender
-
bounded-spsc-queue
A bounded SPSC queue
-
rcell
A Cell which can hold either an Arc or an Weak smartpointer or be empty
-
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.
-
semalock
concurrently writing to files in a safe and efficient manner
-
atomic-destroy
An value which can be atomically read and destroyed; like an atomic Option
-
atomic-story
An brief overview of atomics and memory ordering on a multi-threaded context with examples
-
update_channel
A channel for single updatable values
-
gex_sys_build_parse_mak
Parse mak file to build gex-sys
-
cpu-affinity
Cross-Platform CPU affinity
-
agner-utils
An actor toolkit inspired by Erlang/OTP (utils)
-
go-spawn
that provides macros to spawn and join threads with minimal boilerplate
-
readlock
A weird alternative to Arc<RwLock<T>>
-
atomic_box
A struct which allows multiple threads to safely update and read from a shared non-nullable pointer to heap data
-
run-them
A CLI to launch a single command with many workers, serializing the output
-
ppipe
An elegantly simple and lightweight library for making iterator pipelines concurrent and blazingly fast, hence the name ppipe (parallel pipe)
-
todc-mem
Algorithms for shared-memory distributed systems
-
mth_calc
demonstrating Cargo. Contains helper method for running a process in parallel on all available processors.
-
ordered-locks
Compiletime deadlock avoidance
-
moka
A fast and concurrent cache library inspired by Java Caffeine
-
concurrency_toolkit
Easy switching between std::sync, tokio::sync and loom::sync
-
try-rwlock
Fast non-blocking readers-writer lock
-
lock-free-freelist
A fast lock free limited length free list for multiple producer and consumer
-
simplelock
abstractions for inter-process synchronization
-
prawnypool
interface for using thread pools in Rust
-
box-counter
counter
-
htb
Hierarchical token bucket implementation
-
readahead-iterator
Readahead from an iterator on a separate thread, returning items in order and synchronously
-
hv-guarded-borrow
Traits and implementations for generic use of "guarded" borrows
-
dynqueue
Dynamically extendable Rayon parallel iterator
-
mrogalski-looper
Clean abstraction for a single-threaded event loop. Built as a lightweight wrapper around the std::sync::mpsc package.
-
kik_sync_service
A synchronous threading worker channel for generating the results you want with the data you need
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
concurrency_traits
Traits for concurrent primitives
-
slog-json-concur
JSON drain for slog-rs with concurrency
-
threadbeam
specialized channel type for beaming data out of a newly spawned thread
-
melodium-engine
Mélodium core engine and executor implementation
-
flexible-locks
Flexible Locks
-
tc-tensor
TinyChain's Tensor collection type
-
amadeus-parquet
An Apache Parquet implementation in Rust
-
treiber_stack
A lockless, thread-safe, atomic linked-list
-
android-wakelock
Safe and ergonomic Rust bindings to the Android WakeLock API
-
lightproc
Lightweight process abstraction for Rust
-
spliter
way to implement Rayon's ParallelIterator
-
atomic-maybe-uninit
Atomic operations on potentially uninitialized integers
-
shareable
Thread shareable objects using the minimal amount of synchronization
-
jobsteal
A work-stealing fork-join threadpool written in Rust
-
channel_io
Reader implementation on channel of bytes
-
atomic-borrow
atomic reference counter
-
arl
A rate limiter to be used with tokio
-
tasque
thread pool library
-
unbounded-spsc
An unbounded spsc queue built from
bounded_spsc_queue
s -
icicle-core
GPU ZK acceleration by Ingonyama
-
async-liveliness-monitor
A Liveliness Monitor for your Asynchronous Runtimes
-
nvrtc
Bindings for NVIDIA® CUDA™ NVRTC in Rust
-
simple_behavior_tree
behavior tree
-
maybe-async-channel
A channel which may or may not be async
-
zkmq
Message Queue, backed by Zookeeper
-
laststage
fast, durable, high concurrent HashMap
-
hytra
Datastructure for fast multi-threaded updates
-
atomic-hyperloglog
thread-safe hyperloglog, with atomics
-
mt-debug-counters
support high performance debug counters for heavy multithreaded applications
-
parking_monitor
Parking-lot-flavored monitor synchronization construct
-
pflock
A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
jwalk
Filesystem walk performed in parallel with streamed and sorted results
-
contrie
Concurrent map and set
-
consume
Memory order consume for when it's known that the compiler can't elide the dependency
-
consumable_vec
generic approach to create a mutual database for multiple producers and consumers
-
rayoff
rayon but it's map-reduce
-
threadgroup
Manage groups of threads as one unit, join the first one that finishes, timeout on join attempts
-
slock
An async mutex that never deadlocks
-
fast-threadpool
Thread-pool implementation optimized to minimize latency
-
syncell
Sync alternative to RefCell
-
mpmcpq
Multi-producer multi-consumer Priority Queue
-
spindle_db
A db backend for
spindle
: ergonomic GPGPU data parallel computing in Rust -
disk_log
**High Throughout, NonBlocking** Disk-based logger
-
thread_reviver
A Discord bot to revive any archived threads (to counter Discord's auto-archive function)
-
waithandle
that makes signaling between threads a bit more ergonomic
-
task-notify
Notify async tasks when someone mutates data they're interested in
-
double-checked-cell-async
A thread-safe lazily initialized cell using double-checked locking
-
mycorrh
fast concurrent messaging system for Rust
-
base-coroutine
A fast and safe implementation of stackful coroutines with scheduler which supports preemptive scheduling
-
dynamic-pool
a lock-free, thread-safe, dynamically-sized object pool
-
deploy
The
deploy
library to aide writing and debugging of distributed programs, as well as tooling to run them across a cluster -
more-sync
More synchronization utils
-
lagoon
A thread pool crate with an array of features
-
coroutines
High performance coroutine library with native experience
-
sentinel-rocket
Sentinel middleware for Rocket
-
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
-
colosseum
A variety of arena allocators for Rust, including thread-safe arenas
-
once_mut
Safe mutable reference to static variable that can be obtained only once
-
lock_freedom
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
rhythm
Rate limiter which allows VIPs, written in Rust
-
busan
An actor implementation for Rust
-
rusty-variation
deadlock-free session-typed communication
-
waitcell
A cell type containing a value which may not yet be available
-
hv-lease-tracker
no-std compatible tracking of borrow origins, for providing better diagnostics when implementing interior mutability primitives
-
ump-ng-server
Server message dispatch loop for ump-ng
-
quinine
Atomic monotonic containers (Mono{Box,Arc})
-
thepipelinetool_task
task package used for thepipelinetool
-
tokio-cron
cron scheduler for tokio
-
chashmap
Fast, concurrent hash maps with extensive API
-
sync-wait-group
Wait group for synchronizing the beginning or end of some computation
-
fiona
Concurrent runtime written against liburing
-
workers_pool
A long running threadpool for parallel task execution
-
hv-elastic
Safe and almost-safe abstractions for lengthening lifetimes and
'static
“loaning” of non-'static
types -
muscat
Multithreaded Side Channel Attacks Tool
-
uchan
Multi-producer single-consumer channel for message passing
-
forkjoin
A work stealing fork-join parallelism library for Rust
-
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
-
async_ach-notify
Async Atomic Channel
-
worker-pool
handle a set of worker threads, which need to communicate back their result to the main thread
-
hurdles
Counter-based thread barrier
-
actors-rs
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
remutex
Recursive mutex, adapted from Rust's standard library
-
provenant
A version of Arc that can free memory while weak pointers exist by probabilistically tracking provenace
-
kernel
Abstract Reactive Streams
-
spsc-bip-buffer
A concurrent, spsc ring-buffer with sized reservations
-
indigo
A framework and utility library for modern applications
-
closure-future
Easily run closures on thread pools and turn their result into Futures
-
employer
Spawn worker threads and check on them later
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions
. -
workctl
number of higher-level control mechanisms for concurrent work scheduling, built on standard library concurrency primatives
-
locker
named mutex/locker for rust-lang concurrency
-
sea-streamer-stdio
🌊 SeaStreamer Standard I/O Backend
-
skl
A lock-free thread-safe concurrent ARENA based (heap backend or memory map backend) skiplist implementation which helps develop MVCC memtable for LSM-Tree
-
concurrent-biproxy
a proxy that concurrent transfer message from one client to an other client
-
hadron-client
The Hadron Rust client library
-
momen
low overhead thread pool
-
a_r_c_h_e_r_y
TEMPORARY CRATE
-
rs_taskflow
executing graphs of tasks
-
bichannel
Zero dependency std::mpsc based bidirectional channel
-
tiny-actor
A minimal actor framework for Rust
-
spsc-buffer
Single-producer single-consumer lock-free buffer
-
par-map
Parallel map and flat_map
-
shared-mutex
A RwLock that can be used with a Condvar
-
unros-core
stub
-
stream-channel
stream in channel
-
stretto
high performance thread-safe memory-bound Rust cache
-
dynpool
A thread manager that is lightweight, flexible, and rescalable
-
wasefire-sync
Portable non-blocking mutex
-
iterator_ilp
Iterator extensions for instruction-parallel reductions
-
mrsc
mpsc with requests
-
semaphorus
Atomic semaphores
-
readlock-tokio
A weird alternative to Arc<RwLock<T>>, using tokio's RwLock
-
sync_cow
Thread-safe clone-on-write container for fast concurrent writing and reading
-
flow-mel
Mélodium core flow control library
-
polyester
Parallel iterator adaptors that accept arbitrary iterators
-
lockless
Composable, lock-free, allocation-light data structures
-
rendezvous_swap
Swap data and sync execution between a pair of threads efficiently
-
tange
Scalable Task-based Parallelism Framework
-
mongo-lock-async
Distributed mutex locks with MongoDB
-
balter-runtime
A load/stress testing framework
-
refptr
Inherently reference counted structs
-
rustpool
A data and thread pool library for Rust
-
ste
A single-threaded executor with some tricks up its sleeve
-
srmap
A lock-free, eventually consistent, concurrent multi-value map
-
wei-task
wei task
-
thread-broadcaster
A SPMC (Single producer multi consumer) broadcasting channel to broadcast notifications between threads
-
work_pool
work queue wrapped by a thread pool
-
boomerang
'Reactors' Deterministic Actor Model
-
pool_barrier
A barrier for blocking a main thread until the completion of work which has been offloaded to worker threads, without blocking the worker threads
-
ccl
Fast datastructures for use in highly concurrent systems
-
mpmc
copy-pasted from old rust stdlib
-
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… -
hyaline-smr
Garbage Collector(Hyaline- Safe Memory Reclaimation) for lock free data structures
-
context-coroutine
set of extensions to provide stackful coroutines; it is not officially associated with the context crate
-
kiss-icp-ops-eigen
Unofficial Pure Rust Implementation of kiss-icp
-
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
-
theatre
A concise async actor model implementation
-
wasserglas
A fixed size thread-safe object pool with automatic reattachment
-
haphazard
Dynamic memory management for lock-free data structures using hazard pointers
-
atomic_immut
Atomic immutable value
-
rslint_rowan
threadsafe fork of rowan for the rslint project
-
countdown_latch
A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes
-
monotone
counters and queues for coordination in distributed systems
-
threadpool-crossbeam-channel
A fork of the threadpool create, which uses crossbeam-channel instead of std::mpsc
-
request-channel
Async MPSC request-reponse channel
-
init_guard
A Synchronization Primitive for guarding against double initialization
-
pipeliner
nice interface for parallel programming with iterators
-
brod
A wrapper library providing an API for executing Kafka producers in parallel
-
futex-queue
An efficient MPSC queue with timer capability based on Linux futex. Suitable for real-time applications.
-
user-sync
user-space synchronization
-
anode
Concurrency library for Rust
-
bondi
Single producer, multi consumer lock-free ring buffer (experimental)
-
sling
Sequentially lockign (SeqLock) Ring Buffer
-
locklessness
Composable, lock-free, allocation-light data structures
-
promissory
One-shot value exhange between threads
-
atomic-queue
bounded lock-free queue for use in Audio applications, ported from https://github.com/max0x7ba/atomic_queue
-
rush_lua_engine
The rules engine is based on the rete algorithm
-
ping-pong-cell
An atomic cell for up to two threads
-
async-once-watch
Asynchronous and shareable container which value is set once
-
zsling
Rust Wrapper around a Sequentially lockign (SeqLock) Ring Buffer written in Zig
-
spin_loop
-
atomic_cell
Lock-free thread-safe mutable memory locations
-
gex-sys
GASNet-EX bindings for Crayfish
-
instrumented-mpsc
Wrapper for futures mpsc unbounded providing Prometheus metrics
-
pagetable
Wait-free 4-level 64-bit pagetable for roughly-contiguous keys
-
observable-btree
Reactive Observable BTree
-
gothack-future-parking_lot
An "as simple as possible" Future implementation for parking_lot
-
cura
arc-lock-system that should clean up the code a lot
-
sorted-channel
sorted message-based communication channel
-
rjq
Redis job queue
-
cortex-m-rtfm
Real Time For the Masses (RTFM): a concurrency framework for building real time systems
-
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
-
evelyn
event distribution library
-
amadeus-types
Harmonious distributed data analysis in Rust
-
conveyor_belt
Queue and batch processing library
-
kai-cli
Kai - todo.txt task scheduler
-
sea-streamer-file
🌊 SeaStreamer File Backend
-
c-map
Very fast concurrent hashmap
-
eventbus
Safe, fast and concurrent event system, inspired by the MinecraftForge event bus
-
proc-lock-api
APIs for the proc-lock crate
-
horde
threads
-
sea-streamer-runtime
🌊 SeaStreamer async runtime abstraction
-
llq
Wait-free SPSC linked-list queue with individually reusable nodes
-
stoplight
stoppable tasks/threads
-
access-queue
limit the number of simultaneous accesses to a value
-
concache
A fast, concurrent, shared hash map
-
sentinel-tower
Sentinel middleware for Tower
-
async-rwlock
Async reader-writer lock
-
arbalest
Like Arc<T> but where weak references don't forbid mutable access
-
movie
An actor / thread orchestration library / macro / framework
-
dashmap_with_out_t_map_trait
Blazing fast concurrent HashMap for Rust
-
para
A dataflow/pipeline parallelization framework
-
lock-hierarchy
Prevent dead locks by enforcing lock hierarchies
-
simple-mutex
A mutex more efficient than std and simpler than parking_lot
-
qrwlock
Fair queued read-write lock
-
cachemap2
A concurrent insert-only hashmap for caching values
-
taskpile
threadpool implementation
-
option-lock
mutex for Option values
-
pairlock
A reader-writer lock with wait-free reads
-
blasoxide-mt
multithreading for blasoxide
-
borrowed-thread
thread-safe way to pass borrow to thread::spawn
-
metadata-store
store for recoverable metadata that is written in atomic batches
-
rework
Multi-threaded task processing in the Master-Worker pattern
-
son_of_grid_engine
Interface with son of grid engine (formerly sun grid engine) to run rust programs on clusters
-
clone-replace
Share mutable data by cloning and replacing a reference version
-
mpmc-ringbuf
queue
-
pmpmc
A priority multi producer multi consumer channel
-
hv-cell
A no-std port of the
atomic_refcell
crate with additionalArc
-centric functionality -
open-coroutine-core
The open-coroutine is a simple, efficient and generic coroutine library
-
pour
Optionally consed radix tries for fast set operations
-
terminate
abstract logic to terminate threads, coroutines and the like
-
amadeus-aws
Harmonious distributed data analysis in Rust
-
lf-queue
A lock-free multi-producer multi-consumer unbounded queue
-
fuze
A mechanism to wait for a single signal which can be checked at any time
-
ump-server
Server message dispatch loop for ump
-
logmap
A concurrent hashmap using a log for buckets
-
ctrlc_fnonce
Wrapper for ctrlc to execute a FnOnce and exit the process upon Ctrl-C
-
datacake-node
The core cluster membership system built ontop of Quickwit's chitchat
-
portable-atomic-util
Synchronization primitives built with portable-atomic
-
jotty
embeddable distributed processing framework for both short and long running batch jobs
-
waitable
A synchronized (atomic) value container implementing the Mutex+Condvar pattern for efficient blocking waits
-
rustix-futex-sync
Linux futex-based synchronization
-
unsync_channel
!Send/!Sync channels for Rust
-
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.
-
future-parking_lot
An "as simple as possible" Future implementation for parking_lot
-
waitmap
an awaitable concurrent hash map
-
roundabout
An message oriented concurrent runtime
-
riffy
An unbounded, wait-free, multi-producer-single-consumer queue
-
bbq-rs
A Block-based Bounded Queue for Exchanging Data and Profiling
-
sstb
A thread-safe sstables library
-
run-down
protection in rust
-
embassy-sync
no-std, no-alloc synchronization primitives with async support
-
synctree
Thread-safe tree data structure
-
streambed-patterns
Patterns for working with streambed
-
may_actor
Actor library based on MAY
-
hybrid-lock
A hybrid lock with optimistic locking
-
amadeus-commoncrawl
Harmonious distributed data analysis in Rust
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
ach-ring
Atomic Channel
-
rolock
Read Only Lock
-
thread-safe
Container that allows thread safety for thread-unsafe objects
-
scheduled-executor
Single and multi-threaded task scheduler
-
read-cell
Read-only Cell counterpart
-
taskqueue
Parallel execution of the task queue with the ability to add new tasks inside the running tasks
-
tokio-sync-read-stream
Create a stream from a std::io::Read using Tokio blocking threads
-
fibril_verifier
Verifies behavior for distributed systems implemented with the Fibril library
-
kiss-icp-runtime
Unofficial Pure Rust Implementation of kiss-icp
-
static_locks
The
parking_lot
locks but usable in statics and const fn -
hv-atom
Convenient abstractions for atomic operations on smart pointer/reference types, based on the
atom
crate -
liblightning
High-performance general-purpose stackful coroutine library