-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
spin
Spin-based synchronization primitives
-
rayon
work-stealing parallelism for Rust
-
dashmap
Blazing fast concurrent HashMap for Rust
-
thread_local
Per-object thread-local storage
-
async-lock
Async synchronization primitives
-
async-channel
Async multi-producer multi-consumer channel
-
flume
A blazingly fast multi-producer channel
-
crossbeam
Tools for concurrent programming
-
ringbuf
Lock-free SPSC FIFO ring buffer with direct access to inner data
-
threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
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
-
arcstr
A better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings
-
jobserver
GNU Make jobserver for Rust
-
triomphe
A fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)
-
event-listener
Notify async tasks or threads
-
loom
Permutation testing for concurrent code
-
thread-priority
managing threads priority and schedule policies
-
sled
Lightweight high-performance pure-rust transactional embedded database
-
mpi
Message Passing Interface bindings for Rust
-
kanal
The fast sync and async channel that Rust deserves
-
sync_wrapper
enlisting the compiler's help in proving the absence of concurrency
-
state
safe and effortless global and thread-local state management
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
rtrb
A realtime-safe single-producer single-consumer ring buffer
-
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
-
stateright
A model checker for implementing distributed systems
-
may
Rust Stackful Coroutine Library
-
atomic_float
Floating point types which can be safely shared between threads
-
kameo
Fault-tolerant Async Actors Built on Tokio
-
corosensei
A fast and safe implementation of stackful coroutines
-
rayon-cond
Experimental iterator wrapper that is conditionally parallel or serial
-
mock_instant
way to mock an std::time::Instant
-
flurry
Rust port of Java's ConcurrentHashMap
-
local-channel
A non-threadsafe multi-producer, single-consumer, futures-aware, FIFO queue
-
bus
A lock-free, bounded, single-producer, multi-consumer, broadcast channel
-
try-lock
A lightweight atomic lock
-
radium
Portable interfaces for maybe-atomic types
-
fragile
wrapper types for sending non-send values to other threads
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
shuttle
testing concurrent Rust code
-
maitake-sync
No-std async synchronization primitives from Maitake
-
ratelimit
ratelimiter that can be shared between threads
-
sdd
Scalable lock-free delayed memory reclaimer
-
leaky-bucket
A token-based rate limiter based on the leaky bucket algorithm
-
scheduled-thread-pool
A scheduled thread pool
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
fslock
files as locks
-
parking
Thread parking and unparking
-
triple_buffer
triple buffering, useful for sharing frequently updated data between threads
-
seize
Fast, efficient, and predictable memory reclamation for concurrent data structures
-
rustc-rayon
work-stealing parallelism for Rust - fork for rustc
-
atomic_refcell
Threadsafe RefCell
-
surrealkv
A low-level, versioned, embedded, ACID-compliant, key-value database for Rust
-
executors
A collection of high-performance task executors
-
once_map
Single assignment and lazy maps
-
concurrent-map
a lock-free linearizable B+ tree
-
orx-concurrent-vec
A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations
-
typedmap
A hash map (dash map). A type of value is defined by trait implemented on key type
-
async-condvar-fair
Condition variables for async Rust
-
mpstthree
implementing Multiparty Session Types for 2 or more participants
-
process_control
Ergonomically run processes with limits
-
gst-plugin-threadshare
GStreamer Threadshare Plugin
-
chili
low-overhead parallelization library
-
automerge
A JSON-like data structure (a CRDT) that can be modified concurrently by different users, and merged again automatically
-
atomig
Generic, convenient and lock-free
stdatomics viaAtomic<T>. Can be used with many primitive types (including floats) and with custom types. -
dagrs
follows the concept of Flow-based Programming and is suitable for the execution of multiple tasks with graph-like dependencies. Dagrs has the characteristics of high performance and asynchronous execution…
-
paralight
A lightweight parallelism library for indexed structures
-
television
A cross-platform, fast and extensible general purpose fuzzy finder TUI
-
mco
Rust Coroutine Library like go
-
waker-fn
Convert closures into wakers
-
ppl
A structured parallel programming library for Rust
-
crossbeam-channel
Multi-producer multi-consumer channels for message passing
-
linux-futex
Futex: A Linux-specific fast user-space locking primitive
-
sea-streamer
🌊 The stream processing toolkit for Rust
-
guardian
owned mutex guards for refcounted mutexes
-
workerpool
A thread pool for running a number of jobs on a fixed set of stateful worker threads
-
clashmap
Sharded hashmap suitable for fast concurrent access
-
idr-ebr
An efficient concurrent ID to object resolver
-
lockable
offers hash map, hash set and cache data structures where individual entries can be locked
-
indicatif-log-bridge
Bridge the log crate and indicatif to stop log lines from mixing up with progress bars
-
fault-injection
fault injection, concurrency delay injection, and error source annotation
-
aws-sdk-s3-transfer-manager
A high performance Amazon S3 transfer manager for Rust
-
atomic-time
AtomicDuration,AtomicOptionDuration,AtomicSystemTime,AtomicOptionSystemTime,AtomicInstantandAtomicOptionInstantfor Rust -
uid
creation of unique IDs
-
safe-lock
A lock struct with a
const fnconstructor and nounsafe- ARCHIVED -
shred
Dispatches systems in parallel which need read access to some resources, and write access to others
-
rclite
small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs
-
messaging_thread_pool
aiding the creation of typed thread pool of objects that is communicated with via channels
-
readlock
A weird alternative to Arc<RwLock<T>>
-
parallel-sh
Execute commands in parallel
-
disruptor
Low latency inter-thread communication via a ringbuffer (inspired by the LMAX Disruptor)
-
append-only-vec
Append-only, concurrent vector
-
futures-util
Common utilities and extension traits for the futures-rs library
-
concurrent-queue
Concurrent multi-producer multi-consumer queue
-
happylock
Free deadlock prevention
-
pausable_clock
A source of time information that can be paused and resumed
-
ocl
OpenCL bindings and interfaces for Rust
-
crossbeam-utils
concurrent programming
-
infinitree
Embedded, encrypted database with tiered cache
-
rs-store
Redux Store for Rust
-
st3
A very fast lock-free, bounded, work-stealing LIFO queue
-
ringbuffer-spsc
A fast thread-safe single producer-single consumer ring buffer
-
oqueue
Non-interleaving multithreaded output queue
-
pueue
A cli tool for managing long running shell commands
-
irondash_run_loop
Consistent, platform-independent interface to system run loop
-
rskafka
A minimal Rust client for Apache Kafka
-
deqp-runner
A VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline
-
evolution
Efficiently evolve your old fixed-length data files into modern file formats
-
mea
A runtime-agnostic library providing essential synchronization primitives for asynchronous Rust programming
-
grip-grab
A faster, more lightweight ripgrep alternative
-
sync_file
Files that can be read concurrently
-
rearch
Re-imagined approach to application design and architecture
-
recloser
A concurrent circuit breaker implemented with ring buffers
-
rtsc
Real-time Synchronization Components
-
atomptr
A safe copy-on-write wrapper around
AtomicPtrwith some extra tricks -
atomicow
A
Cow-like data structure where owned data is stored inside anArc -
inline-array
efficient immutable inlinable byte array
-
mcslock
Mellor-Crummey and Scott contention-free lock for mutual exclusion, referred to as MCS lock
-
fast-able
The world's martial arts are fast and unbreakable; 天下武功 唯快不破
-
ordered-channel
A channel that always receives messages in the correct order, even if they were sent out of order
-
gabriel2
Indeed, an actor library based on Tokio, written in Rust
-
p3-maybe-rayon
Feature-gated wrapper around rayon
-
tsuki-scheduler
light wight, composable and extensible scheduler for every runtime
-
boxcar
A concurrent, append-only vector
-
io-reactor
Concurrent I/O resource management using reactor pattern
-
threadbound
Make any value Sync but only available on its original thread
-
ruva
Event Driven Message Handling
-
pi_share
rc, arc, lock, atomic
-
synchronoise
Synchronization primitives that build upon the standard library
-
scx_rustland
BPF component (dispatcher) that implements the low level sched-ext functionalities and a user-space counterpart (scheduler), written in Rust, that implements the actual scheduling policy…
-
paradis
Parallel processing with disjoint indices
-
rcu_cell
a lockless rcu cell implementation
-
resilient-rs
fault tolerance, including retry strategies, backoff mechanisms, and failure handling
-
beekeeper
A full-featured worker pool library for parallelizing tasks
-
rsevents
Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores
-
atomic-dbg
Atomic
dbg/eprintln/eprintmacros -
trauma
Simplify and prettify HTTP downloads
-
thread-id
Get a unique thread ID
-
minstant
A drop-in replacement for
std::time::Instantthat measures time with high performance and high accuracy powered by TSC -
orx-concurrent-iter
A thread-safe and ergonomic concurrent iterator trait and efficient lock-free implementations
-
loole
A safe async/sync multi-producer, multi-consumer channel
-
batch-aint-one
I got 99 problems, but a batch ain't one
-
renege
Tracking cache validity using fast concurrent invalidation propogation
-
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
-
nbio
Non-Blocking I/O
-
krecik
Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL
-
progress-token
tracking progress of long-running tasks
-
sharded_mutex
No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.
-
pbrt-r3
pbrt-v3
-
thingvellir
a concurrent, shared-nothing abstraction that manages an assembly of things
-
protoflow
implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
pi_arr
lock-free & auto-expansion array
-
mpsc
mpsc channel
-
melodium
Flow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely
-
actify
An intutive actor model with minimal boilerplate
-
atom_box
A safe idiomatic Rust implementation of Atomic Box using hazard pointers
-
concurrent_arena
u32 concurrent insertion/removal arena that returns ArenaArc
-
leapfrog
A fast, lock-free concurrent hash map
-
task-local-extensions
Task-local container for arbitrary data
-
wd_tools
tools for rust
-
speare
actor-like thin abstraction over tokio::task and flume channels
-
rush_expr_engine
The rules engine is based on the rete algorithm
-
ofilter
fast thread-safe Bloom filter
-
omango
Concurrency collections
-
syndicate-tools
Syndicate command-line utilities
-
pariter
Parallel iterator processing
-
spinning_top
spinlock crate based on the abstractions provided by
lock_api -
fast-stm
Performance-focused implementation of software transactional memory. Allows composable atomic operations
-
ptr_cell
Thread-safe cell based on atomic pointers
-
schedules
A lightweight Rust library for managing operations across multiple time scales
-
atomic-arena
Generational arena that allows reserving keys from other threads
-
async-local
For using thread locals within an async context across await points
-
atomic-take
Atomically take a value out of a container once
-
apocalypse
actor framework for Rust
-
aarc
Atomically updatable variants of Arc and Weak for lock-free concurrency
-
picomux
A protocol to multiplex multiple AsyncRead/Write streams over a single one, inspired by smux and http2
-
acton-core
Acton Core provides the core functionality and abstractions used by the Acton Reactive crate. It includes the essential building blocks for creating reactive and distributed systems.
-
lock-hierarchy
Prevent dead locks by enforcing lock hierarchies
-
simple_coro
(ab)using async/await to write simple state-machine based coroutines
-
splaycast
Stream-specific broadcast channel
-
no_deadlocks
A Runtime Deadlock Debugger
-
openfga-client
Type-safe client SDK for OpenFGA with optional Authorization Model management and Authentication (Bearer or Client Credentials)
-
buffet
Thread-local buffer pool for the
loonacrate -
choir
Task Orchestration Framework
-
lockmap
A high-performance, thread-safe HashMap implementation for Rust that provides fine-grained locking at the key level
-
jod-thread
std::thread which joins on drop by default
-
nexus-actor-core-rs
Core library for Nexus Actor
-
gettid
Helper to get an integer ID for the current thread
-
desync
A hassle-free data type for asynchronous programming
-
shmap
A key-value store based on linux shared-memory files (shm) for persisting state across program restarts
-
alopt
providing efficient synchronization primitives that integrate Option into their design
-
defer-drop
Defer dropping large types to a background thread
-
atom
A safe abstraction around AtomicPtr
-
arccstr
Thread-safe, reference-counted null-terminated immutable strings
-
elysees
A fork of triomphe, now with more pointer trickery
-
mutex
An abstraction over closure-based mutexes
-
ballista
Distributed Compute
-
potential
PubSub lib with sync and async API
-
magnetic
Low-latency lock-free queues
-
rw-cell
Write data to cell from anything place your application without copy, lock and reading in one place
-
sync42
synchronization tools
-
atomic_once_cell
Thread-safe and lock-free OnceCell and Lazy
-
mintex
minimal mutex
-
keepcalm
shared types for multi-threaded programs
-
fdup
find duplicate files recursively and in parallel
-
prun
Run 🍺
-
reactivate
Thread Safe Reactive Data Structure. Made with ❤️ for 🦀
-
amfiteatr_core
A framework to model and simulate game theory problems with many agents
-
locktick
Automated lock accounting & profiling
-
pi_atom
The global thread safe atomic string pool reduces the memory occupation of the same string and is also used for HashMap keys
-
gasket
Staged Event-Driven Architecture (SEDA) framework
-
lever
Pillars for Transactional Systems and Data Grids
-
liner_broker
Redis based message serverless broker
-
voice-stream
Voice stream is a real-time audio stream processing with voice activity detection. This library provides a high-level interface for capturing audio input, performing voice detection using Silero VAD…
-
atomic-shim
Atomic types for unsupported platforms
-
bcast
Low latency broadcast (SPMC) buffer designed to work with shared memory
-
simd-itertools
SIMD-accelerated alternatives for common operations like contains, max, find etc
-
file-per-thread-logger
A logging implementation that writes logs in one file per thread
-
balter
A load/stress testing framework
-
tonari-actor
A minimalist actor framework aiming for high performance and simplicity
-
oneshot-uniffi
Patched version of oneshot specifically for the UniFFI project. This removes the
loomtarget and dependency which helps with UniFFI’s downstream consumers -
winmsg-executor
Per-thread async rust executor for windows
-
batch-processing
A batch library for processing a list of items in parallel
-
txn_lock
support transactional versioning
-
swap-buffer-queue
A buffering MPSC queue
-
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.
-
pubsub-bus
Thread-safe one-to-many publish-subscribe event system. Simple and easy to use. It just works (hopefully).
-
rose_bloom
A concurrent growing element size linked list with stable pointers
-
rc_event_queue
VecDeque-like fast, unbounded, FIFO, concurent read-lock-free message queue
-
virtual-buffer
A cross-platform library for dealing with buffers backed by raw virtual memory
-
append-only-bytes
Shareable append-only bytes
-
sovran-arc
Memory management swift-isms brought to Rust
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
channel
Rust advanced queue library
-
mpsc_requests
mpsc channels but with a response
-
cfavml
CF's Accelerated Vector Math Library providing SIMD optimzied routines for vector operations
-
portable_atomic_enum
An attribute to create an portable atomic wrapper around a C-style enum
-
commonware-runtime
Execute asynchronous tasks with a configurable scheduler
-
slog-atomic
Atomic run-time controllable drain for slog-rs
-
lock-free-static
Lock-free static variables
-
api-rate-limiter
rate limiter for Rust APIs
-
samsa
Rust-native Kafka/Redpanda protocol and client implementation
-
utils-atomics
Various atomic utils
-
freactor
A lightweight framework for asynchronous execution flow
-
blazemap
Implements a vector-based slab-like map with an interface similar to that of HashMap, and also provides tools for generating lightweight identifiers that can be type-safely used as keys for this map
-
semka
Semaphore implementation
-
blazingqlog
QUIC QLOG parser written in Rust
-
linked
Create families of linked objects that can collaborate across threads while being internally single-threaded
-
node-replication
An operation-log based approach that transform single-threaded data structures into concurrent, replicated structures
-
round_mult
A tiny library to round a number up or down to a multiplier
-
par_slice
Slices that may be accessed from multiple threads with different levels of safety
-
maelstrom-worker-child
Helper library for maelstrom-worker
-
per-thread-mutex
Synchronization lock designed for wrapping thread-unsafe C libraries
-
wipe-on-fork
A replacement to OnceCell, LazyCell, Once, OnceLock, LazyLock that wipes itself when being forked in Unix
-
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
-
blocking-threadpool
A thread pool for running a number of jobs on a fixed set of worker threads
-
amity
Concurrency algorithms
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
sharded-vec-writer
Write parts of a Vec from different threads
-
async_once
async once tool for lazy_static
-
swimos_sync
SwimOS Synchronization Channels
-
rust_supervisor
An Erlang-inspired process supervision library for Rust
-
svix-ksuid
A pure Rust and fully tested KSUID implementation
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
rsvow
A Rust-like implementation of JavaScript's Promise mechanism
-
replay-channel
A broadcast channel where new receivers replay all past messages before receiving new ones
-
stdout-channel
Write stdout to an async queue
-
atomx
Thread safe data structures based on atomic data types
-
io-pipe
A fast and thread-safe library for creating multi-writer and single-reader pipelines in Rust
-
papaya
A fast and ergonomic concurrent hash-table for read-heavy workloads
-
tlrepo
Thread-local git2::Repository, shareable across threads
-
async-signals
easier and safe Unix signal handling with async Stream
-
sigq
Queue that signals waiting consumers about node availability
-
mpmc-async
A multi-producer, multi-consumer async channel with reservations
-
rusturnate
A sync or async mutex, with or without timeouts
-
parallel-stream
Data parallelism library for async-std
-
atomic-wait
Cross-platform atomic wait and wake (aka futex) functionality
-
k-lock
A fast mutex for short critical sections
-
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…
-
treiber_stack
A lockless, thread-safe, atomic linked-list
-
command_history
managing command history in Rust applications
-
may_actor
Actor library based on MAY
-
amadeus
Harmonious distributed data processing & analysis in Rust. parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common crawl
-
maybe-rayon
Either acts as rayon or creates a single-threaded facade
-
iterator_ilp
Iterator extensions for instruction-parallel reductions
-
someday
Lock-free MVCC primitive
-
nexus-actor-utils-rs
Nexus Actor
-
xstm
A Rust-implemented Software Transactional Memory (STM) library using TL2 (Transactional Locking II) algorithm
-
active_standby
A concurrency primitive for high concurrency reads
-
evtcall
Rust Event Driven Framework
-
split_channel
stream-of-messages abstraction with split send/recv channels
-
real-time
Safely share data with a real-time thread
-
disruptor-rs
A high-performance ring buffer implementation of the LMAX Disruptor pattern
-
td_rthreadpool
thread wrapper for Rust
-
onering
High throughput synchronous queue
-
oscd
interactive OSC (Open Sound Control) debugger for terminal
-
atomic-destructor
Atomic destructor for multi-threaded env
-
pawawwewism
a wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3
-
twinsies
Smart pointer providing 2-way joint ownership of an object
-
pacwrap-agent
Executable agent for conducting containerized transactions
-
orama-js-pool
Create a pool of JavaScript engines to invoke JavaScript code concurrently
-
debugrs
logger that mimics the npm debug module
-
merge-streams
Merge multiple streams into one
-
watchable
RwLock-like type that is compatible with both multi-threaded and async code
-
myriam
Actor model implementation for local and remote actors
-
patrolilo
Job scheduler with integrated NTFY notifications
-
crossfire
channels for async and threads
-
rust_kits
kits
-
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
-
atomic_enum
An attribute to create an atomic wrapper around a C-style enum
-
init-once
Concurrent, non-blocking lazy initialization of values
-
antidote
Poison-free versions of the standard library Mutex and RwLock types
-
visa-device-handler
handle NI-VISA connections and simplify its use
-
orx-parallel
A performant and configurable parallel computing library for computations defined as compositions of iterator methods
-
forte
A low-overhead thread-pool with support for non-static async closures
-
multi-readers
Combining multiple readers
-
pargraph
Operator based parallel graph processing
-
sovran-state
state management for Rust
-
streameroo
Compilation of mini-frameworks & utilities for data-streaming applications
-
armc
that facilitates Mutex access to variables
-
acto
light-weight Actor library for Rust
-
thread_local_collect
Supports the collection and aggregation of thread-local data across threads
-
atomic-counter
Atomic (thread-safe) counters for Rust
-
pochta
Addressable channel registry
-
xstream-util
A command line tool to split a stream to child processes
-
latches
A downward counter (CountDownLatch) which can be used to synchronize threads or coordinate tasks
-
parallel_worker
A parallel worker implementation in Rust. Allows to start tasks in parallel and receive the results blocking or non-blocking.
-
smolscale2
hitdns fork of original smolscale
-
flawless
Toolkit for writing durable execution workflows in Rust
-
future-local-storage
An init-once-per-future cell for thread-local values
-
orx-concurrent-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance concurrent collection
-
electrologica
High performance concurrent primitives for Rust
-
rearch-tokio
Re-imagined approach to application design and architecture
-
shipyard_scenegraph
Scenegraph for Entity Component System
-
spmc
channel
-
listfree
lockfree prepend-only list
-
pijul
A distributed version control system
-
signals2
A thread-safe signal/slot library inspired by boost::signals2
-
scored_set
A scored sorted set data structure for Rust
-
topograph
A miniscule thread pool and toposort scheduler
-
spawns-compat
Async runtime detections for thread context task spawner
-
async-atomic
Atomics which can be subscribed to and asynchronously notify when updated
-
asyncgit
allow using git2 in a asynchronous context
-
par-iter-sync
Parallel Iterator With Sequential Output
-
sea-streamer-fuse
Stream processing toolbox
-
unlock
Instrumented synchronization primitives helping you to unlock performance issues
-
concurrent-slotmap
A lock-free concurrent slotmap
-
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
-
night
A scalable Task Queue for executing asynchronous tasks in topological order
-
kueue
A robust, user-level, work-stealing, distributed task scheduler
-
qeztorncodegen
* The development of Torn's API v2 is still ongoing. * If selections remain unaltered, they will default to the API v1 version. * Unlike API v1, API v2 accepts both selections and IDs as path and query parameters…
-
open-coroutine-hook
The syscall hook for open-coroutine
-
freezebox
deref'able lazy-initialized container
-
tensr
A high-performance, cross-platform, multi-backend tensor/array library for Rust
-
parallel-processor
Framework to manage asynchronous execution of multiple compute units communicating using messages
-
atomic-interval
A tiny implementation of an atomic timer
-
aranya-util
needed by other Aranya crates
-
floxide-event
Event-driven node abstractions for the floxide framework
-
atomic_pincell
Threadsafe pinnable RefCell
-
rayon-progress-bar
work-stealing parallelism for Rust
-
vlock
A fast and scalable multi-version shared state lock with wait-free read access
-
with_daemon
An async client-daemon abstraction framework
-
ruget
Alternative to wget written in Rust
-
simple-semaphore
🔐 A lightweight implementation of a Semaphore in Rust
-
perthread
ThreadMap structure for accessing PerThread thread local variables form a static context
-
task_pool
Flexible abstraction for task-based composable multithreading
-
parallel_operations
perform binary operations in parallel using threads
-
crossbeam-skiplist-mvcc
Support MVCC (Multiple Version Concurrent Control) for
crossbeam-skiplist -
livekit-runtime
Async runtime compatibility layer for LiveKit
-
raw_sync_2
Lightweight wrapper around OS synchronization primitives
-
crossbeam-queue
Concurrent queues
-
kvdb-lib
thread-safe key-value storage library using DashMap
-
arcu
An Rcu implementation using an Arc to keep the read critical section short and handle cleanup
-
devproxy
A local development proxy for testing different network conditions
-
atomicbox
Safe atomic pointers to boxed data
-
permit
A struct for cancelling operations
-
global_counter
Global, thread-safe counters
-
direct_ring_buffer
A high-performance, lock-free ring buffer for single-producer, single-consumer scenarios
-
atomicell
Multi-threaded RefCell on atomics
-
simple-left-right
Lockfree, realtime safe and copy-free Synchronisation
-
lockfree
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
xarray
version of the XArray with copy-on-write capabilities
-
range-lock
Range lock for std::vec::Vec
-
lock_free_hashtable
Lock-free (almost) insertion only hashtable
-
conquer-once
Synchronization primitives for lazy and one-time initialization
-
rufutex
Ulrich Drepper's mutex using futex implementation in Rust
-
logisheets_controller
the core of LogiSheets
-
fluxion
actor framework written in rust and designed for distributed systems
-
circ
Efficient referenced counted pointers for non-blocking concurrency
-
lvm-sys2
LVM FFI bindings
-
work-queue
A concurrent work-stealing queue for building schedulers
-
pptr
Type-Driven Asynchronous Actor Runtime
-
que
A high performance channel with optional backpressure, interprocess capability, and a multiconsumer mode
-
snowdon
A lightweight thread-safe snowflake ID implementation for Rust
-
openshmem-rs
Wrappers for the OpenSHMEM API
-
kontroli
Type checking for the lambda-Pi calculus modulo rewriting
-
logfather
straightforward logging library for Rust
-
sync-arena
thread-safe arena allocator
-
multipool
A configurable thread pool with optional work-stealing support and task priority scheduling
-
affinitypool
running blocking jobs on a dedicated thread pool with CPU core affinity
-
benjamin_batchly
Low latency batching tool. Bundle lots of single concurrent operations into sequential batches of work.
-
thread-executor
Lightweight futures executor using std::thread::park
-
tracing-mutex
Ensure deadlock-free mutexes by allocating in order, or else
-
parallely
command line process parallelization executor
-
mini-tokio
basic asynchronous rust executor
-
dag-scheduler
a scheduler of dag computation graph
-
danube-client
The async client for Danube Messaging Broker platform
-
sentry_arroyo
working with streaming data
-
par
Session types, as an implementation of linear logic with MIX
-
act-zero
Ergonomic actor system
-
async_chanx
Implement
Sinkfor some channel implementations -
buf-mutex
Buffered mutexes
-
debouncer
A simple debouncer for Rust
-
high-level-kafka
High Level Kafka client for Rust
-
mq
Message Queue
-
throttle-client
Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.
-
peachy
async task manager, similar to thread pool but cooler and for structs
-
kekbit
Ultralight persistent data channels
-
peace-lock
A zero-cost abstraction lock that helps check contention free algorithms
-
local-sync
Non-threadsafe data structure for async usage
-
sync-cell-slice
Cells and slices that are accessible from multiple threads
-
nexus-actor-remote-rs
Remote library for Nexus Actor
-
smart_channel
channel subscription system
-
cond_sync
Hides the boilerplate code needed with std::sync::Condvar
-
sinner
Easy cross-thread resource sharing for Rust!
-
xenevtchn
Rust bindings for Xen event channel API
-
whisk
fast lockless async channels
-
atomicring
AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer
-
progpool
Job pool with terminal progress bar
-
bastion
Fault-tolerant Runtime for Rust applications
-
ebr
epoch-based reclamation with low cacheline ping-pong
-
pinned-mutex
Mutex wrappers with structural pinning
-
EMCompute
fast , simple and cross-platform parallel computing library
-
congestion-limiter
Dynamic congestion-based concurrency limits for controlling backpressure
-
namaste
-
adaptive-barrier
Barrier with adaptable number of thread subsciptions
-
async-sema
Async semaphore library
-
parascope
Weggli ruleset scanner for source code and binaries
-
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
-
fork-map
running operations in a child process spawned by
fork() -
mailboxxy
micro actor library for rust
-
print_queues
A print queues that can be add from different thread and print on main thread
-
amfiteatr_classic
some classic game theory problems to research on
-
tc-transact
Traits and locking utilities for a TinyChain transaction
-
ballista-scheduler
Ballista Distributed Compute - Scheduler
-
tokio-cadence
Tokio-based metric sinks for Cadence
-
putex
process mutex
-
send_cells
Safe and unsafe cells implementing Send/Sync
-
dpc-pariter
Parallel iterator processing
-
bound
Wrap lock guards and other structs along with the locks or other data they are derived by shared reference from, in a struct you can pass around and store anywhere
-
thread_map
Types that are simple and easy-to-use alternatives to the
std::thread_localmacro -
can_adapter
load CAN adapters typically used to diagnose vehicles
-
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.
-
bus_queue
Lock-free Bounded non-Blocking Pub-Sub Queue
-
constellation-rs
Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs
-
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…
-
halt
functionality for pausing, stopping, and resuming iterators, readers, and writers
-
pi_append_vec
Only supports append vectors, lock free
-
parallel-future
fluent async task experiments
-
erl_nif
Write Erlang and Elixir NIFs in Rust
-
rayon-cancel
An adapter to interrupt rayon parallel iterators
-
x32_osc_state
X32 State Tracker via Open Sound Control
-
watch
A synchronous message passing channel that only retains the most recent value
-
orchestrator_lock
A Mutex whose access order is managed by a separate thread
-
interaction-calculus
A parallel model of computation
-
usync
fast, drop-in, synchronization primitives
-
zallocator
Amortizes the cost of small allocations by allocating memory in bigger chunks
-
session_types
session types in Rust
-
disrustor
This project is a port of the LMAX Disruptor to Rust
-
thread_tryjoin
Try joining a thread
-
nullnet-libtunnel
tunneling traffic
-
dynamic_services
A dynamic services injection framework
-
atomicoption
An atomic, nullable, owned pointer
-
infinitree-backends
Embedded, encrypted database with tiered cache -- backends
-
miyabi_scheduler
Thread pool scheduler with extra specific abilities
-
augmented-atomics
Implements some extra types and utilities over atomics for building audio-thread / GUI synchronization
-
clhlock
Craig and, indenpendently, Magnussen, Landin, and Hagersten queue lock for mutual exclusion, referred to as CLH lock
-
neon-runtime
Bindings to the Node.js native addon API, used by the Neon implementation
-
logical-expressions
working with logical expressions
-
employees
A small runtime that hides all the boilerplate when using threads
-
redlock
distributed locking mechanism built on top of Redis
-
atomiclock
A non-blocking lock that can be used in async contexts
-
caos
Concurrent Append Only Segment-list
-
rgraph
A task graph library
-
thread-counter
way of efficiently keeping track of active threads and waiting for them to exit
-
norpc
Framework for in-process microservices
-
umpx
Collection of ump extensions
-
arthouse
Art-Net (DMX over UDP/IP) adapter for Project Lighthouse
-
byte-pool
Pool of byte slices, for efficient memory usage
-
fslock-arti-fork
files as locks, forked for use in Arti
-
poll-channel
Poll on channel
-
hopper
an unbounded mpsc with bounded memory
-
seqlock
A reader-writer lock that provides extremely fast read access without starving writers
-
crossbeam-deque
Concurrent work-stealing deque
-
oricalchum
A lightweight actor model
-
notify-future
Support asynchronous notification completion future
-
kincir
message streaming library inspired by Watermill
-
ringbuf-blocking
Blocking version of ringbuf
-
protoflow-syntax
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
async-skipdb
An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine
-
easy-threadpool
A relatively simple thread pool which you can send jobs to
-
take-once
A thread-safe container for one-time storage and one-time consumption of a value
-
global-channel
global channels
-
jumphash
A Fast, Minimal Memory, Consistent Hash Algorithm
-
stakker_log
Logging support for Stakker
-
classic-sync
ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems
-
bztree
BzTree implementation for Rust
-
tokio-scheduler-types
Types for tokio-scheduler-rs
-
moro
Experimental structured concurrency support for async Rust (similar to trio's nurseries)
-
diplomatic-bag
A wrapper type that allows you to send
!Sendtypes to different threads -
eventbus-tiny
A small, dependency-free crate that provides a multi-producer broadcast-consumer event bus
-
noir-compute
Network of Operators In Rust
-
blackhole
...to throw your threads into
-
goko
A lock-free, eventually consistent, concurrent covertree
-
folklore
A lock-free concurrent hash map
-
readlock-tokio
A weird alternative to Arc<RwLock<T>>, using tokio's RwLock
-
pinboard
A lock-free, threadsafe way to publish data, just stick it on the pinboard
-
fenris-paradis
Parallel processing of disjoint indices for the fenris library
-
apalis-core
Core for apalis: simple, extensible multithreaded background processing for Rust
-
mop
Flexible and modular single or multi-objective solver for contiguous and discrete problems
-
skedge
Ergonomic single-process job scheduling for Rust programs
-
thread-manager
A streamlined Rust library for efficient thread pooling and parallel job execution, designed for simplicity, flexibility, and performance
-
may_queue
May's internal queue library
-
stm
Software transactional memory. Allows composable atomic operations.
-
safe-fork
A tiny library providing
forkto safe Rust -
ufotofu_queues
Infallible queues that support bulk enqueueing and dequeueing
-
mwcas
Multi-word CAS primitive
-
syncthreads
Safe thread synchronization
-
nblock
Non-Blocking Runtime
-
yaambo
concurrent skip lists
-
carpet
A thread-safe, fully-parallel directed graph
-
entro-spin
Entro Spin is a 64-bit, true-random number generator algorithm
-
mtlog
Multi-threaded logger with support for log files
-
ump
Micro message passing library for threads/tasks communication
-
synchronized
Convenient and simple macro for code synchronization in multithreading
-
irox-threading
Blocking and Asynchronous Threading Tools
-
platoon
An experimental mini async runtime
-
rusty_junctions
Join Pattern implementation in Rust
-
sparking-lot-core
parking on addresses
-
lotsa
Execute lots of operations spread over any number of threads
-
taskalicious
Common Rust task workers
-
critical-once-cell
Thread-safe OnceCell and Lazy backed by critical section
-
aranya-afc-util
using Aranya Fast Channels
-
flashmap
A lock-free eventually consistent concurrent hash map
-
either-slot
An atomic slot whose senders can either place their value into the slot, or retrive all the data from the slot
-
queued_rust
queue type for better privacy managment and data orginization
-
rust-toolchain
Types to model a Rust toolchain
-
uflow
ordered, mixed-reliability, and congestion-controlled data transfer over UDP
-
smartpool
A very customizable, future-aware threadpool
-
snarc
Sendable Non-Atomically Reference Counted
-
rcu_list
a lockless concurrent list implementation
-
sti
STd Improved
-
simpl_actor
tokio actors
-
lock_ext
Extensions to std::sync::Mutex
-
threadpool-executor
A threadpool executor
-
crossbeam-skiplist-fd
A long-term maintained forked version of the crossbeam-skiplist for supporting more flexible key comparison customization
-
fast-counter
A sharded concurrent counter
-
sentinel-core
The flow sentinel of your microservices
-
lfchring
Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication
-
invocation-counter
Datastructure to answer to: how many times a function has been called in the last X minutes?
-
ora-worker
Part of the Ora scheduler framework
-
fast-async-mutex
lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)
-
kademlia-dht
Kademlia DHT
-
may_waiter
coroutine communication blocker
-
del-cudarc
funcs for cudarc
-
tc-scalar
TinyChain's scalar value enum, including concurrently-resolvable op definitions and references
-
left-right-cell
A cell with lock-free concurrent read access
-
threadcell
A cell whose value can only be accessed by a owning thread
-
tlid
Thread Local ID generator by predefined range without atomics/locks/random/time
-
ipmpsc
Inter-process Multiple Producer, Single Consumer Channels
-
asyncified
A small library for operating on long lived sync values in an async context
-
sync_2
A little crate providing a Rust implemented Mutex and RwLock
-
flue
An efficient and secure actor runtime library
-
spring-stream
Integrate sea-streamer with spring-rs
-
simplelock
abstractions for inter-process synchronization
-
tokio-etcd-lock
WIP
-
deborrow
Splits mutable references safely into their fields, and helps with reference manipulation
-
spsc-ringbuf-core
Heapless ring buffer
-
atomic-waitgroup
A waitgroup implementation supports async with advanced features
-
leaklist
concurrent, lock-free, singly-linked list
-
stuck
Multi-threading scheduled task facility building on cooperative stackful coroutine
-
microlock
waiting: Small locks and other timing things!
-
sas
Salty-and-Sweet one-line Rust Runtime Performance Optimization Library
-
lock_tree
Prevent deadlocks at compile time. A standalone republication of the netstack3 lock-ordering crate, part of Google's Fuchsia OS.
-
gamozolabs/kernel
Pure Rust x86_64 bootloader and kernel
-
zkstate
Share a struct across multiple instances of an application using zookeeper
-
rsevents-extra
Synchronization objects built on top of rsevents. Semaphore, countdown event, and more.
-
lariv
Linked Atomic Random Insert Vector: a thread-safe, self-memory-managed vector with no guaranteed sequential insert
-
cuneiform-fields
Field level [no_std] cache optimizations for Rust
-
mscheduler
Use mongodb to schedule task running
-
ordered-parallel-iterator
Performs tasks in parallel returning completed tasks in order of appearance
-
bevy_gpu_compute
Empowering anyone to leverage GPU-acceleration with as little barrier-to-entry as possible
-
tagged-rendezvous
Rendezvous hashing with support for tag-based exclusions
-
fast-logger
Fast logger for Rust
-
ring-channel
Bounded MPMC channel abstraction on top of a ring buffer
-
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.
-
handoff
An unbuffered, asynchronous, single-producer/single-consumer channel
-
vin
An ergonomic actor framework
-
rayon-wasm
work-stealing parallelism for Rust
-
runloop
Cancelable non-blocking polling threads (with optional timeouts)
-
uppercut
Small and simple actor model implementation
-
squeue
sized queue
-
yaks
Minimalistic framework for automatic multithreading of hecs via rayon
-
nyoom
A filesystem walker for floppy-disk
-
take_put_back
A common abstraction of the process of taking some piece out, processing it and then putting it back
-
xrm
Cross Runtime Manager
-
threadsafe_zmq
Threadsafe zeromq
-
mbarc-map
Minimally-blocking, Atomic Reference Counted Map
-
aligned-task-scheduler
A scheduler that runs tasks at exact minute intervals with an optional offset, ensuring tasks are aligned to precise time boundaries
-
graph_csr
that provides utility functions for manipulating graphs in a CSR format, used as the baseline for constructing powerful graph algorithms
-
xloc
A fast, multi-threaded line counting utility written in Rust
-
rtfm-syntax
The Real Time for The Masses (RTFM) meta language
-
genzero
that lets you get the latest value of a type
-
multithreading
in Rust
-
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
-
sender-sink
classes for working with tokio UnboundedSender and the Sink trait
-
pipe-channel
Channel implementation based on pipes
-
tokio-prometheus-metered-channel
Metered tokio channels with Prometheus metrics integration
-
flo-state
Lightweight actor library
-
redsync
Redlock for distributed locks with Redis
-
gpgpu
WIP GPGPU framework built on top of wgpu
-
mogul
Agnosticly helps to manage concurrent versions of things
-
ratelimit_meter
A leaky-bucket-as-a-meter rate-limiting implementation in Rust
-
async-datachannel
Async Wrapper for datachannel
-
oxidator
A reusable LMAX Disruptor Implementation in Rust
-
remutex
Recursive mutex, adapted from Rust's standard library
-
left-right
A concurrency primitive for high concurrency reads over a single-writer data structure
-
stdworld
signal-safe std replacement
-
parseq
Parallel sequential iterator
-
bi
-
chute
Lockfree mpmc/spmc broadcast queue
-
tourniquet
Async native round-robin manager for remote services
-
packed-atomic
get any time access to atomic values
-
phazer
Two-phase commit for file creation
-
cooptex
Deadlock free Mutexes
-
fast-smr
Toward fast, wait-free, portable, and robust memory reclamation
-
striped-lock
Striped Lock for Rust
-
ns3-parallel
A Multitask Parallel Concurrent Executor for ns-3 (network simulator)
-
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!)
-
two_phase_channel
A safe synchronisation-free parallel communication channel by statically forbidding conflicting accesses
-
sea-streamer-socket
🌊 SeaStreamer backend-agnostic Socket API
-
unbounded-spsc
An unbounded spsc queue built from
bounded_spsc_queues -
omango-futex
Futex for Rust
-
periodically
running tasks on a schedule
-
dropout
Drop your objects out of main thread
-
mongo_sync
instant coding answers via the command line(just like howdoi)
-
quickwit-actors
Actor framework used in quickwit
-
parsli
Parallel status lines for Rust
-
vigil
liveness checking watchdog for detecting deadlocks/livelocks/starvation etc
-
sortlock
providing ordered locking
-
with_lock
Deadlock freedom
-
dager
create and execute a graph of nodes
-
actix-broker
Message broker for the Actix actor framework
-
little_raft
The lightest distributed consensus library. Run your own replicated state machine!
-
serviceless
actor model in rust, like actix
-
swapper
Swap ownership between threads
-
local_thread
A local thread management library for Rust. No more 'static functions in order to start threads!
-
sharded-offset-map
A map from u64 to T that can be written from multiple threads
-
maybe_parallel_iterator
Toggle parallelism with feature flags!
-
async-fifo
MPMC & oneshot channels with (a)sync API
-
client-handle
A macro to generate client handles when using multithreaded / asynchronous code
-
ev_slotmap
A lock-free, eventually consistent, concurrent slot map
-
big_data
Safe Rust code for creating Erlang NIF to store big data
-
terminate-thread
terminatable thread implemented with pthread
-
hebo
Distributed MQTT broker
-
cobalt-async
collection of helpful functions for working with async Rust
-
crossbeam-skiplist
A concurrent skip list
-
guest
By-value memory storage without by-value memory access
-
affair
A Tokio-based worker abstraction layer
-
hey_listen
An event-dispatcher-collection offering async, sync, parallel, and prioritised solutions!
-
threadstack
A more ergonomic and more flexible form of thread local storage
-
mth_calc
demonstrating Cargo. Contains helper method for running a process in parallel on all available processors.
-
cogo
Rust Coroutine Library like go
-
os-thread-local
OS-backed thread-local storage. This crate provides a
ThreadLocaltype as an alternative tostd::thread_local!that allows per-object thread-local storage, while providing a similar API… -
try-mutex
Fast non-blocking mutex
-
undead
search for dead code in your Python projects
-
ref-portals
Safely use (stack) references outside their original scope
-
spry
Resilient, self-healing async process hierarchies in the style of Erlang/OTP
-
boomerang
Deterministic Middleware for Robotics
-
evmap
A lock-free, eventually consistent, concurrent multi-value map
-
rearch-effects
Re-imagined approach to application design and architecture
-
skipchannel
skipchannels allow to communicate between threads, but always skip to the last sent value
-
godwit-daemon
A daemon runner for GodWit
-
stele
An atomic Vec-like structure with no copying on allocation
-
flo_stream
Pubsub and related streams for Rust futures
-
cht
Lockfree resizeable concurrent hash table
-
efflux
Easy MapReduce and Hadoop Streaming interfaces in Rust
-
threadalone
Make any value Send + Sync but only available on its original thread. Don't use on multi-threaded environments!
-
semalock
concurrently writing to files in a safe and efficient manner
-
semrs
A pure rust implementation of semaphores
-
pcp-mutex
A Priority Ceiling Protocol (PCP) mutex, based on Linux PI futex. Allows efficient and deadlock free execution.
-
atomic_cell
Lock-free thread-safe mutable memory locations
-
evlru
An eventually consistent LRU designed for lock-free concurrent reads
-
rhythm
Rate limiter which allows VIPs, written in Rust
-
hala-rs
Hala rust standard library facade
-
dynamic-pool
a lock-free, thread-safe, dynamically-sized object pool
-
asimov-flow
ASIMOV Software Development Kit (SDK) for Rust
-
parking_monitor
Parking-lot-flavored monitor synchronization construct
-
melodium-common
Common Mélodium elements and traits
-
read-write-store
A concurrent, unordered collection for Rust, where each element has an internally generated ID and a read-write lock
-
sharded_queue
ShardedQueue is currently the fastest concurrent collection which can be used under highest concurrency and load
-
tcb
A middleware service for delivering messages in a causal order
-
relaxed
Wrappers around Atomics that always use
Ordering::Relaxed -
brutils
Some utilities for Rust
-
sync_select
A short-circuiting (verbose)
std::thread::scope -
key-message-channel
Multi-producer single-consumer queue capable of queuing messages by message key
-
glock
Granular locking crate for Rust
-
datacake
A batteries included framework for building fault-tolerance distributed data systems
-
jthread
Deadlock-free Mutual Exclusion locks for Rust
-
rpar
Run terminal command multiple times in parallel
-
quickwit-indexing
Quickwit indexing
-
atomiclock_async
async lock
-
crosstalk
An extremely lightweight, topic-based, cross-thread, in-memory communication library
-
locker
named mutex/locker for rust-lang concurrency
-
wrrm
Write-rarely-read-many wrapper
-
RaceNG
Revolutionary, innovative, groundbreaking random number generator using race conditions
-
rt-history
An RT-safe history log with error checking
-
workpool
Distribute work to a set of threads and wait for completion
-
option-lock
mutex for Option values
-
pflock
A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.
-
unknownrori-simple-thread-pool
A lighweight thread pool for networking and other stuff
-
more-sync
More synchronization utils
-
asc
Atomic Strong Count
-
hvm-core
massively parallel Interaction Combinator evaluator
-
hyaline-smr
Garbage Collector(Hyaline- Safe Memory Reclaimation) for lock free data structures
-
parallel_reader
reading from a file (or any
Readstream) and processing it by chunks, in parallel -
hammer-cli
Hammer is a no-config cli tool for running concurrent tasks with monorepo support
-
hytra
Datastructure for fast multi-threaded updates
-
arc-cell
Helper for a simple Cell-like object containing Arc/Weak
-
agner-sup
An actor toolkit inspired by Erlang/OTP (supervisors)
-
chashmap
Fast, concurrent hash maps with extensive API
-
rcurs
An oxidized RCU implementation
-
portable-atomic-util
Synchronization primitives built with portable-atomic
-
exec-rs
that provides utility traits for task execution and, if the sync feature is enabled, the ability to synchronise tasks based on the value of a key
-
isilon
rest api bindings
-
jwalk
Filesystem walk performed in parallel with streamed and sorted results
-
priomutex
A mutex where waiting threads specify a priority
-
node-workers
A pool of long-lived nodejs workers
-
multi
An easy way to run multiple commands in parallel
-
peril
Fast and safe Hazard pointers for Rust
-
java-threadpool
这是一个跟java ThreadPoolExecutor线程池 使用方式基本相同的线程池
-
nysa
A bus for passing messages around between independent subsystems of an application
-
waitcell
A cell type containing a value which may not yet be available
-
base-coroutine
A fast and safe implementation of stackful coroutines with scheduler which supports preemptive scheduling
-
callback_cell
Like an Atomic<Option<Box<FnOnce()>>>
-
async_ach-waker
Async Atomic Channel
-
geese_pool
Message-passing system for networking with Geese
-
lending_thread_pool
A thread pool where workers can lend their data to their tasks
-
io_partition
allowing to use just a part of a Read + Seek object
-
lazy_ref
Implements a non-blocking synchronization primitive for lazy-initialized immutable references
-
discrab
Discord bot wrapper
-
db
Lightweight high-performance pure-rust transactional embedded database
-
conqueue
multi-producer, single-consumer queue (MPSC)
-
team
toolbox lib for fun
-
irondash_message_channel
Rust interface to irondash MessageChannel
-
menmos-std
Menmos library containing misc. reusable utilities
-
greenie
Green threads and coroutines in stable Rust
-
essential-lock
A minimal crate containing Essential's locking method that is safe to use in async code
-
lateral
process parallelizer to make lives better at the commandline
-
nvrtc
Bindings for NVIDIA® CUDA™ NVRTC in Rust
-
concurrency-demo-benchmarks
A small utility to benchmark different approaches for building concurrent applications
-
app_ctx
An AppCtx implementation in Rust, like ApplicationContext in SpringBoot
-
orx-concurrent-option
ConcurrentOption is a lock-free concurrent read and write option type
-
atomiq
Convenient tool for atomics in Rust
-
bmrng
async MPSC request-response channel for Tokio
-
protex
(Process Mutex) concurrency in process level
-
cache-padded
Prevent false sharing by padding and aligning to the length of a cache line
-
operator-framework
Tools and helpers used to create Kubernetes operators
-
lockless
Composable, lock-free, allocation-light data structures
-
rendezvous_swap
Swap data and sync execution between a pair of threads efficiently
-
std-semaphore
A counting, blocking sempahore extracted from rust 1.7.0
-
autoincrement
wrapper for different purposes
-
dfmutex
Deadlock-free Mutex locks
-
distribuidos_sync
Sync common utils using standard library
-
proc-lock
cross-process locking API
-
opifex
Latin word meaning artisan or manufacturer and referring to a worker who created something
-
para
A dataflow/pipeline parallelization framework
-
highroller
high-level rolling index that is thread-safe and guarantees cheap runtime-unique IDs
-
rs_transducers
transducers for Rust
-
tomt_async
Primarily a dumping ground for personal async snippets that may be used in other ToMT projects. If this crate is useful to others please let us know.
-
proglog
Thread safe progress logging
-
testbench
Testing and benchmarking tools for concurrent Rust code
-
single_value_channel
Concurrent single-value update and receive channel
-
simt_cuda_sys
part of simt. cuda driver api bindings
-
oncemutex
A mutex providing one-time synchronized access, then safe unsynchronized access
-
shared-local-state
shared local state registry for use in EBR, IO, etc
-
rcu_128
RCU (Read-Copy-Update) implementation for platforms supporting atomic 128-bit operations
-
mutex-timeouts
let you specify a timeout on a mutex lock
-
opool
High-performance, lock-free local and concurrent object pool with automated allocation, cleanup, and verification
-
bursty
Test support for exarcebating contention in multi-threaded code
-
pinnable
A Mutex that can be pinned
-
atomic_prim_traits
Traits over primitive atomic types
-
managed-thread
Real fearless concurrency! Spawn threads that will be automatically destroyed when no longer needed
-
lockpool
offers a pool of locks where individual locks can be locked/unlocked by key
-
dynamic_ocl
Dynamically-loaded OpenCL bindings
-
crb-parallel
CRB | Composable Runtime Blocks | Parallel
-
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 -
todc-utils
building and testing distributed systems
-
constellation-internal
Common components for the
constellationframework -
name_locker
interface for asynchronous name lockers, that can run an async task with lock on a given name
-
protoflow-zeromq
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
try-rwlock
Fast non-blocking readers-writer lock
-
init_guard
A Synchronization Primitive for guarding against double initialization
-
concurrent_lru
A concurrent LRU cache
-
arrow-rayon
Use parallel iterators for Apache Arrow with rayon
-
atomic-hyperloglog
thread-safe hyperloglog, with atomics
-
queue-ext
The extended feature of the queue can convert the pop() function of the queue to Stream and the push() function to Sender
-
spawn_groups
Structured concurrency construct written in Rust, for Rustaceans
-
lock_many
Retry-based locking multiple mutexes at once
-
wasm-bindgen-rayon
Adapter for using Rayon-based concurrency on the Web
-
absinthe
Are you an Actor & Async junkie? Then your app needs some Absinthe!
-
lazy_id
A thread-safe lazily-initialized ID
-
deque
A (mostly) lock-free concurrent work-stealing deque
-
atomic_mut
that facilitates atomic operations on arbitrary structs
-
yanoo
Lock-free mpmc broadcast channel
-
hala-lockfree
Some lockfree structure for rust
-
aranya-daemon-api
UDS tarpc API between the Aranya client and the daemon
-
semaphore-key
control concurrent thread access by key using a shared semaphore
-
fan
Simplifies fanning-out (and eventually -in) with channels
-
pakr-fsm
Template to implement finite-state-machines
-
simt
compute support for rust
-
ero
Erlang-inspired framework for organizing async code in a fault-tolerant way
-
syncbuf
Append-only data structures with lock-free thread-safety and constant-time indexing
-
tokio-condvar
A Condition Variable for Tokio Applications
-
scheduler
Binding to set the linux scheduler (priority, policy, affinity, &c.)
-
mpi-fork-fnsp
Message Passing Interface bindings for Rust (FORK)
-
locklessness
Composable, lock-free, allocation-light data structures
-
botcore
Production-grade asynchronous bot engine with enterprise observability features
-
gosh-remote
Distributed parallel computing over multiple nodes
-
lofi
Low Overhead Fibers
-
shareable
Thread shareable objects using the minimal amount of synchronization
-
unsync_channel
!Send/!Sync channels for Rust
-
threadgroup
Manage groups of threads as one unit, join the first one that finishes, timeout on join attempts
-
atomicdouble
128-bit atomics for generic type
-
swap_channel
A safe lock-free parallel communication channel based on mem::swap
-
concurrent-slice
Extend slice-type types with methods for concurrent processing
-
slb
Sharded load balancing text-streaming Unix tool
-
mrsc
mpsc with requests
-
actress
actor library for Rust
-
rstreams
Async Stream-Processing toolkit with actor model flavor
-
sea-streamer-redis
🌊 SeaStreamer Redis Backend
-
ocl-interop
Creates an OpenCL Context with OpenGL Interop enabled
-
shared_resources
shared resources container which is thread-safe, and lock-free
-
idle
Collection of idle strategies to be used by thread(s) when they have no work to perform
-
ringbuf-basedrop
A fork of the
ringbufcrate that uses basedrop’s Shared pointer in place of Arc -
spliter
way to implement Rayon's ParallelIterator
-
ncd
Concurrency library
-
thread-lock
A wrapper that locks non-Send and non-Sync data to a specific thread
-
employer
Spawn worker threads and check on them later
-
shared_vector
Reference counted vector data structure
-
atomic_pingpong
Lightweight no_std ping-pong buffer, using AtomicU8 for synchronization
-
sesh
deadlock-free session-typed communication
-
process-sync
Synchronization primitives for multiprocess environments
-
amadeus-parquet
An Apache Parquet implementation in Rust
-
async_monad
Asynchronous monad for rust
-
ligmars
Safe bindings to the LGMP C library
-
jobsys
Lockless Work Stealing Job System
-
simdvec
Vectors, but with the operational speedup of SIMD!
-
nexus-acto-rs
Actors
-
acteur
A safe actor-like framework that just works. Simple, robust, fast, documented.
-
piz
piz (a Parallel Implementation of Zip) is a ZIP archive reader designed to concurrently decompress files using a simple API
-
CESE4015_Concurrency_RJN_JVL
This progrmam is a concurrent version of grep. It uses
-
zolegus
-
atomic-destroy
An value which can be atomically read and destroyed; like an atomic Option
-
ticketed_lock
Ticketed lock system - allows one to separate lock request from the actual waiting
-
tc-tensor
TinyChain's Tensor collection type
-
atomic-enums
atomic enumerations
-
threadfin
A thread pool for running multiple tasks on a configurable group of threads
-
threadling
Threads as traits
-
scrummage
Fight over OS process prioritisation
-
command-executor
Command Executor thread pool
-
sea-streamer-examples
🌊 The stream processing toolkit for Rust
-
rust-releases-core
Base traits and definitions for rust-releases
-
slacktor
extremely fast, bare-bones, low-overhead, supervisorless, no-std actor library
-
ulock-sys
Rust bindings for Darwin's (e.g. macOS, iOS, ...) not-entirely-public ulock API, which provides futex-like functionality.
-
concurrent-list
An append-only, single-writer multi-reader unrolled linked list
-
cpu-affinity
Cross-Platform CPU affinity
-
takecell
A cell type which value can only be taken once
-
wait_notify
a synchronization primitive for Rust that provides basic wait and notify functionality
-
chunklist
A Chunk List is a new, concurrent, chunk-based data structure that is easily modifiable and allows for fast runtime operations
-
one_at_a_time_please
For serialising calls to functions
-
foreback
Future adapters for running aditional work in the background
-
bustle
Benchmarking harness for concurrent key-value collections
-
sharded-slab
A lock-free concurrent slab
-
grandma
A lock-free, eventually consistent, concurrent covertree
-
sleepfast
Sleep for very small amounts of time quickly
-
channel-receiver
Channel Receiver
-
base-threadpool
minimalistic threadpool implementation
-
lock_pool
Robust, efficient, high performance, asynchronous object pooling
-
channel_io
Reader implementation on channel of bytes
-
bombs
Efficient single-producer multi-consumer channel types
-
object-space
An object store library for highly concurrent program written in Rust
-
async-map-reduce
Fast map-reduce based on threading
-
overdose
Fast, Row Oriented, Kotlin, Scala-like dataframe
-
stop-thread
Various ways of stopping threads on various platforms, without requiring the thread to poll
-
ductile
A channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface
-
pssh-rs
parallel ssh tool written in rust
-
shared-expiry-get
concurrent async get with expiration for Rust
-
sling
Sequentially lockign (SeqLock) Ring Buffer
-
threadmap
WIP
-
rayon-tlsctx
thread local contexts for rayon loops
-
PRUEBA
Colas tarea
-
mqb
Lock free in memory message queue broker
-
thread_isolated
Isolating values allowing access via closures run on an owning thread
-
ump-ngx
Collection of ump-ng extensions
-
async-mutex
Async mutex
-
async-events
Waiting for external task completion in asynchronous Rust code
-
multithread
API for data-parallel tasks, rayon-lite
-
stewart
A minimalist, high-performance, and non-exclusive actor system
-
status_executor
Run your work on some context (thread) and get status info back
-
uchan
Multi-producer single-consumer channel for message passing
-
minicoroutine
mini coroutine library in rust
-
oxidater
A reusable LMAX Disruptor Implementation in Rust
-
ste
A single-threaded executor with some tricks up its sleeve
-
atomic_box
A struct which allows multiple threads to safely update and read from a shared non-nullable pointer to heap data
-
parallel-iterator
Parallelize any iterator with ease!
-
task_log
Task based logging
-
breadcrumb_channel
Unbounded broadcast channel with clone-on-receive semantics
-
gaffer
Prioritised, parallel job scheduler with concurrent exclusion, job merging, recurring jobs and load limiting for lower priorities
-
nstd_thread
NSTD threading crate
-
dekker
Dekker's algorithm for mutual exclusion
-
atomic-try-update
Primitives that make it easy to implement correct lock-free algorithms
-
lockfree-ringbuffer
A lock-free ring buffer implementation in Rust
-
hdlibaflexecutor
libafl_cc compiled executor for LKL
-
conveyor_belt
Queue and batch processing library
-
bi_channel
Manage bidirectional mpsc channels more conveniently
-
tpool
So simple thread pool
-
persistent_stack
Concurrent persistent stack
-
maxwell-utils
Maxwell utils implementation for Rust
-
multiqueue2
A fast mpmc broadcast queue
-
channel-sender
Channel Sender
-
concurrency_traits
Traits for concurrent primitives
-
mlt-sys
Bindings for the MLT Multimedia framework
-
wasm_thread
An std thread replacement for wasm32 target
-
is_main_thread
A simply tool to check if current thread is the main one
-
shardize
proc macro that generates code to create a sharded form of an existing container
-
specs-static
extension for Specs that adds custom ids
-
gpca
'Async Hyper-Graph Cellular Automata' computational model
-
tucan
fast, and multithreaded interner with loose type requirement
-
canal
multithreaded concurrency primitives, including queues and channels
-
rustcbuildx
$RUSTC_WRAPPER tool to sandbox cargo builds and execute jobs remotely
-
rattler_repodata_gateway
interact with Conda repodata
-
atomiclock_spinlock
spinlock
-
core_affinity
Manages CPU affinities
-
twitch_api
talking with the new Twitch API aka. "Helix", EventSub and more!
-
hv-guarded-borrow
Traits and implementations for generic use of "guarded" borrows
-
htb
Hierarchical token bucket implementation
-
contrie
Concurrent map and set
-
rayon-scan
A parallel prefix scan function for ParallelIterator
-
kcas
A lock-free, allocation-free multi-word compare-and-swap library
-
cnr
An operation-log based approach for data replication
-
fiona
Concurrent runtime written against liburing
-
ora-api
Part of the Ora scheduler framework
-
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.
-
coarsetime
Time and duration crate optimized for speed
-
workerpool-rs
workerpool for rust
-
refcapsule
Safely send references to other threads
-
scherben-map
Concurrent Sharded HashMap for Rust
-
asynciter
Asynchronous iterator
-
workctl
number of higher-level control mechanisms for concurrent work scheduling, built on standard library concurrency primatives
-
steelmill
A resource manager (dependency injector / factory) designed for distributed systems and simulation testing
-
run-them
A CLI to launch a single command with many workers, serializing the output
-
coro
Stackful, first-class asymmetric coroutines
-
shared_channel
Multi-producer, multi-consumer FIFO queue communication primitives
-
msg_channel
message channel
-
bastion-executor
Cache affine NUMA-aware executor for Rust
-
snowflake-multi-threaded
The rust-lang implementation of Twitter's id generator algorithm snowflake, it thread safety | Twitter 的id生成器算法snowflake的rust-lang 实现
-
runnel
the pluggable io stream. now support: stdio, string io, in memory pipe
-
rtrb-basedrop
A fork of the
rtrbcrate that uses basedrop’s Shared pointer in place of Arc -
talaria
A high performance, cyclic message passing library
-
clone-replace
Share mutable data by cloning and replacing a reference version
-
cuckoocache
High performance concurrent cache
-
ump-ng
Micro message passing library for threads/tasks communication
-
dashmap_with_out_t_map_trait
Blazing fast concurrent HashMap for Rust
-
spinout
A thread-safe clonable and mutable smart-pointer akin to
Arc<Mutex<T>>, using spin-lock instead of system futex -
native_db
Drop-in embedded database
-
todc-mem
Algorithms for shared-memory distributed systems
-
tyra
Typed Actor System
-
jackiechan
Bounded mpsc channel optimized for lazy bulk operations
-
oneshot-broadcast
channel that broadcasts a value once without cloning it
-
hwlocality
Idiomatic Rust bindings for the hwloc hardware locality library
-
crossbeam-epoch
Epoch-based garbage collection
-
csplib
CSP for concurrent programming
-
futures-executor-preview
Executors for asynchronous tasks based on the futures-rs library
-
thespis
The interface of the thespis actor model (contains only traits)
-
colosseum
A variety of arena allocators for Rust, including thread-safe arenas
-
scoped-pool
A flexible thread pool providing scoped threads
-
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)…
-
asparit
Async Parallel Iterators for Rust
-
waitable
A synchronized (atomic) value container implementing the Mutex+Condvar pattern for efficient blocking waits
-
slottle
A throttle pool library designed for thread-based concurrency
-
async-once-watch
Asynchronous and shareable container which value is set once
-
hadron-client
The Hadron Rust client library
-
crossbeam-skiplist_piedb
A concurrent skip list
-
genserver
Elixir inspired async actor library
-
process-muxer
single-threaded process multiplexing
-
shared-resource-pool-builder
Create thread pools with a shared resource
-
agent_rt
agent scheduling
-
disruption_types
Types for communicating with the Discord API and gateway
-
ditto
CRDTs for common data structures like maps, sets, vecs, strings, and JSON
-
amadeus-serde
Harmonious distributed data analysis in Rust
-
rusty-variation
deadlock-free session-typed communication
-
rust-waitgroup
A Golang like WaitGroup
-
swimming
Dive into Efficiency with Swimming: A High-Performance, No-Nonsense Connection Pool
-
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.
-
async-datachannel-wasm
Async Wrapper for WebRTC datachannel in the browser environment
-
async_ach-notify
Async Atomic Channel
-
nettu_scheduler_api_structs
Nettu scheduler api types
-
rayon_iter_concurrent_limit
Limit the concurrency of an individual rayon parallel iterator method with a convenient macro
-
singleflight
port of Go's singleflight package for call collapsing
-
zkmq
Message Queue, backed by Zookeeper
-
funnel
data structure that makes it easy to read from multiple channels from a single source
-
acto-rs
Experimental actor library, under development. (renamed from minions_rs).
-
arae
Cursed data structures
-
inert
lets you use non-Sync values in a Sync way
-
fused-reader
fused reader type that if writer thread dies while holding armed fuse the reader will get BrokenPipe error
-
rdispatcher
Dispatcher for Rust, broadcast and subscribe many to many
-
mpmc
copy-pasted from old rust stdlib
-
blocking_semaphore
performant blocking semaphore
-
voluntary-servitude
Thread-safe appendable list with lock-free iterator
-
log-mel
Mélodium logging library
-
or_poisoned
Unwrap std lock guards in a semantic way
-
datacake-crdt
A conflict free replicated datatype based on a hybrid logical clock implementation for building eventually consistent data stores
-
stream-kmerge
K-way merge for streams
-
secc
Implements a Skip-Enabled Concurrent Channel (SECC) for Rust
-
quartz_sched
Minimalistic scheduling library for Rust
-
crossbeam-skiplist-pr1132
A concurrent skip list
-
cloudi
API
-
turbolift
Easy distribution interface 🚡
-
protoflow-flume
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
rayon_croissant
<lqd> bikeshedding the name: something that is mapped folded and collected, a 🥐
-
mrogalski-looper
Clean abstraction for a single-threaded event loop. Built as a lightweight wrapper around the std::sync::mpsc package.
-
membarrier
Process-wide memory barrier
-
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. -
consume
Memory order consume for when it's known that the compiler can't elide the dependency
-
sentinel-rocket
Sentinel middleware for Rocket
-
slice_adapter
help share slice between thread
-
embassy-time-queue-utils
Timer queue driver trait for embassy-time
-
double-checked-cell-async
A thread-safe lazily initialized cell using double-checked locking
-
thread_lake
A very high level thread pool manager
-
bondi
Single producer, multi consumer lock-free ring buffer (experimental)
-
agner-utils
An actor toolkit inspired by Erlang/OTP (utils)
-
atomic-borrow
atomic reference counter
-
tc-server
TinyChain's cluster server logic, including peer discovery and replication
-
pacwrap-core
providing core functionality for pacwrap
-
moka
A fast and concurrent cache library inspired by Java Caffeine
-
rayon_logs
Traces for the rayon work-stealing library
-
send-cell
Immutable memory region with runtime Send checking
-
atomic_ref_box
Box with thread-safe, immutable weak references
-
scx_layered
highly configurable multi-layer BPF / user space hybrid scheduler used within sched_ext, which is a Linux kernel feature which enables implementing kernel thread schedulers in BPF and dynamically loading them…
-
concurrency_toolkit
Easy switching between std::sync, tokio::sync and loom::sync
-
context-coroutine
set of extensions to provide stackful coroutines; it is not officially associated with the context crate
-
zestors
A fast and flexible actor-framework for building fault-tolerant Rust applications
-
rider
bounded executor for tokio; limit the count of tasks running 🚦
-
actors-rs
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
rjq
Redis job queue
-
objectpool
lock-free object pool, support no_std
-
caring
Sharing is caring: a safe library for mmap'ing memory in multiple processes
-
monotone
counters and queues for coordination in distributed systems
-
mutex_logger
logger that usess mutex for thread safty
-
paradis-demo
demo functionality for paradis, not intended for use
-
nolock
A collection of Lock-Free Datastructures
-
callysto
Stream processing framework
-
swimming-pool
threadpool for running a number of jobs on a fixed number of threads
-
conquer-util
concurrent and lock-free programming
-
parking_lot_rt
Parking-lot fork for real-time applications
-
zeet
Work-stealing thread pool built on crossbeam
-
orx-concurrent-ordered-bag
An efficient, convenient and lightweight grow-only concurrent data structure allowing high performance and ordered concurrent collection
-
go-spawn
that provides macros to spawn and join threads with minimal boilerplate
-
sched-clock
A timer for task scheduling
-
thfmr-protocol
Internal control protocol encoding and decoding library for the TouHou.FM Radio project
-
thunk
Primitives for generic lazy evaluation in Rust. This crate requires nightly for
untagged_unions. -
onetime
(aka. oneshot) async spsc channel
-
wasserglas
A fixed size thread-safe object pool with automatic reattachment
-
piper
Async pipes, channels, mutexes, and more
-
RobotS
Actor framework
-
lock_freedom
concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers
-
readahead-iterator
Readahead from an iterator on a separate thread, returning items in order and synchronously
-
deploy
The
deploylibrary to aide writing and debugging of distributed programs, as well as tooling to run them across a cluster -
sea-streamer-file
🌊 SeaStreamer File Backend
-
lossyq
concurrent single publisher, single consumer queue with fixed length, that never blocks the writer
-
work-steal-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
ppipe
An elegantly simple and lightweight library for making iterator pipelines concurrent and blazingly fast, hence the name ppipe (parallel pipe)
-
poolio
A thread-pool
-
and-then-concurrent
Concurrent and-then combinator for Rust streams
-
scheduling
job scheduler
-
rusty-junctions-macro
Generation and Client Macro API for rusty-junctions
-
easy-parallel
Run closures in parallel
-
rayon-core
Core APIs for Rayon
-
hurdles
Counter-based thread barrier
-
bufchan
buffered MPSC channel
-
bevy_gpu_compute_core
Empowering anyone to leverage GPU-acceleration with as little barrier-to-entry as possible
-
swap-arc
A swappable Arc
-
threadReactive
Synchronous Reactive system
-
multiqueue
A fast mpmc broadcast queue
-
queued-task
concurrent queue task processing
-
quinine
Atomic monotonic containers (Mono{Box,Arc})
-
syncell
Sync alternative to RefCell
-
hyperbridge
Fast multi-producer multi-consumer channel with async support
-
hv-lease-tracker
no-std compatible tracking of borrow origins, for providing better diagnostics when implementing interior mutability primitives
-
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.
-
threadbeam
specialized channel type for beaming data out of a newly spawned thread
-
balter-runtime
A load/stress testing framework
-
rayoff
rayon but it's map-reduce
-
governor
A rate-limiting implementation in Rust
-
eiz
some more code
-
storage-map
Concurrent append-only map storage
-
simple-mutex
A mutex more efficient than std and simpler than parking_lot
-
cocoro
A more type-safe take on Rust stackless coroutines
-
concurrent-initializer
concurrent initializer to ensure initialization only once per key
-
mpmcpq
Multi-producer multi-consumer Priority Queue
-
tokio-bichannel
Bidirectional tokio::sync::mpsc channel
-
broadcaster
Broadcasting futures mpmc channel
-
rpools
A minimalist workerpool for rust
-
mtlog-progress
A progress bar implementation working gracefully with mtlog's logger
-
sync-cell
A collection of easier to use thread-safe types for the creation of larger thread safe systems
-
chunker
Minimalistic parallel executor
-
monitor
synchronization construct
-
movie
An actor / thread orchestration library / macro / framework
-
xarc
xarcprovides atomically swappable atomically refcounted smart pointers as a safer building block for lockfree algorithms than raw atomic pointers.Xarcis comparable toArcbut… -
ump-ng-server
Server message dispatch loop for ump-ng
-
dynqueue
Dynamically extendable Rayon parallel iterator
-
read-write-api
interface to unify single-threaded code and RwLocks-based code
-
linux-rtic
A Real-Time Interrupt-driven Concurrency (RTIC) implementation for Linux
-
paladin-core
distributed algorithm toolkit. Write distributed algorithms without the complexities of distributed systems programming.
-
kernel
Abstract Reactive Streams
-
amadeus-commoncrawl
Harmonious distributed data analysis in Rust
-
bndpresbufch
Bounds-preserving channel for passing buffers
-
update_channel
A channel for single updatable values
-
once_mut
Safe mutable reference to static variable that can be obtained only once
-
sync_cow
Thread-safe clone-on-write container for fast concurrent writing and reading
-
fbinit-tokio
detail of fbinit crate
-
elk-mq
A Message Queue implementation in rust, using Redis as a communication medium
-
gemino
A multi producer multi consumer (MPMC) broadcasting channel
-
quick_cache
Lightweight and high performance concurrent cache
-
key-mutex
Access mutexes by key
-
ya-ring-buf
Ring Buffer. SPSC channel with direct access for bytes/Copy.
-
protoflow-crossbeam
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
atomic-memcpy
Byte-wise atomic memcpy
-
ach
Atomic Channel
-
raliguard
Lazy rate limit semaphore implementation for your asynchronous code frequency execution
-
fenic
test concurrent code
-
access-queue
limit the number of simultaneous accesses to a value
-
arl
A rate limiter to be used with tokio
-
cicd-mel
Mélodium CI/CD library
-
open-coroutine-queue
Concurrent work-stealing queue, implemented using st3 and crossbeam-deque
-
ctrlc
Easy Ctrl-C handler for Rust projects
-
evelyn
event distribution library
-
par-map
Parallel map and flat_map
-
thread-owned-lock
Mutex which can only be unlocked by the owning thread
-
bounded-spsc-queue
A bounded SPSC queue
-
llq
Wait-free SPSC linked-list queue with individually reusable nodes
-
consumable_vec
generic approach to create a mutual database for multiple producers and consumers
-
tokio-par-stream
parallel streams powered by tokio
-
spinning
Mutexes and SIX locks implemented by spinning
-
wakerset
no_std, no_alloc storage of Wakers embedded in the Future type
-
parking_lot_core
An advanced API for creating custom synchronization primitives
-
kik_sync_service
A synchronous threading worker channel for generating the results you want with the data you need
-
simplesignal
A dead simple signal system implementation
-
atomic-story
An brief overview of atomics and memory ordering on a multi-threaded context with examples
-
arrows
An actor framework in rust with message durability and ingestion order processing of of messages
-
hv-elastic
Safe and almost-safe abstractions for lengthening lifetimes and
'static“loaning” of non-'statictypes -
datacake-rpc
A zero-copy, actor-like RPC framework using rkyv
-
chex
Global exit signal library
-
flexible-locks
Flexible Locks
-
tc-fs
TinyChain's transactional filesystem interface layer
-
forkjoin
A work stealing fork-join parallelism library for Rust
-
sync_rw_cell
Thread-safe version of RefCell
-
stoplight
stoppable tasks/threads
-
sentinel-actix
Sentinel middleware for Actix-Web
-
hv-cell
A no-std port of the
atomic_refcellcrate with additionalArc-centric functionality -
lock-free-multi-producer-single-consumer-ring-buffer
A lock-free, multi-producer, single-consumer (MPSC) ring buffer. Optimized for sending and receiving 'bursts' of messages. Can also be used as a ring queue. It is a Rust port of Mindaugas Rasiukevicius's ringbuf.
-
agner-init-ack
An actor toolkit inspired by Erlang/OTP (init-ack)
-
felicia
service for accessing and sharing lists of bad actors
-
wei-scheduler
wei scheduler
-
concache
A fast, concurrent, shared hash map
-
phoenix-tls
creating always present thread locals
-
statman
Stat Manager
-
terminate
abstract logic to terminate threads, coroutines and the like
-
structured-spawn
Structured async spawn implementations for Tokio
-
ga-scheduler
A Genetic Algorithm optimizer designed for scheduling and similar tasks
-
slave-pool
thread pool
-
rust-concurrent
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
stretto
high performance thread-safe memory-bound Rust cache
-
malobu
Atomic MPMC Bus
-
npnc
Lock-free queues
-
momen
low overhead thread pool
-
executor-service
A fast and efficient Thread Pool like Java ExecutorService
-
unit16
whp-unit16
-
sea-streamer-runtime
🌊 SeaStreamer async runtime abstraction
-
kai-cli
Kai - todo.txt task scheduler
-
fibril
implementing distributed systems with commmunicating fibers
-
pairlock
A reader-writer lock with wait-free reads
-
lightproc
Lightweight process abstraction for Rust
-
amadeus-aws
Harmonious distributed data analysis in Rust
-
ccl
Fast datastructures for use in highly concurrent systems
-
polyester
Parallel iterator adaptors that accept arbitrary iterators
-
yastl
scoped threadpool library
-
refptr
Inherently reference counted structs
-
tasic
Tokio, Async_STD, Smol, Interface Crate
-
ping-pong-cell
An atomic cell for up to two threads
-
simple-rw-global
GlobalContainer based on std::sync::RwLock
-
theatre
A concise async actor model implementation
-
libmcs
A MCS Lock Library
-
hybrid-lock
A hybrid lock with optimistic locking
-
rw_lease
Fast Reader-Writer lock with reader draining support. Based on a single (parameterisable) atomic usize.
-
amadeus-types
Harmonious distributed data analysis in Rust
-
multichannel
A mpmc priority multi channel with dynamic channel registration and freezing
-
open-coroutine-iouring
The io_uring support for open-coroutine
-
rustix-futex-sync
Linux futex-based synchronization
-
threatpool
thread pool
-
protoflow-blocks
Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages
-
simple_event_map
event map based on channels, provides a receiver that is either blocking or async
-
sea-streamer-types
🌊 SeaStreamer Traits & Types
-
padlock
Safely acquire RwLock/Mutex locks
-
tiny-actor
A minimal actor framework for Rust
-
open-coroutine-core
The open-coroutine is a simple, efficient and generic coroutine library
-
arbalest
Like Arc<T> but where weak references don't forbid mutable access
-
busan
An actor implementation for Rust
-
shrink_pool
A thread pool which agressively terminates its threads as soon as they are idle
-
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
-
atomic_immut
Atomic immutable value
-
navvy
MPSC Channel broker allowing channels of different types to be stored in a single data structure
-
thread-broadcaster
A SPMC (Single producer multi consumer) broadcasting channel to broadcast notifications between threads
-
gothack-future-parking_lot
An "as simple as possible" Future implementation for parking_lot
-
wasefire-sync
Portable non-blocking mutex
-
blinkcast
Fast, bounded, multiple-producer, multiple-consumer, lossy, broadcast channel
-
toktor
A small tokio-based Actor framework
-
callysto-avro
Avro serde for Callysto Stream Processing Framework
-
concurrent-round-robin
A concurrent wrr implementation for rust
-
testtools
Helpers for eliminating boilerplate code in tests
-
tasque
thread pool library
-
parallel-event-emitter
Parallel Event Emitter for concurrent listener invocation based on futures-rs and futures-cpupool
-
concurrent_open_map
A concurrent hashmap implementation in Rust
-
agner-actors
An actor toolkit inspired by Erlang/OTP (actors)
-
lagoon
A thread pool crate with an array of features
-
mycorrh
fast concurrent messaging system for Rust
-
fencing
tokens
-
jobsteal
A work-stealing fork-join threadpool written in Rust
-
riffy
An unbounded, wait-free, multi-producer-single-consumer queue
-
paradis-core
core functionality for paradis
-
faucet
Back-pressured MPMC queue that can be drained after signaling completion
-
triex
Trivial Executor
-
fuze
A mechanism to wait for a single signal which can be checked at any time
-
sorted-channel
sorted message-based communication channel
-
melodium-engine
Mélodium core engine and executor implementation
-
tinypool
thread pool implementation in Rust
-
infinitree-macros
Embedded, encrypted database with tiered cache
-
skipdb
An embedded, in-memory, zero-copy, atomicity, consistency, MVCC, almost lock-free and serializable snapshot isolation database engine
-
tpx
Task scheduler
-
skl
A lock-free thread-safe concurrent ARENA based (heap backend or memory map backend) skiplist implementation which helps develop MVCC memtable for LSM-Tree
-
sento
A lock-free, append-only atomic pool
-
bplustree
Concurrent in-memory B+ Tree featuring optimistic lock coupling
-
mula
Share expensive computation with various requesters
-
tractor
Actor system modelled after Pony's actors
-
threadpool-crossbeam-channel
A fork of the threadpool create, which uses crossbeam-channel instead of std::mpsc
-
moka2
hitdns fork of A fast and concurrent cache library inspired by Java Caffeine
-
spin_loop
-
static_locks
The
parking_lotlocks but usable in statics and const fn -
double-checked-cell
A thread-safe lazily initialized cell using double-checked locking
-
spsc-bip-buffer
A concurrent, spsc ring-buffer with sized reservations
-
task_queue
thread pool for Rust
-
rustc-rayon-core
Core APIs for Rayon - fork for rustc
-
c-map
Very fast concurrent hashmap
-
ump-server
Server message dispatch loop for ump
-
brod
A wrapper library providing an API for executing Kafka producers in parallel
-
agner
An actor toolkit inspired by Erlang/OTP
-
lock_cell
A custom locking cell type written in Rust
-
graphile_worker_ctx
Worker Context package for graphile_worker, a high performance Rust/PostgreSQL job queue
-
boomerang_builder
The Reactor assembly API for Boomerang
-
optimistic-cell
lock-like structure for low-overhead optimistic concurrency
-
hv-atom
Convenient abstractions for atomic operations on smart pointer/reference types, based on the
atomcrate -
mpmc-ringbuf
queue
-
hj_thread_pool
thread pool implementation in Rust
-
jotty
embeddable distributed processing framework for both short and long running batch jobs
-
agner-helm
An actor toolkit inspired by Erlang/OTP (control panel)
-
read-cell
Read-only Cell counterpart
-
ach-cell
Atomic Channel
-
async-semaphore
An async semaphore
-
mtlog-tokio
Scoped logging for tokio runtimes with support for log files
-
delay-queue
A concurrent unbounded blocking queue where each element can only be removed when its delay expires
-
atomic-bus
Atomic MPMC Bus
-
timeslice
periodic time slice scheduler
-
lockness
TODO
-
sea-streamer-stdio
🌊 SeaStreamer Standard I/O Backend
-
datacake-node
The core cluster membership system built ontop of Quickwit's chitchat
-
open-coroutine-hooks
The syscall hook for open-coroutine
-
worker-pool
handle a set of worker threads, which need to communicate back their result to the main thread
-
tange
Scalable Task-based Parallelism Framework
-
moite_moite
Split a value in two owned parts
-
horde
threads
-
batch_queue
A single-producer single-consumer Rust queue with smart batching
-
rs_taskflow
executing graphs of tasks
-
monotone-cli
Monotonic counter cli implemented on top of AWS DynamoDB
-
threadpool-simple
Threadpool for working with many tasks easily
-
rayon-core-wasm
Core APIs for Rayon
-
mini-moka
A lighter edition of Moka, a fast and concurrent cache library
-
yaar-lock
Fast, no_std synchronization primitives