Lib.rs

parking_lot

More compact and efficient implementations of the standard synchronization primitives

spin

Spin-based synchronization primitives

rayon

work-stealing parallelism for Rust

async-lock

Async synchronization primitives

thread_local

Per-object thread-local storage

async-channel

Async multi-producer multi-consumer channel

crossbeam

Tools for concurrent programming

ringbuf

Lock-free SPSC FIFO ring buffer with direct access to inner data

dashmap

Blazing fast concurrent HashMap for Rust

flume

A blazingly fast multi-producer channel

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

neon

A safe abstraction layer for Node.js

serenity

Discord API

jobserver

GNU Make jobserver for Rust

loom

Permutation testing for concurrent code

scc

A collection of high-performance containers and utilities providing both asynchronous and synchronous interfaces

kanal

The fast sync and async channel that Rust deserves

thread-priority

managing threads priority and schedule policies

boxcar

A concurrent, append-only vector

threadpool

A thread pool for running a number of jobs on a fixed set of worker threads

sled

Lightweight high-performance pure-rust transactional embedded database

sync_wrapper

enlisting the compiler's help in proving the absence of concurrency

leaky-bucket

A token-based rate limiter based on the leaky bucket algorithm

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.

corosensei

A fast and safe implementation of stackful coroutines

parking

Thread parking and unparking

simple_logger

A logger that prints all messages with a readable output format

atomic_float

Floating point types which can be safely shared between threads

stateright

A model checker for implementing distributed systems

crossfire

channels for async and threads

thread-id

Get a unique thread ID

lockfree-object-pool

A thread-safe object pool collection with automatic return and attach/detach semantics

archery

Abstract over the atomicity of reference-counting pointers

rayon-cond

Experimental iterator wrapper that is conditionally parallel or serial

radium

Portable interfaces for maybe-atomic types

s3sync

Reliable, flexible, and fast synchronization tool for S3

diatomic-waker

An async, lock-free synchronization primitive for task wakeup

local-channel

A non-threadsafe multi-producer, single-consumer, futures-aware, FIFO queue

triple_buffer

triple buffering, useful for sharing frequently updated data between threads

throttle-server

Provide semaphores for distributed systems via an http interface

try-lock

A lightweight atomic lock

wasm-bindgen-rayon

Adapter for using Rayon-based concurrency on the Web

maitake-sync

No-std async synchronization primitives from Maitake

gst-plugin-threadshare

GStreamer Threadshare Plugin

mpi

Message Passing Interface bindings for Rust

orx-concurrent-vec

A thread-safe, efficient and lock-free vector allowing concurrent grow, read and update operations

scheduled-thread-pool

A scheduled thread pool

state

safe and effortless global and thread-local state management

coarsetime

Time and duration crate optimized for speed

guardian

owned mutex guards for refcounted mutexes

parallel-sh

Execute commands in parallel

may

Rust Stackful Coroutine Library

waker-fn

Convert closures into wakers

ratelimit

ratelimiter that can be shared between threads

jod-thread

std::thread which joins on drop by default

process_control

Ergonomically run processes with limits

papaya

A fast and ergonomic concurrent hash-table for read-heavy workloads

affinitypool

running blocking jobs on a dedicated thread pool with CPU core affinity

dson

A delta-state CRDT implementation

shuttle

testing concurrent Rust code

aws-sdk-s3-transfer-manager

A high performance Amazon S3 transfer manager for Rust

rclite

small, fast, and memory-friendly reference counting compatible with Arc and Rc APIs

futures-channel

Channels for asynchronous communication using futures-rs

shipyard

Entity Component System

futures-intrusive

Futures based on intrusive data structures - for std and no-std environments

inline-array

efficient immutable inlinable byte array

atomig

Generic, convenient and lock-free std atomics via Atomic<T>. Can be used with many primitive types (including floats) and with custom types.

spawned-concurrency

Spawned Concurrency

crossbeam-utils

concurrent programming

sdd

Scalable lock-free delayed memory reclaimer

keepcalm

shared types for multi-threaded programs

mea

A runtime-agnostic library providing essential synchronization primitives for asynchronous Rust programming

hydra

A framework for writing fault tolerant, highly scalable applications with the Rust programming language

memo-map

implementing a synchronized map for memoization

flurry

Rust port of Java's ConcurrentHashMap

