-
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
-
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
-
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
-
may
Rust Stackful Coroutine Library
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
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
-
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
scheduled-thread-pool
A scheduled thread pool
-
corosensei
A fast and safe implementation of stackful coroutines
-
shuttle
testing concurrent Rust code
-
pueue
A cli tool for managing long running shell commands
-
waker-fn
Convert closures into wakers
-
mpstthree
implementing Multiparty Session Types for 2 or more participants
-
sea-streamer
🌊 The stream processing toolkit for Rust
-
atomic-take
Atomically take a value out of a container once
-
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
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
spinning_top
spinlock crate based on the abstractions provided by
lock_api
-
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
-
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
-
messaging_thread_pool
aiding the creation of typed thread pool of objects that is communicated with via channels
-
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
-
recloser
A concurrent circuit breaker implemented with ring buffers
-
crossfire
channels for async and threads
-
boxcar
A concurrent, append-only vector
-
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
-
futures-channel
Channels for asynchronous communication using futures-rs
-
rayon-progress-bar
work-stealing parallelism for Rust
-
callysto
Stream processing framework
-
maitake-sync
No-std async synchronization primitives from Maitake
-
lockable
offers hash map and cache data structures where individual entries can be locked
-
st3
A very fast lock-free, bounded, work-stealing LIFO queue
-
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
-
rearch
Re-imagined approach to application design and architecture
-
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
-
local-sync
Non-threadsafe data structure for async usage
-
flurry
Rust port of Java's ConcurrentHashMap
-
signals2
A thread-safe signal/slot library inspired by boost::signals2
-
choir
Task Orchestration Framework
-
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
-
open-coroutine
efficient and generic stackful-coroutine library
-
everygarf
Concurrently download every Garfield comic to date
-
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
-
perthread
ThreadMap structure for accessing PerThread thread local variables form a static context
-
skipdb
An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine
-
gst-plugin-threadshare
GStreamer Threadshare Plugin
-
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
-
timely-communication-master
Communication layer for timely dataflow
-
deqp-runner
A VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline
-
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.
-
crony
cron runner that spawns another thread to run your cron jobs
-
io-reactor
Concurrent I/O resource management using reactor pattern
-
mpvipc
A small library which provides bindings to control existing mpv instances through sockets
-
ringbuffer-spsc
A fast thread-safe single producer-single consumer ring buffer
-
infinitree
Embedded, encrypted database with tiered cache
-
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 -
utils-atomics
Various atomic utils
-
fault-injection
fault injection, concurrency delay injection, and error source annotation
-
freezebox
deref'able lazy-initialized container
-
oxidd-manager-index
Index-based manager implementation for OxiDD
-
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
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
shipyard_scenegraph
Scenegraph for Entity Component System
-
kueue
A robust, user-level, work-stealing, distributed task scheduler
-
namaste
-
trauma
Simplify and prettify HTTP downloads
-
file-per-thread-logger
A logging implementation that writes logs in one file per thread
-
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
-
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
-
tonari-actor
A minimalist actor framework aiming for high performance and simplicity
-
renoir
Network of Operators In Rust
-
bastion
Fault-tolerant Runtime for Rust applications
-
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
-
lock_ext
Extensions to std::sync::Mutex
-
fiddler-cli
Data Stream processor CLI written in rust
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
thread_io
performing I/O in background thread
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
concurrent-map
a lock-free linearizable B+ tree
-
async-local
For using thread locals within an async context and across await points
-
batch-aint-one
I got 99 problems, but a batch ain't one
-
permit
A struct for cancelling operations
-
happylock
Free deadlock prevention
-
command-executor
Command Executor thread pool
-
balter
A load/stress testing framework
-
ppl
A structured parallel programming library for Rust
-
work-queue
A concurrent work-stealing queue for building schedulers
-
swap-buffer-queue
A buffering MPSC queue
-
crossbeam-queue
Concurrent queues
-
sdd
Scalable lock-free memory reclaimer
-
tasklet
A task scheduling library
-
mutringbuf
A very simple lock-free SPSC ring buffer, with in-place mutability
-
rcu_cell
a lockless rcu cell implementation
-
atom_box
A safe idiomatic Rust implementation of Atomic Box using hazard pointers
-
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
-
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
-
easy-parallel
Run closures in parallel
-
reactivate
Thread Safe Reactive Data Structure. Made with ❤️ for 🦀
-
evident
Pub/Sub library using IDs to identify events
-
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
-
timeslice
periodic time slice scheduler
-
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
-
guardian
owned mutex guards for refcounted mutexes
-
ordered-channel
A channel that always receives messages in the correct order, even if they were sent out of order
-
pi_atom
The global thread safe atomic string pool reduces the memory occupation of the same string and is also used for HashMap keys
-
pariter
Parallel iterator processing
-
maybe-rayon
Either acts as rayon or creates a single-threaded facade
-
actify
An intutive actor model with minimal boilerplate
-
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
-
incr
fast and self-contained data structures for checking whether a new value is greater than the previous maximum
-
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
-
trc
A faster Arc
-
left-right
A concurrency primitive for high concurrency reads over a single-writer data structure
-
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
-
rustc-rayon
work-stealing parallelism for Rust - fork for rustc
-
atomic-shim
Atomic types for unsupported platforms
-
amity
Concurrency algorithms
-
fork-map
running operations in a child process spawned by
fork()
-
left-right-cell
A cell with lock-free concurrent read access
-
async-cpupool
async threadpool for CPU-bound tasks
-
semka
Semaphore implementation
-
sharded-thread
Expirement for now
-
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.
-
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
-
threadbound
Make any value Sync but only available on its original thread
-
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
-
spmc
channel
-
bi
-
fast-logger
Fast logger for Rust
-
parking
Thread parking and unparking
-
pausable_clock
A source of time information that can be paused and resumed
-
blackhole
...to throw your threads into
-
round_mult
A tiny library to round a number up or down to a multiplier
-
print_queues
A print queues that can be add from different thread and print on main thread
-
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
-
rtic-time
lib TODO
-
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
-
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
-
retry-if
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
global_counter
Global, thread-safe counters
-
watch
A synchronous message passing channel that only retains the most recent value
-
leaklist
concurrent, lock-free, singly-linked list
-
lock_pool
Robust, efficient, high performance, asynchronous object pooling
-
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.
-
rust-debugging-locks
debugging locks in Rust
-
hyperbridge
Fast multi-producer multi-consumer channel with async support
-
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
-
async-skipdb
An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine
-
deborrow
Splits mutable references safely into their fields, and helps with reference manipulation
-
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
-
atomicell
Multi-threaded RefCell on atomics
-
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
-
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!)
-
rayon_iter_concurrent_limit
Limit the concurrency of an individual rayon parallel iterator method with a convenient macro
-
executor-service
A fast and efficient Thread Pool like Java ExecutorService
-
stewart
A minimalist, high-performance, and non-exclusive actor system
-
executors
A collection of high-performance task executors
-
peace-lock
A zero-cost abstraction lock that helps check contention free algorithms
-
wasm_sync
Synchronization primitives for both web and native
-
quartz_sched
Minimalistic scheduling library for Rust
-
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
-
sync42
synchronization tools
-
mpsc
mpsc channel
-
oxidd-manager-pointer
Pointer-based manager implementation for OxiDD
-
crossbeam-deque
Concurrent work-stealing deque
-
session_types
session types in Rust
-
rush_core
The rules engine is based on the rete algorithm
-
smolscale2
hitdns fork of original smolscale
-
rpools
A minimalist workerpool for rust
-
omango-futex
Futex for Rust
-
idle
Collection of idle strategies to be used by thread(s) when they have no work to perform
-
txn_lock
support transactional versioning
-
visa
(Virtual Instrument Software Architecture) Wrapper which allows concurrent and dynamic switching between visa implementations from different vendors
-
task_pool
Flexible abstraction for task-based composable multithreading
-
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
-
jtp
thread pool, similar to the ThreadPoolExecutor in java
-
antidote
Poison-free versions of the standard library Mutex and RwLock types
-
ora-worker
Part of the Ora scheduler framework
-
kontroli
Type checking for the lambda-Pi calculus modulo rewriting
-
single_value_channel
Concurrent single-value update and receive channel
-
parking_lot_rt
Parking-lot fork for real-time applications
-
fenic
test concurrent code
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
flowync
multithreading a/synchronization
-
snowdon
A lightweight thread-safe snowflake ID implementation 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
-
operational-transform
Operational Transformation
-
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
-
uf_rush
A lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure
-
uid
creation of unique IDs
-
drain
that supports graceful shutdown
-
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
-
multichannel
A multi producer single consumer bundle of channels with configurable priorities, weights and the ability to freeze specific channels
-
swap_channel
A safe lock-free parallel communication channel based on mem::swap
-
with_lock
Deadlock freedom
-
crossbeam-utils
concurrent programming
-
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
-
libmcl-sys
This system crate provides Rust language bindings to the Minos Compute Library (MCL)
-
loole
A safe async/sync multi-producer, multi-consumer channel
-
async-ringbuf
Async SPSC FIFO ring buffer
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
rtic-monotonic
Core abstractions of the Real-Time Interrupt-driven Concurrency Monotonic timers
-
may_queue
May's internal queue library
-
rewrk
HTTP benchmarking tool
-
ratelimit_meter
A leaky-bucket-as-a-meter rate-limiting implementation in Rust
-
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
-
bztree
BzTree implementation for Rust
-
flashmap
A lock-free eventually consistent concurrent hash map
-
cloudi
API
-
ump
Micro message passing library for threads/tasks communication
-
range-lock
Range lock for std::vec::Vec
-
constellation-internal
Common components for the
constellation
framework -
queue-ext
The extended feature of the queue can convert the pop() function of the queue to Stream and the push() function to Sender
-
atomicslice
thread-safe shared slices that are just about as fast as possible to read while also being writable
-
threadcell
A cell whose value can only be accessed by a owning thread
-
hopper
an unbounded mpsc with bounded memory
-
entropy-ecs
一个虚拟世界
-
ligmars
Safe bindings to the LGMP C library
-
rt-history
An RT-safe history log with error checking
-
todc-utils
building and testing distributed systems
-
throttle-client
Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.
-
caos
Concurrent Append Only Segment-list
-
aramid
Synthetic fibers
-
pulse
async wake signals
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
rusty_junctions
Join Pattern implementation in Rust
-
synchronoise
Synchronization primitives that build upon the standard library
-
rc_event_queue
VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue
-
crius
hystrix-like circuit breaker
-
parseq
Parallel sequential iterator
-
fast-able
The world's martial arts are fast and unbreakable; 天下武功 唯快不破
-
halt
functionality for pausing, stopping, and resuming iterators, readers, and writers
-
redsync
Redlock for distributed locks with Redis
-
sas
Salty-and-Sweet one-line Rust Runtime Performance Optimization Library
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
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
-
threadpool-executor
A threadpool executor
-
simt
compute support for rust
-
coroutine
in Rust
-
thread_lake
A very high level thread pool manager
-
ringbuf-blocking
Blocking version of ringbuf
-
ebr
epoch-based reclamation with low cacheline ping-pong
-
workerpool-rs
workerpool for rust
-
async-events
Waiting for external task completion in asynchronous Rust code
-
mvsync
A standalone async and worker thread library, with expandable traits and command buffers
-
whisk
fast lockless async channels
-
tc-scalar
TinyChain's scalar value enum, including concurrently-resolvable op definitions and references
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
atomic-destructor
Atomic destructor for multi-threaded env
-
arc-cell
Helper for a simple Cell-like object containing Arc/Weak
-
poolio
A thread-pool
-
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
-
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…
-
libblobd-direct
blobd, direct variant
-
spinning
Mutexes and SIX locks implemented by spinning
-
fast-counter
A sharded concurrent counter
-
folklore
A lock-free concurrent hash map
-
moro
Experimental structured concurrency support for async Rust (similar to trio's nurseries)
-
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
-
tlid
Thread Local ID generator by predefined range without atomics/locks/random/time
-
nolock
A collection of Lock-Free Datastructures
-
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
-
taskschd
windows taskschd demo
-
pcp-mutex
A Priority Ceiling Protocol (PCP) mutex, based on Linux PI futex. Allows efficient and deadlock free execution.
-
leapfrog
A fast, lock-free concurrent hash map
-
classic-sync
ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems
-
oxidd-rules-bdd
Binary decision diagrams (BDDs) for OxiDD
-
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-datachannel
Async Wrapper for datachannel
-
seqlock
A reader-writer lock that provides extremely fast read access without starving writers
-
context
Cooperative multitasking for Rust using Boost.Context
-
atomx
Thread safe data structures based on atomic data types
-
supermon
A set of utilities for coordinating watchers, middleware, and consumers via channels
-
txn
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
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
-
zestors
A fast and flexible actor-framework for building fault-tolerant Rust applications
-
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
-
burstq
A multi-producer, multi-consumer channel that supports sending or receiving multiple values in a single operation
-
parsli
Parallel status lines for Rust
-
hey_listen
An event-dispatcher-collection offering async, sync, parallel, and prioritised solutions!
-
PRUEBA
Colas tarea
-
ach-cell
Atomic Channel
-
potential
Borrowing for futures - Potential enables interior mutation using mutex and asynchronous borrowing (leasing) through a oneshot channel
-
tinypool
thread pool implementation in Rust
-
shared_resources
shared resources container which is thread-safe, and lock-free
-
pargraph
Operator based parallel graph processing
-
sync_2
A little crate providing a Rust implemented Mutex and RwLock
-
tc-transact
Traits and locking utilities for a TinyChain transaction
-
per-thread-object
Efficient per-object thread-local storage implementation
-
swimming
Dive into Efficiency with Swimming: A High-Performance, No-Nonsense Connection Pool
-
lockpool
offers a pool of locks where individual locks can be locked/unlocked by key
-
winhooker
a helper for hooking functions in windows on x64
-
leanify-many
spawn leanify subprocesses
-
open-coroutine-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
xloc
A fast, multi-threaded line counting utility written in Rust
-
rustodrive
Rust bindings for controlling multiple ODrives with the CAN protocol
-
tourniquet-tonic
Async native round-robin manager for remote services. Tonic integration.
-
fluxion
actor framework written in rust and designed for distributed systems
-
jthread
Deadlock-free Mutual Exclusion locks for Rust
-
shared-local-state
shared local state registry for use in EBR, IO, etc
-
blinkcast
Fast, bounded, multiple-producer, multiple-consumer, lossy, broadcast channel
-
hala-sync
Hala synchronous primitive
-
pawawwewism
a wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3
-
pime
Rust Python Integration Made Easy
-
readfish-tools
Tools for analysing adaptive sampling data
-
stronghold-rlu
Read-Log-Update software transactional memory like synchronization mechanism
-
async-map-reduce
Fast map-reduce based on threading
-
ballista-scheduler
Ballista Distributed Compute - Scheduler
-
stakker_log
Logging support for Stakker
-
zkstate
Share a struct across multiple instances of an application using zookeeper
-
yuki
multithreaded web archiver
-
cuneiform-fields
Field level [no_std] cache optimizations for Rust
-
testtools
Helpers for eliminating boilerplate code in tests
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
native-timer
Timer library which uses OS timer capabilities
-
amfiteatr_proc_macro
Procedural macro crate for amfiteatr_* crates
-
ns3-parallel
A Multitask Parallel Concurrent Executor for ns-3 (network simulator)
-
lock-free-static
Lock-free static variables
-
sea-streamer-examples
🌊 The stream processing toolkit for Rust
-
simple-rw-global
GlobalContainer based on std::sync::RwLock
-
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
-
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
-
thread_tryjoin
Try joining a thread
-
pi_arr
lock-free & auto-expansion array
-
frappe
Functional Reactive Programming library for Rust
-
tagged-rendezvous
Rendezvous hashing with support for tag-based exclusions
-
cht
Lockfree resizeable concurrent hash table
-
crusty
Fast && scalable Broad Web Crawler developed on top of crusty-core
-
shared-resource-pool-builder
Create thread pools with a shared resource
-
concurrent_lru
A concurrent LRU cache
-
scherben-map
Concurrent Sharded HashMap for Rust
-
gts-logger
Gts logger
-
bmrng
async MPSC request-response channel for Tokio
-
tokio-etcd-lock
WIP
-
mtxgroup
mutex group locks all mutexes at the same time
-
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.
-
usync
fast, drop-in, synchronization primitives
-
hidefix
Concurrent HDF5 and NetCDF4 reader (experimental)
-
despero-hecs-schedule
shedulable systems and parallel execution for hecs
-
fast-async-mutex
lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)
-
sig_fig_histogram
histogram type that is exponentially distributed and human-friendly
-
big_data
Safe Rust code for creating Erlang NIF to store big data
-
condow_core
Framework for concurrent downloads
-
apalis-core
Core for apalis: simple, extensible multithreaded background processing for Rust
-
async-map
A rarely-locking, shared map for Rust
-
kcas
A lock-free, allocation-free multi-word compare-and-swap library
-
humthreads
Threads for humans
-
paradis
Experimental parallel processing of disjoint indices
-
godwit-daemon
A daemon runner for GodWit
-
verona-rt
Idiomatic binding to the verona runtime
-
coarsetime
Time and duration crate optimized for speed
-
rtfm-syntax
The Real Time for The Masses (RTFM) meta language
-
geph-nat
concurrent NAT thingy used throughout Geph
-
tyra
Typed Actor System
-
dager
create and execute a graph of nodes
-
channel-sender
Channel Sender
-
semanticsimilarity_rs
designed to compute similarity/distance metrics between embeddings
-
ocl-interop
Creates an OpenCL Context with OpenGL Interop enabled
-
hala-lockfree
Some lockfree structure for rust
-
parallel-iterator
Parallelize any iterator with ease!
-
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
-
atomicbox
Safe atomic pointers to boxed data
-
csplib
CSP for concurrent programming
-
open-coroutine-iouring
The io_uring support for open-coroutine
-
unlock
Instrumented synchronization primitives helping you to unlock performance issues
-
currant
spawn concurrent shell processes in rust
-
vigil
liveness checking watchdog for detecting deadlocks/livelocks/starvation etc
-
bustle
Benchmarking harness for concurrent key-value collections
-
ccd
A windows simple, fast chrome_cookie_decryptor
-
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
-
takecell
A cell type which value can only be taken once
-
sesh
deadlock-free session-typed communication
-
cache-padded
Prevent false sharing by padding and aligning to the length of a cache line
-
gts-transport
Gts transport
-
elysees
A fork of triomphe, now with more pointer trickery
-
shared-expiry-get
concurrent async get with expiration for Rust
-
little_raft
The lightest distributed consensus library. Run your own replicated state machine!
-
slave-pool
thread pool
-
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
-
graph
high-performant graph algorithms
-
nbchan
Highly optimized non-blocking communication channels
-
gpgpu
WIP GPGPU framework built on top of wgpu
-
conqueue
multi-producer, single-consumer queue (MPSC)
-
threadstack
A more ergonomic and more flexible form of thread local storage
-
sync-unsafe-cell
A backport of the SyncUnsafeCell standard library type for use in older Rust versions
-
mongo_sync
instant coding answers via the command line(just like howdoi)
-
acto
light-weight Actor library for Rust
-
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
-
swap-arc
A swappable Arc
-
atomic_pingpong
Lightweight no_std ping-pong buffer, using AtomicU8 for synchronization
-
meslin
Ergonomic messaging for Rust
-
melodium-common
Common Mélodium elements and traits
-
status_executor
Run your work on some context (thread) and get status info back
-
adirector
asynchronous tokio task spawner with a limited size
-
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
-
mlsp
small library for smart pointers that use both thread local and global atomic counters
-
adaptive-barrier
Barrier with adaptable number of thread subsciptions
-
timer-rs
timer used to schedule execution of closures at a given timestamp
-
per-thread-mutex
Synchronization lock designed for wrapping thread-unsafe C libraries
-
rs_lockfree
a lock-Free lib based on practical Hazard Pointers algorithm
-
threadpool-simple
Threadpool for working with many tasks easily
-
juliex
a very basic future executor
-
fragile
wrapper types for sending non-send values to other threads
-
secc
Implements a Skip-Enabled Concurrent Channel (SECC) for Rust
-
key-rwlock
keyed asynchronous reader-writer locks
-
witty-actors
Fork of quickwit-actors, Actor framework used in quickwit
-
seda_bus
A Staged Event-Driven Architectural message bus
-
jobpool
lightweight threadpool implementation
-
mscheduler
Use mongodb to schedule task running
-
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
-
stronghold-stm
Software transactional memory
-
thread-lock
A wrapper that locks non-Send and non-Sync data to a specific thread
-
revenq
A concurrent, revision-based event queue implementation
-
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
-
exclusion-set
a lock-free concurrent set
-
swapper
Swap ownership between threads
-
glock
Granular locking crate for Rust
-
norpc
Framework for in-process microservices
-
response_channel
A bidirectional response channel
-
maybe_parallel_iterator
Toggle parallelism with feature flags!
-
scoped-threadpool-std
scoped threadpool implementation and related tests including a password hasher
-
concurrency-demo-benchmarks
A small utility to benchmark different approaches for building concurrent applications
-
io_partition
allowing to use just a part of a Read + Seek object
-
bufchan
buffered MPSC channel
-
oncemutex
A mutex providing one-time synchronized access, then safe unsynchronized access
-
kiss-icp
Unofficial Pure Rust Implementation of kiss-icp
-
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
-
jadesrandomutil
A random util library for Rust for Jade
-
thread-control
control threads' execution/status
-
thread_timer
cancelable timer with no external dependencies
-
priomutex
A mutex where waiting threads specify a priority
-
rtrb-basedrop
A fork of the
rtrb
crate that uses basedrop’s Shared pointer in place of Arc -
seckoo
A concurrent Cuckoo Hash Table
-
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
-
wrrm
Write-rarely-read-many wrapper
-
mwcas
Multi-word CAS primitive
-
threadpooled
Threadpool implementation
-
kademlia-dht
Kademlia DHT
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
rusty-jokes
A humorous Rust crate that brings joy and entertainment to Rust programmers with features like Laughable Lifetimes, Comedic Concurrency, and Punchline Pointers
-
distribuidos_sync
Sync common utils using standard library
-
async-mutex
Async mutex
-
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
-
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
-
sync-cell
A collection of easier to use thread-safe types for the creation of larger thread safe systems
-
dfmutex
Deadlock-free Mutex locks
-
slb
Sharded load balancing text-streaming Unix tool
-
task-exec-queue
A asynchronous task execution queue
-
krata-runtime
Runtime for running guests on the krata hypervisor
-
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
-
atomic-try-update
Primitives that make it easy to implement correct lock-free algorithms
-
diatomic-waker
An async, lock-free synchronization primitive for task wakeup
-
arcu
An Rcu implementation using an Arc to keep the read critical section should and handle cleanup
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
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
-
conquer-util
concurrent and lock-free programming
-
bursty
Test support for exarcebating contention in multi-threaded code
-
structured_persistent_logger
A structured 'log' logger that allows for persistent fields
-
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
-
scrummage
Fight over OS process prioritisation
-
std-semaphore
A counting, blocking sempahore extracted from rust 1.7.0
-
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
-
ordered-parallel-iterator
Performs tasks in parallel returning completed tasks in order of appearance
-
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
-
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
-
vlock
A fast and scalable multi-version shared state lock with wait-free read access
-
atomicdouble
128-bit atomics for generic type
-
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 实现
-
channel-receiver
Channel Receiver
-
refcapsule
Safely send references to other threads
-
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.
-
npnc
Lock-free queues
-
rt-watchdog
Real-time userspace watchdog for Rust
-
cpq
A Concurrent Priority Queue implemented in Safe Rust
-
dekker
Dekker's algorithm for mutual exclusion
-
gix-features
integrate various capabilities using compile-time feature flags
-
bastion-executor
Cache affine NUMA-aware executor for Rust
-
lib-wc
Will's Programming Toolbox
-
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)
-
genserver
Elixir inspired async actor library
-
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
-
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.
-
paragraphs
A Parallel Graph Execution Library
-
steelmill
A resource manager (dependency injector / factory) designed for distributed systems and simulation testing
-
ach-util
Atomic Channel
-
talaria
A high performance, cyclic message passing library
-
sea-streamer-socket
🌊 SeaStreamer backend-agnostic Socket API
-
rusty_hausdorff
A parallel implementation of the directed Hausdorff distance
-
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
-
toktor
A small tokio-based Actor framework
-
fused-reader
fused reader type that if writer thread dies while holding armed fuse the reader will get BrokenPipe error
-
yaambo
concurrent skip lists
-
tucan
fast, and multithreaded interner with loose type requirement
-
magnetic
Low-latency lock-free queues
-
kafka_json_processor_core
The core logic for your Kafka processor, part of kafka-json-processor project
-
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
-
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
-
barriers
A barrier spin lock implementation
-
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 🥐
-
spinout
A thread-safe clonable and mutable smart-pointer akin to
Arc<Mutex<T>>
, using spin-lock instead of system futex -
blobd
Blob storage designed for huge amounts of random reads and small objects with constant latency
-
gosh-remote
Distributed parallel computing over multiple nodes
-
sleepfast
Sleep for very small amounts of time quickly
-
ora-scheduler
Part of the Ora scheduler framework
-
crossbeam-skiplist
A concurrent skip list
-
asparit
Async Parallel Iterators for Rust
-
object-space
An object store library for highly concurrent program written in Rust
-
mogul
Agnosticly helps to manage concurrent versions of things
-
raliguard
Lazy rate limit semaphore implementation for your asynchronous code frequency execution
-
thinkofname/think_ecs
Source code of the game Univercity: https://store.steampowered.com/app/808160/UniverCity/
-
tasic
Tokio, Async_STD, Smol, Interface Crate
-
minicoroutine
mini coroutine library in rust
-
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
-
ipmpsc
Inter-process Multiple Producer, Single Consumer Channels
-
foco
Topic-based strongly typed pubsub for no_std rust
-
discord-termview
Spawn multiple concurrent unix terminals in Discord
-
node-workers
A pool of long-lived nodejs workers
-
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 -
crossbeam-epoch
Epoch-based garbage collection
-
smartpool
A very customizable, future-aware threadpool
-
queuingtask
queueingtask is a library for running different threads in order in Rust
-
arrows
An actor framework in rust with message durability and ingestion order processing of of messages
-
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
-
multithread
API for data-parallel tasks, rayon-lite
-
tc-fs
TinyChain's transactional filesystem interface layer
-
atomicbox_nostd
Fork of the atomicbox library that works in no_std contexts
-
grandma
A lock-free, eventually consistent, concurrent covertree
-
lofi
Low Overhead Fibers
-
xio_jobset
XIO jobset datatypes
-
time_sigil
task scheduler
-
is_main_thread
A simply tool to check if current thread is the main one
-
locktree
Experimental compiler-checked deadlock-freedom
-
parallel_reader
reading from a file (or any
Read
stream) and processing it by chunks, in parallel -
poolter
Thread Pool implementation for Rust using JavaScript Promise like functional syntax
-
rcurs
An oxidized RCU implementation
-
bombs
Efficient single-producer multi-consumer channel types
-
cnr
An operation-log based approach for data replication
-
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…
-
drive-server
Exchange files locally using mDNS
-
wasm_thread
An std thread replacement for wasm32 target
-
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
-
mt-kahypar-sys
Rust bindings to Mt-KaHyPar
-
skippy-rs
A set of lock free, thread safe, and fast data structures implemented via a Skip List
-
fibril
implementing distributed systems with commmunicating fibers
-
par-array-init
Convenience functions for initializing arrays in parallel
-
slottle
A throttle pool library designed for thread-based concurrency
-
rearch-tokio
Re-imagined approach to application design and architecture
-
ulock-sys
Rust bindings for Darwin's (e.g. macOS, iOS, ...) not-entirely-public ulock API, which provides futex-like functionality.
-
cell-family
Cheap cells accessed through unique owners
-
gemino
A multi producer multi consumer (MPMC) broadcasting channel
-
schedwalk
Test futures under all possible polling schedules
-
process_control
Ergonomically run processes with limits
-
atomic-memcpy
Byte-wise atomic memcpy
-
rdispatcher
Dispatcher for Rust, broadcast and subscribe many to many
-
rtfm-core
Core abstractions of the Real Time For the Masses framework
-
send-cell
Immutable memory region with runtime Send checking
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
talos_messenger_actions
Messenger actions for Talos
-
rcell
A Cell which can hold either an Arc or an Weak smartpointer or be empty
-
inert
lets you use non-Sync values in a Sync way
-
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
-
proc-lock
cross-process locking API
-
scoped-pool
A flexible thread pool providing scoped threads
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
lazy_id
A thread-safe lazily-initialized ID
-
lines-rs
⚡ A fast line counter written in rust
-
thread-local-panic-hook
Panic hooks that work per thread
-
key-mutex
Access mutexes by key
-
std-threadpool
Threadpool implementation
-
crossbeam-skiplist_piedb
A concurrent skip list
-
ev_slotmap
A lock-free, eventually consistent, concurrent slot map
-
mbarc-map
Minimally-blocking, Atomic Reference Counted Map
-
no-std-async
Async synchronization primitives for #[no_std] rust
-
one_at_a_time_please
For serialising calls to functions
-
piper
Async pipes, channels, mutexes, and more
-
overdose
Fast, Row Oriented, Kotlin, Scala-like dataframe
-
gaffer
Prioritised, parallel job scheduler with concurrent exclusion, job merging, recurring jobs and load limiting for lower priorities
-
parallel-event-emitter
Parallel Event Emitter for concurrent listener invocation based on futures-rs and futures-cpupool
-
acteur
A safe actor-like framework that just works. Simple, robust, fast, documented.
-
yastl
scoped threadpool library
-
rsevents-extra
Synchronization objects built on top of rsevents. Semaphore, countdown event, and more.
-
benjamin_batchly
Low latency batching tool. Bundle lots of single concurrent operations into sequential batches of work.
-
lossyq
concurrent single publisher, single consumer queue with fixed length, that never blocks the writer
-
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.
-
once_mut
Safe mutable reference to static variable that can be obtained only once
-
membarrier
Process-wide memory barrier
-
key-message-channel
Multi-producer single-consumer queue capable of queuing messages by message key
-
chunker
Minimalistic parallel executor
-
captain-workflow-manager
Run and manage jobs that depend on each other on a variety of backends.s
-
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
-
tenorite
A concurrency abstraction library. Provides a client-server model for asynchronous workers
-
taski
async task DAG execution
-
bounded-spsc-queue
A bounded SPSC queue
-
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
-
concurrency_toolkit
Easy switching between std::sync, tokio::sync and loom::sync
-
semalock
concurrently writing to files in a safe and efficient manner
-
box-counter
counter
-
atomic-story
An brief overview of atomics and memory ordering on a multi-threaded context with examples
-
denog_runtime
denog runtime library
-
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>>
-
run-them
A CLI to launch a single command with many workers, serializing the output
-
rayon-core
Core APIs for Rayon
-
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
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
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
-
specs-static
extension for Specs that adds custom ids
-
governor
A rate-limiting implementation in Rust
-
atomic-destroy
An value which can be atomically read and destroyed; like an atomic Option
-
prawnypool
interface for using thread pools in Rust
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
htb
Hierarchical token bucket implementation
-
hv-guarded-borrow
Traits and implementations for generic use of "guarded" borrows
-
dynqueue
Dynamically extendable Rayon parallel iterator
-
amadeus-parquet
An Apache Parquet implementation in Rust
-
readahead-iterator
Readahead from an iterator on a separate thread, returning items in order and synchronously
-
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
-
contrie
Concurrent map and set
-
shareable
Thread shareable objects using the minimal amount of synchronization
-
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
-
channel_io
Reader implementation on channel of bytes
-
flexible-locks
Flexible Locks
-
atomic-borrow
atomic reference counter
-
tc-tensor
TinyChain's Tensor collection type
-
simple_behavior_tree
behavior tree
-
hytra
Datastructure for fast multi-threaded updates
-
android-wakelock
Safe and ergonomic Rust bindings to the Android WakeLock API
-
moka
A fast and concurrent cache library inspired by Java Caffeine
-
atomic-maybe-uninit
Atomic operations on potentially uninitialized integers
-
maybe-async-channel
A channel which may or may not be async
-
update_channel
A channel for single updatable values
-
concurrency_traits
Traits for concurrent primitives
-
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 -
lightproc
Lightweight process abstraction for Rust
-
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
-
zkmq
Message Queue, backed by Zookeeper
-
laststage
fast, durable, high concurrent HashMap
-
atomic-hyperloglog
thread-safe hyperloglog, with atomics
-
mt-debug-counters
support high performance debug counters for heavy multithreaded applications
-
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
-
spliter
way to implement Rayon's ParallelIterator
-
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
-
jobsteal
A work-stealing fork-join threadpool written in Rust
-
slock
An async mutex that never deadlocks
-
coroutines
High performance coroutine library with native experience
-
spindle_db
A db backend for
spindle
: ergonomic GPGPU data parallel computing in Rust -
treiber_stack
A lockless, thread-safe, atomic linked-list
-
fast-threadpool
Thread-pool implementation optimized to minimize latency
-
task-notify
Notify async tasks when someone mutates data they're interested in
-
parking_monitor
Parking-lot-flavored monitor synchronization construct
-
syncell
Sync alternative to RefCell
-
deploy
The
deploy
library to aide writing and debugging of distributed programs, as well as tooling to run them across a cluster -
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
-
lock_freedom
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
double-checked-cell-async
A thread-safe lazily initialized cell using double-checked locking
-
mycorrh
fast concurrent messaging system for Rust
-
more-sync
More synchronization utils
-
lagoon
A thread pool crate with an array of features
-
disk_log
**High Throughout, NonBlocking** Disk-based logger
-
dynamic-pool
a lock-free, thread-safe, dynamically-sized object pool
-
sentinel-rocket
Sentinel middleware for Rocket
-
waitcell
A cell type containing a value which may not yet be available
-
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
-
mpmcpq
Multi-producer multi-consumer Priority Queue
-
thepipelinetool_task
task package used for thepipelinetool
-
rhythm
Rate limiter which allows VIPs, written in Rust
-
hurdles
Counter-based thread barrier
-
rusty-variation
deadlock-free session-typed communication
-
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})
-
tokio-cron
cron scheduler for tokio
-
chashmap
Fast, concurrent hash maps with extensive API
-
indigo
A framework and utility library for modern applications
-
workers_pool
A long running threadpool for parallel task execution
-
closure-future
Easily run closures on thread pools and turn their result into Futures
-
muscat
Multithreaded Side Channel Attacks Tool
-
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
-
busan
An actor implementation for Rust
-
worker-pool
handle a set of worker threads, which need to communicate back their result to the main thread
-
actors-rs
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
gex-sys
GASNet-EX bindings for Crayfish
-
remutex
Recursive mutex, adapted from Rust's standard library
-
concurrent-round-robin
A concurrent wrr implementation for rust
-
provenant
A version of Arc that can free memory while weak pointers exist by probabilistically tracking provenace
-
sync-wait-group
Wait group for synchronizing the beginning or end of some computation
-
amfiteatr_classic
some classic game theory problems to research on
-
stretto
high performance thread-safe memory-bound Rust cache
-
fiona
Concurrent runtime written against liburing
-
polyester
Parallel iterator adaptors that accept arbitrary iterators
-
hv-elastic
Safe and almost-safe abstractions for lengthening lifetimes and
'static
“loaning” of non-'static
types -
uchan
Multi-producer single-consumer channel for message passing
-
employer
Spawn worker threads and check on them later
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions
. -
locker
named mutex/locker for rust-lang concurrency
-
a_r_c_h_e_r_y
TEMPORARY CRATE
-
rs_taskflow
executing graphs of tasks
-
kernel
Abstract Reactive Streams
-
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
-
hyaline-smr
Garbage Collector(Hyaline- Safe Memory Reclaimation) for lock free data structures
-
hadron-client
The Hadron Rust client library
-
momen
low overhead thread pool
-
sea-streamer-stdio
🌊 SeaStreamer Standard I/O Backend
-
workctl
number of higher-level control mechanisms for concurrent work scheduling, built on standard library concurrency primatives
-
rendezvous_swap
Swap data and sync execution between a pair of threads efficiently
-
atomic
Generic Atomic<T> wrapper type
-
dynpool
A thread manager that is lightweight, flexible, and rescalable
-
sync_cow
Thread-safe clone-on-write container for fast concurrent writing and reading
-
spsc-buffer
Single-producer single-consumer lock-free buffer
-
lockless
Composable, lock-free, allocation-light data structures
-
par-map
Parallel map and flat_map
-
stream-channel
stream in channel
-
iterator_ilp
Iterator extensions for instruction-parallel reductions
-
bichannel
Zero dependency std::mpsc based bidirectional channel
-
semaphorus
Atomic semaphores
-
readlock-tokio
A weird alternative to Arc<RwLock<T>>, using tokio's RwLock
-
context-coroutine
set of extensions to provide stackful coroutines; it is not officially associated with the context crate
-
spsc-bip-buffer
A concurrent, spsc ring-buffer with sized reservations
-
shared-mutex
A RwLock that can be used with a Condvar
-
tange
Scalable Task-based Parallelism Framework
-
monotone
counters and queues for coordination in distributed systems
-
wasefire-sync
Portable non-blocking mutex
-
balter-runtime
A load/stress testing framework
-
haphazard
Dynamic memory management for lock-free data structures using hazard pointers
-
mrsc
mpsc with requests
-
rustpool
A data and thread pool library for Rust
-
kiss-icp-ops-eigen
Unofficial Pure Rust Implementation of kiss-icp
-
srmap
A lock-free, eventually consistent, concurrent multi-value map
-
wei-task
wei task
-
work_pool
work queue wrapped by a thread pool
-
boomerang
'Reactors' Deterministic Actor Model
-
mongo-lock-async
Distributed mutex locks with MongoDB
-
theatre
A concise async actor model implementation
-
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
-
gothack-future-parking_lot
An "as simple as possible" Future implementation for parking_lot
-
ccl
Fast datastructures for use in highly concurrent systems
-
ste
A single-threaded executor with some tricks up its sleeve
-
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… -
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
-
thread-broadcaster
A SPMC (Single producer multi consumer) broadcasting channel to broadcast notifications between threads
-
threadpool-crossbeam-channel
A fork of the threadpool create, which uses crossbeam-channel instead of std::mpsc
-
wasserglas
A fixed size thread-safe object pool with automatic reattachment
-
tiny-actor
A minimal actor framework for Rust
-
refptr
Inherently reference counted structs
-
mpmc
copy-pasted from old rust stdlib
-
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
-
unros-core
stub
-
init_guard
A Synchronization Primitive for guarding against double initialization
-
locklessness
Composable, lock-free, allocation-light data structures
-
arbalest
Like Arc<T> but where weak references don't forbid mutable access
-
atomic_box
A struct which allows multiple threads to safely update and read from a shared non-nullable pointer to heap data
-
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)
-
request-channel
Async MPSC request-reponse channel
-
son_of_grid_engine
Interface with son of grid engine (formerly sun grid engine) to run rust programs on clusters
-
sling
Sequentially lockign (SeqLock) Ring Buffer
-
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
-
sorted-channel
sorted message-based communication channel
-
spin_loop
-
access-queue
limit the number of simultaneous accesses to a value
-
ach-ring
Atomic Channel
-
observable-btree
Reactive Observable BTree
-
cura
arc-lock-system that should clean up the code a lot
-
open-coroutine-core
The open-coroutine is a simple, efficient and generic coroutine library
-
zsling
Rust Wrapper around a Sequentially lockign (SeqLock) Ring Buffer written in Zig
-
amadeus-types
Harmonious distributed data analysis in Rust
-
rjq
Redis job queue
-
kai-cli
Kai - todo.txt task scheduler
-
instrumented-mpsc
Wrapper for futures mpsc unbounded providing Prometheus metrics
-
eventbus
Safe, fast and concurrent event system, inspired by the MinecraftForge event bus
-
evelyn
event distribution library
-
async-once-watch
Asynchronous and shareable container which value is set once
-
dashmap_with_out_t_map_trait
Blazing fast concurrent HashMap for Rust
-
atomic_cell
Lock-free thread-safe mutable memory locations
-
async-rwlock
Async reader-writer lock
-
taskpile
threadpool implementation
-
melodium-lang
Mélodium language parsing and semantic analyser
-
proc-lock-api
APIs for the proc-lock crate
-
conveyor_belt
Queue and batch processing library
-
horde
threads
-
sea-streamer-runtime
🌊 SeaStreamer async runtime abstraction
-
llq
Wait-free SPSC linked-list queue with individually reusable nodes
-
stoplight
stoppable tasks/threads
-
sea-streamer-file
🌊 SeaStreamer File Backend
-
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
-
para
A dataflow/pipeline parallelization framework
-
portable-atomic-util
Synchronization primitives built with portable-atomic
-
option-lock
mutex for Option values
-
blasoxide-mt
multithreading for blasoxide
-
lft-rust
A lock-free threadpool implementation. We provide a traditional single queue threadpool and a lock-free threadpool
-
mpmc-ringbuf
queue
-
sentinel-actix
Sentinel middleware for Actix-Web
-
movie
An actor / thread orchestration library / macro / framework
-
async_ach-notify
Async Atomic Channel
-
qrwlock
Fair queued read-write lock
-
cachemap2
A concurrent insert-only hashmap for caching values
-
logmap
A concurrent hashmap using a log for buckets
-
pairlock
A reader-writer lock with wait-free reads
-
terminate
abstract logic to terminate threads, coroutines and the like
-
borrowed-thread
thread-safe way to pass borrow to thread::spawn
-
rework
Multi-threaded task processing in the Master-Worker pattern
-
amadeus-aws
Harmonious distributed data analysis in Rust
-
run-down
protection in rust
-
clone-replace
Share mutable data by cloning and replacing a reference version
-
thread-safe
Container that allows thread safety for thread-unsafe objects
-
metadata-store
store for recoverable metadata that is written in atomic batches
-
lock-hierarchy
Prevent dead locks by enforcing lock hierarchies
-
c-map
Very fast concurrent hashmap
-
td_rthreadpool
thread wrapper for Rust
-
fuze
A mechanism to wait for a single signal which can be checked at any time
-
pmpmc
A priority multi producer multi consumer channel
-
ump-server
Server message dispatch loop for ump
-
hv-cell
A no-std port of the
atomic_refcell
crate with additionalArc
-centric functionality -
jotty
embeddable distributed processing framework for both short and long running batch jobs
-
ctrlc_fnonce
Wrapper for ctrlc to execute a FnOnce and exit the process upon Ctrl-C
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
pour
Optionally consed radix tries for fast set operations
-
flow-mel
Mélodium core flow control library
-
waitable
A synchronized (atomic) value container implementing the Mutex+Condvar pattern for efficient blocking waits
-
lf-queue
A lock-free multi-producer multi-consumer unbounded queue
-
future-parking_lot
An "as simple as possible" Future implementation for parking_lot
-
synctree
Thread-safe tree data structure
-
rustix-futex-sync
Linux futex-based synchronization
-
unsync_channel
!Send/!Sync channels for Rust
-
sstb
A thread-safe sstables library
-
rtic-core
Core abstractions of the Real-Time Interrupt-driven Concurrency framework
-
embassy-sync
no-std, no-alloc synchronization primitives with async support
-
waitmap
an awaitable concurrent hash map
-
roundabout
An message oriented concurrent runtime
-
read-cell
Read-only Cell counterpart
-
bbq-rs
A Block-based Bounded Queue for Exchanging Data and Profiling
-
riffy
An unbounded, wait-free, multi-producer-single-consumer queue
-
amadeus-commoncrawl
Harmonious distributed data analysis in 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.
-
streambed-patterns
Patterns for working with streambed
-
may_actor
Actor library based on MAY
-
work-steal-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
datacake-node
The core cluster membership system built ontop of Quickwit's chitchat
-
cortex-m-rtfm
Real Time For the Masses (RTFM): a concurrency framework for building real time systems
-
hybrid-lock
A hybrid lock with optimistic locking
-
scheduled-executor
Single and multi-threaded task scheduler
-
liblightning
High-performance general-purpose stackful coroutine library
-
kiss-icp-runtime
Unofficial Pure Rust Implementation of kiss-icp
-
tokio-sync-read-stream
Create a stream from a std::io::Read using Tokio blocking threads
-
threads
Traits to abstract thread-pools
-
static_locks
The
parking_lot
locks but usable in statics and const fn -
fibril_verifier
Verifies behavior for distributed systems implemented with the Fibril library
-
scheduling
job scheduler