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