batch-aint-one

I got 99 problems, but a batch ain't one

recloser

A concurrent circuit breaker implemented with ring buffers

rs-store

Redux Store for Rust

gix-lock

A git-style lock-file implementation

mutex

An abstraction over closure-based mutexes

amity

Concurrency algorithms

typedmap

A hash map (dash map). A type of value is defined by trait implemented on key type

mpstthree

implementing Multiparty Session Types for 2 or more participants

hk

managing git hooks

atomic-wait

Cross-platform atomic wait and wake (aka futex) functionality

append-only-vec

Append-only, concurrent vector

disruptor

Low latency inter-thread communication via a ringbuffer (inspired by the LMAX Disruptor)

ringbuffer-spsc

A fast thread-safe single producer-single consumer ring buffer

storyteller

focused on supporting user oriented output while supporting multiple output types (e.g. json, a progressbar, etc.)

sluice

Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels

concurrent-queue

Concurrent multi-producer multi-consumer queue

paralight

A lightweight parallelism library for indexed structures

idr-ebr

An efficient concurrent ID to object resolver

uid

creation of unique IDs

fdup

find duplicate files recursively and in parallel

rustc-rayon

work-stealing parallelism for Rust - fork for rustc

desync

A hassle-free data type for asynchronous programming

sync_file

Files that can be read concurrently

multiqueue2

A fast mpmc broadcast queue

async-condvar-fair

Condition variables for async Rust

ipc-rpc

A wrapper over servo/ipc-channel which provides many high level features

botcore

Production-grade asynchronous bot engine with enterprise observability features

par-core

Switchable parallel execution core

lockable

offers hash map, hash set and cache data structures where individual entries can be locked

ocl

OpenCL bindings and interfaces for Rust

ndd

Non De-Duplicated cell. For statics guaranteed not to share memory with any other static/const.

synchronized

convenient macro for synchronizing code in multithreading

pausable_clock

A source of time information that can be paused and resumed

rtactor

An Actor framework specially designed for Real-Time constrained use cases

rx-rust

Reactive Programming in Rust inspired by ReactiveX https://reactivex.io/

scc2

High-performance containers and utilities for concurrent and asynchronous programming

rtsc

Real-time Synchronization Components

mcslock

Mellor-Crummey and Scott contention-free lock for mutual exclusion, referred to as MCS lock

nam-bellperson

zk-SNARK library

executors

A collection of high-performance task executors

sea-streamer

🌊 The stream processing toolkit for Rust

orx-parallel

High performance, configurable and expressive parallel computation library

atomic-take

Atomically take a value out of a container once

happylock

Free deadlock prevention

pumps

Eager streams for Rust

orx-concurrent-iter

A thread-safe and ergonomic concurrent iterator trait and efficient lock-free implementations

parallel_task

A fast data parallelism library for Rust

cano

& Fast Async Workflows in Rust - Build data processing pipelines with Tasks and Nodes

act_rs

Act.rs is a minimal actor framework

nbio

Non-Blocking I/O

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

instance-copy-on-write

A native Rust implementation of the glibc/libc syslog

oqueue

Non-interleaving multithreaded output queue

titanrt

Typed reactive runtime for real-time systems

pagetable

Wait-free 4-level 64-bit pagetable for roughly-contiguous keys

erl_dist

Erlang Distribution Protocol

yaque

disk-backed persistent queue for Rust

saa

Word-sized low-level synchronization primitives providing both asynchronous and synchronous interfaces

observable-property

A thread-safe observable property implementation for Rust

ordered-channel

A channel that always receives messages in the correct order, even if they were sent out of order

typedflake

A Snowflake-style ID generator library with newtype-driven design

steady_state

Framework for building long running low latency actor based services on Linux. Provides visual telemetry to watch data flows between actors. Uses Erlang style supervisors to defend…

async-event

An efficient async condition variable for lock-free algorithms

threadbound

Make any value Sync but only available on its original thread

some_executor

A trait for libraries that abstract over any executor

ironshield-cli

IronShield CLI component

ark-vrf

Elliptic curve VRF with additional data

concurrent-map

a lock-free linearizable B+ tree

uefi_corosensei

A fast and safe implementation of stackful coroutines. This is a fork adapted to work in a UEFI environment.

atomptr

