Lib.rs

parking_lot

More compact and efficient implementations of the standard synchronization primitives

crossbeam

Tools for concurrent programming

crossbeam-channel

Multi-producer multi-consumer channels for message passing

rayon

work-stealing parallelism for Rust

threadpool

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

spin

Spin-based synchronization primitives

dashmap

Blazing fast concurrent HashMap for Rust

flume

blazingly fast multi-producer channel

sled

Lightweight high-performance pure-rust transactional embedded database

sharded-slab

lock-free concurrent slab

simple_logger

logger that prints all messages with a readable output format

crossbeam-queue

Concurrent queues

async-lock

Async synchronization primitives

ringbuf

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

portable-atomic

Portable atomic types including support for 128-bit atomics, atomic float, etc

arcstr

better reference-counted string type, with zero-cost (allocation-free) support for string literals, and reference counted substrings

gix-features

integrate various capabilities using compile-time feature flags

triomphe

fork of std::sync::Arc with some extra functionality and without weak references (originally servo_arc)

thread_local

Per-object thread-local storage

state

safe and effortless global and thread-local state management

loom

Permutation testing for concurrent code

mpi

Message Passing Interface bindings for Rust

lasso

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

leaky-bucket

token-based rate limiter based on the leaky bucket algorithm

radium

Portable interfaces for maybe-atomic types

stateright

model checker for implementing distributed systems

thread-priority

managing threads priority and schedule policies

jobserver

GNU make jobserver for Rust

rskafka

minimal Rust client for Apache Kafka

shuttle

testing concurrent Rust code

atomic-take

Atomically take a value out of a container once

ipc-channel

multiprocess drop-in replacement for Rust channels

scheduled-thread-pool

scheduled thread pool

spinning_top

spinlock crate based on the abstractions provided by lock_api

triple_buffer

triple buffering, useful for sharing frequently updated data between threads

thingbuf

I'm at the buffer pool. I'm at the MPSC channel. I'm at the combination MPSC channel and buffer pool.

archery

Abstract over the atomicity of reference-counting pointers

thread-id

Get a unique thread ID

crossbeam-deque

Concurrent work-stealing deque

parking

Thread parking and unparking

rtrb

realtime-safe single-producer single-consumer ring buffer

bus

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

atomic

Generic Atomic<T> wrapper type

lockfree-object-pool

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

crabz

Parallel Compression

deno_napi

NAPI implementation for Deno

corosensei

fast and safe implementation of stackful coroutines

kanal

fast sync and async channel that Rust deserves

async_once

async once tool for lazy_static

throttle-server

Provide semaphores for distributed systems via an http interface

desync

hassle-free data type for asynchronous programming

rustc-rayon

work-stealing parallelism for Rust - fork for rustc

mpstthree

implementing Multiparty Session Types for 2 or more participants

may

Stackful Coroutine Library

st3

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

lasso-rs

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

try-lock

lightweight atomic lock

ratelimit

ratelimiter that can be shared between threads

rtic-monotonics

that provides implementations of the Monotonic trait from rtic-time

seize

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

sync_wrapper

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

parallel-sh

Execute commands in parallel

crossfire

channels for async and threads

runnel

pluggable io stream. now support: stdio, string io, in memory pipe

par-iter-sync

Parallel Iterator With Sequential Output

vin

ergonomic actor framework

svix-ksuid

pure Rust and fully tested KSUID implementation

typedmap

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

trauma

Simplify and prettify HTTP downloads

oqueue

Non-interleaving multithreaded output queue

sea-streamer

🌊 The stream processing toolkit for Rust

signals2

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

ppl

structured parallel programming library for Rust

synchronoise

Synchronization primitives that build upon the standard library

rsevents

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

rustup-toolchain

working with rustup toolchains

indicator

Abstractions for stream aggregation, we call them Indicator s

concurrent-queue

Concurrent multi-producer multi-consumer queue

sharded_queue

