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