A safe copy-on-write wrapper around AtomicPtr with some extra tricks

mambo_map

lightweight, simple, minimally blocking multithreaded hashtable

chili

low-overhead parallelization library

rust_web_crawler

A short summary of what your crate does

ballista-scheduler

Ballista Distributed Compute - Scheduler

rsevents

Manual and auto reset events for signaling threads and writing new synchronization primitives like semaphores

concurrent_arena

u32 concurrent insertion/removal arena that returns ArenaArc

evmap

A lock-free, eventually consistent, concurrent multi-value map

crossbeam-channel

Multi-producer multi-consumer channels for message passing

locktick

Automated lock accounting & profiling

irondash_message_channel

Rust interface to irondash MessageChannel

atomic-file-install

For atomically installing a file or a symlink

poly-once

A thread-safe cell providing async and sync initialization primitives similar to OnceLock

mco

Rust Coroutine Library like go

trauma

Simplify and prettify HTTP downloads

weavegraph

Graph-driven, concurrent agent workflow framework with versioned state, deterministic barrier merges, and rich diagnostics

rust_di

DI — Dependency Injection for Rust

workerpool

A thread pool for running a number of jobs on a fixed set of stateful worker threads

tonari-actor

A minimalist actor framework aiming for high performance and simplicity

nexus-actor-core-rs

Core library for Nexus Actor

linked

Create families of linked objects that can collaborate across threads while being internally single-threaded

seize

Fast, efficient, and predictable memory reclamation for concurrent data structures

atomic-time

AtomicDuration, AtomicOptionDuration, AtomicSystemTime, AtomicOptionSystemTime, AtomicInstant and AtomicOptionInstant for Rust

renege

Tracking cache validity using fast concurrent invalidation propogation

rcu_cell

a lockless rcu cell implementation

io-reactor

Concurrent I/O resource management using reactor pattern

safe-lock

A lock struct with a const fn constructor and no unsafe - ARCHIVED

send_cells

Safe and unsafe cells implementing Send/Sync

breaker-machines

High-performance circuit breaker with fallback support and rate-based thresholds

tracing-mutex

Ensure deadlock-free mutexes by allocating in order, or else

scx_cosmos

Lightweight scheduler optimized for preserving task-to-CPU locality. https://github.com/sched-ext/scx/tree/main

routingkit-cch

Rust bindings for RoutingKit's Customizable Contraction Hierarchies (CCH)

router-radix

A high-performance radix tree based HTTP router for Rust

wrapit

A lightweight Rust crate that wraps any variable using interior mutability (RefCell, Mutex, or RwLock) for ergonomic shared mutation

loole

A safe async/sync multi-producer, multi-consumer channel

fault-injection

fault injection, concurrency delay injection, and error source annotation

omango

Concurrency collections

j4rs

j4rs stands for 'Java for Rust' and allows effortless calls to Java code, from Rust

sbitmap

Fast and scalable bitmap implementation based on Linux kernel's sbitmap

pbrt-r3

pbrt-v3

valida

Modular validation system for Rust with support for nested structures and localization

st3

A very fast lock-free, bounded, work-stealing LIFO queue

television-fuzzy

The revolution will be televised

rdkafka-redux

Rust wrapper for librdkafka

setup_read_cleanup

safely transitioning through the three phases of shared resource access: setup, read, and cleanup

taskflow-rs

A high-performance, async-first task orchestration framework for Rust

kronos-compute

A high-performance compute-only Vulkan implementation with cutting-edge GPU optimizations

serenity_self

Discord API. A fork of Serenity for user account support.

fork_union

Low-latency OpenMP-style NUMA-aware cross-platform fine-grained parallelism library

perdix

High-performance GPU-accelerated ring buffer for AI terminal multiplexing

batch-processing

A batch library for processing a list of items in parallel

cocoro

A more type-safe take on Rust stackless coroutines

pariter

Parallel iterator processing

proglog

Thread safe progress logging

protoflow-zeromq

Protoflow implements flow-based programming (FBP) for Rust using Protocol Buffers messages

pend

do now, wait later – tiny job runner

thingvellir

a concurrent, shared-nothing abstraction that manages an assembly of things

bab

build a bus - low-level components for your next message bus

melodium

Flow-oriented language & tool, focusing on treatments applied on data, allowing high scalability and massive parallelization safely

