-
orx-concurrent-iter
A thread-safe, ergonomic and lightweight concurrent iterator trait and efficient implementations
-
melodium
Dataflow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely
-
atomic-file-install
For atomically installing a file or a symlink
-
melodium-common
Common Mélodium elements and traits
-
melodium-engine
Mélodium core engine and executor implementation
-
melodium-lang
Mélodium language parsing and semantic analyser
-
melodium-repository
Repository managment crate for Mélodium, with dependency resolution and retrieval
-
boxcar
A concurrent, append-only vector
-
std-mel
Mélodium standard library
-
json-mel
Mélodium JSON data processing library
-
swimming
Dive into Efficiency with Swimming: A High-Performance, No-Nonsense Connection Pool
-
melodium-loader
Loading engine for Mélodium, with dependency resolution and retrieval
-
regex-mel
Mélodium regex library
-
encoding-mel
Mélodium text encode/decode library
-
sql-mel
Mélodium SQL library
-
process-mel
Mélodium external process management library
-
javascript-mel
Mélodium JavaScript language library
-
fs-mel
Mélodium core filesystem interaction library
-
thread-priority
managing threads priority and schedule policies
-
http-mel
Mélodium HTTP library
-
melodium-doc
Documentation generator for Mélodium projects
-
rearch-effects
Re-imagined approach to application design and architecture
-
melodium-core
Core implementation for compiled Mélodium elements
-
disruptor
Low latency inter-thread communication via a ringbuffer (inspired by the LMAX Disruptor)
-
toktor
A small tokio-based Actor framework
-
multichannel
A mpmc priority multi channel with dynamic channel registration and freezing
-
rtic-sync
Synchronization primitives for asynchronous contexts
-
dropout
Drop your objects out of main thread
-
rearch
Re-imagined approach to application design and architecture
-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
mpstthree
implementing Multiparty Session Types for 2 or more participants
-
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
rearch-tokio
Re-imagined approach to application design and architecture
-
async-skipdb
An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine
-
skipdb
An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
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.
-
txn
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
stretto
high performance thread-safe memory-bound Rust cache
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
sea-streamer
🌊 The stream processing toolkit for Rust
-
surrealkv
A low-level, versioned, embedded, ACID-compliant, key-value database for Rust
-
loom
Permutation testing for concurrent code
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
async-ringbuf
Async SPSC FIFO ring buffer
-
blazemap
Implements a vector-based slab-like map with an interface similar to that of HashMap, and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map
-
steelmill
A resource manager (dependency injector / factory) designed for distributed systems and simulation testing
-
balter
A load/stress testing framework
-
callback_cell
Like an Atomic<Option<Box<FnOnce()>>>
-
sea-streamer-redis
🌊 SeaStreamer Redis Backend
-
sea-streamer-file
🌊 SeaStreamer File Backend
-
sea-streamer-socket
🌊 SeaStreamer backend-agnostic Socket API
-
sea-streamer-stdio
🌊 SeaStreamer Standard I/O Backend
-
sea-streamer-examples
🌊 The stream processing toolkit for Rust
-
roboplc
Framework for PLCs and real-time micro-services
-
sea-streamer-kafka
🌊 SeaStreamer Kafka / Redpanda Backend
-
jobserver
GNU Make jobserver for Rust
-
sea-streamer-types
🌊 SeaStreamer Traits & Types
-
sea-streamer-runtime
🌊 SeaStreamer async runtime abstraction
-
parking_lot_rt
Parking-lot fork for real-time applications
-
balter-runtime
A load/stress testing framework
-
yazi-scheduler
Yazi task scheduler
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
irox-progress
An ecosystem for displaying progress, either in a UI or on the terminal
-
oracle_sql_tools
An extension to the Rust-Oracle crate to make simple queries easy to implement
-
pi_key_alloter
lock free Key(idx:u32, version:u32) alloter
-
krata-runtime
Runtime for running guests on the krata hypervisor
-
krata-xenevtchn
xen evtchn for krata
-
flurry
Rust port of Java's ConcurrentHashMap
-
throttle-client
Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.
-
thepipelinetool_task
task package used for thepipelinetool
-
omango
Concurrency collections
-
thingbuf
I'm at the buffer pool. I'm at the MPSC channel. I'm at the combination MPSC channel and buffer pool.
-
mvsync
A standalone async and worker thread library, with expandable traits and command buffers
-
scc
High performance containers and utilities for concurrent and asynchronous programming
-
kameo
Fault-tolerant Async Actors Built on Tokio
-
tasklet
A task scheduling library
-
namaste
-
seize
Fast, efficient, and robust memory reclamation for concurrent data structures
-
retry-if
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
sdd
Scalable lock-free memory reclaimer
-
balter-core
A load/stress testing framework
-
uactor
The fastest and most modular actor system that doesn’t force you to pay for what you don’t need
-
moka
A fast and concurrent cache library inspired by Java Caffeine
-
async-channel
Async multi-producer multi-consumer channel
-
omango-futex
Futex for Rust
-
sled
Lightweight high-performance pure-rust transactional embedded database
-
ratelimit
ratelimiter that can be shared between threads
-
idr-ebr
An efficient concurrent ID to object resolver
-
razel
a command executor with caching for data processing pipelines
-
cargo-steady-state
Code generator for steady_state projects based on a structured dot file
-
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…
-
fiddler-cli
Data Stream processor CLI written in rust
-
rose_bloom
A concurrent growing element size linked list with stable pointers
-
ptr_cell
Thread-safe cell based on atomic pointers to externally stored data
-
async-cpupool
async threadpool for CPU-bound tasks
-
asyncgit
allow using git2 in a asynchronous context
-
once_map
Single assignment and lazy maps
-
orx-concurrent-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance concurrent collection
-
stuck
Multi-threading scheduled task facility building on cooperative stackful coroutine
-
orx-concurrent-vec
An efficient, convenient and lightweight grow-only read & write concurrent data structure allowing high performance concurrent collection
-
orx-concurrent-ordered-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance and ordered concurrent collection
-
rt
A real-time operating system capable of full preemption
-
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
-
oxidd-rules-bdd
Binary decision diagrams (BDDs) for OxiDD
-
oxidd-manager-index
Index-based manager implementation for OxiDD
-
oxidd-manager-pointer
Pointer-based manager implementation for OxiDD
-
mcslock
Mellor-Crummey and Scott contention-free spin-lock for mutual exclusion, referred to as MCS lock
-
parseq
Parallel sequential iterator
-
mtzip
making zip archives with multithreaded compression
-
sync_wrapper
enlisting the compiler's help in proving the absence of concurrency
-
smolscale2
hitdns fork of original smolscale
-
mpmc-async
A multi-producer, multi-consumer async channel with reservations
-
ora-worker
Part of the Ora scheduler framework
-
gst-plugin-threadshare
GStreamer Threadshare Plugin
-
arthouse
Art-Net (DMX over UDP/IP) adapter for Project Lighthouse
-
employees
A small runtime that hides all the boilerplate when using threads
-
amfiteatr_proc_macro
Procedural macro crate for amfiteatr_* crates
-
mock_instant
way to mock an std::time::Instant
-
amfiteatr_classic
some classic game theory problems to research on
-
amfiteatr_core
A framework to model and simulate game theory problems with many agents
-
burstq
A multi-producer, multi-consumer channel that supports sending or receiving multiple values in a single operation
-
quick_cache
Lightweight and high performance concurrent cache
-
idle
Collection of idle strategies to be used by thread(s) when they have no work to perform
-
aarc
Atomically updatable variants of Arc and Weak for lock-free concurrency
-
chashmap-async
Concurrent async hash maps with key-scoped locking
-
key-mutex
Access mutexes by key
-
rayon-progress-bar
work-stealing parallelism for Rust
-
everygarf
Concurrently download every Garfield comic to date
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
iterator_ilp
Iterator extensions for instruction-parallel reductions
-
amity
Concurrency algorithms
-
jwalk-meta
Filesystem walk performed in parallel with streamed and sorted results
-
mutringbuf
A very simple lock-free SPSC ring buffer, with in-place mutability
-
thingvellir
a concurrent, shared-nothing abstraction that manages an assembly of things
-
drain
that supports graceful shutdown
-
real-time
Safely share data with a real-time thread
-
ocl
OpenCL bindings and interfaces for Rust
-
pi_atom
The global thread safe atomic string pool reduces the memory occupation of the same string and is also used for HashMap keys
-
rayon
work-stealing parallelism for Rust
-
timedmap
A hash map with expiring key-value pairs
-
glommio
thread-per-core crate that makes writing highly parallel asynchronous applications in a thread-per-core architecture easier for rustaceans
-
multithreading
in Rust
-
reactivate
Thread Safe Reactive Data Structure. Made with ❤️ for 🦀
-
rw-cell
Write data to cell from anything place your application without copy, lock and reading in one place
-
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
-
unros-core
stub
-
sync_file
Files that can be read concurrently
-
crosstalk
An extremely lightweight, topic-based, cross-thread, in-memory communication library
-
radicle-node
The Radicle Node
-
parallel-processor
Framework to manage asynchronous execution of multiple compute units communicating using messages
-
dyn_object
Ergonomic and thread safe version of Box<dyn Any>
-
reference-counted-singleton
Reference-counted singleton whose protected data can be recreated as needed
-
moongraph-macros
Derive macros for the moongraph library
-
async-local
For using thread locals within an async context and across await points
-
pueue
A cli tool for managing long running shell commands
-
winhooker
a helper for hooking functions in windows on x64
-
vlock
A fast and scalable multi-version shared state lock with wait-free read access
-
mbarc-map
Minimally-blocking, Atomic Reference Counted Map
-
messaging_thread_pool
aiding the creation of typed thread pool of objects that is communicated with via channels
-
gabriel2
Indeed, an actor library, not a framework, written in Rust
-
renoir
Network of Operators In Rust
-
crabz
Parallel Compression
-
jobslot
GNU make jobserver for Rust
-
folklore
A lock-free concurrent hash map
-
concread
Concurrently Readable Data-Structures for Rust
-
wasm_thread
An std thread replacement for wasm32 target
-
happylock
Free deadlock prevention
-
gix-lock
A git-style lock-file implementation
-
prefork
forking processes
-
ofilter
fast thread-safe Bloom filter
-
pi_arr
lock-free & auto-expansion array
-
actify
An intutive actor model with minimal boilerplate
-
caos
Concurrent Append Only Segment-list
-
gix-features
integrate various capabilities using compile-time feature flags
-
rider
bounded executor for tokio; limit the count of tasks running 🚦
-
apalis-core
Core for apalis: simple, extensible multithreaded background processing for Rust
-
paladin-core
distributed algorithm toolkit. Write distributed algorithms without the complexities of distributed systems programming.
-
rtic
Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems
-
ferroc
A fast & lock-free memory allocator library
-
adirector
asynchronous tokio task spawner with a limited size
-
shuttle
testing concurrent Rust code
-
bi
-
atomx
Thread safe data structures based on atomic data types
-
atomic-destructor
Atomic destructor for multi-threaded env
-
jtp
thread pool, similar to the ThreadPoolExecutor in java
-
zallocator
Amortizes the cost of small allocations by allocating memory in bigger chunks
-
may
Rust Stackful Coroutine Library
-
thread-owned-lock
Mutex which can only be unlocked by the owning thread
-
atomig
Generic, convenient and lock-free
std
atomics viaAtomic<T>
. Can be used with many primitive types (including floats) and with custom types. -
simple_behavior_tree
behavior tree
-
tokio-async-utils
Async utils such as TaskHandle type that aborts task on handle drop
-
fork-map
running operations in a child process spawned by
fork()
-
portable_atomic_enum
An attribute to create an portable atomic wrapper around a C-style enum
-
may_queue
May's internal queue library
-
irox-threading
Blocking and Asynchronous Threading Tools
-
ebri
[NOTE: un-tested. use at your own risk.] ebri (ebr-integrated), that is, a
no-std
EBR (Epoch-Based Reclamation) implementation. thanks to the idea fromscc::ebr
. -
lock_pool
Robust, efficient, high performance, asynchronous object pooling
-
two_phase_channel
A safe synchronisation-free parallel communication channel by statically forbidding conflicting accesses
-
portable_atomic_enum_macros
An attribute to create an portable atomic wrapper around a C-style enum
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
swimming-pool
threadpool for running a number of jobs on a fixed number of threads
-
rayon_iter_concurrent_limit
Limit the concurrency of an individual rayon parallel iterator method with a convenient macro
-
swap_channel
A safe lock-free parallel communication channel based on mem::swap
-
wasefire-sync
Portable non-blocking mutex
-
rtic-macros
Procedural macros, syntax parsing, and codegen of the RTIC crate
-
minstant
A drop-in replacement for
std::time::Instant
that measures time with high performance and high accuracy powered by TSC -
hwlocality
Idiomatic Rust bindings for the hwloc hardware locality library
-
parallel_logger
A logger implementing the log::Log trait that allows other loggers to run in a separate thread, reducing load on the calling thread significantly
-
thread_local
Per-object thread-local storage
-
semanticsimilarity_rs
designed to compute similarity/distance metrics between embeddings
-
jxl-threadpool
Internal crate of jxl-oxide to abstract over thread pool implementation
-
archery
Abstract over the atomicity of reference-counting pointers
-
async-condvar-fair
Condition variables for async Rust
-
blinkcast
Fast, bounded, multiple-producer, multiple-consumer, lossy, broadcast channel
-
pi_share
rc, arc, lock, atomic
-
io-reactor
Concurrent I/O resource management using reactor pattern
-
atomic_enum
An attribute to create an atomic wrapper around a C-style enum
-
hwlocality-sys
Low-level bindings for the hwloc hardware locality library
-
rust-debugging-locks
debugging locks in Rust
-
picokafka
Kafka library for tarantool-module based on librdkafka
-
time_sigil
task scheduler
-
ddo
generic and efficient framework for MDD-based optimization
-
ump-ng-server
Server message dispatch loop for ump-ng
-
ump-server
Server message dispatch loop for ump
-
hala-sync
Hala synchronous primitive
-
hala-lockfree
Some lockfree structure for rust
-
sync42
synchronization tools
-
tatl
in-process alerting
-
arcu
An Rcu implementation using an Arc to keep the read critical section should and handle cleanup
-
process_control
Ergonomically run processes with limits
-
thread-manager
A streamlined Rust library for efficient thread pooling and parallel job execution, designed for simplicity, flexibility, and performance
-
atomic-interval
A tiny implementation of an atomic timer
-
tourniquet-tonic
Async native round-robin manager for remote services. Tonic integration.
-
governor
A rate-limiting implementation in Rust
-
close_already
Speeds up programs writing lots of files on Windows
-
uf_rush
A lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure
-
icicle-core
GPU ZK acceleration by Ingonyama
-
recloser
A concurrent circuit breaker implemented with ring buffers
-
unlock
Instrumented synchronization primitives helping you to unlock performance issues
-
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.
-
ringbuf-blocking
Blocking version of ringbuf
-
geph-nat
concurrent NAT thingy used throughout Geph
-
atomptr
A safe, dependency-less abstraction for typed atomic smart pointers
-
async-metronome
Unit testing framework for async Rust
-
coarsetime
Time and duration crate optimized for speed
-
tari_shutdown
A convenient shutdown signal
-
trc
A faster Arc
-
ppl
A structured parallel programming library for Rust
-
ballista-scheduler
Ballista Distributed Compute - Scheduler
-
s3put
Upload a single file/stream to S3 using chunks
-
sas
Salty-and-Sweet one-line Rust Runtime Performance Optimization Library
-
ballista-core
Ballista Distributed Compute
-
verona-rt
Idiomatic binding to the verona runtime
-
kiss-icp-runtime
Unofficial Pure Rust Implementation of kiss-icp
-
verona-rt-sys
Low level bindings to verona-rt
-
kiss-icp
Unofficial Pure Rust Implementation of kiss-icp
-
someday
Lock-free MVCC primitive
-
kiss-icp-ops-eigen
Unofficial Pure Rust Implementation of kiss-icp
-
rayon-scan
A parallel prefix scan function for ParallelIterator
-
ligmars
Safe bindings to the LGMP C library
-
reord
Run your tests multi-threaded, but in a reproducible way
-
txn_lock
support transactional versioning
-
sharded-thread
Expirement for now
-
thread-lock
A wrapper that locks non-Send and non-Sync data to a specific thread
-
tc-transact
Traits and locking utilities for a TinyChain transaction
-
tc-scalar
TinyChain's scalar value enum, including concurrently-resolvable op definitions and references
-
maitake-sync
No-std async synchronization primitives from Maitake
-
tc-fs
TinyChain's transactional filesystem interface layer
-
entro-spin
Entro Spin is a 64-bit, true-random number generator algorithm
-
timeslice
periodic time slice scheduler
-
testtools
Helpers for eliminating boilerplate code in tests
-
lockable
offers hash map and cache data structures where individual entries can be locked
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
wei-scheduler
wei scheduler
-
threadbath
A minimal implementation of a thread pool
-
callysto
Stream processing framework
-
ordered-channel
A channel that always receives messages in the correct order, even if they were sent out of order
-
mem_btree
A Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.
-
open-coroutine
efficient and generic stackful-coroutine library
-
threadalone
Make any value Send + Sync but only available on its original thread. Don't use on multi-threaded environments!
-
open-coroutine-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
hexchat-api
API for HexChat plugin development
-
open-coroutine-iouring
The io_uring support for open-coroutine
-
left-right-cell
A cell with lock-free concurrent read access
-
fslock-arti-fork
files as locks, forked for use in Arti
-
open-coroutine-core
The open-coroutine is a simple, efficient and generic coroutine library
-
atomicslice
thread-safe shared slices that are just about as fast as possible to read while also being writable
-
wasm_sync
Synchronization primitives for both web and native
-
open-coroutine-macros
The proc macros for open-coroutine
-
open-coroutine-hooks
The syscall hook for open-coroutine
-
acto
light-weight Actor library for Rust
-
cachemap2
A concurrent insert-only hashmap for caching values
-
threatpool
thread pool
-
batch-aint-one
I got 99 problems, but a batch ain't one
-
rayon-core
Core APIs for Rayon
-
meslin
Ergonomic messaging for Rust
-
refcell-lock-api
A single-threaded implementation of lock_api for RefCell, to alllow abstracting between single-threaded & multi-threaded code
-
talaria
A high performance, cyclic message passing library
-
atomic-queue
bounded lock-free queue for use in Audio applications, ported from https://github.com/max0x7ba/atomic_queue
-
sig_fig_histogram
histogram type that is exponentially distributed and human-friendly
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
fenic
test concurrent code
-
swctx
One-shot channel with some special semantics
-
parallel-sh
Execute commands in parallel
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
async-lock
Async synchronization primitives
-
chess_dl
Chess.com game downloader
-
crossbeam
Tools for concurrent programming
-
rtic-time
lib TODO
-
mintex
minimal mutex
-
crossbeam-queue
Concurrent queues
-
crossbeam-utils
concurrent programming
-
sharded_mutex
No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.
-
crossbeam-deque
Concurrent work-stealing deque
-
crossbeam-epoch
Epoch-based garbage collection
-
embassy-time-queue-driver
Timer queue driver trait for embassy-time
-
crossbeam-skiplist
A concurrent skip list
-
rtic-monotonics
that provides implementations of the Monotonic trait from rtic-time
-
leaklist
concurrent, lock-free, singly-linked list
-
no-std-async
Async synchronization primitives for #[no_std] rust
-
mini-moka
A lighter edition of Moka, a fast and concurrent cache library
-
rcurs
An oxidized RCU implementation
-
svix-ksuid
A pure Rust and fully tested KSUID implementation
-
pargraph
Operator based parallel graph processing
-
std-threadpool
Threadpool implementation
-
loole
A safe async/sync multi-producer, multi-consumer channel
-
rline
Input line retrieval using libreadline's "Alternate Interface"
-
tinypool
thread pool implementation in Rust
-
latches
A downward counter (CountDownLatch) which can be used to synchronize threads or coordinate tasks
-
watchable
RwLock-like type that is compatible with both multi-threaded and async code
-
rearch-macros
Re-imagined approach to application design and architecture
-
file_rw
high-performance, memory-mapped file I/O utilities
-
sync-cell
A collection of easier to use thread-safe types for the creation of larger thread safe systems
-
faucet
Back-pressured MPMC queue that can be drained after signaling completion
-
rt-watchdog
Real-time userspace watchdog 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 -
futures-channel
Channels for asynchronous communication using futures-rs
-
atomic-time
AtomicDuration
,AtomicOptionDuration
,AtomicSystemTime
,AtomicOptionSystemTime
,AtomicInstant
andAtomicOptionInstant
for Rust -
shared_resources
shared resources container which is thread-safe, and lock-free
-
task_pool
Flexible abstraction for task-based composable multithreading
-
shmap
A key-value store based on unix shared-memory files (shm) for persisting state across program restarts
-
prawnypool
interface for using thread pools in Rust
-
utils-atomics
Various atomic utils
-
status_executor
Run your work on some context (thread) and get status info back
-
jthread
Deadlock-free Mutual Exclusion locks for Rust
-
atomic-try-update
Primitives that make it easy to implement correct lock-free algorithms
-
guardian
owned mutex guards for refcounted mutexes
-
flue
An efficient and secure actor runtime library
-
portable-atomic-util
Synchronization primitives built with portable-atomic
-
bufchan
buffered MPSC channel
-
timely-communication-master
Communication layer for timely dataflow
-
haphazard
Dynamic memory management for lock-free data structures using hazard pointers
-
perthread
ThreadMap structure for accessing PerThread thread local variables form a static context
-
lock_ext
Extensions to std::sync::Mutex
-
uni_rc_lock
trait which may represent either Rc<RefCell<T>> or Arc<RwLock<T>>
-
rpools
A minimalist workerpool for rust
-
mco
Rust Coroutine Library like go
-
either-slot
An atomic slot whose senders can either place their value into the slot, or retrive all the data from the slot
-
htb
Hierarchical token bucket implementation
-
try-lock
A lightweight atomic lock
-
portable-atomic
Portable atomic types including support for 128-bit atomics, atomic float, etc
-
mt-kahypar-sys
Rust bindings to Mt-KaHyPar
-
mscheduler
Use mongodb to schedule task running
-
d2_iterators_in_rust
D2 Iterators
-
task-exec-queue
A asynchronous task execution queue
-
jadesrandomutil
A random util library for Rust for Jade
-
rustix-futex-sync
Linux futex-based synchronization
-
embassy-sync
no-std, no-alloc synchronization primitives with async support
-
talos_messenger_actions
Messenger actions for Talos
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
sparking-lot-core
parking on addresses
-
print_queues
A print queues that can be add from different thread and print on main thread
-
async-events
Waiting for external task completion in asynchronous Rust code
-
ora-scheduler
Part of the Ora scheduler framework
-
radium
Portable interfaces for maybe-atomic types
-
paradis
Experimental parallel processing of disjoint indices
-
priority-inheriting-lock
A priority-inheriting lock based on Linux futexes
-
phazer
Two-phase commit for file creation
-
paradis-core
Experimental parallel processing of disjoint indices
-
flow-mel
Mélodium core flow control library
-
conv-mel
Mélodium core types conversion library
-
ops-mel
Mélodium core operations library
-
mtxgroup
mutex group locks all mutexes at the same time
-
type-mel
Mélodium core types utilities library
-
text-mel
Mélodium text utilities library
-
engine-mel
Mélodium core engine interaction library
-
my_threadpool
threadpool
-
no_deadlocks
A Runtime Deadlock Debugger
-
graph
high-performant graph algorithms
-
structured_persistent_logger
A structured 'log' logger that allows for persistent fields
-
blocking-threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
fluxion
actor framework written in rust and designed for distributed systems
-
rtrb
A realtime-safe single-producer single-consumer ring buffer
-
swap-buffer-queue
A buffering MPSC queue
-
rsiot-channel-utils
Вспомогательные компоненты
-
concurrent-map
a lock-free linearizable B+ tree
-
ebr
epoch-based reclamation with low cacheline ping-pong
-
deborrow
Splits mutable references safely into their fields, and helps with reference manipulation
-
choir
Task Orchestration Framework
-
atom_box
A safe idiomatic Rust implementation of Atomic Box using hazard pointers
-
mycorrh
fast concurrent messaging system for Rust
-
parking_monitor
Parking-lot-flavored monitor synchronization construct
-
tlrepo
Thread-local git2::Repository, shareable across threads
-
cloudi
API
-
app-frame
Compile-time dependency-injected application framework with a service orchestrator
-
lock-free-static
Lock-free static variables
-
deqp-runner
A VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline
-
mpi
Message Passing Interface bindings for Rust
-
kcas
A lock-free, allocation-free multi-word compare-and-swap library
-
spinning_top
spinlock crate based on the abstractions provided by
lock_api
-
shipyard_scenegraph
Scenegraph for Entity Component System
-
liblgmp-sys
Raw bindings to the LGMP library by gnif
-
parking
Thread parking and unparking
-
renege
Tracking cache validity using fast concurrent invalidation propogation
-
per-thread-mutex
Synchronization lock designed for wrapping thread-unsafe C libraries
-
streambed-patterns
Patterns for working with streambed
-
atomic-maybe-uninit
Atomic operations on potentially uninitialized integers
-
box-counter
counter
-
atomic_refcell
Threadsafe RefCell
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
ocl-interop
Creates an OpenCL Context with OpenGL Interop enabled
-
rush_core
The rules engine is based on the rete algorithm
-
rush_expr_engine
The rules engine is based on the rete algorithm
-
rush_lua_engine
The rules engine is based on the rete algorithm
-
thread_db
Rust wrapper for libthread_db
-
mpsc
mpsc channel
-
arl
A rate limiter to be used with tokio
-
queue-ext
The extended feature of the queue can convert the pop() function of the queue to Stream and the push() function to Sender
-
PRUEBA
Colas tarea
-
ump
Micro message passing library for threads/tasks communication
-
ump-ng
Micro message passing library for threads/tasks communication
-
semka
Semaphore implementation
-
once_mut
Safe mutable reference to static variable that can be obtained only once
-
simple-rw-global
GlobalContainer based on std::sync::RwLock
-
peace-lock
A zero-cost abstraction lock that helps check contention free algorithms
-
waker-fn
Convert closures into wakers
-
todc-utils
building and testing distributed systems
-
dfmutex
Deadlock-free Mutex locks
-
mmap-sync
package allowing sharing of data between processes in a wait-free and zero-copy fashion from mapped memory
-
easy-parallel
Run closures in parallel
-
piper
Async pipes, channels, mutexes, and more
-
entropy-ecs
一个虚拟世界
-
resman
Runtime managed resource borrowing
-
specs
Entity-Component-System library written in Rust
-
arcow
Atomically Reference-counted Copy-On-Write shared pointer
-
atomic_once_cell
Thread-safe and lock-free OnceCell and Lazy
-
todc-mem
Algorithms for shared-memory distributed systems
-
key-rwlock
keyed asynchronous reader-writer locks
-
trauma
Simplify and prettify HTTP downloads
-
tokio-etcd-lock
WIP
-
shrink_pool
A thread pool which agressively terminates its threads as soon as they are idle
-
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
-
sigq
Queue that signals waiting consumers about node availability
-
evident
Pub/Sub library using IDs to identify events
-
app-state
Thread-safe, mutable application states for rust
-
tracing-mutex
Ensure deadlock-free mutexes by allocating in order, or else
-
incr
fast and self-contained data structures for checking whether a new value is greater than the previous maximum
-
kueue
A robust, user-level, work-stealing, distributed task scheduler
-
blake2s_simd
a pure Rust BLAKE2s implementation with dynamic SIMD
-
taskpile
threadpool implementation
-
visa
(Virtual Instrument Software Architecture) Wrapper which allows concurrent and dynamic switching between visa implementations from different vendors
-
read-write-api
interface to unify single-threaded code and RwLocks-based code
-
redis-streams-dump
A small utility to dump Redis Streams content into a SeaStreamer file
-
wei-task
wei task
-
genserver
Elixir inspired async actor library
-
atomicell
Multi-threaded RefCell on atomics
-
muscat
Multithreaded Side Channel Attacks Tool
-
append-only-vec
Append-only, concurrent vector
-
crawly
A lightweight async Web crawler in Rust, optimized for concurrent scraping while respecting
robots.txt
rules -
unsync_channel
!Send/!Sync channels for Rust
-
dashmap
Blazing fast concurrent HashMap for Rust
-
indicatif-log-bridge
Bridge the log crate and indicatif to stop log lines from mixing up with progress bars
-
crossfire
channels for async and threads
-
stateright
A model checker for implementing distributed systems
-
memo-map
implementing a synchronized map for memoization
-
shared_cell
Interior mutability between concurrent tasks on the same thread
-
bursty
Test support for exarcebating contention in multi-threaded code
-
corosensei
A fast and safe implementation of stackful coroutines
-
async-stm
Asynchronous Software Transactional Memory
-
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
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
command-executor
Command Executor thread pool
-
conveyor_belt
Queue and batch processing library
-
timer-rs
timer used to schedule execution of closures at a given timestamp
-
atomic-memcpy
Byte-wise atomic memcpy
-
flume
A blazingly fast multi-producer channel
-
sharded_queue
ShardedQueue is currently the fastest concurrent collection which can be used under highest concurrency and load
-
parsli
Parallel status lines for Rust
-
spindle_db
A db backend for
spindle
: ergonomic GPGPU data parallel computing in Rust -
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!)
-
local-sync
Non-threadsafe data structure for async usage
-
classic-sync
ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems
-
agner-utils
An actor toolkit inspired by Erlang/OTP (utils)
-
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…
-
simple-task
A distributed task queue for learning Rust
-
rp2040-monotonic
RTIC Monotonic implementation based on RP2040's Timer peripheral
-
thread_io
performing I/O in background thread
-
minicoroutine
mini coroutine library in rust
-
tasic
Tokio, Async_STD, Smol, Interface Crate
-
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. -
inline-array
efficient immutable inlinable byte array
-
fault-injection
fault injection, concurrency delay injection, and error source annotation
-
shared-local-state
shared local state registry for use in EBR, IO, etc
-
lariv
Linked Atomic Random Insert Vector: a thread-safe, self-memory-managed vector with no guaranteed sequential insert
-
mpvipc
A small library which provides bindings to control existing mpv instances through sockets
-
rapidsync
Rapid & threadsafe embedded data stores
-
pawawwewism
a wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3
-
rt-history
An RT-safe history log with error checking
-
readfish-tools
Tools for analysing adaptive sampling data
-
rhythm
Rate limiter which allows VIPs, written in Rust
-
packed_simd
Portable Packed SIMD vectors
-
atomic
Generic Atomic<T> wrapper type
-
snowdon
A lightweight thread-safe snowflake ID implementation for Rust
-
ccd
A windows simple, fast chrome_cookie_decryptor
-
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.
-
work-queue
A concurrent work-stealing queue for building schedulers
-
navactor
A cli tool for creating and updating actors from piped input
-
aramid
Synthetic fibers
-
mailbox_processor_rs
Actor abstraction inspired by the FSharp MailboxProcessor
-
oqueue
Non-interleaving multithreaded output queue
-
taskschd
windows taskschd demo
-
geese_pool
Message-passing system for networking with Geese
-
metadata-store
store for recoverable metadata that is written in atomic batches
-
round_mult
A tiny library to round a number up or down to a multiplier
-
stewart
A minimalist, high-performance, and non-exclusive actor system
-
threadbound
Make any value Sync but only available on its original thread
-
tpx
Task scheduler
-
android-wakelock
Safe and ergonomic Rust bindings to the Android WakeLock API
-
derivable-object-pool
A thread-safe derivable object pool collection with automatic reusage of objects
-
lock_freedom
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
atomic-polyfill
Atomic polyfills, for targets where they're not available
-
simt
compute support for rust
-
infinitree
Embedded, encrypted database with tiered cache
-
simt_cuda_sys
part of simt. cuda driver api bindings
-
infinitree-backends
Embedded, encrypted database with tiered cache -- backends
-
lock_cell
A custom locking cell type written in Rust
-
readlock
A weird alternative to Arc<RwLock<T>>
-
atomic-hyperloglog
thread-safe hyperloglog, with atomics
-
infinitree-macros
Embedded, encrypted database with tiered cache
-
readlock-tokio
A weird alternative to Arc<RwLock<T>>, using tokio's RwLock
-
libblobd-direct
blobd, direct variant
-
crony
cron runner that spawns another thread to run your cron jobs
-
exclusion-set
a lock-free concurrent set
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
rewrk
HTTP benchmarking tool
-
threadpool-executor
A threadpool executor
-
async-map
A rarely-locking, shared map for Rust
-
libmcl-sys
This system crate provides Rust language bindings to the Minos Compute Library (MCL)
-
leapfrog
A fast, lock-free concurrent hash map
-
datacake-crdt
A conflict free replicated datatype based on a hybrid logical clock implementation for building eventually consistent data stores
-
vin
An ergonomic actor framework
-
datacake-rpc
A zero-copy, actor-like RPC framework using rkyv
-
datacake-node
The core cluster membership system built ontop of Quickwit's chitchat
-
datacake-eventual-consistency
Eventually consistent state replication as a library (consensus, RPC and conflict resolution) for building your own eventually consistent databases
-
datacake-sqlite
A pre-built implementation of datacake's Storage trait using SQLite
-
mongo-lock-async
Distributed mutex locks with MongoDB
-
vin-macros
Procedural macros that power vin
-
gts-transport
Gts transport
-
gts-logger
Gts logger
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
nyoom
A filesystem walker for floppy-disk
-
thread-broadcaster
A SPMC (Single producer multi consumer) broadcasting channel to broadcast notifications between threads
-
atomic_pingpong
Lightweight no_std ping-pong buffer, using AtomicU8 for synchronization
-
sync-unsafe-cell
A backport of the SyncUnsafeCell standard library type for use in older Rust versions
-
fast-logger
Fast logger for Rust
-
fencing
tokens
-
leaky-bucket
A token-based rate limiter based on the leaky bucket algorithm
-
disrustor
This project is a port of the LMAX Disruptor to Rust
-
rclite
small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs
-
fibril
implementing distributed systems with commmunicating fibers
-
fast-able
The world's martial arts are fast and unbreakable; 天下武功 唯快不破
-
fibril_verifier
Verifies behavior for distributed systems implemented with the Fibril library
-
treiber_stack
A lockless, thread-safe, atomic linked-list
-
fibril_core
Core types for the Fibril library
-
vin-core
Core types and traits for vin
-
file-per-thread-logger
A logging implementation that writes logs in one file per thread
-
whisk
fast lockless async channels
-
witty-actors
Fork of quickwit-actors, Actor framework used in quickwit
-
app-world
A framework agnostic approach to managing frontend application state
-
promise_out
promiseOut version for rust
-
rtic-common
lib TODO
-
spsc-ringbuf-core
Heapless ring buffer
-
state
safe and effortless global and thread-local state management
-
mt-debug-counters
support high performance debug counters for heavy multithreaded applications
-
watch
A synchronous message passing channel that only retains the most recent value
-
despero-hecs-schedule
shedulable systems and parallel execution for hecs
-
threadpool-simple
Threadpool for working with many tasks easily
-
concurrent_arena
u32 concurrent insertion/removal arena that returns ArenaArc
-
augmented-atomics
Implements some extra types and utilities over atomics for building audio-thread / GUI synchronization
-
interaction-calculus
A parallel model of computation
-
blaze-rs
A Rustified OpenCL Experience
-
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
-
tokio-cron
cron scheduler for tokio
-
cura
arc-lock-system that should clean up the code a lot
-
cache-padded
Prevent false sharing by padding and aligning to the length of a cache line
-
unknownrori-simple-thread-pool
A lighweight thread pool for networking and other stuff
-
busan
An actor implementation for Rust
-
threadcell
A cell whose value can only be accessed by a owning thread
-
workerpool-rs
workerpool for rust
-
unbounded-spsc
An unbounded spsc queue built from
bounded_spsc_queue
s -
taski
async task DAG execution
-
brod
A wrapper library providing an API for executing Kafka producers in parallel
-
freezebox
deref'able lazy-initialized container
-
rsevents-extra
Synchronization objects built on top of rsevents. Semaphore, countdown event, and more.
-
signals2
A thread-safe signal/slot library inspired by boost::signals2
-
stochastic-queue
Queue and MPMC channel that pops in a random order
-
yuki
multithreaded web archiver
-
mutex-timeouts
let you specify a timeout on a mutex lock
-
yaambo
concurrent skip lists
-
multithread
API for data-parallel tasks, rayon-lite
-
redsync
Redlock for distributed locks with Redis
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
permit
A struct for cancelling operations
-
par-iter-sync
Parallel Iterator With Sequential Output
-
tucan
fast, and multithreaded interner with loose type requirement
-
may_waiter
coroutine communication blocker
-
blobd
Blob storage designed for huge amounts of random reads and small objects with constant latency
-
lever
Pillars for Transactional Systems and Data Grids
-
boomerang
'Reactors' Deterministic Actor Model
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
redlock
distributed locking mechanism built on top of Redis
-
protoactor
in Rust
-
spin
Spin-based synchronization primitives
-
workpool
Distribute work to a set of threads and wait for completion
-
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.
-
rs_taskflow
executing graphs of tasks
-
simple_thread_pool
thread pool
-
matrix_operations_cuda
perform matrix operations using cuda
-
seqlock
A reader-writer lock that provides extremely fast read access without starving writers
-
sorted-channel
sorted message-based communication channel
-
lib-wc
Will's Programming Toolbox
-
rusty-jokes
A humorous Rust crate that brings joy and entertainment to Rust programmers with features like Laughable Lifetimes, Comedic Concurrency, and Punchline Pointers
-
orphan-crippler
Two-way oneshot channel for task abstraction
-
rolock
Read Only Lock
-
tokio-sync-read-stream
Create a stream from a std::io::Read using Tokio blocking threads
-
threadpooled
Threadpool implementation
-
rustc-rayon
work-stealing parallelism for Rust - fork for rustc
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
membarrier
Process-wide memory barrier
-
channel-receiver
Channel Receiver
-
channel-sender
Channel Sender
-
voracious_radix_sort
State of the art radix sort algorithms. Single thread and multi thread versions.
-
seckoo
A concurrent Cuckoo Hash Table
-
poolio
A thread-pool
-
denog_runtime
denog runtime library
-
rendezvous_swap
Swap data and sync execution between a pair of threads efficiently
-
raw_sync_2
Lightweight wrapper around OS synchronization primitives
-
executor-service
A fast and efficient Thread Pool like Java ExecutorService
-
distrustc-server
A Rust-compatible distcc implementation
-
distrustc-client
A Rust-compatible distcc implementation
-
distrustc
A Rust-compatible distcc implementation
-
keepcalm
shared types for multi-threaded programs
-
desync
A hassle-free data type for asynchronous programming
-
scherben-map
Concurrent Sharded HashMap for Rust
-
rcu_cell
a lockless rcu cell implementation
-
scheduled-thread-pool
A scheduled thread pool
-
qvnt-i
Advanced quantum computation simulator
-
zestors
A fast and flexible actor-framework for building fault-tolerant Rust applications
-
hammer-cli
Hammer is a no-config cli tool for running concurrent tasks with monorepo support
-
nvrtc
Bindings for NVIDIA® CUDA™ NVRTC in Rust
-
tonari-actor
A minimalist actor framework aiming for high performance and simplicity
-
async-map-reduce
Fast map-reduce based on threading
-
evlru
An eventually consistent LRU designed for lock-free concurrent reads
-
rtic-syntax
The Real-Time Interrupt-driven Concurrency (RTIC) meta language
-
rayon-wasm
work-stealing parallelism for Rust
-
cortex-m-rtic-macros
Procedural macros of the cortex-m-rtic crate
-
cortex-m-rtic
Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems
-
rayon-core-wasm
Core APIs for Rayon
-
swap-arc
A swappable Arc
-
our
Ergonomic, highly generic wrapper for shared mutable data
-
sling
Sequentially lockign (SeqLock) Ring Buffer
-
zsling
Rust Wrapper around a Sequentially lockign (SeqLock) Ring Buffer written in Zig
-
bbq-rs
A Block-based Bounded Queue for Exchanging Data and Profiling
-
tokio-condvar
A Condition Variable for Tokio Applications
-
rewrk-core
HTTP benchmarking as a library made simple
-
task-notify
Notify async tasks when someone mutates data they're interested in
-
gosh-remote
Distributed parallel computing over multiple nodes
-
runnel
the pluggable io stream. now support: stdio, string io, in memory pipe
-
semaphore-key
control concurrent thread access by key using a shared semaphore
-
myriam
Remote actors on top of libp2p
-
work-steal-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
xtensa-atomic-emulation-trap
An atomic emulation trap handler for non atomic Xtensa targets
-
bustle
Benchmarking harness for concurrent key-value collections
-
kafka_json_processor_core
The core logic for your Kafka processor, part of kafka-json-processor project
-
threadfin
A thread pool for running multiple tasks on a configurable group of threads
-
chunker
Minimalistic parallel executor
-
maybe-rayon
Either acts as rayon or creates a single-threaded facade
-
phonecall
A tiny easy to use helper that makes function calls through threads/ tasks easier with tokio channels
-
rayonzip
Make zip archives with concurrent compression using rayon
-
pflock
A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
maybe-async-channel
A channel which may or may not be async
-
atomic-take
Atomically take a value out of a container once
-
range-lock
Range lock for std::vec::Vec
-
hebo
Distributed MQTT broker
-
hebo_codec
Packet codec for MQTT protocol
-
kanal
The fast sync and async channel that Rust deserves
-
context
Cooperative multitasking for Rust using Boost.Context
-
gzp
Parallel Compression
-
blackhole
...to throw your threads into
-
native-timer
Timer library which uses OS timer capabilities
-
sync-wait-object
Synchronous Wait Object (abstraction over Mutex & CondVar)
-
vigil
liveness checking watchdog for detecting deadlocks/livelocks/starvation etc
-
base-coroutine
A fast and safe implementation of stackful coroutines with scheduler which supports preemptive scheduling
-
runcc
run commands concurrently with rust and cargo
-
rly
Run shell commands concurrently with ease. Currently only a CLI tool.
-
gemino
A multi producer multi consumer (MPMC) broadcasting channel
-
tc-tensor
TinyChain's Tensor collection type
-
local-ex
Thread local async executor
-
skippy-rs
A set of lock free, thread safe, and fast data structures implemented via a Skip List
-
linux-futex
Futex: A Linux-specific fast user-space locking primitive
-
sentinel-rocket
Sentinel middleware for Rocket
-
sentinel-actix
Sentinel middleware for Actix-Web
-
bombs
Efficient single-producer multi-consumer channel types
-
atomic-wait
Cross-platform atomic wait and wake (aka futex) functionality
-
sync_cow
Thread-safe clone-on-write container for fast concurrent writing and reading
-
ringbuffer-spsc
A fast thread-safe single producer-single consumer ring buffer
-
ductile
A channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface
-
there
planning and executing commands on local and remote hosts
-
select-macro
Waits on multiple concurrent branches
-
synchronized
Convenient and simple macro for code synchronization in multithreading
-
waitable
A synchronized (atomic) value container implementing the Mutex+Condvar pattern for efficient blocking waits
-
lockness
TODO
-
sero
lightweight library for maintaining a shared store of locks
-
priority-async-mutex
An async mutex where the lock operation takes a priority
-
ur-script
UR e-series controller written in rust. Designed to be deployable on embedded systems without access to std.
-
mpmcpq
Multi-producer multi-consumer Priority Queue
-
congee
ART-OLC concurrent adaptive radix tree
-
pooled-writer
using N threads to write to M compressed files/writers
-
key-lock
mutual exclusion by keys
-
qrwlock
Fair queued read-write lock
-
fiona
Concurrent runtime written against liburing
-
mpmc-ringbuf
queue
-
ordered-locks
Compiletime deadlock avoidance
-
jwalk
Filesystem walk performed in parallel with streamed and sorted results
-
td_rthreadpool
thread wrapper for Rust
-
st3
A very fast lock-free, bounded, work-stealing LIFO queue
-
rcell
A Cell which can hold either an Arc or an Weak smartpointer or be empty
-
cell-family
Cheap cells accessed through unique owners
-
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
-
qvnt
Advanced quantum computation simulator
-
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
-
sentinel-core
The flow sentinel of your microservices
-
async-datachannel
Async Wrapper for datachannel
-
async-datachannel-wasm
Async Wrapper for WebRTC datachannel in the browser environment
-
sentinel-tower
Sentinel middleware for Tower
-
sentinel-tonic
Sentinel middleware for Tonic
-
slock
An async mutex that never deadlocks
-
request-channel
Async MPSC request-reponse channel
-
work_pool
work queue wrapped by a thread pool
-
optimistic-cell
lock-like structure for low-overhead optimistic concurrency
-
lockpool
offers a pool of locks where individual locks can be locked/unlocked by key
-
per-thread-object
Efficient per-object thread-local storage implementation
-
bronzeflow-core
Core of bronzeflow
-
fast-counter
A sharded concurrent counter
-
async-liveliness-monitor
A Liveliness Monitor for your Asynchronous Runtimes
-
channel-drain
Drain channels with simple syntax
-
systick-monotonic
RTIC Monotonic implementation based on SysTick
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
momen
low overhead thread pool
-
csplib
CSP for concurrent programming
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
refcapsule
Safely send references to other threads
-
uchan
Multi-producer single-consumer channel for message passing
-
ns3-parallel
A Multitask Parallel Concurrent Executor for ns-3 (network simulator)
-
cpq
A Concurrent Priority Queue implemented in Safe Rust
-
atomic-borrow
atomic reference counter
-
csq
A Concurrent Set Queue implemented in Safe Rust
-
try-mutex
Fast non-blocking mutex
-
key-message-channel
Multi-producer single-consumer queue capable of queuing messages by message key
-
bztree
BzTree implementation for Rust
-
mwcas
Multi-word CAS primitive
-
atomic_cell
Lock-free thread-safe mutable memory locations
-
stronghold-stm
Software transactional memory
-
fragile
wrapper types for sending non-send values to other threads
-
response_channel
A bidirectional response channel
-
diatomic-waker
An async, lock-free synchronization primitive for task wakeup
-
rework
Multi-threaded task processing in the Master-Worker pattern
-
run-them
A CLI to launch a single command with many workers, serializing the output
-
dwt-systick-monotonic
RTIC Monotonic implemenation based on Systick and DWT
-
tyra
Typed Actor System
-
flowync
multithreading a/synchronization
-
spinout
A thread-safe clonable and mutable smart-pointer akin to
Arc<Mutex<T>>
, using spin-lock instead of system futex -
humthreads
Threads for humans
-
lock-hierarchy
Prevent dead locks by enforcing lock hierarchies
-
par-dfs
Parallel, serial, and async dfs and bfs traversal
-
mogul
Agnosticly helps to manage concurrent versions of things
-
async_ach-notify
Async Atomic Channel
-
more-sync
More synchronization utils
-
synchronoise
Synchronization primitives that build upon the standard library
-
tiny-actor
A minimal actor framework for Rust
-
mpc-bench
Multi-party computation experimentation library
-
piz
piz (a Parallel Implementation of Zip) is a ZIP archive reader designed to concurrently decompress files using a simple API
-
nolock
A collection of Lock-Free Datastructures
-
ach-linked
Atomic Channel
-
async_ach-waker
Async Atomic Channel
-
hyperbridge
Fast multi-producer multi-consumer channel with async support
-
rsevents
Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores
-
anode
Concurrency library for Rust
-
graph_csr
that provides utility functions for manipulating graphs in a CSR format, used as the baseline for constructing powerful graph algorithms
-
quartz_sched
Minimalistic scheduling library for Rust
-
diamond-types
The world's fastest text CRDT
-
clustr
Multithreaded string clustering
-
try-rwlock
Fast non-blocking readers-writer lock
-
tagged-rendezvous
Rendezvous hashing with support for tag-based exclusions
-
ach-cell
Atomic Channel
-
ach-util
Atomic Channel
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
threadbeam
specialized channel type for beaming data out of a newly spawned thread
-
norpc
Framework for in-process microservices
-
shipyard
Entity Component System
-
proglog
Thread safe progress logging
-
thread-local-panic-hook
Panic hooks that work per thread
-
triex
Trivial Executor
-
flashmap
A lock-free eventually consistent concurrent hash map
-
rustodrive
Rust bindings for controlling multiple ODrives with the CAN protocol
-
schedwalk
Test futures under all possible polling schedules
-
magnetic
Low-latency lock-free queues
-
kai-cli
Kai - todo.txt task scheduler
-
ach-pubsub
Atomic Channel
-
ach
Atomic Channel
-
async_ach-spsc
Async Atomic Channel
-
async_ach-pubsub
Async Atomic Channel
-
async_ach
Async Atomic Channel
-
slog-json-concur
JSON drain for slog-rs with concurrency
-
benjamin_batchly
Low latency batching tool. Bundle lots of single concurrent operations into sequential batches of work.
-
ach-mpmc
Atomic Channel
-
ach-spsc
Atomic Channel
-
sync-wait-group
Wait group for synchronizing the beginning or end of some computation
-
concurrent-interner
A string interner usable from multiple threads
-
whitebreadx
A breadx library that provides a wrapper for libxcb and libX11
-
stakker_log
Logging support for Stakker
-
stronghold-rlu
Read-Log-Update software transactional memory like synchronization mechanism
-
maybe_parallel_iterator
Toggle parallelism with feature flags!
-
left-right
A concurrency primitive for high concurrency reads over a single-writer data structure
-
halt
functionality for pausing, stopping, and resuming iterators, readers, and writers
-
hlocl
High-level bindings for OpenCL
-
hybrid-lock
A hybrid lock with optimistic locking
-
condow_core
Framework for concurrent downloads
-
workers_pool
A long running threadpool for parallel task execution
-
kontroli
Type checking for the lambda-Pi calculus modulo rewriting
-
uppercut
Small and simple actor model implementation
-
one_at_a_time_please
For serialising calls to functions
-
moro
Experimental structured concurrency support for async Rust (similar to trio's nurseries)
-
worker-pool
handle a set of worker threads, which need to communicate back their result to the main thread
-
lft-rust
A lock-free threadpool implementation. We provide a traditional single queue threadpool and a lock-free threadpool
-
syncell
Sync alternative to RefCell
-
active_standby
A concurrency primitive for high concurrency reads
-
rtrb-basedrop
A fork of the
rtrb
crate that uses basedrop’s Shared pointer in place of Arc -
ringbuf-basedrop
A fork of the
ringbuf
crate that uses basedrop’s Shared pointer in place of Arc