ShardedQueue is currently the fastest concurrent collection which can be used under highest concurrency and load

atom

safe abstraction around AtomicPtr

piz

(a Parallel Implementation of Zip) is a ZIP archive reader designed to concurrently decompress files using a simple API

once_map

Single assignment and lazy maps

qp2p

Peer-to-peer networking library using QUIC

concurrent-map

lock-free linearizable B+ tree

picokafka

Kafka library for tarantool-module based on librdkafka

choir

Task Orchestration Framework

crossbeam-epoch

Epoch-based garbage collection

may_queue

May's internal queue library

maitake-sync

No-std async synchronization primitives from Maitake

no_deadlocks

Runtime Deadlock Debugger

async-condvar-fair

Condition variables for async Rust

keepcalm

shared types for multi-threaded programs

file-lock

File locking via POSIX advisory record locks

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

redlock

distributed locking mechanism built on top of Redis

deqp-runner

VK-GL-CTS/dEQP wrapper program to parallelize it across CPUs and report results against a baseline

dark-std

asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang

fault-injection

fault injection, concurrency delay injection, and error source annotation

process_control

Ergonomically run processes with limits

hypercore-protocol

Replication protocol for Hypercore feeds

someday

Eventually consistent, multi version concurrency

ring-channel

Bounded MPMC channel abstraction on top of a ring buffer

lever

Pillars for Transactional Systems and Data Grids

messaging_thread_pool

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

lazycell

providing a lazily filled Cell struct

pinboard

lock-free, threadsafe way to publish data, just stick it on the pinboard

thread_io

performing I/O in background thread

freezebox

FreezeBox: a deref'able lazy-initialized container

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

atomicring

AtomicRingBuffer is a constant-size almost lock-free concurrent ring buffer

dagrs

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.

kueue

robust, user-level, work-stealing, distributed task scheduler

apalis-core

Core for apalis: simple, extensible multithreaded background processing for Rust

wasmrs-guest

wasmRS guest implementation of the RSocket protocol for reactive streams in WebAssembly

rtic-syntax

Real-Time Interrupt-driven Concurrency (RTIC) meta language

permit

struct for cancelling operations

haphazard

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

threadbound

any value Sync but only available on its original thread

rtthost

RTT (Real-Time Transfer) client

rucron

Job Scheduling Crate

waker-fn

Convert closures into wakers

tc-transact

Traits and locking utilities for a TinyChain transaction

disruptor

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

atom_box

safe idiomatic Rust implementation of Atomic Box using hazard pointers

deadqueue

Dead simple async queue

thingvellir

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

lock_api

Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.

boxcar

concurrent, append-only vector

everygarf

Concurrently download every Garfield comic to date

fs-lock

Locked files that can be used like normal File

shred

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

atomic_once_cell

Thread-safe and lock-free OnceCell and Lazy

melodium

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

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!)

rcron

cron job scheduling for rust

neon-runtime

Bindings to the Node.js native addon API, used by the Neon implementation

skl

lock-free thread-safe concurrent ARENA based (heap backend or memory map backend) skiplist implementation which helps develop MVCC memtable for LSM-Tree

uuid7

proposed UUID Version 7

atto

Future project

s3get

Download a single file from S3 using chunks

rayon-cond

Experimental iterator wrapper that is conditionally parallel or serial

blocking-threadpool

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

rearch

Re-imagined approach to application design and architecture

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

watchable

RwLock-like type that is compatible with both multi-threaded and async code

utils-atomics

Various atomic utils

erldash

terminal-based Erlang dashboard

datacake-crdt

conflict free replicated datatype based on a hybrid logical clock implementation for building eventually consistent data stores

peace-lock

zero-cost abstraction lock that helps check contention free algorithms

owning_ref

creating references that carry their owner with them

kvx

Abstraction layer over various key-value store backends

boomphf

Scalable and Efficient Minimal Perfect Hash Functions

tracing-mutex

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

range-lock

Range lock for std::vec::Vec

throttle-client