snakeice-rdkafka

Rust wrapper for librdkafka

steppe

Follow the progress of a task easily

liner_broker

Redis based message serverless broker

shred

Dispatches systems in parallel which need read access to some resources, and write access to others

rate_limiters

Flexible and easy-to-use Rust library for implementing rate limits

gol_engines

Tools for Conway's Game of Life

prun

Run 🍺

rex-sm

Hierarchical state machine

no_deadlocks

A Runtime Deadlock Debugger

wdk-mutex

An idiomatic Rust mutex type for Windows kernel driver development

clashmap

Sharded hashmap suitable for fast concurrent access

elasticq

Thread-safe, dynamically resizable queues with lock-based and lock-free implementations for high-throughput scenarios

ppl

A structured parallel programming library for Rust

generic-container

Abstract over "containers" that hold a T, such as a T itself, Box<T>, or Arc<Mutex<T>>

concurrent-pool

A concurrent object pool

async_nursery

Primitive for structured concurrency

slave-pool

thread pool

pi_slot_deque

Two terminal queue based on slotmap

thread-share

safe and efficient data sharing between threads with zero-copy operations, change detection, and enhanced thread management

stupid_utils

that provides some simple and maybe stupid or useful tools

taskorch

Concurrent Pool for task processing

rose_bloom

A concurrent growing element size linked list with stable pointers

mintex

minimal mutex

take-once

A thread-safe container for one-time storage and one-time consumption of a value

splaycast

Stream-specific broadcast channel

fast-able

The world's martial arts are fast and unbreakable; 天下武功 唯快不破

grip-grab

A faster, more lightweight ripgrep alternative

spindle

rayon-based threadpool

invocation-counter

Datastructure to answer to: how many times a function has been called in the last X minutes?

eips

Efficient intention-preserving sequence CRDT

ecmascript_atomics

ECMAScript and Java memory model racy atomics

commonware-runtime

Execute asynchronous tasks with a configurable scheduler

proc-daemon

A foundational framework for building high-performance, resilient daemon services in Rust. Handles all the boilerplate for signal handling, graceful shutdown, logging, and configuration.

rw-cell

Write data to cell from anything place your application without copy, lock and reading in one place

choir

Task Orchestration Framework

theta

Actor Framework

vibe-code

Parallel CPU execution without threads or channels

singleton-registry

A thread-safe singleton registry for Rust with isolated, per-type storage

resilient-rs

fault tolerance, including retry strategies, backoff mechanisms, and failure handling

pueue

A cli tool for managing long running shell commands

keyed-lock

A keyed lock for synchronization

shakespeare

An actor framework

casial-core

Consciousness-aware context coordination engine - The Casial substrate for paradox-resilient AI agent context management and coordination

par_slice

Slices that may be accessed from multiple threads with different levels of safety

linch

In development

progress-token

tracking progress of long-running tasks

simple_json_server

way to build a JSON-based server with automatic JSON serialization/deserialization, error handling, async support, type safety, and comprehensive RustDoc generation

zero-pool

High-performance thread pool with consistent low-latency task dispatch

synchronoise

Synchronization primitives that build upon the standard library

ristretto_gc

JVM Garbage Collector

paradis

Parallel processing with disjoint indices

env-lock

Set and lock environment variables for tests

str_cache

A fast, lock-free, thread-safe string interning library

noworkers

A small asyncronous worker pool manages thread pool limiting, cancellation and error propogation, inspired by golangs errgroup (requires tokio)

defer-drop

Defer dropping large types to a background thread

az_logger

Very simple logging crate for my projects

atom_box

A safe idiomatic Rust implementation of Atomic Box using hazard pointers

round_mult

A tiny library to round a number up or down to a multiplier

halt

worker threads that can be paused, stopped, and resumed

edon

embedding Nodejs (libnode) within Rust

wakerset

no_std, no_alloc storage of Wakers embedded in the Future type

krecik

Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL

amfiteatr_classic

some classic game theory problems to research on

concurrent-slotmap

A lock-free concurrent slotmap

zc_buffer

High-Performance Rust Zero-Copy Inspired Buffer Library based on Bytes

balter

A load/stress testing framework

spinning_top

spinlock crate based on the abstractions provided by lock_api

pawdist

Dynamic test distribution system that solves Playwright's static sharding imbalances

