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