Client for Throttle. Throttle is an http semaphore service, providing semaphores for distributed systems.

local-sync

Non-threadsafe data structure for async usage

ringbuf-blocking

Blocking version of ringbuf

asyncgit

allow using git2 in a asynchronous context

bastion-executor

Cache affine NUMA-aware executor for Rust

concurrent_arena

u32 concurrent insertion/removal arena that returns ArenaArc

minimax

Generic implementations of Minimax

resman

Runtime managed resource borrowing

ocl-interop

Creates an OpenCL Context with OpenGL Interop enabled

ipc-rpc

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

mco

Coroutine Library like go

command-executor

Command Executor thread pool

swap-buffer-queue

buffering MPSC queue

genserver

Elixir inspired async actor library

redsync

Redlock for distributed locks with Redis

hyperbridge

Fast multi-producer multi-consumer channel with async support

slog-atomic

Atomic run-time controllable drain for slog-rs

jobslot

GNU make jobserver for Rust

rcu_cell

lockless rcu cell implementation

global_counter

Global, thread-safe counters

scoped_threadpool

scoped and cached threadpools

type-map

typemap container with FxHashMap

storyteller

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

semaphore-key

control concurrent thread access by key using a shared semaphore

amadeus

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

active_standby

concurrency primitive for high concurrency reads

threadcell

cell whose value can only be accessed by a owning thread

blackhole

...to throw your threads into

rs-consul