messaging_thread_pool

aiding the creation of typed thread pool of objects that is communicated with via channels

obsidian-scheduler

scheduling tasks with both callback and event-based timers

bus

A lock-free, bounded, single-producer, multi-consumer, broadcast channel

v_queue

file based queue

fibre

High-performance, safe, memory-efficient sync/async channels built for real-time, low-overhead communication in concurrent Rust applications

rs2-stream

A high-performance, production-ready async streaming library for Rust

phylactery

Safe and thin wrappers around lifetime extension to allow non-static values to cross static boundaries

parallel_worker

A parallel worker implementation in Rust. Allows to start tasks in parallel and receive the results blocking or non-blocking.

tessell-execution-engine

Production-ready async execution engine for system commands

jorm

A fast, reliable DAG execution engine with native Rust performance

iterator_ilp

Iterator extensions for instruction-parallel reductions

atomic-cuckoo-filter

Highly concurrent Cuckoo Filter

atomic-counter

Atomic (thread-safe) counters for Rust

per-thread-mutex

Synchronization lock designed for wrapping thread-unsafe C libraries

par

Session types, as an implementation of linear logic with MIX

stuck

Multi-threading scheduled task facility building on cooperative stackful coroutine

pi_arr

lock-free & auto-expansion array

lfqueue

Fast concurrent lock-free MPMC queues

superqueue

A tiny, lock-light, type-routed message bus providing event streams and latest-value topics (snapshots) for fast state and event dispatch

chronograph

Timestamp Tracers

k-lock

A fast mutex for short critical sections

circuitbreaker-rs

A production-grade, zero-boilerplate, lock-efficient, observability-ready Circuit Breaker library

infinitree

Embedded, encrypted database with tiered cache

aarc

Atomically updatable variants of Arc and Weak for lock-free concurrency

qrush

Lightweight Job Queue and Task Scheduler for Rust (Actix + Redis + Cron)

evtcall

Rust Event Driven Framework

cowboy

Safe & convenient container for quick prototyping

dropping-thread-local

A dynamically allocated ThreadLocal that ensures destructors are run on thread exit

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

transactional

optimistic lock-free confirmation-based transactional model for Rust

tempref

type whose value remains unchanged even when accessed through a mutable reference

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

tendrils

Tiny, flexible helpers for managing shared state (Arc<Mutex<T>> / Arc<RwLock<T>>) safely in async Rust

rds_lock

asynchronous redis distributed read-write lock implementation based on tokio and redis-rs

atom

A safe abstraction around AtomicPtr

atomics

Basic utils for concurrent programming. Backoff, spinlocks, seqlock, atomic type wrappers.

lamlock

MCS-style flat-combining mutex with panic-awareness

node-replication

An operation-log based approach that transform single-threaded data structures into concurrent, replicated structures

quartz

Port of the original Java Quartz Scheduler to Rust

flo_scene

Entity-messaging system for composing large programs from small programs

fluxion

actor framework written in rust and designed for distributed systems

wb_async_utils

working with async code

atomic_enum

An attribute to create an atomic wrapper around a C-style enum

lace-ws

work-stealing library based on the lace deque

ra_ap_flycheck

TBD

shmap

A key-value store based on linux shared-memory files (shm) for persisting state across program restarts

recluse

A web crawler framework for Rust

ptr_cell

Thread-safe cell based on atomic pointers

onering

High throughput synchronous queue

nexus-actor-utils-rs

Nexus Actor

spragga

A scalable concurrent priority queue with relaxed ordering semantics

fast-pull

Pull everything fast

shared_thread

similar to shared_child, but for threads instead of processes

sgx_tstd

Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language

rust_supervisor

An Erlang-inspired process supervision library for Rust

haphazard

Dynamic memory management for lock-free data structures using hazard pointers

elysees

A fork of triomphe, now with more pointer trickery

mesocarp

High-performance concurrency, synchronization, scheduling, and logging primitives in Rust

novtb

Zoned Data-Parallelism with Core Affinity

siafu

Ergonomic job scheduling library for Rust

copy-channels

A collection of cross-thread channels for copyable types

mumu

Lava Mumu is a language for those in the now and that know

pawawwewism

a wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3

theta-sync

A high-performance no_std MPSC channel with full Tokio compatibility

vec_parallel

