-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
spin
Spin-based synchronization primitives
-
rayon
work-stealing parallelism for Rust
-
async-channel
Async multi-producer multi-consumer channel
-
thread_local
Per-object thread-local storage
-
async-lock
Async synchronization primitives
-
crossbeam
Tools for concurrent programming
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
dashmap
Blazing fast concurrent HashMap for Rust
-
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
-
flume
A blazingly fast multi-producer channel
-
neon
A safe abstraction layer for Node.js
-
serenity
Discord API
-
loom
Permutation testing for concurrent code
-
scc
A collection of high-performance asynchronous/concurrent containers with both asynchronous and synchronous interfaces
-
jobserver
GNU Make jobserver for Rust
-
kanal
The fast sync and async channel that Rust deserves
-
thread-priority
managing threads priority and schedule policies
-
crossfire
channels for async and threads
-
boxcar
A concurrent, append-only vector
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
simple_logger
A logger that prints all messages with a readable output format
-
sled
Lightweight high-performance pure-rust transactional embedded database
-
corosensei
A fast and safe implementation of stackful coroutines
-
mpi
Message Passing Interface bindings for Rust
-
rtrb
A realtime-safe single-producer single-consumer ring buffer
-
sync_wrapper
enlisting the compiler's help in proving the absence of concurrency
-
leaky-bucket
A token-based rate limiter based on the leaky bucket algorithm
-
parking
Thread parking and unparking
-
wasm-bindgen-rayon
Adapter for using Rayon-based concurrency on the Web
-
threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
thread-id
Get a unique thread ID
-
thingbuf
I'm at the buffer pool. I'm at the MPSC channel. I'm at the combination MPSC channel and buffer pool.
-
hwlocality
Idiomatic Rust bindings for the hwloc hardware locality library
-
orx-parallel
High performance, configurable and expressive parallel computation library
-
archery
Abstract over the atomicity of reference-counting pointers
-
diatomic-waker
An async, lock-free synchronization primitive for task wakeup
-
triple_buffer
triple buffering, useful for sharing frequently updated data between threads
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
atomic_float
Floating point types which can be safely shared between threads
-
stateright
A model checker for implementing distributed systems
-
may
Rust Stackful Coroutine Library
-
atomic_refcell
Threadsafe RefCell
-
gst-plugin-threadshare
GStreamer Threadshare Plugin
-
radium
Portable interfaces for maybe-atomic types
-
waker-fn
Convert closures into wakers
-
shipyard
Entity Component System
-
papaya
A fast and ergonomic concurrent hash-table for read-heavy workloads
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
recloser
A concurrent circuit breaker implemented with ring buffers
-
sdd
Scalable lock-free delayed memory reclaimer
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
ocl
OpenCL bindings and interfaces for Rust
-
append-only-vec
Append-only, concurrent vector
-
flurry
Rust port of Java's ConcurrentHashMap
-
state
safe and effortless global and thread-local state management
-
paralight
A lightweight parallelism library for indexed structures
-
crb
CRB | Composable Runtime Blocks
-
parallel-sh
Execute commands in parallel
-
crossbeam-utils
concurrent programming
-
mea
A runtime-agnostic library providing essential synchronization primitives for asynchronous Rust programming
-
local-channel
A non-threadsafe multi-producer, single-consumer, futures-aware, FIFO queue
-
try-lock
A lightweight atomic lock
-
affinitypool
running blocking jobs on a dedicated thread pool with CPU core affinity
-
gix-lock
A git-style lock-file implementation
-
shuttle
testing concurrent Rust code
-
guardian
owned mutex guards for refcounted mutexes
-
process_control
Ergonomically run processes with limits
-
s3sync
Reliable, flexible, and fast synchronization tool for S3
-
futures-channel
Channels for asynchronous communication using futures-rs
-
maitake-sync
No-std async synchronization primitives from Maitake
-
fork_union
Low-latency OpenMP-style NUMA-aware cross-platform fine-grained parallelism library
-
spawned-concurrency
Spawned Concurrency
-
scheduled-thread-pool
A scheduled thread pool
-
saa
Word-sized low-level synchronization primitives providing both asynchronous and synchronous interfaces
-
aws-sdk-s3-transfer-manager
A high performance Amazon S3 transfer manager for Rust
-
jod-thread
std::thread which joins on drop by default
-
inline-array
efficient immutable inlinable byte array
-
v_queue
file based queue
-
orx-concurrent-iter
A thread-safe and ergonomic concurrent iterator trait and efficient lock-free implementations
-
signals_receipts
exfiltration of the receipt of POSIX signals
-
idr-ebr
An efficient concurrent ID to object resolver
-
atomig
Generic, convenient and lock-free
stdatomics viaAtomic<T>. Can be used with many primitive types (including floats) and with custom types. -
batch-aint-one
I got 99 problems, but a batch ain't one
-
keepcalm
shared types for multi-threaded programs
-
blocking-threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
ratelimit
ratelimiter that can be shared between threads
-
rs-store
Redux Store for Rust
-
amity
Concurrency algorithms
-
dependency-injector
High-performance, lock-free dependency injection container for Rust
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
disruptor
Low latency inter-thread communication via a ringbuffer (inspired by the LMAX Disruptor)
-
atomic-time
AtomicDuration,AtomicOptionDuration,AtomicSystemTime,AtomicOptionSystemTime,AtomicInstantandAtomicOptionInstantfor Rust -
rusty_pool
Self growing / shrinking
ThreadPoolimplementation based on crossbeam’s multi-producer multi-consumer channels that enables awaiting the result of a task and offers async support -
bach
Discrete-event simulation environment for async workflows
-
ringbuffer-spsc
A fast thread-safe single producer-single consumer ring buffer
-
mutex
An abstraction over closure-based mutexes
-
masstree
A high-performance concurrent ordered map (trie of B+trees)
-
bevy_platform
common platform agnostic APIs, as well as platform-specific features for Bevy Engine
-
starshard
A blazing-fast sharded concurrent HashMap using hashbrown and RwLock, with lazy shards, atomic length cache, async support, conditional operations, batch operations, TTL/metrics/transactions
-
hk
managing git hooks
-
rclite
small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs
-
storyteller
focused on supporting user oriented output while supporting multiple output types (e.g. json, a progressbar, etc.)
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
oxanus
& fast job queue system
-
ctfs
Causal consistency at nanosecond latency. Algebraic invariants without coordination.
-
mpstthree
implementing Multiparty Session Types for 2 or more participants
-
kovan
High-performance wait-free memory reclamation for lock-free data structures. Bounded memory usage, predictable latency.
-
pumps
Eager streams for Rust
-
ironshield-cli
IronShield CLI component
-
backfill
A boringly-named priority work queue system for doing async tasks
-
atomic-wait
Cross-platform atomic wait and wake (aka futex) functionality
-
instance-copy-on-write
A MT-safe copy-on-write implementation for the data structures
-
apecs
An asyncronous and parallel entity-component system
-
erl_dist
Erlang Distribution Protocol
-
multiqueue2
A fast mpmc broadcast queue
-
sync_file
Files that can be read concurrently
-
uid
creation of unique IDs
-
dson
A delta-state CRDT implementation
-
flo_stream
Pubsub and related streams for Rust futures
-
botcore
Production-grade asynchronous bot engine with enterprise observability features
-
setup_read_cleanup
safely transitioning through the three phases of shared resource access: setup, read, and cleanup
-
tonari-actor
A minimalist actor framework aiming for high performance and simplicity
-
krecik
Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL
-
rtactor
An Actor framework specially designed for Real-Time constrained use cases
-
smallring
High-performance ring buffer with automatic stack/heap optimization | 高性能环形缓冲区，支持栈/堆自动优化
-
leo3
Rust bindings for the Lean4 theorem prover
-
seize
Fast, efficient, and predictable memory reclamation for concurrent data structures
-
par-core
Switchable parallel execution core
-
atomic-take
Atomically take a value out of a container once
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
pueue
A cli tool for managing long running shell commands
-
breaker-machines
High-performance circuit breaker with fallback support and rate-based thresholds
-
scc2
High-performance containers and utilities for concurrent and asynchronous programming
-
orx-concurrent-vec
A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations
-
nbio
Non-Blocking I/O
-
rustc-rayon
work-stealing parallelism for Rust - fork for rustc
-
diamond-types-extended
Unified CRDT library with ergonomic API - fork of diamond-types
-
repartir
Sovereign AI-grade distributed computing primitives for Rust (CPU, GPU, HPC)
-
rust_di
DI — Dependency Injection for Rust
-
bf-tree
modern read-write-optimized concurrent larger-than-memory range index in Rust from Microsoft Research
-
chili
low-overhead parallelization library
-
happylock
Free deadlock prevention
-
velocityx
A production-ready Rust crate for lock-free concurrent data structures with performance monitoring
-
tarnish
Process isolation library with automatic panic recovery for running untrusted Rust code
-
rtsc
Real-time Synchronization Components
-
drain
that supports graceful shutdown
-
maiko
Lightweight event-driven actor runtime with topic-based pub/sub for Tokio
-
converge-core
Converge Agent OS - correctness-first, context-driven multi-agent runtime
-
observable-property
A thread-safe observable property implementation for Rust
-
dagx
A minimal, type-safe, runtime-agnostic async DAG (Directed Acyclic Graph) executor with compile-time cycle prevention and true parallel execution
-
act_rs
Act.rs is a minimal actor framework
-
linked
Create families of linked objects that can collaborate across threads while being internally single-threaded
-
html2pdf-api
Thread-safe headless browser pool for high-performance HTML to PDF conversion with native Rust web framework integration
-
ballista-scheduler
Ballista Distributed Compute - Scheduler
-
st3
A very fast lock-free, bounded, work-stealing LIFO queue
-
sea-streamer
🌊 The stream processing toolkit for Rust
-
async-condvar-fair
Condition variables for async Rust
-
env-lock
Set and lock environment variables for tests
-
oqueue
Non-interleaving multithreaded output queue
-
messaging_thread_pool
aiding the creation of typed thread pool of objects that is communicated with via channels
-
locktick
Automated lock accounting & profiling
-
flashmap
A lock-free eventually consistent concurrent hash map
-
synchronized
convenient macro for synchronizing code in multithreading
-
mcslock
Mellor-Crummey and Scott contention-free lock for mutual exclusion, referred to as MCS lock
-
concurrent-map
a lock-free linearizable B+ tree
-
atomic-file-install
For atomically installing a file or a symlink
-
atomptr
A safe copy-on-write wrapper around
AtomicPtrwith some extra tricks -
television-fuzzy
The revolution will be televised
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
rav1d-disjoint-mut
A provably safe abstraction for concurrent disjoint mutable access to contiguous storage
-
firq-core
Core multi-tenant scheduler with DRR fairness, deadlines, and backpressure
-
crossync
A fast concurrent programming suite for Rust
-
nexus-id
High-performance ID generators for low-latency systems
-
fdup
find duplicate files recursively and in parallel
-
threadbound
Make any value Sync but only available on its original thread
-
rsevents
Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores
-
sadi
Semi-Automatic Dependency Injector
-
wasm_safe_thread
Cross-platform std::thread + std::sync replacement for native and wasm32
-
acton-ai
An agentic AI framework where each agent is an actor
-
lockable
offers hash map, hash set and cache data structures where individual entries can be locked
-
rust_web_crawler
A short summary of what your crate does
-
weavegraph
Graph-driven, concurrent agent workflow framework with versioned state, deterministic barrier merges, and rich diagnostics
-
xutex
an extremely fast async mutex with alternative sync API
-
rcu_cell
a lockless rcu cell implementation
-
precise_rate_limiter
A high-performance, precise rate limiter using tokio channels and atomic operations
-
loole
A safe async/sync multi-producer, multi-consumer channel
-
pbrt-r3
pbrt-v3
-
sayiir-runtime
Execution runtime, checkpointing runner and distributed workers for Sayiir workflows
-
pausable_clock
A source of time information that can be paused and resumed
-
trauma
Simplify and prettify HTTP downloads
-
pi_arr
lock-free & auto-expansion array
-
proc-daemon
A foundational framework for building high-performance, resilient daemon services in Rust. Handles all the boilerplate for signal handling, graceful shutdown, logging, and configuration.
-
ferrompi
A safe, generic Rust wrapper for MPI with support for MPI 4.0+ features, shared memory windows, and hybrid MPI+OpenMP
-
contatori
High-performance sharded atomic counters for Rust
-
actify
An intutive actor model with minimal boilerplate
-
concurrent_arena
u32 concurrent insertion/removal arena that returns ArenaArc
-
bab
build a bus - low-level components for your next message bus
-
abfall
Concurrent tri-color tracing garbage collector for Rust with incremental and concurrent mark-sweep
-
fast-able
The world's martial arts are fast and unbreakable; 天下武功 唯快不破
-
atom_box
A safe idiomatic Rust implementation of Atomic Box using hazard pointers
-
kronos-compute
A high-performance compute-only Vulkan implementation with cutting-edge GPU optimizations
-
cocoro
A more type-safe take on Rust stackless coroutines
-
rate_limiters
Flexible and easy-to-use Rust library for implementing rate limits
-
wdk-mutex
An idiomatic Rust mutex type for Windows kernel driver development
-
renege
Tracking cache validity using fast concurrent invalidation propogation
-
axsched
Various scheduler algorithms in a unified interface
-
ringkernel-ecosystem
Ecosystem integrations for RingKernel - actors, web frameworks, data processing, ML
-
asupersync
Spec-first, cancel-correct, capability-secure async runtime for Rust
-
avila-parallel
Zero-dependency parallel library with work stealing, SIMD, lock-free operations, adaptive execution, and memory-efficient algorithms
-
fault-injection
fault injection, concurrency delay injection, and error source annotation
-
open-coroutine
efficient and generic stackfull-coroutine library
-
elasticq
Thread-safe, dynamically resizable queues with lock-based and lock-free implementations for high-throughput scenarios
-
typedflake
A Snowflake-style ID generator library with newtype-driven design
-
agentic-jujutsu
AI-powered Jujutsu VCS wrapper for multi-agent collaboration - 10-100x faster than Git with MCP protocol support
-
txn_lock
support transactional versioning
-
micropool
Low-latency thread pool with parallel iterators
-
deltaflow
The embeddable workflow engine. Type-safe, Elixir-inspired pipelines.
-
poly-once
A thread-safe cell providing async and sync initialization primitives similar to OnceLock
-
product-os-command-control
Product OS : Command and Control provides a set of tools for running command and control across a distributed set of Product OS : Servers
-
tasker-worker
Worker foundation system for multi-language step execution
-
virtual-buffer
A cross-platform library for dealing with buffers backed by raw virtual memory
-
io-pipe
A fast and thread-safe library for creating multi-writer and single-reader pipelines in Rust
-
rx-rust
Reactive Programming in Rust inspired by ReactiveX https://reactivex.io/
-
omango
Concurrency collections
-
executors
A collection of high-performance task executors
-
liner_broker
Redis based message serverless broker
-
cano
High-performance orchestration engine for building resilient, self-healing systems in Rust. Uses Finite State Machines (FSM) for strict, type-safe transitions.
-
batch-processing
A batch library for processing a list of items in parallel
-
fast-stm
Performance-focused implementation of software transactional memory. Allows composable atomic operations
-
aarc
An atomically updatable Arc for lock-free concurrency
-
valida
Modular validation system for Rust with support for nested structures and localization
-
mco
Rust Coroutine Library like go
-
loom-rs
Weaving threads together - A bespoke thread pool runtime combining tokio and rayon with CPU pinning capabilities
-
tracing-mutex
Ensure deadlock-free mutexes by allocating in order, or else
-
archx
High-performance CPU/GPU adaptive optimization library with SIMD and Multithreading
-
parallel_task
A fast data parallelism library for Rust
-
uefi_corosensei
A fast and safe implementation of stackful coroutines. This is a fork adapted to work in a UEFI environment.
-
rabbit-auto
Wrappers for lapin publishers and consumers
-
tasker-orchestration
Orchestration system for tasker workflow coordination
-
par_slice
Slices that may be accessed from multiple threads with different levels of safety
-
stylo
CSS engine
-
thread-share
safe and efficient data sharing between threads with zero-copy operations, change detection, and enhanced thread management
-
spindle
rayon-based threadpool
-
luminengine
A high-performance financial quantitative trading order book matching framework
-
rose_bloom
A concurrent growing element size linked list with stable pointers
-
wbackend
WASMA – Resource-first runtime: CPU-priority, GPU-optional, platform-agnostic
-
taskorch
Concurrent Pool for task processing
-
rumpsteak-lean-bridge
Lean verification bridge for Rumpsteak session types
-
ppl
A structured parallel programming library for Rust
-
titanrt
Typed reactive runtime for real-time systems
-
auth-policy
evaluating authorization decisions against declarative policies
-
mintex
minimal mutex
-
atomic_list
Lock-free circular ring of intrusive ref-counted nodes plus shared cursors
-
docsrs-mcp
MCP server for Rust crate documentation from docs.rs
-
laminar-core
Core streaming engine for LaminarDB - reactor, operators, and state management
-
splaycast
Stream-specific broadcast channel
-
mechutil
structures and functions for mechatronics applications
-
qrush
Lightweight Job Queue and Task Scheduler for Rust (Actix + Redis + Cron)
-
readlock-tokio
A weird alternative to Arc<RwLock<T>>, using tokio's RwLock
-
steady_state
Framework for building long running low latency actor based services on Linux. Provides visual telemetry to watch data flows between actors. Uses Erlang style supervisors to defend…
-
phylactery
Safe and thin wrappers around lifetime extension to allow non-static values to cross static boundaries
-
scx_loader
DBUS on-demand loader of sched-ext schedulers
-
grip-grab
A faster, more lightweight ripgrep alternative
-
cc-vm
Rust bindings for the cc virtualization library
-
async_nursery
Primitive for structured concurrency
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
fibre
High-performance, safe, memory-efficient sync/async channels built for real-time, low-overhead communication in concurrent Rust applications
-
clashmap
Sharded hashmap suitable for fast concurrent access
-
shakespeare
An actor framework
-
a3s-lane
Lane-based priority command queue for async task scheduling with reliability, scalability, and observability features
-
d-engine
Lightweight Raft consensus engine - recommended entry point for most users
-
melodium
Flow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely
-
wasm_safe_mutex
A suite of WebAssembly-safe synchronization primitives that paper over platform-specific locking constraints
-
hazarc
A wait-free AtomicArc optimized for read-intensive use cases
-
memo-map
implementing a synchronized map for memoization
-
routingkit-cch
Rust bindings for RoutingKit's Customizable Contraction Hierarchies (CCH)
-
winhook
x86_64 function hooking library for Windows and Wine
-
shot-limit
multiple strategy rate limiting library
-
lock-free-static
Lock-free static variables
-
async-cpupool
async threadpool for CPU-bound tasks
-
yaque
disk-backed persistent queue for Rust
-
optx-stm
Hybrid Software Transactional Memory (STM) library exploring NOrec vs TL2 tradeoffs
-
events_once
Efficient oneshot events (channels) with support for single-threaded events, object embedding, event pools and event lakes
-
latches
A downward counter (CountDownLatch) which can be used to synchronize threads or coordinate tasks
-
syndicate-schema-plugin
Support for using Preserves Schema with Syndicate macros
-
ptab
Lock-free concurrent table optimized for read-heavy workloads
-
rdkafka-redux
Rust wrapper for librdkafka
-
choir
Task Orchestration Framework
-
router-radix
A high-performance radix tree based HTTP router for Rust
-
iterator_ilp
Iterator extensions for instruction-parallel reductions
-
memmap3
Safe, zero-copy memory-mapped I/O. Drop-in replacement for memmap2 with persistent structs and zero unsafe in user code.
-
wpool
A thread pool that limits the number of tasks executing concurrently, without restricting how many tasks can be queued
-
halt
worker threads that can be paused, stopped, and resumed
-
starlang
Erlang-style concurrency for Rust
-
wasefire-sync
Portable non-blocking mutex
-
synchronoise
Synchronization primitives that build upon the standard library
-
irondash_message_channel
Rust interface to irondash MessageChannel
-
defer-drop
Defer dropping large types to a background thread
-
resilient-rs
fault tolerance, including retry strategies, backoff mechanisms, and failure handling
-
particle_accelerator
Particle Accelerator – a modular, ECS-ready physics engine for Rust
-
axsync
ArceOS synchronization primitives
-
az_logger
Very simple logging crate for my projects
-
novtb
Zoned Data-Parallelism with Core Affinity
-
singleton-registry
A thread-safe singleton registry for Rust with isolated, per-type storage
-
atomic-progress
A high-performance, cloneable progress tracker with minimal locking overhead
-
rs2-stream
A high-performance, production-ready async streaming library for Rust
-
spinning_top
spinlock crate based on the abstractions provided by
lock_api -
range-lock
Range lock for std::vec::Vec
-
lock_freedom
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
crossbeam-queue
Concurrent queues
-
sandl
A framework for building parallel execution engines with dependency management, type-safe method dispatch, and event observation
-
rdkafka-autoschematic-fork
Rust wrapper for librdkafka
-
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
veda-rs
High-performance parallel runtime for Rust with work-stealing and adaptive scheduling
-
casial-core
Consciousness-aware context coordination engine - The Casial substrate for paradox-resilient AI agent context management and coordination
-
ndd
Non De-Duplicated cell. For statics guaranteed not to share memory with any other static/const.
-
market_square
A lock-free mpmc "square"
-
rtic-monotonics
that provides implementations of the Monotonic trait from rtic-time
-
orama-js-pool
Create a pool of JavaScript engines to invoke JavaScript code concurrently
-
sbitmap
Fast and scalable bitmap implementation based on Linux kernel's sbitmap
-
pargraph
Operator based parallel graph processing
-
atomic-cuckoo-filter
Highly concurrent Cuckoo Filter
-
fukurow-engine
Reasoning engine orchestration that integrates reasoners and rules for Fukurow
-
rust-stream-ext-concurrent
Concurrent behavior extensions for any futures::stream::Stream objects
-
rumpsteak-aura-choreography
Choreographic programming for Rumpsteak - effect-based distributed protocols
-
appendvec
A concurrent append-only container of immutable values
-
distronomicon
GitHub release updater for Linux binaries
-
oxidd-rules-zbdd
Zero-suppressed decision diagrams (ZBDDs) for OxiDD
-
spdk-io
SPDK for Rust with async/await
-
wrapit
A lightweight Rust crate that wraps any variable using interior mutability (
RefCell,Mutex, orRwLock) for ergonomic shared mutation -
potassium
A lean and mean job scheduler
-
parcode
A high-performance, lazy load and parallelized caching library for complex Rust data structures
-
light-qsbr
A lightweight Quiescent-State-Based Reclamation (QSBR) library for safe memory reclamation in lock-free and async runtimes
-
snakeice-rdkafka
Rust wrapper for librdkafka
-
vibe-code
Parallel CPU execution without threads or channels
-
noworkers
A small asyncronous worker pool manages thread pool limiting, cancellation and error propogation, inspired by golangs errgroup (requires tokio)
-
concurrent-pool
A concurrent object pool
-
lite-sync
Fast, lightweight async primitives: SPSC channel, oneshot, notify, and atomic waker
-
banuid
Fast, secure, 64-bit lexicographically sortable unique identifiers
-
safer_owning_ref
creating references that carry their owner with them
-
uniflight
Coalesces duplicate async tasks into a single execution
-
steppe
Follow the progress of a task easily
-
serenity_self
Discord API. A fork of Serenity for user account support.
-
lasso2
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
-
left-right
A concurrency primitive for high concurrency reads over a single-writer data structure
-
prism3-rust-atomic
User-friendly atomic operations wrapper providing JDK-like atomic API
-
io-reactor
Concurrent I/O resource management using reactor pattern
-
take-once
A thread-safe container for one-time storage and one-time consumption of a value
-
evtcall
Rust Event Driven Framework
-
safe-lock
A lock struct with a
const fnconstructor and nounsafe- ARCHIVED -
ftail
logging implementation for the
logcrate with support for multiple channels -
rex-sm
Hierarchical state machine
-
ordered-channel
A channel that always receives messages in the correct order, even if they were sent out of order
-
rust-tango
A lock-free, high-performance IPC channel inspired by Firedancer's Tango
-
test_cpu_parallel
Generate CPU- or memory-intensive workloads for benchmarking
-
proglog
Thread safe progress logging
-
synchrony
that provides both sync and unsync versions of common synchronization primitives
-
parallel_worker
A parallel worker implementation in Rust. Allows to start tasks in parallel and receive the results blocking or non-blocking.
-
potential
PubSub lib with sync and async API
-
fluxion
actor framework written in rust and designed for distributed systems
-
daedalus-runtime
Runtime executor for Daedalus plans with backpressure and plugins
-
no_deadlocks
A Runtime Deadlock Debugger
-
multipool
A configurable thread pool with optional work-stealing support and task priority scheduling
-
escher-execution-engine
Production-ready async execution engine for system commands
-
cowboy
Safe & convenient container for quick prototyping
-
merc_aterm
A thread-safe library to manipulate and store first-order terms
-
atomx
Thread safe data structures based on atomic data types
-
wakerset
no_std, no_alloc storage of Wakers embedded in the Future type
-
ipckit
A cross-platform IPC (Inter-Process Communication) library for Rust and Python
-
pend
do now, wait later – tiny job runner
-
par
Session types, as an implementation of linear logic with MIX
-
global_counter
Global, thread-safe counters
-
readahead-iterator
Readahead from an iterator on a separate thread, returning items in order and synchronously
-
gol_engines
Tools for Conway's Game of Life
-
lingxia-messaging
Messaging infrastructure for LingXia framework
-
quetzalcoatl
Lock-free ring buffers (SPSC, MPSC, SPMC, and broadcast) for high-performance concurrent communication
-
eips
Efficient intention-preserving sequence CRDT
-
simple-left-right
Lockfree, realtime safe and copy-free Synchronisation
-
atom
A safe abstraction around AtomicPtr
-
threadsafe_zmq
Thread-safe ZeroMQ wrapper with sync and async support
-
thingvellir
a concurrent, shared-nothing abstraction that manages an assembly of things
-
flume-overwrite
sending values to a flume bounded channel, overwriting the oldest values if the channel is full
-
glommio
thread-per-core crate that makes writing highly parallel asynchronous applications in a thread-per-core architecture easier for rustaceans
-
rw-cell
Write data to cell from anything place your application without copy, lock and reading in one place
-
writecell
Shareable string writers using internal mutability
-
rayon-ca
High-performance cellular automaton's implementation in Rust LIB with CLI app and WebP animation export
-
ecmascript_atomics
ECMAScript and Java memory model racy atomics
-
invocation-counter
Datastructure to answer to: how many times a function has been called in the last X minutes?
-
snp
A fast, reliable pre-commit framework written in Rust with 100% Python pre-commit compatibility
-
fast-yaml-parallel
Multi-threaded YAML processing with work-stealing parallelism
-
kcr_authzed_com
Kubernetes Custom Resource Bindings
-
json-sync
High-performance JSON synchronization for map-like structures
-
sync-arena
thread-safe arena allocator
-
sarlacc
Thread-safe lock-free interning of data
-
atomics
Basic utils for concurrent programming. Backoff, spinlocks, seqlock, atomic type wrappers.
-
ach-ring
Atomic Channel
-
str_cache
A fast, lock-free, thread-safe string interning library
-
mtlog
Multi-threaded logger with support for log files
-
jlizard-simple-threadpool
lightweight threadpool implementation
-
paradis
Parallel processing with disjoint indices
-
resilient-rabbitmq-client
Easily deploy resilient RabbitMQ consumers and publishers
-
rust-task-queue
Production-ready Redis task queue with intelligent auto-scaling, Actix Web integration, and enterprise-grade observability for high-performance async Rust applications
-
joerl
An Erlang-inspired actor model library for Rust
-
orx-concurrent-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance concurrent collection
-
cronscheduler
A high-performance async cron scheduler for Rust, supporting both async and blocking tasks with fine-grained scheduling policies
-
sgx_tstd
Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language
-
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
stuck
Multi-threading scheduled task facility building on cooperative stackful coroutine
-
simple_json_server
way to build a JSON-based server with automatic JSON serialization/deserialization, error handling, async support, type safety, and comprehensive RustDoc generation
-
leopard_vec
A high-performance parallelized vector container with deferred execution for bulk parallel operations
-
lockfree_progress_bar
A high-performance, lock-free progress bar for parallel Rust applications
-
armature-distributed
Distributed systems primitives for Armature
-
asyncnal
Fast concurrent & local asyncronous signalling
-
dropping-thread-local
A dynamically allocated ThreadLocal that ensures destructors are run on thread exit
-
chronograph
Timestamp Tracers
-
cross-locks
FIFO-fair global locks that work identically on native, browser-WASM and head-less WASM
-
round_mult
A tiny library to round a number up or down to a multiplier
-
mumu
Lava Mumu is a language for those in the now and that know
-
svix-ksuid
A pure Rust and fully tested KSUID implementation
-
mth_calc
demonstrating Cargo. Contains helper method for running a process in parallel on all available processors.
-
acto
light-weight Actor library for Rust
-
zero-pool
High-performance thread pool with consistent low-latency task dispatch
-
ra_ap_flycheck
TBD
-
rs-eda
rust EDA event-driven framework
-
lfqueue
Fast concurrent lock-free MPMC queues
-
orchestrator_lock
A Mutex whose access order is managed by a separate thread
-
rsmg-core
Core atomic pointer management and concurrent data structures for the RSMG framework
-
tower-resilience-bulkhead
Bulkhead pattern for Tower services - resource isolation and concurrency limiting
-
desync
A hassle-free data type for asynchronous programming
-
node-replication
An operation-log based approach that transform single-threaded data structures into concurrent, replicated structures
-
acts-next
a fast, lightweight, extensiable workflow engine
-
theta
Actor Framework
-
atomic-waitgroup
A waitgroup implementation supports async with advanced features
-
wait_on_address
Cross-platform atomic wait and wake (aka futex) functionality
-
queuingtask
queueingtask is a library for running different threads in order in Rust
-
versust
structured concurrency patterns
-
rust_supervisor
An Erlang-inspired process supervision library for Rust
-
transactional
optimistic lock-free confirmation-based transactional model for Rust
-
compact-waitgroup
A compact asynchronous WaitGroup synchronization primitive
-
atomic_enum
An attribute to create an atomic wrapper around a C-style enum
-
spark-channel
A generic channel listener implementation for Spark Rust SDK
-
node-flow
Runtime-agnostic, asynchronous node-based framework for building composable flows
-
watch
A synchronous message passing channel that only retains the most recent value
-
keyed-lock
A keyed lock for synchronization
-
futures-dag
dynamic DAG scheduler for async futures. Provides a Stream-based API that executes futures only after all their dependencies have completed. Nodes can be inserted while the DAG is running…
-
someday
Lock-free MVCC primitive
-
vec_parallel
Construct your Vec in parallel
-
umpx
Collection of ump extensions
-
identify
Strongly-typed UUIDs, statically associated with other types
-
picopub
A sync/async pub-sub library with bounded queues and backpressure using Mutex and Condvar
-
rds_lock
asynchronous redis distributed read-write lock implementation based on tokio and redis-rs
-
tg-sync
Synchronization primitives for rCore tutorial OS, including mutex, semaphore, and condvar
-
async-event
An efficient async condition variable for lock-free algorithms
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
crossbeam-deque
Concurrent work-stealing deque
-
stdout-channel
Write stdout to an async queue
-
ruvector-attention-node
Node.js bindings for ruvector-attention
-
hflow
A lightweight concurrent task progress manager for CLI applications
-
commonware-runtime
Execute asynchronous tasks with a configurable scheduler
-
bpm-engine
Lightweight embeddable BPM runtime for long-running, stateful workflows with tokens, timers, Saga compensation, and crash recovery
-
smr-swap
A minimal-locking, high-performance Single-Writer Multiple-Reader swap container using epoch-based memory reclamation
-
protoflow
implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
scud-task-core
Core library for SCUD task management
-
access-cell
A cell that allows re-entrant mutable access without deadlock
-
asyncgit
allow using git2 in a asynchronous context
-
std-ext
Extend the standard library functionality
-
thulp-registry
Tool registry and management for thulp
-
hft-jobs
Allocation-free job system for HFT and real-time systems
-
active-uuid-registry
managing context-aware process UUIDs
-
shaq
SPSC FIFO queue backed by shared memory for IPC
-
ratelimit_meter
A leaky-bucket-as-a-meter rate-limiting implementation in Rust
-
ofilter
fast thread-safe Bloom filter
-
timely-master
A low-latency data-parallel dataflow system in Rust
-
listfree
lockfree prepend-only list
-
signals2
A thread-safe signal/slot library inspired by boost::signals2
-
threadpools
Efficient, configurable, zero-dependency thread pool implementations. Flexible and usable for a wide variety of applications.
-
twinkle_client
Helper for making stateful clients that can notify on change
-
main_thread
Cross-platform library to check if the current thread is the main thread
-
thread_io
performing I/O in background thread
-
fan-lang
Fantom programming language
-
process_anywhere
Tools for running computer processes locally or remotely via SSH
-
ptr_cell
Thread-safe cell based on atomic pointers
-
shared_thread
similar to shared_child, but for threads instead of processes
-
leapfrog
A fast, lock-free concurrent hash map
-
tapis-actors
Abaco (Actor Based Containers) is an API and distributed computing platform funded by the National Science Foundation to provide Functions-as-a-service to the research computing community…
-
pawawwewism
a wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3
-
acty
A lightweight, async actor framework built on Tokio
-
rearch-tokio
Re-imagined approach to application design and architecture
-
cuckoofilter-mmap
cuckkoo filter use mmap
-
carboxyl
functional reactive programming
-
slave-pool
thread pool
-
web-wt-sys
Hand-crafted low-level Rust bindndings to WebTransport Web API for WebAssembly
-
spring-stream
Integrate sea-streamer with spring-rs
-
infinitree
Embedded, encrypted database with tiered cache
-
procref
Cross-platform process reference counting for shared service lifecycle management
-
circuitbreaker-rs
A production-grade, zero-boilerplate, lock-efficient, observability-ready Circuit Breaker library
-
sqrtx
Square root calculation
-
fusabi-host
Shared host/runtime utilities for Fusabi across Scarab/Tolaria/Hibana/Phage
-
atomic-counter
Atomic (thread-safe) counters for Rust
-
crossbeam-skiplist-mvcc
Support MVCC (Multiple Version Concurrent Control) for
crossbeam-skiplist -
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
-
miyabi-orchestrator
Complete autonomous AI development operations platform - Rust edition
-
cynosure
High performance data structures & primitives from beyond the Blackwall
-
linch
In development
-
thread_map
Types that are simple and easy-to-use alternatives to the
std::thread_localmacro -
ibag
A thread-safe, immutable bag for holding any value
-
specs
Entity-Component-System library written in Rust
-
async_once
async once tool for lazy_static
-
gil
A collection of high-performance, lock-free concurrent queues (SPSC, MPSC, MPMC, SPMC) with sync and async support
-
siafu
Ergonomic job scheduling library for Rust
-
nexus-channel
High-performance lock-free SPSC channel for low-latency systems
-
asimov-flow
ASIMOV Software Development Kit (SDK) for Rust
-
moz-cli-version-check
Opt-in version checking library for Mozilla CLI tools
-
metriken
A fast and lightweight metrics library
-
kikiutils
simplify Rust development
-
atomic-arena
Generational arena that allows reserving keys from other threads
-
tempref
type whose value remains unchanged even when accessed through a mutable reference
-
mambo_map
lightweight, simple, minimally blocking multithreaded hashtable
-
may_waiter
coroutine communication blocker
-
occams-rpc-tokio
occams-rpc runtime adaptor for tokio ecology occams-rpc is a modular, pluggable RPC for high throughput scenario, supports various runtimes, with a low-level streaming interface, and high-level remote API call interface
-
lace-ws
work-stealing library based on the lace deque
-
magnetic
Low-latency lock-free queues
-
bcast
Low latency broadcast (SPMC) buffer designed to work with shared memory
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
clasp-test-utils
Test utilities for CLASP protocol crates
-
lynn_sundial
支持cron的异步并发定时任务管理器
-
lamlock
MCS-style flat-combining mutex with panic-awareness
-
k8s-controller
lightweight framework for writing kubernetes controllers
-
ebr
epoch-based reclamation with low cacheline ping-pong
-
fast-steal
特别快的多线程任务调度器，支持超细颗粒度的任务窃取
-
atomic-maybe-uninit
Atomic operations on potentially uninitialized integers
-
pressure-measurement
压力测试
-
parallel_downloader
A robust, concurrent file downloader designed to be resilient, supporting automatic retries, crash recovery, and download verification
-
recluse
A web crawler framework for Rust
-
portable_atomic_enum
An attribute to create an portable atomic wrapper around a C-style enum
-
suck
Suck data up through a channel
-
mpsc
mpsc channel
-
progress-token
tracking progress of long-running tasks
-
ida-rs
A thread-safe, no_std, sparse ID allocator using a radix tree. Ideal for systems programming.
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
rust-releases
Find, index and obtain all officially available Rust releases
-
archy
An async application framework with services, systems, and dependency injection
-
sprinter
Run parallel queued tasks
-
quartz
Port of the original Java Quartz Scheduler to Rust
-
elysees
A fork of triomphe, now with more pointer trickery
-
utils-atomics
Various atomic utils
-
parseq
Parallel sequential iterator
-
mbarrier
Cross-platform memory barrier implementations for Rust, inspired by Linux kernel
-
zimq
Tokio-based asynchronous in-process message queue
-
flo_scene
Entity-messaging system for composing large programs from small programs
-
fluxrpc-core
RPC framework supporting multiple protocols and codecs
-
haphazard
Dynamic memory management for lock-free data structures using hazard pointers
-
actor12
A lightweight actor framework for Rust with async support
-
thread-manager
A streamlined Rust library for efficient thread pooling and parallel job execution, designed for simplicity, flexibility, and performance
-
rx_core_common
rx_core's core traits and implementations
-
atomic_once_cell
Thread-safe and lock-free OnceCell and Lazy
-
copy-channels
A collection of cross-thread channels for copyable types
-
avx-parallel
Zero-dependency parallel library with work stealing, SIMD, lock-free operations, adaptive execution, and memory-efficient algorithms
-
resolver
Expression evaluator
-
lockmap
A high-performance, thread-safe HashMap implementation for Rust that provides fine-grained locking at the key level
-
perdix
High-performance GPU-accelerated ring buffer for AI terminal multiplexing
-
atomic-shim
Atomic types for unsupported platforms
-
batched-queue
A high-performance, highly-concurrent batched queue implementation for Rust
-
lowlet
Low-latency IPC library using shared memory and lock-free structures
-
reft-light
A concurrency primitive for high concurrency reads over a single-writer data structure
-
sharded_ringbuf
A Tokio async, sharded SPSC/MPSC/MPMC ring buffer in Rust
-
lambda-channel
A crossbeam-like channel concurrently executes lambda functions
-
anthropic-types
Type definitions for Anthropic API communication
-
bztree
BzTree implementation for Rust
-
sovran-arc
Memory management swift-isms brought to Rust
-
permit
A struct for cancelling operations
-
freezebox
deref'able lazy-initialized container
-
sqlite-mumu
plugin for the mumu ecosystem
-
urcu2
Safe API to liburcu
-
maniac-runtime
High-performance async runtime with M:N threading and stackful coroutines
-
pacwrap-agent
Executable agent for conducting containerized transactions
-
ump-ngx
Collection of ump-ng extensions
-
cbloom
Concurrent implementation of Bloom filters
-
fraktor-rs
Specification-driven actor runtime bridging Akka/Pekko and Proto.Actor semantics across no_std and std targets
-
nexus-slab
A high-performance slab allocator optimized for predictable tail latency
-
obsidian-scheduler
scheduling tasks with both callback and event-based timers
-
seqmap
A blazing fast seqlock-based concurrent hashmap where every data cell is its own seqlock, suitable for thousands of concurrent readers and writers
-
lfchring
Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication
-
silva
A fast Rust inference engine for tree ensemble models supporting XGBoost, LightGBM, and native formats
-
tokio-prometheus-metered-channel
Metered tokio channels with Prometheus metrics integration
-
job-pool
Thread Pool
-
puniyu_registry
puniyu 的注册中心模块
-
sync-unsafe-cell
A backport of the SyncUnsafeCell standard library type for use in older Rust versions
-
rediq
A distributed task queue framework for Rust based on Redis
-
fetchchromium
fetch Chromium builds rapidly
-
quid
fast, concurrent, lock-free UID generation library
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
queued-task
concurrent queue task processing
-
file-per-thread-logger
A logging implementation that writes logs in one file per thread
-
concurrent-slotmap
A lock-free concurrent slotmap
-
amadeus
Harmonious distributed data processing & analysis in Rust. parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common crawl
-
hypercounter
An atomic, lock-free, hash map-like counter structure
-
api-rate-limiter
rate limiter for Rust APIs
-
numaperf-topo
NUMA topology discovery and CPU locality mapping
-
pi_key_alloter
lock free Key(idx:u32, version:u32) alloter
-
untrusted
Safe, fast, zero-panic, zero-crashing, zero-allocation parsing of untrusted inputs in Rust
-
throttle-client
Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.
-
actrix
Actor-based RTC framework
-
kontroli
Type checking for the lambda-Pi calculus modulo rewriting
-
multipull
keeps every multi-repo project up to date with one fast, parallel git pull
-
qrush-engine
Lightweight Job Queue and Task Scheduler for Rust (Actix + Redis + Cron)
-
pi_slot_deque
Two terminal queue based on slotmap
-
ironshield
Snagging this name before anyone else does
-
rarena-allocator
Lock-free ARENA allocator which can be used in both memory and on-disk
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
bgdrop
that uses a dedicated thread and channel to reduce latency caused by memory deallocation
-
rusearch
A super-fast, parallel, recursive directory search CLI for developers and power users
-
sinner
Easy cross-thread resource sharing for Rust!
-
axiom-spinlock
A lightweight, no_std-compatible spinlock and exponential backoff implementation for low-level concurrent systems
-
threadfin
A thread pool for running multiple tasks on a configurable group of threads
-
per-thread-mutex
Synchronization lock designed for wrapping thread-unsafe C libraries
-
unique-rc
Unique owner Rc, like Box, can Send and DerefMut
-
firq-tower
Tower middleware integration for Firq scheduling
-
chorus_lib
Choreographic Programming in Rust
-
voltura_platform
common platform agnostic APIs, as well as platform-specific features for Voltura Engine
-
snowdon
A lightweight thread-safe snowflake ID implementation for Rust
-
dsp-process
Declarative processing
-
uf_rush
A lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure
-
opentalk-roomserver-types-livekit
Opentalk RoomServer LiveKit Types
-
breaker_machines_native
Ruby FFI bindings for breaker-machines circuit breaker
-
kovan-mvcc
Multi-Version Concurrency Control (MVCC) implementation based on the Percolator model using Kovan
-
pulse
async wake signals
-
roam-session
Session/state machine (handshake, request_id/channel_id routing, flow control)
-
libphosh
Rust bindings for libphosh
-
atomic_token_bucket
Lock-free Token Bucket algorithm implemented using atomics
-
rusturnate
A sync or async mutex, with or without timeouts
-
sharded_mutex
No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
bpmn-engine
BPMN 2.0 execution engine for Rust with JSON and XML format support
-
hft-channel
SPMC broadcast channel for HFT and real-time systems
-
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
-
spd3303x
controlling the *Siglent SPD3303X* programmable power supply
-
pubsub-bus
Thread-safe one-to-many publish-subscribe event system. Simple and easy to use. It just works (hopefully).
-
amfiteatr_classic
some classic game theory problems to research on
-
myriam
Actor model implementation for local and remote actors
-
swap-buffer-queue
A buffering MPSC queue
-
rong_event
Event module for RongJS
-
rt-history
An RT-safe history log with error checking
-
atomicell
Multi-threaded RefCell on atomics
-
nscldaq_ringmaster
RUST replacement for NSCLDAQ RingMaster - only requires ring2stdout
-
relayr
Cron scheduler with a delegated-flavour syntax
-
command-executor
Command Executor thread pool
-
conveyor-etl-routing
Routing engine and pipeline management for Conveyor ETL
-
order-book
A price-priority order book implementation with support for market depth aggregation and thread-safe operations
-
spawned-rt
Spawned Runtime
-
p2panda-sync
Local-first sync for append-only logs and traits to build your own
-
television-previewers
The revolution will be televised
-
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
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
shmap
A key-value store based on linux shared-memory files (shm) for persisting state across program restarts
-
tatl
in-process alerting
-
incr
fast and self-contained data structures for checking whether a new value is greater than the previous maximum
-
bolt
The package provides a hierarchical read-write lock
-
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
-
atum
Lock-free bidirectional Atom Table, optimized for multi-threaded workloads
-
spindle_rs
A distributed locking crate built on Cloud Spanner and TrueTime
-
k-lock
A fast mutex for short critical sections
-
stinger-rwlock-watch
An RwLock with a tokio::watch channel that is notified when releasing the write lock. Also, a readOnly lock.
-
armc
that facilitates Mutex access to variables
-
distributed-lock-mongo
MongoDB backend for distributed locks using atomic updates and TTL indexes
-
foofighters
A lightweight, work-stealing thread pool
-
atomic-id
Very fast and unique id generation
-
threadcell
A cell whose value can only be accessed by a owning thread
-
vndb-api
Fully Functional Visual Novel Database (VNDB) HTTPS API Wrapper
-
fluent-fsm
way to create a state machine
-
microlock
waiting: Small locks and other timing things!
-
schedules
A lightweight Rust library for managing operations across multiple time scales
-
session_types
session types in Rust
-
zeta-inference
Unified inference runtime for high-performance LLM execution
-
atomicbox
Safe atomic pointers to boxed data
-
single_value_channel
Concurrent single-value update and receive channel
-
disrustor
This project is a port of the LMAX Disruptor to Rust
-
congestion-limiter
Dynamic congestion-based concurrency limits for controlling backpressure
-
ringkernel
GPU-native persistent actor model framework - Rust port of DotCompute Ring Kernel
-
sfo-pool
A work allocation pool
-
spmc
channel
-
gridsystem
A high-performance, parallel-capable 2D grid library
-
taskflow-rs
A high-performance, async-first task orchestration framework for Rust
-
rtic-syntax
The Real-Time Interrupt-driven Concurrency (RTIC) meta language
-
fatbinary
manipulate CUDA fatbinary format
-
const-fnv1a-hash
A #![no_std] crate for performing FNV1A-16/32/64/128 hashing on Rust stable at compile time
-
norpc
Framework for in-process microservices
-
namaste
-
cfavml
CF's Accelerated Vector Math Library providing SIMD optimzied routines for vector operations
-
rgraph
A task graph library
-
balter
A load/stress testing framework
-
keywatch
Async channel that coalesces per-key Add/Delete updates with an optional cooldown
-
pithanos
Fast, lock-free probabilistic data structures for modern Rust
-
my-flag
flag implementation for
tokio -
channel
Rust advanced queue library
-
jobflow
Executes jobs in order
-
open-coroutine-hook
The syscall hook for open-coroutine
-
simple_coro
(ab)using async/await to write simple state-machine based coroutines
-
shared-resource-pool-builder
Create thread pools with a shared resource
-
que
A high performance channel with optional backpressure, interprocess capability, and a multiconsumer mode
-
hab-rs
Rust rule engine for openHAB
-
task-motel
Opinionated (Tokio) task manager with nested task groups and stoppable tasks
-
justalock-client
A distributed lock powered by the justalock service
-
lock_ext
Extensions to std::sync::Mutex
-
boca
Aruba implementation in Rust
-
gnostr-asyncgit
gnostr:fork of asyncgit
-
yuan-id
A lightweight and high-performance u64 ID generator with customizable step allocation and async persistence
-
sbc
Multi-producer, multi-consumer synchronous broadcast channel
-
event-trigger-action-system
A system that triggers actions based on events with user-programmable triggers
-
stm
Software transactional memory. Allows composable atomic operations.
-
llmcc-bumpalo
Thread-safe bumpalo wrapper with pre-allocation support. Fork of bumpalo-herd (https://crates.io/crates/bumpalo-herd) with configurable chunk sizes.
-
kueue
A robust, user-level, work-stealing, distributed task scheduler
-
atomic-interval
A tiny implementation of an atomic timer
-
atomic_struct
Proc-macro crate to derive atomic struct with Arc<tokio::Mutex<T>> fields
-
rtipc
Real-Time IPC, based on a zero-copy, wait-free circular message queue implementation
-
treiber_stack
A lockless, thread-safe, atomic linked-list
-
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…
-
gabriel2
Indeed, an actor library based on Tokio, written in Rust
-
stakker_log
Logging support for Stakker
-
limqch
A channel built on top of limq
-
streambed-patterns
Patterns for working with streambed
-
catalyx
A reactive streaming runtime inspired by join calculus and chemical reaction models
-
easy_mutex
A cloneable mutex wrapper that simplifies everyday use
-
takecell
A cell type which value can only be taken once
-
win-kernel
windows-kernel
-
mdstream-tokio
Tokio glue for mdstream (delta coalescing and optional actor helpers)
-
ngx-tickle
tools for async nginx modules
-
parallel-processor
Framework to manage asynchronous execution of multiple compute units communicating using messages
-
mutex_trait2
Generic mutex trait
-
active_standby
A concurrency primitive for high concurrency reads
-
app-frame
Compile-time dependency-injected application framework with a service orchestrator
-
daedalus-core
Core types and shared utilities for the Daedalus dataflow stack
-
hyperfile-reactor
A lightweight task execution framework built on top of Tokio's LocalSet
-
sids
sample actor-model scheme providing abstraction over actor types and messages that can be sent across threads
-
goko
A lock-free, eventually consistent, concurrent covertree
-
file-crawler
A fast, concurrent, async and customisable file crawler
-
nu-experimental
Nushell experimental options
-
jumphash
A Fast, Minimal Memory, Consistent Hash Algorithm
-
ringkernel-cpu
CPU backend for RingKernel - testing and fallback implementation
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
tower-resilience-adaptive
Adaptive concurrency limiter for Tower services using AIMD and Vegas algorithms
-
thread_lake
A very high level thread pool manager
-
hipthread
no-std thread library based on pthread
-
swmr-cell
A thread-safe single-writer multi-reader cell with wait-free reads and version-based garbage collection
-
nio-threadpool
general purpose threadpool implementation
-
spragga
A scalable concurrent priority queue with relaxed ordering semantics
-
blackhole
...to throw your threads into
-
ecmascript_futex
Cross-platform atomic wait and wake (aka futex) functionality using the ECMAScript Atomics memory model
-
parcoll
Collections for parallel computing, such as SPSC, SPMC, and MPSC and MPMC queues
-
fork-map
running operations in a child process spawned by
fork() -
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
minllm
minimalist LLM framework implemented in Rust with Python bindings
-
atask
An async task implementation
-
fast-pull
Pull everything fast
-
id-gnrt-rust-impl
A fast, thread-safe Rust implementation of the Snowflake ID generator algorithm
-
statewatcher
shared state channel where readers are notified of updates, inspired by tokio::watch but for std
-
mwcas
Multi-word CAS primitive
-
wb_async_utils
working with async code
-
skiplist-rust
A lockless skiplist implementation in Rust
-
oncelock
A fast and simple implementation of OnceLock
-
async-observe
Async single-producer, multi-consumer channel that only retains the last sent value
-
fast-async-mutex
lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)
-
threads_pool
This package provides an easy way to create and manage thread pools, so you don't have to
-
direct_ring_buffer
A high-performance, lock-free ring buffer for single-producer, single-consumer scenarios
-
tourniquet-tonic
Async native round-robin manager for remote services. Tonic integration.
-
EMCompute
fast , simple and cross-platform parallel computing library
-
crius
hystrix-like circuit breaker
-
intid-allocator
Types to allocate and free integer ids
-
merc_sharedmutex
read efficient readers-writer lock based on the busy-forbidden protocol
-
classic-sync
ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems
-
prism3-atomic
User-friendly atomic operations wrapper providing JDK-like atomic API
-
waitfree-sync
A collection of wait-free data structures
-
ncd
Nate's Central Dispatch. Rust concurrency library.
-
byor
Bring your own runtime!
-
rlock
Redis-backed lock library providing both async and sync Mutex, RwLock, and others
-
either-slot
An atomic slot whose senders can either place their value into the slot, or retrive all the data from the slot
-
prism3-concurrent
Concurrent utilities library providing thread pools, task scheduling, synchronization primitives and other concurrent programming tools
-
split_channel
stream-of-messages abstraction with split send/recv channels
-
par-iter-sync
Parallel Iterator With Sequential Output
-
threadpool-executor
A threadpool executor
-
rusty_junctions
Join Pattern implementation in Rust
-
oxidd-manager-pointer
Pointer-based manager implementation for OxiDD
-
disrupt-rs
Concurrent Ringbuffer inspired by the LMAX Disruptor
-
miyabi_scheduler
Thread pool scheduler with extra specific abilities
-
yatch
🦇 Experimental batching on
mpscchannels withVecDequein Rust -
antidote
Poison-free versions of the standard library Mutex and RwLock types
-
rucron
Job Scheduling Crate
-
onering
High throughput synchronous queue
-
cineyma
A lightweight actor framework for Rust with typed messages, OTP-style supervision, and distributed clustering
-
rx_rust_mp
A protoype implementation of the ReactiveX API in Rust using a message passing approach
-
parail
Easily switch between sequential and parallel
-
sea-streamer-socket
🌊 SeaStreamer backend-agnostic Socket API
-
tc-transact
Traits and locking utilities for a TinyChain transaction
-
real-time
Safely share data with a real-time thread
-
spinout
A thread-safe clonable and mutable smart-pointer akin to
Arc<Mutex<T>>, using spin-lock instead of system futex -
bevy_platform_support
Platform compatibility support for Bevy Engine
-
gpgpu
WIP GPGPU framework built on top of wgpu
-
bloomz
A fast, flexible Bloom filter library for Rust with parallel operations support
-
try-lock-portable-atomic
A lightweight atomic lock
-
raw_sync
Lightweight wrapper around OS synchronization primitives
-
sparking-lot-core
parking on addresses
-
declarative_lock
A thread-aware resource locking manager for Rust that enforces declaration-before-locking, guaranteeing deadlock freedom and preventing double-locking by tracking resource usage per thread
-
stronghold-rlu
Read-Log-Update software transactional memory like synchronization mechanism
-
enough-ffi
C FFI helpers for the enough cooperative cancellation trait
-
xorlist
-
kademlia-dht
Kademlia DHT
-
std-semaphore
A counting, blocking sempahore extracted from rust 1.7.0
-
owning_ref
creating references that carry their owner with them
-
tlid
Thread Local ID generator by predefined range without atomics/locks/random/time
-
work-queue
A concurrent work-stealing queue for building schedulers
-
shizuku
Modern microservices framework based on NATS
-
acteur
A safe actor-like framework that just works. Simple, robust, fast, documented.
-
takeaway
An efficient work-stealing task queue with prioritization and batching
-
bastion
Fault-tolerant Runtime for Rust applications
-
theta-sync
A high-performance no_std MPSC channel with full Tokio compatibility
-
async-redis-lock
asynchronous redis distributed lock implementation based on tokio and redis-rs
-
rc_event_queue
VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue
-
sync-fd
syncprimitives with associated file descriptors -
clhlock
Craig and, indenpendently, Magnussen, Landin, and Hagersten queue lock for mutual exclusion, referred to as CLH lock
-
io-engine
block-based IO, intend to mask AIO/io_uring underneath
-
circ
Efficient referenced counted pointers for non-blocking concurrency
-
context
Cooperative multitasking for Rust using Boost.Context
-
spincell
A small, lightweight thread-safe cell implementation targeting no_std environments
-
bus_queue
Lock-free Bounded non-Blocking Pub-Sub Queue
-
service-channel
actor model in rust, like actix
-
kcr_addons_cluster_x_k8s_io
Kubernetes Custom Resource Bindings
-
gosh-remote
Distributed parallel computing over multiple nodes
-
debugit
Debug-print any value without trait bounds using specialization (Rust nightly channel)
-
frugal_async
frugally working with async code
-
retrogress
Progress bars with a thin API around complex features
-
fast-down
Download everything fast
-
shm-primitives
Lock-free primitives for shared memory IPC: SPSC ring buffers and Treiber stack slab allocators
-
re_mutex
A wrapper around
parking_lot::Mutexuseful for debugging deadlocks -
waitx
A lightweight & low-latency, pure signaling primitive
-
dportable
Portable interface for various utilities
-
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!)
-
wasm_sync
Synchronization primitives for both web and native
-
descartes-explore
Various exploration and record-and-replay utilities for DesCartes
-
blewm
Bloom Filter that Bloo(m) my Mind
-
uactor
The fastest and most modular actor system that doesn't force you to pay for what you don't need
-
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.
-
async_logger
Asyncronous logger allows writing arbitrary slices to a memory buffer, which then processed by a writer in it's own thread
-
seqlock
A reader-writer lock that provides extremely fast read access without starving writers
-
timely-communication-master
Communication layer for timely dataflow
-
re_quota_channel
A channel that applies backpressure based on byte size
-
fast-counter
A sharded concurrent counter
-
readfish-tools
Tools for analysing adaptive sampling data
-
sinter
An easy to use & fast global interning pool
-
critical-once-cell
Thread-safe OnceCell and Lazy backed by critical section
-
dag-scheduler
a scheduler of dag computation graph
-
tendrils
Tiny, flexible helpers for managing shared state (Arc<Mutex<T>> / Arc<RwLock<T>>) safely in async Rust
-
thread-checked-lock
Gracefully error when a thread attempts to acquire the same lock twice
-
atomic-lend-cell
lending immutable references across threads with explicit owner-borrower semantics, offering both atomic reference counting and lightweight flag-based implementations
-
killswitch_std
A thread-safe kill switch using only the standard library
-
kovan-map
Lock-free concurrent hash maps using kovan memory reclamation
-
zkstate
Share a struct across multiple instances of an application using zookeeper
-
tapis_actors
Abaco (Actor Based Containers) is an API and distributed computing platform funded by the National Science Foundation to provide Functions-as-a-service to the research computing community…
-
async-liveliness-monitor
A Liveliness Monitor for your Asynchronous Runtimes
-
snaplock
RwLock with lock-free Reads and sequential Writes
-
crossbeam-epoch
Epoch-based garbage collection
-
td_rthreadpool
thread wrapper for Rust
-
sack
A lock-free data structure for adding & retrieving items
-
apalis-core
Core for apalis: simple, extensible multithreaded background processing for Rust
-
kerf
tokio-based trace event collector
-
creche
A replacement for std::process::Command and related types in the standard library. Runs single processes, and pipelines of processes, with configuration of file descriptors and environment for each child process.
-
logfast
Insanely fast logging with a simple interface
-
readlock
A weird alternative to Arc<RwLock<T>>
-
hydra-dashmap
A fork of dashmap for the hydra framework
-
asyncified
A small library for operating on long lived sync values in an async context
-
portable-atomic-util
Synchronization primitives built with portable-atomic
-
yaks
Minimalistic framework for automatic multithreading of hecs via rayon
-
bi
-
parallel-future
fluent async task experiments
-
talos_messenger_actions
Messenger actions for Talos
-
tagged-rendezvous
Rendezvous hashing with support for tag-based exclusions
-
eval-utility
Wrapper function of the evaluator crate. Provides python-like built-in functions.
-
simd-itertools
SIMD-accelerated alternatives for common operations like contains, max, find etc
-
atrilocks
collection of light weight async synchronization primitives based on atomics
-
remutex
Recursive mutex, adapted from Rust's standard library
-
meowtex
Saddened by the feeling that Rust multitasking types are not puppy-/kittycoded enough for you? Then this crate is for you!
-
async-datachannel
Async Wrapper for datachannel
-
parallel_bzip2_decoder
High-performance parallel bzip2 decompression library
-
stele
An atomic Vec-like structure with no copying on allocation
-
future-pool
efficient worker pool implementation for async task processing
-
common-game
A package for the 2025 Group Project of the course of Advanced Programming at the University of Trento
-
poolio
A thread-pool
-
kanal-plus
Fork of kanal with extra features (drain_into_blocking, into_stream)
-
waitcell
A cell type containing a value which may not yet be available
-
pipe-channel
Channel implementation based on pipes
-
veecle-telemetry-ui
Veecle OS telemetry UI
-
atomic-destructor
Atomic destructor for multi-threaded env
-
sovran-state
state management for Rust
-
dropout
Drop your objects out of main thread
-
ein-ffi
FFI library for Ein programming language
-
shardmap
A high-performance concurrent sharded map for extreme workloads
-
enough-tokio
Tokio integration for the enough cooperative cancellation trait
-
bounded-taskpool
Bounded taskpool with backpressure
-
ns3-parallel
A Multitask Parallel Concurrent Executor for ns-3 (network simulator)
-
carbonmap
Lock-free concurrent hash map for Rust with zero GC
-
tc-scalar
TinyChain's scalar value enum, including concurrently-resolvable op definitions and references
-
parsli
Parallel status lines for Rust
-
sas
Salty-and-Sweet one-line Rust Runtime Performance Optimization Library
-
swapper
Swap ownership between threads
-
relay_channel
A single-producer, single-consumer channel where the sender waits for the receiver to receive the message before returning
-
revel_cell
-
task_scheduler_rs
A Rust-based scheduler with basic functionality, focused on adding tasks and handling actions like execute, pause, and shutdown using channels for task communication
-
orb-smol
orb interface adaptor for smol-rs ecology. Orb is an abstraction for writing runtime agnostic async code
-
fusabi-plugin-runtime
Plugin loader, hot-reload, and runtime for Fusabi plugins with manifest validation and capability enforcement
-
datastreamservicelib
Rust version of https://gitlab.com/advian-oss/python-datastreamservicelib
-
thid
No-std, no-alloc thread IDs and thread-locals
-
cogo
Rust Coroutine Library like go
-
command_history
managing command history in Rust applications
-
pime
Rust Python Integration Made Easy
-
rayon-scan
A parallel prefix scan function for ParallelIterator
-
statia
A Universal and Lightweight, Zero dependency Rust state management library
-
mongo_sync
instant coding answers via the command line(just like howdoi)
-
buffet
Thread-local buffer pool for the
loonacrate -
faaa_queue
A really fast unbounded lock-free concurrent queue
-
nysa
A bus for passing messages around between independent subsystems of an application
-
godwit-daemon
A daemon runner for GodWit
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
tower-resilience-executor
Executor delegation layer for Tower services - parallel request processing
-
descartes-tokio
tokio interface for DesCartes
-
bau
Fun, simple signaling library
-
read-write-store
A concurrent, unordered collection for Rust, where each element has an internally generated ID and a read-write lock
-
carpet
A thread-safe, fully-parallel directed graph
-
vigil
liveness checking watchdog for detecting deadlocks/livelocks/starvation etc
-
limnus-default-schedulers
default schedulers for limnus. Main, Fixed and Render
-
quickwit-actors
Actor framework used in quickwit
-
hyaline-smr
Garbage Collector(Hyaline- Safe Memory Reclaimation) for lock free data structures
-
shrink_pool
A thread pool which agressively terminates its threads as soon as they are idle
-
brutils
Some utilities for Rust
-
atomic_cell
Lock-free thread-safe mutable memory locations
-
little_raft
The lightest distributed consensus library. Run your own replicated state machine!
-
rust_kits
kits
-
daemonbit
Cross-platform daemon lifecycle primitives
-
coarsetime
Time and duration crate optimized for speed
-
colosseum
A variety of arena allocators for Rust, including thread-safe arenas
-
usync
fast, drop-in, synchronization primitives
-
anycow
A supercharged container for read-heavy, occasionally-updated data structures with multiple storage strategies
-
cerk_runtime_threading
package for CERK. CERK is an open source CloudEvents Router written in Rust with a MicroKernel architecture.
-
orx-concurrent-ordered-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance and ordered concurrent collection
-
flows-image
Building blocks for flow-based image processing
-
async_chanx
Implement
Sinkfor some channel implementations -
localq
No-std async primitives for
!Sendtasks -
quick-bool
A lock-free boolean implementation using atomic operations
-
tcb
A middleware service for delivering messages in a causal order
-
nanosecond-scheduler
Ultra-low latency nanosecond-precision scheduler for temporal consciousness applications
-
seda_bus
A Staged Event-Driven Architectural message bus
-
superqueue
A tiny, lock-light, type-routed message bus providing event streams and latest-value topics (snapshots) for fast state and event dispatch
-
datacake
A batteries included framework for building fault-tolerance distributed data systems
-
local-sync
Non-threadsafe data structure for async usage
-
ring_promise
A minimal, ergonomic, and thread-friendly abstraction for submission/completion ring-based I/O in Rust
-
easy-parallel
Run closures in parallel
-
unknownrori-simple-thread-pool
A lighweight thread pool for networking and other stuff
-
simplelock
abstractions for inter-process synchronization
-
daft-scheduler
Task scheduling for the Daft project
-
numaperf-affinity
Thread pinning and CPU affinity management
-
leaklist
concurrent, lock-free, singly-linked list
-
lock_pool
Robust, efficient, high performance, asynchronous object pooling
-
xstm
A Rust-implemented Software Transactional Memory (STM) library using TL2 (Transactional Locking II) algorithm
-
gaffer
Prioritised, parallel job scheduler with concurrent exclusion, job merging, recurring jobs and load limiting for lower priorities
-
crossbeam-skiplist_piedb
A concurrent skip list
-
par-dfs
Parallel, serial, and async dfs and bfs traversal
-
kovan-stm
Software Transactional Memory (STM) implementation using Kovan for memory reclamation
-
executor-service
A fast and efficient Thread Pool like Java ExecutorService
-
omango-futex
Futex for Rust
-
semalock
concurrently writing to files in a safe and efficient manner
-
lua-bind
Thread-safe Lua binding system with automatic type registration and dependency injection
-
java-threadpool
这是一个跟java ThreadPoolExecutor线程池 使用方式基本相同的线程池
-
contrie
Concurrent map and set
-
hvm-core
massively parallel Interaction Combinator evaluator
-
swap_channel
A safe lock-free parallel communication channel based on mem::swap
-
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.
-
lock-hierarchy
Prevent dead locks by enforcing lock hierarchies
-
concurrent_lru
A concurrent LRU cache
-
rpools
A minimalist workerpool for rust
-
skipchannel
skipchannels allow to communicate between threads, but always skip to the last sent value
-
this-state
way to store state in a thread-safe manner as well as a way to asynchronously wait for state changes
-
tensr
A high-performance, cross-platform, multi-backend tensor/array library for Rust
-
connection-utils
Connection related utilities
-
multi
An easy way to run multiple commands in parallel
-
concurrent-bloom-rs
thread-safe bloom filter
-
priomutex
A mutex where waiting threads specify a priority
-
jxl-threadpool
Internal crate of jxl-oxide to abstract over thread pool implementation
-
hytra
Datastructure for fast multi-threaded updates
-
process-sync
Synchronization primitives for multiprocess environments
-
alan-runtime
A runtime in Rust to run AGC or Alan Graphcode, alan's bytecode format
-
unblock
A thread pool for isolating blocking in async programs
-
ricecoder-agents
Multi-agent framework for specialized task execution
-
thread-guard
thread guard
-
flo_scene_guest
no_std implementation of the guest protocol for flo_scene for smaller wasm guests
-
priority-semaphore
Runtime-agnostic priority-aware async semaphore for Rust
-
mogul
Agnosticly helps to manage concurrent versions of things
-
smartpool
A very customizable, future-aware threadpool
-
faucet
Back-pressured MPMC queue that can be drained after signaling completion
-
oncemutex
A mutex providing one-time synchronized access, then safe unsynchronized access
-
jacques
High-performance lock-free MPMC queues with horizontal scaling and zero-allocation operation
-
async-fifo
MPMC & oneshot channels with (a)sync API
-
std-mel
Mélodium standard library
-
rearch-effects
Re-imagined approach to application design and architecture
-
rsvow
A Rust-like implementation of JavaScript's Promise mechanism
-
sea-streamer-redis
🌊 SeaStreamer Redis Backend
-
breadx
Pure-Rust X11 connection implementation with a focus on adaptability
-
cooptex
Deadlock free Mutexes
-
protoflow-zeromq
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
sync_barrier
Block thread until counter reached zero
-
zallocator
Amortizes the cost of small allocations by allocating memory in bigger chunks
-
pinned-mutex
Mutex wrappers with structural pinning
-
cell-family
Cheap cells accessed through unique owners
-
airlock
no_std async communication
-
nexus-queue
High-performance lock-free SPSC and MPSC queues for low-latency systems
-
terrars-integrations-github
Pre-generated Terrars Github bindings
-
mp2c
A multi producer multi polling consumer library that enables multiple producers to send messages to multiple consumers completely asynchronously
-
fast-logger
Fast logger for Rust
-
des-cartes
DesCartes: A deterministic, replayable, discrete-event simulator for Rust
-
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)…
-
waithandle
that makes signaling between threads a bit more ergonomic
-
yastl
scoped threadpool library
-
tensorwarp
High-throughput concurrency framework optimized for data locality in massively parallel systems
-
ach-cell
Atomic Channel
-
pcp-mutex
A Priority Ceiling Protocol (PCP) mutex, based on Linux PI futex. Allows efficient and deadlock free execution.
-
orx-concurrent-recursive-iter
A concurrent iterator that can be extended recursively by each of its items
-
exclusion-set
a lock-free concurrent set
-
rcu_128
RCU (Read-Copy-Update) implementation for platforms supporting atomic 128-bit operations
-
tasque
thread pool library
-
rust_observable
Push-based data source Observable type
-
chalametpir_common
Common Utilities for ChalametPIR: Private Information Retrieval for Key-Value Databases
-
node-workers
A pool of long-lived nodejs workers
-
cron-task-scheduler
A high-performance async cron scheduler for Rust, supporting both async and blocking tasks with fine-grained scheduling policies
-
raii-counter
RAII Counter
-
simple-semaphore
🔐 A lightweight implementation of a Semaphore in Rust
-
ev_slotmap
A lock-free, eventually consistent, concurrent slot map
-
amadeus-parquet
An Apache Parquet implementation in Rust
-
rust-key-paths
Keypaths for Rust: Static dispatch implementation (rust-keypaths) and legacy dynamic dispatch (key-paths-core). Type-safe, composable access to nested data structures.
-
todc-utils
building and testing distributed systems
-
extractdb
A thread-safe, in-memory hash store supporting concurrent fetches and writes
-
atomicring
AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer
-
operator-framework
Tools and helpers used to create Kubernetes operators
-
slb
Sharded load balancing text-streaming Unix tool
-
peace-lock
A zero-cost abstraction lock that helps check contention free algorithms
-
wrrm
Write-rarely-read-many wrapper
-
dashtable
A concurrent raw hash table
-
parallel-iterator
Parallelize any iterator with ease!
-
bus_writer
Single-reader, multi-writer & single-reader, multi-verifier; broadcasts reads to multiple writeable destinations in parallel
-
tokio-cron
cron scheduler for tokio
-
dager
create and execute a graph of nodes
-
swmr-epoch
Single-writer multi-reader epoch-based garbage collection system with minimal locking
-
automerge-test
testing automerge libraries
-
suplex
Request-Response wrapper over Crossbeam channels
-
mbarc-map
Minimally-blocking, Atomic Reference Counted Map
-
rtfm-syntax
The Real Time for The Masses (RTFM) meta language
-
web-thread-shim
Native shim for the
web-threadcrate -
thread-owned-lock
Mutex which can only be unlocked by the owning thread
-
io_partition
allowing to use just a part of a Read + Seek object
-
oneshot-uniffi
Patched version of oneshot specifically for the UniFFI project. This removes the
loomtarget and dependency which helps with UniFFI’s downstream consumers -
openmp-reducer
OpenMP-style reducers
-
workpool
Distribute work to a set of threads and wait for completion
-
nolock
A collection of Lock-Free Datastructures
-
eridani-hpc-sdk
SDK for building Eridani HPC distributed computing programs
-
tokio-etcd-lock
WIP
-
juliex
a very basic future executor
-
sentinel-rocket
Sentinel middleware for Rocket
-
atomic-hyperloglog
thread-safe hyperloglog, with atomics
-
rukko
communicating with JVM-based Pekko actors
-
fibrous
A lightweight fiber abstraction over multiple backends (ucontext, win32, asm)
-
raw_sync_2
Lightweight wrapper around OS synchronization primitives
-
mqb
Lock free in memory message queue broker
-
pollux
Queue worker pool
-
os-unfair-lock
wrapper for Darwin os_unfair_lock
-
dining_philosophers
The classic concurrency problem, in Rust
-
min-cancel-token
A cancellation token interface and implementation
-
crossbeam-skiplist
A concurrent skip list
-
rustodrive
Rust bindings for controlling multiple ODrives with the CAN protocol
-
rider
bounded executor for tokio; limit the count of tasks running 🚦
-
rt-write-lock
concurrent, realtime write data structure
-
callback_cell
Like an Atomic<Option<Box<FnOnce()>>>
-
fan
Simplifies fanning-out (and eventually -in) with channels
-
forkjoin
A work stealing fork-join parallelism library for Rust
-
tracing-causality
A tracing layer that tracks the causal relationships between spans, and can be concurrently queried elsewhere
-
leaky-bucket-lite
Slimmed down, lazy futures-aware rate limiter implementation
-
quartz_sched
Minimalistic scheduling library for Rust
-
television-channels
The revolution will be televised
-
razor-rpc-codec
codec packages for razor_rpc. razor_rpc is a modular, pluggable RPC for high throughput scenario, supports various runtime, with a low-level streaming interface, and high-level remote API call interface
-
hey_listen
An event-dispatcher-collection offering async, sync, parallel, and prioritised solutions!
-
try-rwlock
Fast non-blocking readers-writer lock
-
anysafe
any safe
-
pollen-scheduler
Task scheduler for Pollen
-
orengine-utils
This repository provides utilities for building high-performance applications
-
surrealkv
A low-level, versioned, embedded, ACID-compliant, key-value database for Rust
-
workctl
number of higher-level control mechanisms for concurrent work scheduling, built on standard library concurrency primatives
-
ringbuf-blocking
Blocking version of ringbuf
-
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.
-
threadgroup
Manage groups of threads as one unit, join the first one that finishes, timeout on join attempts
-
autd3-link-soem
autd3 link using SOEM
-
refcapsule
Safely send references to other threads
-
idle
Collection of idle strategies to be used by thread(s) when they have no work to perform
-
dci
DCI-Closed, a frequent closed itemset mining algorithm, implemented in Rust
-
moga
A multi-objective genetic algorithm framework
-
shareable
Thread shareable objects using the minimal amount of synchronization
-
slice_adapter
help share slice between thread
-
genzero
that lets you get the latest value of a type
-
cht
Lockfree resizeable concurrent hash table
-
monster
Collection of random utilities
-
twice-cell
Like
once-cell, except you set the value twice -
unlock
Instrumented synchronization primitives helping you to unlock performance issues
-
jobsteal
A work-stealing fork-join threadpool written in Rust
-
kafka_json_processor_core
The core logic for your Kafka processor, part of kafka-json-processor project
-
corroded-rs
that bypasses Rust's safety features
-
no-alloc-channel
thread-safe and lock-free single-producer, single-consumer channel which can be
awaited to receive values -
hopper
an unbounded mpsc with bounded memory
-
rustpool
A data and thread pool library for Rust
-
jwalk
Filesystem walk performed in parallel with streamed and sorted results
-
employer
Spawn worker threads and check on them later
-
runloop
Cancelable non-blocking polling threads (with optional timeouts)
-
atomicdouble
128-bit atomics for generic type
-
atomic-queue
bounded lock-free queue for use in Audio applications, ported from https://github.com/max0x7ba/atomic_queue
-
rattler_config
configure rattler and derived tools
-
go-spawn
that provides macros to spawn and join threads with minimal boilerplate
-
sesh
deadlock-free session-typed communication
-
benjamin_batchly
Low latency batching tool. Bundle lots of single concurrent operations into sequential batches of work.
-
starpu-sys
Low-level bindings to the StarPU runtime
-
swimos_algebra
SwimOS Algebraic Traits
-
managed-thread
Real fearless concurrency! Spawn threads that will be automatically destroyed when no longer needed
-
update_channel
A channel for single updatable values
-
mtlog-tokio
Scoped logging for tokio runtimes with support for log files
-
unit16
whp-unit16
-
rusty-jokes
A humorous Rust crate that brings joy and entertainment to Rust programmers with features like Laughable Lifetimes, Comedic Concurrency, and Punchline Pointers
-
constellation-internal
Common components for the
constellationframework -
topograph
A miniscule thread pool and toposort scheduler
-
atomic_immut
Atomic immutable value
-
tasic
Tokio, Async_STD, Smol, Interface Crate
-
tokio-condvar
A Condition Variable for Tokio Applications
-
terraphim_update
Shared auto-update functionality for Terraphim AI binaries
-
mq-surreal
Message Queue for SurrealDB
-
peril
Fast and safe Hazard pointers for Rust
-
flexible-locks
Flexible Locks
-
insert-take
A Concurrent bag supporting atomically inserting and taking all elements
-
shkeleton
Skeleton rust project
-
mini-io-queue
Fixed-length, allocation and lock-free, async I/O oriented single-producer single-consumer queues
-
bursty
Test support for exarcebating contention in multi-threaded code
-
borrowed-thread
thread-safe way to pass borrow to thread::spawn
-
flowync
multithreading a/synchronization
-
cuckoocache
High performance concurrent cache
-
arrows
An actor framework in rust with message durability and ingestion order processing of of messages
-
thread_timer
cancelable timer with no external dependencies
-
thread_isolated
Isolating values allowing access via closures run on an owning thread
-
concurrent-pqueue
A high-performance, thread-safe priority queue with dynamic priority updates
-
rate-guard-core
Rate limiting library with multiple thread-safe algorithms
-
ohos-ffrt
ohos ffrt runtime bindings
-
dag-runner
A DAG runner with async support
-
consumable_vec
generic approach to create a mutual database for multiple producers and consumers
-
single_executor
Traits for concurrent primitives
-
try-mutex
Fast non-blocking mutex
-
bastion-executor
Cache affine NUMA-aware executor for Rust
-
bustle
Benchmarking harness for concurrent key-value collections
-
shared_channel
Multi-producer, multi-consumer FIFO queue communication primitives
-
sleepfast
Sleep for very small amounts of time quickly
-
smolscale2
hitdns fork of original smolscale
-
with_lock
Deadlock freedom
-
skippy-rs
A set of lock free, thread safe, and fast data structures implemented via a Skip List
-
parallel_reader
reading from a file (or any
Readstream) and processing it by chunks, in parallel -
taskqueue
Parallel execution of the task queue with the ability to add new tasks inside the running tasks
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
celery-rs
Community-maintained Rust implementation of Celery (fork of rusty-celery)
-
ste
A single-threaded executor with some tricks up its sleeve
-
datashare
test package, for me learn rust. 学习时创建的
-
bichannel
Zero dependency std::mpsc based bidirectional channel
-
grandma
A lock-free, eventually consistent, concurrent covertree
-
meta_core
Shared infrastructure for ~/.meta/ directory management, lockfile, and atomic JSON store
-
pezsc-utils
I/O for Bizinikiwi runtimes
-
lockfree
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
fused-reader
fused reader type that if writer thread dies while holding armed fuse the reader will get BrokenPipe error
-
anylock
Polymorphic Locks
-
condest
1-norm and condition number estimator by Higham and Tisseur, 2000
-
notifies
various efficient async notifies
-
eshanized-polaris
Rust-native distributed compute and orchestration framework for scaling concurrent workloads
-
ieu
A low-overhead parallel thread pool
-
object-space
An object store library for highly concurrent program written in Rust
-
persistent_stack
Concurrent persistent stack
-
mpi-fork-fnsp
Message Passing Interface bindings for Rust (FORK)
-
lft-rust
A lock-free threadpool implementation. We provide a traditional single queue threadpool and a lock-free threadpool
-
daedalus-engine
High-level engine facade for planning and running Daedalus graphs
-
crdt-lite
A lightweight, column-based CRDT implementation in Rust
-
overdose
Fast, Row Oriented, Kotlin, Scala-like dataframe
-
sdcons
geo-replicated distributed consensus algorithm: SDPaxos
-
status_executor
Run your work on some context (thread) and get status info back
-
actix-jobs
job scheduler for Actix
-
theta-flume
A blazingly fast multi-producer channel
-
infinitree-backends
Embedded, encrypted database with tiered cache -- backends
-
lazy-mut-rs
Alternative to LazyLock<Mutex<T>>
-
streaming-stats
Experimental crate for computing basic statistics on streams
-
sable-core
Core utilities, math, and foundational types for the Sable engine
-
autoincrement
wrapper for different purposes
-
tinypool
thread pool implementation in Rust
-
semka
Semaphore implementation
-
channel_io
Reader implementation on channel of bytes
-
reactivate
Thread Safe Reactive Data Structure. Made with ❤️ for 🦀
-
piz
piz (a Parallel Implementation of Zip) is a ZIP archive reader designed to concurrently decompress files using a simple API
-
atomic-destroy
An value which can be atomically read and destroyed; like an atomic Option
-
walchan
A persistent mpsc-like channel backed by a write-ahead log (WAL)
-
rcurs
An oxidized RCU implementation
-
kcr_devops_kubesphere_io
Kubernetes Custom Resource Bindings
-
reactor_rs
reactor-rust is an implementation of the Reactive-Streams
-
thread_local_collect
Supports the collection and aggregation of thread-local data across threads
-
sever
Coerce hardlinks into new files
-
semaphore-key
control concurrent thread access by key using a shared semaphore
-
csq
A Concurrent Set Queue implemented in Safe Rust
-
lariv
Linked Atomic Random Insert Vector: a thread-safe, self-memory-managed vector with no guaranteed sequential insert
-
single_thread_cell
Create a cell that can only be accessed by a single thread
-
aof-core
Core types, traits, and abstractions for AOF framework
-
augmented-atomics
Implements some extra types and utilities over atomics for building audio-thread / GUI synchronization
-
little-sync
A little rust crate that provides fastest sync types such as Mutex, RwLock and other
-
datacake-crdt
A conflict free replicated datatype based on a hybrid logical clock implementation for building eventually consistent data stores
-
mtxgroup
mutex group locks all mutexes at the same time
-
ubq
Lock-free queue built from linked blocks for concurrent producers and consumers
-
is_main_thread
A simply tool to check if current thread is the main one
-
alopt
providing efficient synchronization primitives that integrate Option into their design
-
threadReactive
Synchronous Reactive system
-
lofi
Low Overhead Fibers
-
response_channel
A bidirectional response channel
-
rotastellar-distributed
Distributed compute coordination for Earth-space AI workloads
-
may_queue
May's internal queue library
-
handoff
An unbuffered, asynchronous, single-producer/single-consumer channel
-
jtp
thread pool, similar to the ThreadPoolExecutor in java
-
wasserglas
A fixed size thread-safe object pool with automatic reattachment
-
close_already
Speeds up programs writing lots of files on Windows
-
mlsp
small library for smart pointers that use both thread local and global atomic counters
-
arcu
An Rcu implementation using an Arc to keep the read critical section short and handle cleanup
-
shared_child
using child processes from multiple threads
-
tucan
fast, and multithreaded interner with loose type requirement
-
caring
Sharing is caring: a safe library for mmap'ing memory in multiple processes
-
two_phase_channel
A safe synchronisation-free parallel communication channel by statically forbidding conflicting accesses
-
simdvec
Vectors, but with the operational speedup of SIMD!
-
rendezvous_swap
Swap data and sync execution between a pair of threads efficiently
-
deqp-runner
A VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline
-
greenie
Green threads and coroutines in stable Rust
-
stoppable_thread
A wrapper for thread that allows it to be easily stopped cooperatively
-
wcq
A Scalable, Portable, and Memory-Efficient Lock-Free FIFO Queue (DISC '19)
-
future-clicker
Reimplementation of manual_future without using
futuresunstable -
bmrng
async MPSC request-response channel for Tokio
-
semrs
A pure rust implementation of semaphores
-
praborrow-core
Core primitives for PraBorrow. Implements Sovereign<T> for distributed ownership enforcement.
-
dynamic-pool
a lock-free, thread-safe, dynamically-sized object pool
-
with_daemon
An async client-daemon abstraction framework
-
lock-free-freelist
A fast lock free limited length free list for multiple producer and consumer
-
nbus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
folklore
A lock-free concurrent hash map
-
coro
Stackful, first-class asymmetric coroutines
-
simple-channels
educational implementation of channels in Rust
-
timeforrust
A task timer library for Rust
-
scoped-pool
A flexible thread pool providing scoped threads
-
rayon-wasm
work-stealing parallelism for Rust
-
libmcs
A MCS Lock Library
-
shardize
proc macro that generates code to create a sharded form of an existing container
-
paragraphs
A Parallel Graph Execution Library
-
ulock-sys
Rust bindings for Darwin's (e.g. macOS, iOS, ...) not-entirely-public ulock API, which provides futex-like functionality.
-
rcu_list
a lockless concurrent list implementation
-
atomic_ref_box
Box with thread-safe, immutable weak references
-
simt_cuda_sys
part of simt. cuda driver api bindings
-
ascolt
Async runtime-agnostic actor framework
-
crossbeam-skiplist-fd
A long-term maintained forked version of the crossbeam-skiplist for supporting more flexible key comparison customization
-
burstq
A multi-producer, multi-consumer channel that supports sending or receiving multiple values in a single operation
-
atomic_pincell
Threadsafe pinnable RefCell
-
tokio-mpmc
A multi-producer multi-consumer queue implementation based on Tokio
-
ohos-ffrt-sys
ohos ffrt system bindings
-
bombs
Efficient single-producer multi-consumer channel types
-
komora-sync
Synchronization structures for the komora db project
-
scrummage
Fight over OS process prioritisation
-
rayon_iter_concurrent_limit
Limit the concurrency of an individual rayon parallel iterator method with a convenient macro
-
nostro2-ring-relay
Lock-free ring buffer relay pool for the Nostr protocol
-
maybe_parallel_iterator
Toggle parallelism with feature flags!
-
geese_pool
Message-passing system for networking with Geese
-
cargo-steady-state
Code generator for steady_state projects based on a structured dot file
-
dynamic_ocl
Dynamically-loaded OpenCL bindings
-
option-lock
mutex for Option values
-
steelmill
A resource manager (dependency injector / factory) designed for distributed systems and simulation testing
-
promissory
One-shot value exhange between threads
-
mpmc-async
A multi-producer, multi-consumer async channel with reservations
-
conquer-util
concurrent and lock-free programming
-
scheduling
job scheduler
-
may_actor
Actor library based on MAY
-
multithreading
in Rust
-
busan
An actor implementation for Rust
-
threadstack
A more ergonomic and more flexible form of thread local storage
-
awaitdrop
WaitGroup
-
jobsys
Lockless Work Stealing Job System
-
priact
A lightweight and ergonomic Actor implementation for Rust, built on tokio, featuring explicit message prioritization via a BinaryHeap
-
lock-free
High-performance lock-free data structures for Rust with zero dependencies
-
xio_jobset
XIO jobset datatypes
-
redsync
Redlock for distributed locks with Redis
-
periodically
running tasks on a schedule
-
schedwalk
Test futures under all possible polling schedules
-
workers_pool
A long running threadpool for parallel task execution
-
tenvis-pulse-core
Core types, traits, and message routing for Pulse
-
uppercut
Small and simple actor model implementation
-
protoflow-syntax
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
elock
A lightweight distributed lock implementation built on top of etcd using leases and watch
-
nocontrol
No control is an early version of a distributed work-stealing orchestrator
-
linkk
creating channels and crossing them to facilitate communication between different parts of a program
-
amfiteatr_core
A framework to model and simulate game theory problems with many agents
-
async-once-watch
Asynchronous and shareable container which value is set once
-
take_lock
a dead simple lock around Option<Box<T>> thats similar in spirit to OnceLock but adds a bit more flexibility by paying a bit in performance
-
cache-padded
Prevent false sharing by padding and aligning to the length of a cache line
-
yep-coc
circular buffer. This one happens to be a zero copy, MPMC, lock free queue.
-
run-them
A CLI to launch a single command with many workers, serializing the output
-
descartes-tower
tower API bindings for DesCartes
-
d-engine-core
Pure Raft consensus algorithm - for building custom Raft-based systems
-
tc-tensor
TinyChain's Tensor collection type
-
currant
spawn concurrent shell processes in rust
-
nblock
Non-Blocking Runtime
-
context-coroutine
set of extensions to provide stackful coroutines; it is not officially associated with the context crate
-
dontshare
Prevent false sharing between data
-
xloc
A fast, multi-threaded line counting utility written in Rust
-
numaperf-core
Core types and error handling for the numaperf NUMA runtime
-
atomiq
Convenient tool for atomics in Rust
-
mailboxxy
micro actor library for rust
-
af-core
A core library and async runtime for Rust applications
-
loomy
A shim to easily run loom tests
-
gstuff
Small macro and trinkets that make my life easier
-
sharded-slab
A lock-free concurrent slab
-
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
-
opool
High-performance, lock-free local and concurrent object pool with automated allocation, cleanup, and verification
-
ump
Micro message passing library for threads/tasks communication
-
ppipe
An elegantly simple and lightweight library for making iterator pipelines concurrent and blazingly fast, hence the name ppipe (parallel pipe)
-
miyabi-worktree
Git worktree management for Miyabi
-
lever
Pillars for Transactional Systems and Data Grids
-
ebri
[NOTE: un-tested. use at your own risk.] ebri (ebr-integrated), that is, a
no-stdEBR (Epoch-Based Reclamation) implementation. thanks to the idea fromscc::ebr. -
statman
Stat Manager
-
ipc_ring
High-performance memory-mapped SPSC ring buffer for Unix IPC
-
spinwait
C#'s SpinWait type for lightweight spinning
-
khonsu
Software Transactional Memory in Rust for Apache Arrow
-
rayon-cancel
An adapter to interrupt rayon parallel iterators
-
db
Lightweight high-performance pure-rust transactional embedded database
-
waitable
A synchronized (atomic) value container implementing the Mutex+Condvar pattern for efficient blocking waits
-
double_decker
unbounded multi-producer multi-subscriber event bus built with crossbeam channels
-
atb
lock-free triple buffer
-
async_wasm_task
Manage the concurrency of async tasks in webassembly Rust
-
init_guard
A Synchronization Primitive for guarding against double initialization
-
work-steal-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
squeue
sized queue
-
hala-sync
Hala synchronous primitive
-
quick_cache
Lightweight and high performance concurrent cache
-
cuneiform-fields
Field level [no_std] cache optimizations for Rust
-
runall
Run multiple commands concurrently
-
amadeus-serde
Harmonious distributed data analysis in Rust
-
async-mutex
Async mutex
-
fraktor-utils-core-rs
Portable no_std toolbox primitives for the fraktor actor runtime
-
published_value
Publish a value from one thread to other threads
-
kovan-channel
Multi-producer multi-consumer channels using Kovan for memory reclamation
-
minicoroutine
mini coroutine library in rust
-
loopq
An efficient SPSC lock-free ring buffer with support for no_std, Embassy, and Tokio
-
simpl_actor
tokio actors
-
shared-lock
A lock that protects multiple objects at once
-
spsc-buffer
Single-producer single-consumer lock-free buffer
-
yot_run_macros
The wrapper macro for a work-stealing, multi-threaded async executor with non-blocking scheduling
-
lendpool
lock-free library for allowing safe and concurrent access to a group of objects
-
rtfm-core
Core abstractions of the Real Time For the Masses framework
-
mpsc_requests
mpsc channels but with a response
-
runnel
the pluggable io stream. now support: stdio, string io, in memory pipe, line pipe
-
spms_ring
Single publisher, multiple subscriber ring buffer for pubsub
-
atomic_box
A struct which allows multiple threads to safely update and read from a shared non-nullable pointer to heap data
-
channels-rs
low latency channels for inter-thread messaging
-
concurrency_traits
Traits for concurrent primitives
-
unirun
Universal project runner
-
indicatif-log-bridge
Bridge the log crate and indicatif to stop log lines from mixing up with progress bars
-
sea-streamer-file
🌊 SeaStreamer File Backend
-
lockpool
offers a pool of locks where individual locks can be locked/unlocked by key
-
rayon-progress-bar
work-stealing parallelism for Rust
-
feagi-state-manager
Runtime state management for FEAGI - cross-platform, RTOS-compatible
-
vlock
A fast and scalable multi-version shared state lock with wait-free read access
-
touch-cli
Fast, Parallelized touch(1) file utility
-
supersonic
A one-stop rust crate for high-speed, high-performance, high-concurrency data-structures
-
atomic_prim_traits
Traits over primitive atomic types
-
objectpool
lock-free object pool, support no_std
-
namedlock
Namespaces for named locks
-
thread-counter
way of efficiently keeping track of active threads and waiting for them to exit
-
quant-iron
high-performance, hardware-accelerated modular quantum computing library with a focus on physical applications. Quant-Iron provides tools to represent quantum states, apply standard quantum gates…
-
agner-actors
An actor toolkit inspired by Erlang/OTP (actors)
-
lazy_ref
Implements a non-blocking synchronization primitive for lazy-initialized immutable references
-
clone-replace
Share mutable data by cloning and replacing a reference version
-
atomic-try-update
Primitives that make it easy to implement correct lock-free algorithms
-
eventbus-tiny
A small, dependency-free crate that provides a multi-producer broadcast-consumer event bus
-
sync-linux-no-libc
A project aiming to reimplement some of the most basic Rust std::sync utilities on Linux without the use of libc
-
lagoon
A thread pool crate with an array of features
-
conveyor_belt
Queue and batch processing library
-
pollen-types
Shared types for Pollen distributed task scheduler
-
tbb
Intel Threading Building Blocks
-
locktree
Experimental compiler-checked deadlock-freedom
-
distributed-lock-postgres
PostgreSQL backend for distributed locks using advisory locks
-
triex
Trivial Executor
-
rsevents-extra
Synchronization objects built on top of rsevents. Semaphore, countdown event, and more.
-
turbo-mpmc
A blazingly fast lock-free MPMC queue that beats crossbeam-channel on SPSC workloads
-
async-spin-sleep
providing a highly accurate asynchronous timer for multiple async tasks using spin sleep in a single thread
-
koper
project
-
ocl-interop
Creates an OpenCL Context with OpenGL Interop enabled
-
fs-mel
Mélodium core filesystem interaction library
-
specs-static
extension for Specs that adds custom ids
-
paradis-demo
demo functionality for paradis, not intended for use
-
shared-mutex
A RwLock that can be used with a Condvar
-
fast-threadpool
Thread-pool implementation optimized to minimize latency
-
lockserver
A distributed lock server for coordinating access to shared resources
-
sieve-cache
SIEVE cache replacement policy with thread-safe wrappers
-
chalametpir_server
Server Implementation of ChalametPIR: Simple, Stateful, Single-Server Private Information Retrieval for Key-Value Databases
-
shared-file
shared, thread-safe file access with independent cursors
-
synapps
event dispatcher for Rust applications. It allows senders to send messages to topics. Subscribers will then receive the message based on their subscription policy.
-
tpool
So simple thread pool
-
swimos_time
SwimOS Time Utlities
-
cacheguard
A lightweight cache guard that pads atomics to prevent false sharing in concurrent Rust systems
-
swimming
Dive into Efficiency with Swimming: A High-Performance, No-Nonsense Connection Pool
-
jobpool
lightweight threadpool implementation
-
zorg
Full-Stack AI Framework for Agent Coordination. Rust implementation coming Q2 2025.
-
ach-pubsub
Atomic Channel
-
pariter
Parallel iterator processing
-
dekker
Dekker's algorithm for mutual exclusion
-
todc-mem
Algorithms for shared-memory distributed systems
-
lazy_id
A thread-safe lazily-initialized ID
-
electrologica
High performance concurrent primitives for Rust
-
kai-cli
Kai - todo.txt task scheduler
-
rt
A real-time operating system capable of full preemption
-
cpu-affinity
Cross-Platform CPU affinity
-
sentinel-actix
Sentinel middleware for Actix-Web
-
work_dispatcher
concurrent data processing framework
-
cnr
An operation-log based approach for data replication
-
linux-futex
Futex: A Linux-specific fast user-space locking primitive
-
re_log_channel
An in-memory channel of Rerun data messages
-
wired_handler
Wired's handler library
-
multithread
API for data-parallel tasks, rayon-lite
-
async-datachannel-wasm
Async Wrapper for WebRTC datachannel in the browser environment
-
haagenti-distributed
Distributed inference across multiple nodes with tensor parallelism
-
limiteron
Unified flow control framework for Rust
-
diplomatic-bag
A wrapper type that allows you to send
!Sendtypes to different threads -
zkmq
Message Queue, backed by Zookeeper
-
concurrency_toolkit
Easy switching between std::sync, tokio::sync and loom::sync
-
yaambo
concurrent skip lists
-
base-threadpool
minimalistic threadpool implementation
-
rusty-variation
deadlock-free session-typed communication
-
starlang-runtime
Runtime infrastructure for Starlang - process registry, scheduler, mailboxes
-
async-barrier
An async barrier
-
pacwrap-core
providing core functionality for pacwrap
-
wasm_thread
An std thread replacement for wasm32 target
-
sharded-offset-map
A map from u64 to T that can be written from multiple threads
-
syncrs
spinlock-based syncronization primitives for no_std enviroments
-
occams-rpc-codec
codec packages for occams_rpc. occams_rpc is a modular, pluggable RPC for high throughput scenario, supports various runtime, with a low-level streaming interface, and high-level remote API call interface
-
lfrlock
A Lock-Free Read Lock where reads never block and writes are serialized using Mutex
-
refcell-lock-api
A single-threaded implementation of lock_api for RefCell, to alllow abstracting between single-threaded & multi-threaded code
-
embassy-sync
no-std, no-alloc synchronization primitives with async support
-
semaphorus
Atomic semaphores
-
lending_thread_pool
A thread pool where workers can lend their data to their tasks
-
consume
Memory order consume for when it's known that the compiler can't elide the dependency
-
atomic_sibling_counter
A shared counter that allows parallel threads/tasks to check how many siblings they have. The counter is atomic and threads/tasks are not synchronized or coupled in any way.
-
async-events
Waiting for external task completion in asynchronous Rust code
-
governor
A rate-limiting implementation in Rust
-
pubsub-tokio
Fun-out pattern implementation based on tokio mpsc channels
-
kcr_operator_shipwright_io
Kubernetes Custom Resource Bindings
-
graphile_worker_crontab_runner
Crontab runner package for graphile worker, a high performance Rust/PostgreSQL job queue
-
locker
named mutex/locker for rust-lang concurrency
-
kcas
A lock-free, allocation-free multi-word compare-and-swap library
-
pcat
A dead-lock free parallel cat implementation
-
mutex_logger
logger that usess mutex for thread safty
-
syncell
Sync alternative to RefCell
-
polyester
Parallel iterator adaptors that accept arbitrary iterators
-
pipeliner
nice interface for parallel programming with iterators
-
atomicbox_nostd
Fork of the atomicbox library that works in no_std contexts
-
conqueue
multi-producer, single-consumer queue (MPSC)
-
relrc
Reference counted pointers, with relationships to other pointers
-
protex
(Process Mutex) concurrency in process level
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
atomicslice
thread-safe shared slices that are just about as fast as possible to read while also being writable
-
re_smart_channel
A channel that keeps track of latency and queue length
-
fusionsql-core
A data fusion platform with scheduler, ai agent studio and core libraries
-
chashmap-async
Concurrent async hash maps with key-scoped locking
-
relaxed
Wrappers around Atomics that always use
Ordering::Relaxed -
a_r_c_h_e_r_y
TEMPORARY CRATE
-
nexus-pool
High-performance object pools for low latency systems
-
ironshield-core
Enterprise-Grade Edge-Native Scraping & L7 DDoS Firewall with Stateless PoW, Bot Fingerprinting, and Origin-Shielding
-
rs_lockfree
a lock-Free lib based on practical Hazard Pointers algorithm
-
ironsbe-channel
High-performance channel abstractions for IronSBE messaging
-
employees
A small runtime that hides all the boilerplate when using threads
-
rust-lockless-slotmap
A (mostly) lockless slotmap implementation in Rust
-
hv-lease-tracker
no-std compatible tracking of borrow origins, for providing better diagnostics when implementing interior mutability primitives
-
amadeus-aws
Harmonious distributed data analysis in Rust
-
malstrom
distributed, stateful stream processing framework written in Rust
-
flo_scene_pipe
Inter-scene and inter-process communication for flo_scene
-
ordr_core
The core part of
ordr(which is probably the one you want) -
batch-lock
A lock manager with batch-lock support
-
cupchan
async overwriting channel between two threads that is wait & block free by swapping cups around
-
graph_csr
that provides utility functions for manipulating graphs in a CSR format, used as the baseline for constructing powerful graph algorithms
-
witty-actors
Fork of quickwit-actors, Actor framework used in quickwit
-
watchable
RwLock-like type that is compatible with both multi-threaded and async code
-
quinine
Atomic monotonic containers (Mono{Box,Arc})
-
arbalest
Like Arc<T> but where weak references don't forbid mutable access
-
squall-error
Agentic error
-
ei-sys
Low level Rust bindings to ei, a library to communicate with distributed Erlang
-
rayon-core
Core APIs for Rayon
-
asparit
Async Parallel Iterators for Rust
-
nexus-logbuf
Lock-free SPSC and MPSC byte ring buffers for logging and archival
-
linux-rtic
A Real-Time Interrupt-driven Concurrency (RTIC) implementation for Linux
-
mpmc
copy-pasted from old rust stdlib
-
swmr-barrier
Asymmetric Heavy-Light memory barriers for Single-Writer Multi-Reader (SWMR) scenarios, optimized for zero-cost readers
-
mutex-timeouts
let you specify a timeout on a mutex lock
-
stewart
A minimalist, high-performance, and non-exclusive actor system
-
spliter
way to implement Rayon's ParallelIterator
-
mcs
Synchronization primitives based on Mellor-Crummey and Scott’s (MCS) queueing spinlock. This library is usable without
std. -
poolter
Thread Pool implementation for Rust using JavaScript Promise like functional syntax
-
kovan-queue
High-performance queue primitives and disruptor implementation for Kovan
-
protoflow-crossbeam
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
vdso-rng
wrapper around the Linux vDSO random number generator
-
open-coroutine-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
tpx
Task scheduler
-
ach-util
Atomic Channel
-
tokio-futures-order
Enforce execution order of multiple tasks
-
amadeus-commoncrawl
Harmonious distributed data analysis in Rust
-
zc_buffer
High-Performance Rust Zero-Copy Inspired Buffer Library based on Bytes
-
simple_thread_pool
thread pool
-
storage-map
Concurrent append-only map storage
-
rdispatcher
Dispatcher for Rust, broadcast and subscribe many to many
-
pinnable
A Mutex that can be pinned
-
disruptor-rs
A high-performance ring buffer implementation of the LMAX Disruptor pattern
-
thread_runner
executing tasks concurrently
-
cfrp
Concurrent Functional Reactive Programming for Rust
-
mrogalski-looper
Clean abstraction for a single-threaded event loop. Built as a lightweight wrapper around the std::sync::mpsc package.
-
melodium-common
Common Mélodium elements and traits
-
daemonbit-lockfile
Cross-platform daemon lifecycle primitives
-
critical-section
Cross-platform critical section
-
threads
Traits to abstract thread-pools
-
pocketflow
A minimalist LLM framework. Let Agents build Agents!
-
entangled
fork-join task executor
-
verona-rt
Idiomatic binding to the verona runtime
-
act_rs_smol
Act.rs smol is a minimal smol oriented actor framework
-
windowed-futures
Helpers for windowed parallel execution of collections of futures
-
television-utils
The revolution will be televised
-
web_worker
implementing web workers to run rayon-styled concurrent work on wasm
-
llt-rs
Low-Latency Primitives Toolkit for Rust
-
async-semaphore
An async semaphore
-
trotcast
An mpmc broadcast impl
-
hadron-client
The Hadron Rust client library
-
double-checked-cell-async
A thread-safe lazily initialized cell using double-checked locking
-
tokio-scheduler-types
Types for tokio-scheduler-rs
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions. -
vin
An ergonomic actor framework
-
atomiclock
A non-blocking lock that can be used in async contexts
-
redlock
distributed locking mechanism built on top of Redis
-
waitq
No-std, no-alloc async waker queue optimized for
!Sendtasks -
raliguard
Lazy rate limit semaphore implementation for your asynchronous code frequency execution
-
rtrb-basedrop
A fork of the
rtrbcrate that uses basedrop’s Shared pointer in place of Arc -
sync-threadpool
A synchronized threadpool allowing submission of new jobs only when a worker is idle
-
synchronous-timer
Simpler synchronous timer/scheduler for Rust applications
-
crosstalk
An extremely lightweight, topic-based, cross-thread, in-memory communication library
-
sync_2
A little crate providing a Rust implemented Mutex and RwLock
-
priority-async-mutex
An async mutex where the lock operation takes a priority
-
rusty-junctions-macro
Generation and Client Macro API for rusty-junctions
-
hop-consensus
Prototype consensus queues for sequencing hop channel actions
-
numaperf-io
Device locality discovery for NICs and storage
-
rayon_logs
Traces for the rayon work-stealing library
-
scherben-map
Concurrent Sharded HashMap for Rust
-
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.
-
thread_binder
Bind rayon pools to limit numa effects
-
fremkit
broadcast log
-
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
-
open-coroutine-iouring
The io_uring support for open-coroutine
-
fixed-cache
A minimalistic, lock-free, fixed-size cache
-
process-events-streaming
Easy to use process with events and data streaming
-
flo_scene_wasm
Supports loading flo_scene subprograms compiled as WASM modules
-
sea-streamer-types
🌊 SeaStreamer Traits & Types
-
one_at_a_time_please
For serialising calls to functions
-
yaar-lock
Fast, no_std synchronization primitives
-
sharded_queue
ShardedQueue is currently the fastest concurrent collection which can be used under highest concurrency and load
-
kotoba-distributed
Distributed execution engine for Kotoba graph processing system
-
send_cells
Safe and unsafe cells implementing Send/Sync
-
distributed-lock-file
File system backend for distributed locks using OS-level file locking
-
orx-concurrent-option
ConcurrentOption is a lock-free concurrent read and write option type
-
par-map
Parallel map and flat_map
-
swimos_byte_channel
SwimOS Byte Channel
-
tark
An
Arcwith a thread-local strong/weak count -
unbounded-spsc
An unbounded spsc queue built from
bounded_spsc_queues -
zestors
A fast and flexible actor-framework for building fault-tolerant Rust applications
-
caos
Concurrent Append Only Segment-list
-
chute
Lockfree mpmc/spmc broadcast queue
-
moka
A fast and concurrent cache library inspired by Java Caffeine
-
rayon-tlsctx
thread local contexts for rayon loops
-
malobu
Atomic MPMC Bus
-
sync_cow
Thread-safe clone-on-write container for fast concurrent writing and reading
-
ccl
Fast datastructures for use in highly concurrent systems
-
atomic_struct_core
Core library for atomic_struct procedural macro
-
ligmars
Safe bindings to the LGMP C library
-
pollen-rs
Embedded decentralized distributed task scheduler
-
affinity
consistent way to set core affinity for currently running threads and processes
-
gts-logger
Gts logger
-
lightproc
Lightweight process abstraction for Rust
-
pflock
A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
tetanus
A custom utils library for some common unsafe operations
-
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…
-
observable-btree
Reactive Observable BTree
-
riker-default
Riker's default Model and modules providing core services
-
scheduled-executor
Single and multi-threaded task scheduler
-
work_pool
work queue wrapped by a thread pool
-
adaptive-barrier
Barrier with adaptable number of thread subsciptions
-
parking_lot_rt
Parking-lot fork for real-time applications
-
snowflake-multi-threaded
The rust-lang implementation of Twitter's id generator algorithm snowflake, it thread safety | Twitter 的id生成器算法snowflake的rust-lang 实现
-
stop-thread
Various ways of stopping threads on various platforms, without requiring the thread to poll
-
generic-container
Abstract over "containers" that hold a T, such as a T itself, Box<T>, or Arc<Mutex<T>>
-
swap-arc
A swappable Arc
-
atomic-memcpy
Byte-wise atomic memcpy
-
wasmind_actor_utils
helpers for building Wasmind actors in Rust
-
send-cell
Immutable memory region with runtime Send checking
-
rust-waitgroup
A Golang like WaitGroup
-
glock
Granular locking crate for Rust
-
rjq
Redis job queue
-
uchan
Multi-producer single-consumer channel for message passing
-
stoplight
stoppable tasks/threads
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
thread_db
Rust wrapper for libthread_db
-
spmc-logger
A single-producer multi-consumer persistent logger
-
sea-streamer-examples
🌊 The stream processing toolkit for Rust
-
rayoff
rayon but it's map-reduce
-
rtic
Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems
-
ping-pong-cell
An atomic cell for up to two threads
-
sync-cell-slice
Cells and slices that are accessible from multiple threads
-
provenant
A version of Arc that can free memory while weak pointers exist by probabilistically tracking provenace
-
key-rwlock
keyed asynchronous reader-writer locks
-
chashmap
Fast, concurrent hash maps with extensive API
-
swctx
One-shot channel with some special semantics
-
async-map
A rarely-locking, shared map for Rust
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
rtic-core
Core abstractions of the Real-Time Interrupt-driven Concurrency framework
-
daemonbit-winmutex
Cross-platform daemon lifecycle primitives
-
tyra
Typed Actor System
-
codas-flow
Low-latency, high-throughput bounded queues ("data flows") for (a)synchronous and event-driven systems
-
starlang-atom
Atom (interned string) implementation for Starlang
-
queue-ext
The extended feature of the queue can convert the pop() function of the queue to Stream and the push() function to Sender
-
mini-moka
A lighter edition of Moka, a fast and concurrent cache library
-
threadpool-crossbeam-channel
A fork of the threadpool create, which uses crossbeam-channel instead of std::mpsc
-
read-cell
Read-only Cell counterpart
-
kcr_onepassword_com
Kubernetes Custom Resource Bindings
-
navactor
A cli tool for creating and updating actors from piped input
-
adirector
asynchronous tokio task spawner with a limited size
-
ice-threads
Lightweight Thread pool implementation
-
theater-server-cli
Standalone CLI for Theater server management
-
once_mut
Safe mutable reference to static variable that can be obtained only once
-
sortlock
providing ordered locking
-
undead
search for dead code in your Python projects
-
simple-rw-global
GlobalContainer based on std::sync::RwLock
-
blocking_semaphore
performant blocking semaphore
-
protoflow-flume
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
rayon_croissant
<lqd> bikeshedding the name: something that is mapped folded and collected, a 🥐
-
cosring
Group theory coset analog to threadsafe SPSC ring buffers
-
datacake-rpc
A zero-copy, actor-like RPC framework using rkyv
-
parallel-event-emitter
Parallel Event Emitter for concurrent listener invocation based on futures-rs and futures-cpupool
-
dynamic_join_array
A dynamic array that can be used to join futures for single thread async programming
-
concache
A fast, concurrent, shared hash map
-
rust-pubsub
A thread-safe, in-memory publish-subscribe library for Rust with flexible subscription modes
-
dynpool
A thread manager that is lightweight, flexible, and rescalable
-
sento
A lock-free, append-only atomic pool
-
ticketed_lock
Ticketed lock system - allows one to separate lock request from the actual waiting
-
ipmpsc
Inter-process Multiple Producer, Single Consumer Channels
-
csplib
CSP for concurrent programming
-
sea-streamer-runtime
🌊 SeaStreamer async runtime abstraction
-
paradis-core
core functionality for paradis
-
chunker
Minimalistic parallel executor
-
switchboard
Enables inter-process communiucation via queues and wakers
-
sublock
Variants of RwLock/RefCell that support sublocks, opened for reading if the main
RwLockis opened for reading, opened for writing if the mainRwLockis opened for writing -
smart_channel
channel subscription system
-
dfmutex
Deadlock-free Mutex locks
-
deploy
The
deploylibrary to aide writing and debugging of distributed programs, as well as tooling to run them across a cluster -
enough
Minimal cooperative cancellation trait for long-running operations
-
deadlocker
Bringing builder pattern to defeat deadlocks
-
fraktor-actor-std-rs
fraktor std helpers for host runtimes
-
nexus-slot
High-performance SPSC conflation slot for latest-value-wins scenarios
-
relay
A lightweight oneshot Future channel
-
rs_taskflow
executing graphs of tasks
-
rusqlite-pool
A minimal connection pool for rusqlite
-
thread-safe
Container that allows thread safety for thread-unsafe objects
-
dynqueue
Dynamically extendable Rayon parallel iterator
-
secc
Implements a Skip-Enabled Concurrent Channel (SECC) for Rust
-
nvrtc
Bindings for NVIDIA® CUDA™ NVRTC in Rust
-
scrappy_do
A concurrent asynchronous webscraping framework
-
proc-lock
cross-process locking API
-
ringbuf-basedrop
A fork of the
ringbufcrate that uses basedrop’s Shared pointer in place of Arc -
genserver
Elixir inspired async actor library
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
asc
Atomic Strong Count
-
threadid
Fast and flexible thread identifiers
-
sea-streamer-stdio
🌊 SeaStreamer Standard I/O Backend
-
cond_sync
Hides the boilerplate code needed with std::sync::Condvar
-
fraktor-utils-std-rs
Standard-library helpers complementing fraktor-utils-core
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
monotone
counters and queues for coordination in distributed systems
-
no-std-async
Async synchronization primitives for #[no_std] rust
-
numaperf
NUMA-first runtime for latency-critical Rust applications
-
spin_loop
-
lockless
Composable, lock-free, allocation-light data structures
-
periodic_do
Run task periodically until it reaches a terminal state
-
ach-once
Atomic Channel
-
mula
Share expensive computation with various requesters
-
ditto
CRDTs for common data structures like maps, sets, vecs, strings, and JSON
-
closure-future
Easily run closures on thread pools and turn their result into Futures
-
parking_monitor
Parking-lot-flavored monitor synchronization construct
-
amadeus-types
Harmonious distributed data analysis in Rust
-
minerva
Materials for causal concurrency with a kairotic component
-
mqtt_actor
An mqtt adapters (from port and adapters) to be used with actix actors
-
boomerang
Deterministic Middleware for Robotics
-
arl
A rate limiter to be used with tokio
-
dashmap_with_out_t_map_trait
Blazing fast concurrent HashMap for Rust
-
xarc
xarcprovides atomically swappable atomically refcounted smart pointers as a safer building block for lockfree algorithms than raw atomic pointers.Xarcis comparable toArcbut… -
movie
An actor / thread orchestration library / macro / framework
-
orx-concurrent-queue
A high performance and convenient thread safe queue that can concurrently grow and shrink with push, extend, pop and pull capabilities
-
multiqueue
A fast mpmc broadcast queue
-
page-lock
reading and writing data from bytes array
-
fiona
Concurrent runtime written against liburing
-
dialectic-tokio-mpsc
A backend for the Dialectic crate using Tokio's MPSC channels
-
wakerizer
Helpers for resources that may have multiple concurrent wakers
-
process-mel
Mélodium external process management library
-
bobbytables
Atomic hashmap for incrementing integers
-
spinning
Mutexes and SIX locks implemented by spinning
-
tange
Scalable Task-based Parallelism Framework
-
bndpresbufch
Bounds-preserving channel for passing buffers
-
deterministic
building blocks for testable systems
-
c-map
Very fast concurrent hashmap
-
key-message-channel
Multi-producer single-consumer queue capable of queuing messages by message key
-
flag-bearer-mutex
Generic async semaphores
-
distributed-lock-redis
Redis backend for distributed locks with RedLock algorithm support
-
thread-lock
A wrapper that locks non-Send and non-Sync data to a specific thread
-
hv-elastic
Safe and almost-safe abstractions for lengthening lifetimes and
'static“loaning” of non-'statictypes -
roundabout
An message oriented concurrent runtime
-
terminate
abstract logic to terminate threads, coroutines and the like
-
mongo-lock-async
Distributed mutex locks with MongoDB
-
arae
Cursed data structures
-
open-coroutine-hooks
The syscall hook for open-coroutine
-
blinkcast
Fast, bounded, multiple-producer, multiple-consumer, lossy, broadcast channel
-
hurdles
Counter-based thread barrier
-
scheduled_channel
A mpmc channel that allows specifying a timestamp for when a message is received
-
protoflow-blocks
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
ora-worker
Part of the Ora scheduler framework
-
evelyn
event distribution library
-
hyperbridge
Fast multi-producer multi-consumer channel with async support
-
threadbeam
specialized channel type for beaming data out of a newly spawned thread
-
waitmap
an awaitable concurrent hash map
-
mrsc
mpsc with requests
-
datacake-node
The core cluster membership system built ontop of Quickwit's chitchat
-
kcr_experimental_kubeblocks_io
Kubernetes Custom Resource Bindings
-
blasoxide-mt
multithreading for blasoxide
-
rework
Multi-threaded task processing in the Master-Worker pattern
-
queuecheck
A thread-safe queue testing and benchmarking library
-
poll-channel
Poll on channel
-
tiny-actor
A minimal actor framework for Rust
-
bufchan
buffered MPSC channel
-
phoenix-tls
creating always present thread locals
-
conman
Concurrency Manager and work item queue in pure safe rust
-
talaria
A high performance, cyclic message passing library
-
llq
Wait-free SPSC linked-list queue with individually reusable nodes
-
starlang-gen-server
GenServer pattern for Starlang
-
access-queue
limit the number of simultaneous accesses to a value
-
actr-runtime
Runtime layer for Actor-RTC framework - actor system, scheduler, and orchestration
-
cloudi
API
-
atomic_pingpong
Lightweight no_std ping-pong buffer, using AtomicU8 for synchronization
-
ngtq
A trait-based abstraction layer for task queues with ID and category support
-
brod
A wrapper library providing an API for executing Kafka producers in parallel
-
channelmap
A DashMap wrapper over Tokio channels
-
kudzu
concurrent, grow-only data structures
-
ump-ng-server
Server message dispatch loop for ump-ng
-
basic_scheduler
A basic time-based scheduling system
-
sling
Sequentially lockign (SeqLock) Ring Buffer
-
concurrent-initializer
concurrent initializer to ensure initialization only once per key
-
orb
An abstraction for writing runtime agnostic async code. Orb provides interfaces to adapt different async runtimes like smol and tokio
-
lossyq
concurrent single publisher, single consumer queue with fixed length, that never blocks the writer
-
read-write-api
interface to unify single-threaded code and RwLocks-based code
-
daemonbit-rundir
Cross-platform daemon lifecycle primitives
-
queueue
Queue-like data structures used in rCore
-
kik_sync_service
A synchronous threading worker channel for generating the results you want with the data you need
-
turbolift
Easy distribution interface 🚡
-
chunklist
A Chunk List is a new, concurrent, chunk-based data structure that is easily modifiable and allows for fast runtime operations
-
optimistic-cell
lock-like structure for low-overhead optimistic concurrency
-
ductile
A channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface
-
slottle
A throttle pool library designed for thread-based concurrency
-
npnc
Lock-free queues
-
rolock
Read Only Lock
-
momen
low overhead thread pool
-
lock_many
Retry-based locking multiple mutexes at once
-
lprq-rs
LPRQ
-
sero
lightweight library for maintaining a shared store of locks
-
horde
threads
-
key-mutex
Access mutexes by key
-
lock_cell
A custom locking cell type written in Rust
-
spin-lock
spin lock implemented by the standard facilities
-
way
Fast Async Channel With no-std Support and Alternative Sync API
-
terminate-thread
terminatable thread implemented with pthread
-
jackiechan
Bounded mpsc channel optimized for lazy bulk operations
-
rayon-core-wasm
Core APIs for Rayon
-
bellande_rwlock
A custom Read-Write Lock implementation developed by the Bellande Architecture Mechanism Research Innovation Center. Offers tools and utilities for concurrent read and write access to shared data
-
magic-ring-buffer
A magic ring buffer (also known as a virtual ring buffer, VRB, or mirrored buffer) which is lock-free for multiple producers and a single consumer
-
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. -
hybrid-lock
A hybrid lock with optimistic locking
-
threadalone
Make any value Send + Sync but only available on its original thread. Don't use on multi-threaded environments!
-
more-sync
More synchronization utils
-
open-coroutine-core
The open-coroutine is a simple, efficient and generic coroutine library
-
xrm
Cross Runtime Manager
-
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.
-
bondi
Single producer, multi consumer lock-free ring buffer (experimental)
-
gothack-future-parking_lot
An "as simple as possible" Future implementation for parking_lot
-
ach-array
Atomic Channel
-
syncbuf
Append-only data structures with lock-free thread-safety and constant-time indexing
-
delay-queue
A concurrent unbounded blocking queue where each element can only be removed when its delay expires
-
blockingqueue
A very very simple wrapper around Rust's mspc channel to work as a blocking queue
-
thinkofname/think_ecs
Source code of the game Univercity: https://store.steampowered.com/app/808160/UniverCity/
-
fifo
First-in-first-out lock-free ring-buffer like kfifo in Linux
-
fslock
files as locks
-
double-checked-cell
A thread-safe lazily initialized cell using double-checked locking
-
ump-ng-autopost
Automatic message poster for ump-ng
-
ringtail
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
qadapt-spin
Synchronization primitives based on spinning. They may contain data, are usable without
std, and static initializers are available -
global-channel
global channels
-
hv-cell
A no-std port of the
atomic_refcellcrate with additionalArc-centric functionality -
hmi_vue3_tauri_lib_v2
面向工业HMI的Tauri后端，内置Modbus任务队列与事件分发
-
barriers
A barrier spin lock implementation
-
striped-lock
Striped Lock for Rust
-
moite_moite
Split a value in two owned parts
-
hyena
async task pool
-
sync-cell
A collection of easier to use thread-safe types for the creation of larger thread safe systems
-
inert
lets you use non-Sync values in a Sync way
-
ach-linked
Atomic Channel
-
json-mel
Mélodium JSON data processing library
-
bounded-spsc-queue
A bounded SPSC queue
-
fuze
A mechanism to wait for a single signal which can be checked at any time
-
thread-broadcaster
A SPMC (Single producer multi consumer) broadcasting channel to broadcast notifications between threads
-
bi_channel
Manage bidirectional mpsc channels more conveniently
-
razor-rpc
modular, pluggable RPC for high throughput scenario, supports various runtimes, with a low-level streaming interface, and high-level remote API call interface
-
parking_method
Obtain parking_lot locks by policy objects
-
nblfq
MPMC queue implementation in no_std Rust
-
fraktor-actor-core-rs
fraktor no_std actor runtime core
-
hv-guarded-borrow
Traits and implementations for generic use of "guarded" borrows
-
fibril
implementing distributed systems with commmunicating fibers
-
ngtask_queue_basic
A trait-based abstraction layer for task queues with ID and category support
-
sync-extra
Convenience functions to Mutex and RwLock
-
concurrent_open_map
A concurrent hashmap implementation in Rust
-
lakka
actors with macros
-
starlang-supervisor
Supervisor pattern for Starlang
-
testtools
Helpers for eliminating boilerplate code in tests
-
phonecall
A tiny easy to use helper that makes function calls through threads/ tasks easier with tokio channels
-
static_locks
The
parking_lotlocks but usable in statics and const fn -
numaperf-sched
Topology-aware work scheduling with locality-preserving stealing
-
gemino
A multi producer multi consumer (MPMC) broadcasting channel
-
open-coroutine-macros
The proc macros for open-coroutine
-
tokio-bichannel
Bidirectional tokio::sync::mpsc channel
-
lock_tree
Prevent deadlocks at compile time. A standalone republication of the netstack3 lock-ordering crate, part of Google's Fuchsia OS.
-
futex-queue
An efficient MPSC queue with timer capability based on Linux futex. Suitable for real-time applications.
-
locklessness
Composable, lock-free, allocation-light data structures
-
squall-network
Agentic network
-
theater-cli
Command-line interface for Theater actor system
-
theatre
A concise async actor model implementation
-
bastion-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
-
rustix-futex-sync
Linux futex-based synchronization
-
hotpath
async Rust profiler with memory and data-flow insights - quickly find and debug performance bottlenecks
-
sea-streamer-kafka
🌊 SeaStreamer Kafka / Redpanda Backend
-
sorted-channel
sorted message-based communication channel
-
squall-tracing
Agentic tracing
-
daemonbit-test
Cross-platform daemon lifecycle primitives
-
simple-mutex
A mutex more efficient than std and simpler than parking_lot
-
padlock
Safely acquire RwLock/Mutex locks
-
rayon-macro
Macros enabling parallelism using the rayon crate
-
mmap-sync
package allowing sharing of data between processes in a wait-free and zero-copy fashion from mapped memory
-
ethos
« τοῦ γὰρ ἤθους αἱ τοιαῦται δοκοῦσι κινήσεις εἶναι… » (NE 1128a.10)
-
mpmcpq
Multi-producer multi-consumer Priority Queue
-
ach-option
Atomic Channel
-
sync_splitter
Safely split a mutable slice in multiple threads at the same time
-
sea-streamer-fuse
Stream processing toolbox
-
synctree
Thread-safe tree data structure
-
balter-runtime
A load/stress testing framework
-
ump-ng
Micro message passing library for threads/tasks communication
-
kestrel-protocol-timer
基于时间轮（Timing Wheel）算法的高性能异步定时器系统
-
datacake-eventual-consistency
Eventually consistent state replication as a library (consensus, RPC and conflict resolution) for building your own eventually consistent databases
-
rbp-autotrain
Automated MCCFR training pipeline orchestration with distributed workers
-
rutin_dashmap
Blazing fast concurrent HashMap for Rust
-
simple_event_map
event map based on channels, provides a receiver that is either blocking or async
-
melodium-engine
Mélodium core engine and executor implementation
-
mpmc-map
Mpmc async map implementation for highly concurrent low-write access
-
worker-pool
handle a set of worker threads, which need to communicate back their result to the main thread
-
television
A very fast, portable and hackable fuzzy finder for the terminal
-
simple-tokio-watchdog
Pretty simple but bulletproof watchdog actor
-
arc_map
A Map of Arc<Mutex<V>> that eases the access of indivdual members
-
workerpool-rs
workerpool for rust
-
synqueue
Internally synchronized (MPMC) queue
-
actress
actor library for Rust
-
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
-
clap-and-async-test
Is a example to use clap with tokio and futures, how run concurrently some functions with a loop inside
-
starlang-application
Application lifecycle management for Starlang
-
riffy
An unbounded, wait-free, multi-producer-single-consumer queue
-
malstrom-kafka
Kafka protocol sources and sinks for the Malstrom stream processing framework
-
batch_queue
A single-producer single-consumer Rust queue with smart batching
-
swimos_sync
SwimOS Synchronization Channels
-
atomic-bus
Atomic MPMC Bus
-
protoflow-core
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
magic-orb
thread-safe, overwrite, heap-stored, fix-sized, locking Ring buffer
-
async-priority-channel
An async channel where pending messages are delivered in order of priority
-
once_map
Single assignment and lazy maps
-
wasmflow-traits
encapsulating the message packets sent across Wasmflow components
-
mpmc-ringbuf
queue
-
eiz
some more code