access to a set of strongly typed apis to interact with consul (https://www.consul.io/)

sparking-lot-core

parking on addresses

rclite

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

lockpool

offers a pool of locks where individual locks can be locked/unlocked by key

pi_share

rc, arc, lock, atomic

lunatic-control

TBD

jod-thread

std::thread which joins on drop by default

leapfrog

fast, lock-free concurrent hash map

recloser

concurrent circuit breaker implemented with ring buffers

lrwn

encoding / decoding LoRaWAN frames

fuchsia-zircon

bindings for the Zircon kernel

round_mult

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

node-replication

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

append-only-vec

Append-only, concurrent vector

iotics-grpc-client

IOTICS gRPC client

workerpool

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

atomig

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

work-queue

concurrent work-stealing queue for building schedulers

atomic-shim

Atomic types for unsupported platforms

sharded_mutex

Atomic Everything

watch

synchronous message passing channel that only retains the most recent value

mpsc

channel

atomicell

Multi-threaded RefCell on atomics

either-slot

atomic slot whose senders can either place their value into the slot, or retrive all the data from the slot

synchronized

Convenient and simple macro for code synchronization in multithreading

riscv-atomic-emulation-trap

atomic emulation trap handler for non atomic RISC-V targets

sdl-parser

SDL parser is a Rust tool designed for parsing Scenario Defined Language files

quartz_sched

Minimalistic scheduling library for Rust

snowdon

lightweight thread-safe snowflake ID implementation for Rust

rustix-futex-sync

Linux futex-based synchronization

rtic-sync

Synchronization primitives for asynchronous contexts

sync_file

Files that can be read concurrently

uid

creation of unique IDs

memo-map

implementing a synchronized map for memoization

maybe-rayon

Either acts as rayon or creates a single-threaded facade

hebo_codec

Packet codec for MQTT protocol

atomptr

safe, dependency-less abstraction for typed atomic smart pointers

atomic_float

Floating point types which can be safely shared between threads

lariv

Linked Atomic Random Insert Vector: a thread-safe, self-memory-managed vector with no guaranteed sequential insert

txn_lock

support transactional versioning

zestors

fast and flexible actor-framework for building fault-tolerant Rust applications

qdk_sim_experimental

Experimental simulators for use with the Quantum Development Kit

tlrepo

Thread-local git2::Repository, shareable across threads

libssh2-sys

Native bindings to the libssh2 library

whisk

fast lockless async channels

executor-service

fast and efficient Thread Pool like Java ExecutorService

lucchetto

easily call a rust function without holding the GVL lock

kube-leader-election

Leader election implementations for Kubernetes workloads

stm

Software transactional memory. Allows composable atomic operations.

scherben-map

Concurrent Sharded HashMap for Rust

disrustor

project is a port of the LMAX Disruptor to Rust

refs

My vision of reference counting

myriam

Remote actors on top of libp2p

queue-ext

extended feature of the queue can convert the pop() function of the queue to Stream and the push() function to Sender

stupid_utils

that provides some simple and maybe stupid or useful tools

iterator_ilp

Iterator extensions for instruction-parallel reductions

with_lock

Deadlock freedom

portable_atomic_enum

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

async-events

Waiting for external task completion in asynchronous Rust code

atomx

Thread safe data structures based on atomic data types

conquer-once

Synchronization primitives for lazy and one-time initialization

basic_tcp_proxy

synchronous TCP proxy crate for forwarding TCP connections

shmap

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

arl

rate limiter to be used with tokio

atomic-wait

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

lockfree

concurrent data structures and a solution to the ABA problem as an alternative of hazard pointers

priority-inheriting-lock

priority-inheriting lock based on Linux futexes

mem_btree

Data Structure of BTree Implemented with Rust, support snapshot. not use any unsafe lib.

sea-streamer-examples

🌊 The stream processing toolkit for Rust

cdk-from-cfn

Turn AWS CloudFormation templates into AWS CDK applications

search-query-parser

parse complex search query into layered search conditions, so it will be easy to construct Elasticsearch query DSL or something else

ccd

windows simple, fast chrome_cookie_decryptor

kanin

RPC microservice framework for AMQP, protobuf and Rust built on lapin (https://github.com/amqp-rs/lapin)

loole

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

lfchring

Concurrent, lock-free implementation of a consistent hashing ring data structure, supporting virtual nodes and keeping track of replication

norpc

Framework for in-process microservices

tc-scalar

TinyChain's scalar value enum, including concurrently-resolvable op definitions and references

fast-async-mutex

lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)

color-rs

that provides types and conversions for working with various color formats. Forked from the unmuntained crate color

blaze-rs

Rustified OpenCL Experience

actix-jobs

job scheduler for Actix

tyra

Typed Actor System

datacake

batteries included framework for building fault-tolerance distributed data systems

agner-init-ack

actor toolkit inspired by Erlang/OTP (init-ack)

std-ext

Extend the standard library functionality

single_value_channel

Concurrent single-value update and receive channel

tinypointers

Pointer implementations that take 8 or 16 bits

scoped-thread-pool

flexible thread pool providing scoped threads. Updated fork of https://github.com/reem/rust-scoped-pool

pausable_clock

source of time information that can be paused and resumed

hopper

unbounded mpsc with bounded memory

derivable-object-pool

thread-safe derivable object pool collection with automatic reusage of objects

left-right

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

employees

small runtime that hides all the boilerplate when using threads

pargraph

Operator based parallel graph processing

tokio-cron

cron scheduler for tokio

pawawwewism

wewy sewious wibwawy fow stwuctuwed concuwwency, i pwomise :3

crawly

lightweight async Web crawler in Rust, optimized for concurrent scraping while respecting robots.txt rules

actix-broker

Message broker for the Actix actor framework

unit16

whp-unit16

deque

(mostly) lock-free concurrent work-stealing deque

kcas

lock-free, allocation-free multi-word compare-and-swap library

ballista-scheduler

Ballista Distributed Compute - Scheduler

mtxgroup

mutex group locks all mutexes at the same time

executors

collection of high-performance task executors

halt

functionality for pausing, stopping, and resuming iterators, readers, and writers

inline-array

efficient immutable inlinable byte array

bursty

Test support for exarcebating contention in multi-threaded code

mop

Flexible and modular single or multi-objective solver for contiguous and discrete problems

lock_free_hashtable

Lock-free (almost) insertion only hashtable

semka

Semaphore implementation

bustle

Benchmarking harness for concurrent key-value collections

session_types

session types in Rust

sea-streamer-redis

🌊 SeaStreamer Redis Backend

nolock

collection of Lock-Free Datastructures

hybrid-rc

Thread-safe hybrid reference counting pointers

geese_pool

Message-passing system for networking with Geese

staging-tracking-allocator

Tracking allocator to control the amount of memory consumed by the process

todc-mem

Algorithms for shared-memory distributed systems

wasm-futures-executor

Executor for asynchronous task based on wasm web workers

fn-store

dynamic persistent value store using closure type as key and storing its return value

os-thread-local

OS-backed thread-local storage. This crate provides a ThreadLocal type as an alternative to std::thread_local! that allows per-object thread-local storage, while providing a similar API…

cloudabi

Low level interface to CloudABI. Contains all syscalls and related types.

mintex

minimal mutex

rp2040-monotonic

RTIC Monotonic implementation based on RP2040's Timer peripheral

uf_rush

lock-free, thread-safe implementation of the Union-Find (Disjoint-Set) data structure

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.

test-with-tokio

attribute macro for tests using tokio with cases and async guards

lib-wc

Will's Programming Toolbox

namaste

mt-debug-counters

support high performance debug counters for heavy multithreaded applications

arccstr

Thread-safe, reference-counted null-terminated immutable strings

yaambo

concurrent skip lists

asyncified

small library for operating on long lived sync values in an async context

irox-threading

Blocking and Asynchronous Threading Tools

kontroli

Type checking for the lambda-Pi calculus modulo rewriting

datacake-rpc

zero-copy, actor-like RPC framework using rkyv

remutex

Recursive mutex, adapted from Rust's standard library

atomic_pingpong

Lightweight no_std ping-pong buffer, using AtomicU8 for synchronization

safe-lock

lock struct with a const fn constructor and no unsafe

sentinel-core

flow sentinel of your microservices

xtensa-atomic-emulation-trap

atomic emulation trap handler for non atomic Xtensa targets

rayon-core

Core APIs for Rayon

ach-cell

Atomic Channel

flashmap

lock-free eventually consistent concurrent hash map

cht

Lockfree resizeable concurrent hash table

voluntary-servitude

Thread-safe appendable list with lock-free iterator

treiber_stack

lockless, thread-safe, atomic linked-list

cache-padded

Prevent false sharing by padding and aligning to the length of a cache line

flo_stream

Pubsub and related streams for Rust futures

microamp

Asymmetric Multi-Processing on microcontrollers

evmap

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

open-coroutine

efficient and generic stackful-coroutine library

constellation-rs

Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs

no-std-async

Async synchronization primitives for #[no_std] rust

rsgc

Concurrent GC library for Rust

rgraph

task graph library

rudderanalytics

RudderStack Rust SDK is an analytics client to track events from your Rust application

cloudi

API

rt-history

RT-safe history log with error checking

fluxion

actor framework written in rust and designed for distributed systems

bombs

Efficient single-producer multi-consumer channel types

unknownrori-simple-thread-pool

lighweight thread pool for networking and other stuff

gbench

tools to benchmark code for further analyzation using Chrome tracing

read-write-api

interface to unify single-threaded code and RwLocks-based code

multiqueue2

fast mpmc broadcast queue

chunker

Minimalistic parallel executor

lightproc

Lightweight process abstraction for Rust

per-thread-object

Efficient per-object thread-local storage implementation

lock-free-static

Lock-free static variables

polymock

thread-safe arena bytes allocator

rsevents-extra

Synchronization objects built on top of rsevents. Semaphore, countdown event, and more.

mwcas

Multi-word CAS primitive

acto

light-weight Actor library for Rust

ra_ap_flycheck

TBD

shrink_pool

thread pool which agressively terminates its threads as soon as they are idle

pi_rt_file

async file 的封装，添加了多线程竞争排序。

shared_cell

Interior mutability between concurrent tasks on the same thread

readlock

weird alternative to Arc<RwLock<T>>

bztree

BzTree implementation for Rust

poolio

thread-pool

rt

real-time operating system capable of full preemption

ductile

channel implementation that allows both local in-memory channels and remote TCP-based channels with the same interface

rearch-tokio

Re-imagined approach to application design and architecture

channel-sender

Channel Sender

bi

kit for reading/writing resources

thread_lake

very high level thread pool manager

neuron-rs

actor system for building reactive, concurrent, and resilient distributed services

octoproxy-server

Server library for octoproxy

per-thread-mutex

Synchronization lock designed for wrapping thread-unsafe C libraries

ns3-parallel

Multitask Parallel Concurrent Executor for ns-3 (network simulator)

chashmap-serde

Fast, concurrent hash maps with extensive API and Serde support

spinout

thread-safe clonable and mutable smart-pointer akin to Arc<Mutex<T>>, using spin-lock instead of system futex

ump

Micro message passing library for threads/tasks communication

proglog

Thread safe progress logging

stronghold-rlu

Read-Log-Update software transactional memory like synchronization mechanism

antidote

Poison-free versions of the standard library Mutex and RwLock types

try-mutex

Fast non-blocking mutex

jni-utils

Extra Utilities for JNI in Rust

minicoroutine

mini coroutine library in rust

rpools

minimalist workerpool for rust

dragonfly-api

Canonical location of the Dragonfly API definition

stewart

minimalist, high-performance, and non-exclusive actor system

mth_calc

demonstrating Cargo. Contains helper method for running a process in parallel on all available processors.

hey_listen

event-dispatcher-collection offering async, sync, parallel, and prioritised solutions!

pcp-mutex

Priority Ceiling Protocol (PCP) mutex, based on Linux PI futex. Allows efficient and deadlock free execution.

mycorrh

fast concurrent messaging system for Rust

ccl_owning_ref

creating references that carry their owner with them

async-datachannel

Async Wrapper for datachannel

conqueue

multi-producer, single-consumer queue (MPSC)

may_waiter

coroutine communication blocker

plonky2_maybe_rayon

Feature-gated wrapper around rayon

tlid

Thread Local ID generator by predefined range without atomics/locks/random/time

sync-unsafe-cell

backport of the SyncUnsafeCell standard library type for use in older Rust versions

shared-expiry-get

concurrent async get with expiration for Rust

twinsies

Smart pointer providing 2-way joint ownership of an object

slazy

small, no-std, macro-based lazy static library for Rust

rayon-wasm

work-stealing parallelism for Rust

atomic_enum

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

split_channel

stream-of-messages abstraction with split send/recv channels

talos_messenger_actions

Messenger actions for Talos

rusty_junctions

Join Pattern implementation in Rust

concurrent_lru

concurrent LRU cache

client-handle

macro to generate client handles when using multithreaded / asynchronous code

ipmpsc

Inter-process Multiple Producer, Single Consumer Channels

zkstate

Share a struct across multiple instances of an application using zookeeper

rust-releases-core

Base traits and definitions for rust-releases

atomic-counter

Atomic (thread-safe) counters for Rust

simplelock

abstractions for inter-process synchronization

async-cpupool

async threadpool for CPU-bound tasks

pi_slot_deque

Two terminal queue based on slotmap

goko

lock-free, eventually consistent, concurrent covertree

usync

fast, drop-in, synchronization primitives

wishbone-bridge

control Wishbone devices

csplib

CSP for concurrent programming

cerk_runtime_threading

package for CERK. CERK is an open source CloudEvents Router written in Rust with a MicroKernel architecture.

graph_csr

that provides utility functions for manipulating graphs in a CSR format, used as the baseline for constructing powerful graph algorithms

singlyton

Safe, single-threaded global state in Rust

little_raft

lightest distributed consensus library. Run your own replicated state machine!

kademlia-dht

Kademlia DHT

ebr

epoch-based reclamation with low cacheline ping-pong