Construct your Vec in parallel

cynosure

High performance data structures & primitives from beyond the Blackwall

khonsu

Software Transactional Memory in Rust for Apache Arrow

lock-free-static

Lock-free static variables

parallel-processor

Framework to manage asynchronous execution of multiple compute units communicating using messages

bcast

Low latency broadcast (SPMC) buffer designed to work with shared memory

spark-channel

A generic channel listener implementation for Spark Rust SDK

atomic-arena

Generational arena that allows reserving keys from other threads

multipool

A configurable thread pool with optional work-stealing support and task priority scheduling

svix-ksuid

A pure Rust and fully tested KSUID implementation

orchestrator_lock

A Mutex whose access order is managed by a separate thread

someday

Lock-free MVCC primitive

latches

A downward counter (CountDownLatch) which can be used to synchronize threads or coordinate tasks

sync-arena

thread-safe arena allocator

tower-resilience-bulkhead

Bulkhead pattern for Tower services - resource isolation and concurrency limiting

wait_on_address

Cross-platform atomic wait and wake (aka futex) functionality

informalsystems-malachitebft-app-channel

High-level interface for building channel-based applications on top of the Malachite BFT consensus engine

jobflow

Executes jobs in order

range-lock

Range lock for std::vec::Vec

sarlacc

Thread-safe lock-free interning of data

retrogress

Progress bars with a thin API around complex features

leapfrog

A fast, lock-free concurrent hash map

identify

Strongly-typed UUIDs, statically associated with other types

crossbeam-queue

Concurrent queues

starshard

A blazing-fast sharded concurrent HashMap using hashbrown and RwLock, with lazy shards, atomic length cache, and async support

acts-next

a fast, lightweight, extensiable workflow engine

rearch-tokio

Re-imagined approach to application design and architecture

cutools

magnetic

Low-latency lock-free queues

zeta-inference

Unified inference runtime for high-performance LLM execution

pubsub-bus

Thread-safe one-to-many publish-subscribe event system. Simple and easy to use. It just works (hopefully).

stylo

CSS engine

rtipc

Real-Time IPC, based on a zero-copy, wait-free circular message queue implementation

prism3-concurrent

Concurrent utilities library providing thread pools, task scheduling, synchronization primitives and other concurrent programming tools

web-wt-sys

Hand-crafted low-level Rust bindndings to WebTransport Web API for WebAssembly

waitx

Lightweight synchronization primitive for one-time ready/wait signaling with optional notification

ratelimit_meter

A leaky-bucket-as-a-meter rate-limiting implementation in Rust

ebr

epoch-based reclamation with low cacheline ping-pong

rust-releases

Find, index and obtain all officially available Rust releases

sovran-arc

Memory management swift-isms brought to Rust

blocking-threadpool

A thread pool for running a number of jobs on a fixed set of worker threads

actor12

A lightweight actor framework for Rust with async support

pacwrap-agent

Executable agent for conducting containerized transactions

queued-task

concurrent queue task processing

bgdrop

that uses a dedicated thread and channel to reduce latency caused by memory deallocation

timely-master

A low-latency data-parallel dataflow system in Rust

sprinter

Run parallel queued tasks

signals2

A thread-safe signal/slot library inspired by boost::signals2

watch

A synchronous message passing channel that only retains the most recent value

threadpools

Efficient, configurable, zero-dependency thread pool implementations. Flexible and usable for a wide variety of applications.

batched-queue

A high-performance, highly-concurrent batched queue implementation for Rust

cuckoofilter-mmap

cuckkoo filter use mmap

amadeus

Harmonious distributed data processing & analysis in Rust. parquet postgres aws s3 cloudfront elb json csv logs hadoop hdfs arrow common crawl

ida-rs

A thread-safe, no_std, sparse ID allocator using a radix tree. Ideal for systems programming.

simple_coro

(ab)using async/await to write simple state-machine based coroutines

orama-js-pool

Create a pool of JavaScript engines to invoke JavaScript code concurrently

rarena-allocator

Lock-free ARENA allocator which can be used in both memory and on-disk

atomx

Thread safe data structures based on atomic data types

mimium-scheduler

basic scheduler implementation as a plugin for mimium

umpx

Collection of ump extensions

reft-light

A concurrency primitive for high concurrency reads over a single-writer data structure