Lib.rs

parking_lot

More compact and efficient implementations of the standard synchronization primitives

crossbeam-channel

Multi-producer multi-consumer channels for message passing

rayon

Simple work-stealing parallelism for Rust

dashmap

Blazing fast concurrent HashMap for Rust

threadpool

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

crossbeam-queue

Concurrent queues

futures-channel

Channels for asynchronous communication using futures-rs

loom

Permutation testing for concurrent code

crossbeam-utils

Utilities for concurrent programming

region

A library for manipulating memory regions

crossbeam

Tools for concurrent programming

evmap

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

spin

Synchronization primitives based on spinning. They may contain data, are usable without std, and static initializers are available

bastion

Fault-tolerant Runtime for Rust applications

arrayfire

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…

amadeus

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

flume

A blazingly fast multi-producer channel

fs2

Cross-platform file locks and file duplication

rustacuda

CUDA Driver API Wrapper

cortex-m-rtic

Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems

bus_queue

Lock-free Bounded non-Blocking Pub-Sub Queue

ringbuf

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

may

Rust Stackful Coroutine Library

executors

A collection of high-performance task executors

faster-rs

Rust wrapper for FASTER by Microsoft Research

lock_api

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

spin_sleep

Accurate sleeping. Only use native sleep as far as it can be trusted, then spin.

crossbeam-deque

Concurrent work-stealing deque

atomic_refcell

Threadsafe RefCell

scheduled-thread-pool

A scheduled thread pool

kafka

Rust client for Apache Kafka

parking

Thread parking and unparking

rustc-rayon

Simple work-stealing parallelism for Rust - fork for rustc

krecik

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

pueue

A cli tool for managing long running shell commands

bastion-executor

Cache affine NUMA-aware executor for Rust

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

rayon-core

Core APIs for Rayon

cortex-m-rtfm-macros

Procedural macros of the cortex-m-rtfm crate

bus

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

double-checked-cell

A thread-safe lazily initialized cell using double-checked locking

stateright

A model checker for implementing distributed systems

try-lock

A lightweight atomic lock

mpstthree

A library implementing Multiparty Session Types for 3 participants

conquer-once

Synchronization primitives for lazy and one-time initialization

radium

Helper traits for working with maybe-atomic values

object-pool

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

lever

Pillars for Transactional Systems and Data Grids

may_queue

May’s internal queue library

atomicring

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

desync

A hassle-free data type for asynchronous programming

spinning_top

A simple spinlock crate based on the abstractions provided by lock_api

thread_io

Crate for performing I/O in background thread

broadcaster

Broadcasting futures mpmc channel

cueball-static-resolver

This is an implementation of the cueball Resolver trait that provides a static list of backends for use by the connection pool

oneshot

Oneshot spsc channel with lock-free non-blocking send and a receiver supporting both thread blocking receive operations as well as Future based async polling

parallel-iterator

Parallelize any iterator with ease!

jod-thread

std::thread which joins on drop by default

throttle-server

Provide semaphores for distributed systems via an http interface

actors-rs

Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.

ipc-channel

A multiprocess drop-in replacement for Rust channels

sluice

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

mpi

Message Passing Interface bindings for Rust

arcstr

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

multiqueue2

A fast mpmc broadcast queue

thread-id

Get a unique thread ID

workerpool

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

axiom

Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka

zookeeper

A minimal ZooKeeper client

chashmap

Fast, concurrent hash maps with extensive API

yaque

Yaque is yet another disk-backed persistent queue for Rust

crossbeam-epoch

Epoch-based garbage collection

etcd-client

An etcd v3 API client

recloser

A concurrent circuit breaker implemented with ring buffers

slog-atomic

Atomic run-time controllable drain for slog-rs

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

atomic-counter

Atomic (thread-safe) counters for Rust

atomig

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

secc

Implements a Skip-Enabled Concurrent Channel (SECC) for Rust

thingvellir

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

atomic_lib

Library for creating, storing, querying, validating and converting Atomic Data

rtfm-syntax

The Real Time for The Masses (RTFM) meta language

asyncgit

allow using git2 in a asynchronous context

hopper

an unbounded mpsc with bounded memory

goko

A lock-free, eventually consistent, concurrent covertree

rayon_logs

Traces for the rayon work-stealing library

shared-bus-rtic

Provides utilities for sharing peripheral communication buses in an RTIC application

sig

ffi library of signal(2) and kill(2)

tcb

A middleware service for delivering messages in a causal order

syncpool

A thread-friendly library for recycle of heavy and heap-based objects to reduce allocation and memory pressure

session_types

An implementation of session types in Rust

async-mutex

Async mutex

arpx

Automate and relate multiple processes

sidekiq

Rust Sidekiq Client

parquet-format

Apache Parquet Format - thrift definition and generated Rust file

swf-emitter

SWF emitter

deque

A (mostly) lock-free concurrent work-stealing deque

shred

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

stm

Implementation of Software transactional memory. Allows composable atomic operations.

lifetime-thread

A thread with a lifetime. Divide a value into master and slave. After the lifetime of the master value ends, the slave value will not be accessible.

storage-map

Concurrent append-only map storage

acto-rs

Experimental actor library, under development. (renamed from minions_rs).

pausable_clock

A source of time information that can be paused and resumed

sonic-channel

Rust client for sonic search backend

crossfire

channels for async and threads

remutex

Recursive mutex, adapted from Rust’s standard library

tlid

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

concurrency

This exist to prove a point

global_counter

Global, thread-safe counters

ruget

Alternative to wget written in Rust

testbench

Testing and benchmarking tools for concurrent Rust code

scoped_threadpool

A library for scoped and cached threadpools

tasque

A simple thread pool library

concurrent-queue

Concurrent multi-producer multi-consumer queue

mchprs

A multithreaded minecraft server built for redstone

async_nursery

Primitive for structured concurrency

flo_stream

Pubsub and related streams for Rust futures

ordered-parallel-iterator

Performs tasks in parallel returning completed tasks in order of appearance

ev_slotmap

A lock-free, eventually consistent, concurrent slot map

lazy_transducer

Lazy, parallel, indexable, generic data iterators

process_control

Methods for ergonomically running processes with timeouts

hidefix

Concurrent HDF5 and NetCDF4 reader (experimental)

halt

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

semalock

A library for concurrently writing to files in a safe and efficient manner

thread_local

Per-object thread-local storage

parallel-stream

Data parallelism library for async-std

actor-es

An event sourcing + CQRS abstraction on top of Riker

cueball

A connection pool to manage connections to a multi-node service

context

Cooperative multitasking for Rust using Boost.Context

cht

Lockfree resizeable concurrent hash table

atomic-shim

Atomic types for unsupported platforms

throttle-client

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

theatre

A concise async actor model implementation

coroutine

Coroutine Library in Rust

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.

signalbool

A simple crate to catch signals and set a boolean flag for later use

lockfree

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

yaks

Minimalistic framework for automatic multithreading of hecs via rayon

elysees

A fork of triomphe::Arc, now with more pointer tricks

single_value_channel

Concurrent single-value update and receive channel

track

Track struct data modifications

thread-priority

Library for managing threads priority and schedule policies

skipchannel

skipchannels allow to communicate between threads, but always skip to the last sent value

cortex-m-rtic-macros

Procedural macros of the cortex-m-rtic crate

pipe-channel

Channel implementation based on pipes

amadeus-types

Harmonious distributed data analysis in Rust

lossyq

This is a concurrent single publisher, single consumer queue with fixed length, that never blocks the writer

rgraph

A task graph library

flurry

Rust port of Java’s ConcurrentHashMap

tari_broadcast_channel

Bounded non-blocking single-producer-multi-consumer broadcast channel

amadeus-parquet

An Apache Parquet implementation in Rust

transaction-pool

Generic transaction pool

dynqueue

Dynamically extendable Rayon parallel iterator

slave-pool

Simple thread pool

ring-channel

Bounded MPMC channel abstraction on top of a ring buffer

thread_tryjoin

Try joining a thread

async-channel

Async multi-producer multi-consumer channel

hexpm

A Rust client for the Hex package manager

mioco

Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)

lazy-init

Lazy initialization

futures-rate

This library provides easy tools to help Rust applications guide critical resources or code paths from being overwhelmed

multi-map

Like a std::collection::HashMap, but allows you to use either of two different keys to retrieve items

concurrent-hashmap

A concurrent hashmap library

rsevents

Manual and auto reset events for signaling remote threads and building synchronization primitives

rcu_cell

a lockless rcu cell implementation

delay

A collection of trait and classes to make your thread wait (and timeout)

caring

Sharing is caring: a safe library for mmap’ing memory in multiple processes

hypercore-protocol

Replication protocol for Hypercore feeds

streamcatcher

A thread-safe, shared (asynchronous), almost-lockless stream buffer

yaar-lock

Fast, no_std synchronization primitives

fast-async-mutex

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

rtic-syntax

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

jobpool

A simple and lightweight threadpool implementation

ocl-core

A low-level OpenCL API

atomic_prim_traits

Traits over primitive atomic types

kademlia-dht

A simple implementation of the Kademlia DHT

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 as long as T can be build statically.

parking_lot_core

An advanced API for creating custom synchronization primitives

lightproc

Lightweight process abstraction for Rust

apodize

simple iterators that yield generalized cosine, hanning, hamming, blackman, nuttall and triangular windows

atomic-option

An atomic, nullable, owned pointer

ghetto-lock

Memcache backed ghetto lock implementation

multiqueue

A fast mpmc broadcast queue

brutils

Some utilities for Rust

hazptr

hazard pointer based concurrent memory reclamation

os-sync

Simple synchronization primitives based on OS semaphore

pinboard

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

git-mirror

Sync between different git repositories

managed-thread

Real fearless concurrency! Spawn threads that will be automatically destroyed when no longer needed

simple_event_map

a simple event map based on channels, provides a receiver that is either blocking or async

ratelimit

a token bucket ratelimiter

swapper

Swap ownership between threads

bchannel

A better channel API

stoplight

Stoplight is a simple library for stoppable tasks/threads

concurrent_prime_sieve

Tools for generating filters and collections with primes concurrently. Rust implementation of the Sieve of Atkin. This implementation runs in O( sqrt(max_num) + section_size ) (where section_size = max_num - min_num)…

signal-notify

Catch OS signals with standard mpsc channel

init_guard

A Synchronization Primitive for guarding against double initialization

eventual

Future & Stream abstraction

rusty_junctions

Join Pattern implementation in Rust

scheduler

Binding to set the linux scheduler (priority, policy, affinity, &c.)

ductile

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

atomic_enum

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

sendify

An unsafe crate to wrap a reference to make it Send + Sync

cw20-atomic-swap

Implementation of Atomic Swaps

priomutex

A mutex where waiting threads specify a priority

kekbit-core

Defines the main abstractions and provides the core components required to work with kekbit channels

or-iterator

Rust iterator which takes two iterators and returns non-empty one

spinning

Mutexes and SIX locks implemented by spinning

miniqueue

A minimalistic single-thread job queue based on fold/reduce

blackhole

…to throw your threads into

glock

Granular locking crate for Rust

bigml-parallel

CLI tool for executing multiple BigML scripts in parallel

nfqueue

Netfilter NFQUEUE high-level bindings

cbloom

Concurrent implementation of Bloom filters

movie

An actor / thread orchestration library / macro / framework

namaste

Simple locks between processes

atomic_immut

Atomic immutable value

spsc-bip-buffer

A concurrent, spsc ring-buffer with sized reservations

per-thread-object

Efficient per-object thread-local storage implementation

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

rayon_croissant

bikeshedding the name: something that is mapped folded and collected, a 🥐

mth_calc

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

flize

non global, configurable and fast concurrent resource reclamation

wait_group

golang sync.WaitGroup in Rust

riker-cqrs

Provides Command Query Responsibility Separation for Riker applications

evc

Eventually consistent synchronization primitive

kontroli

Type checking for the lambda-Pi calculus modulo rewriting

mpsc_requests

mpsc channels but with a response

moniclock

Monotonic clock

apex

A configurable, multi-threaded signals and slots implementation for Rust

hey_listen

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

cuneiform

Cache optimizations for Rust, revived from the slabs of Sumer

raii-counter

RAII Counter

revenq

A concurrent, revision-based event queue implementation

unbounded-spsc

An unbounded spsc queue built from bounded_spsc_queues

rad

A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust

mpmc

copy-pasted from old rust stdlib

pond

A library for scoped and cached threadpools that keep a state

incr

Simple, fast and self-contained data structures for checking whether a new value is greater than the previous maximum

atomic

Generic Atomic wrapper type

magnetic

Low-latency lock-free queues

queuecheck

A thread-safe queue testing and benchmarking library

task_queue

The implementation of the thread pool for Rust

rdispatcher

Dispatcher for Rust, broadcast and subscribe many to many

cuda-runtime-sys

Rust binding to CUDA Runtime APIs

employer

Spawn worker threads and check on them later

delay-queue

A concurrent unbounded blocking queue where each element can only be removed when its delay expires

want

Detect when another Future wants a result

npnc

Lock-free queues

atomic_float

Floating point types which can be safely shared between threads

simplelock

Simple abstractions for inter-process synchronization

colosseum

A variety of arena allocators for Rust, including thread-safe arenas

efflux

Easy MapReduce and Hadoop Streaming interfaces in Rust

ppipe

An elegantly simple and lightweight library for making iterator pipelines concurrent and blazingly fast, hence the name ppipe (parallel pipe)

carboxyl

Library for functional reactive programming

mesos

Mesos library using the new HTTP API

coroutines

High performance coroutine library with native experience

once_spin

Synchronization primitives based on spinning. They may contain data, are usable without std, and static initializers are available

meio

A compact actors framework for the async epoch in Rust & Tokio

shred-derive

Custom derive for shred

shared_channel

Multi-producer, multi-consumer FIFO queue communication primitives

signal-simple

Library to handle and send system signals

amadeus-serde

Harmonious distributed data analysis in Rust

borrowed-thread

thread-safe way to pass borrow to thread::spawn

no_deadlocks

A Runtime Deadlock Debugger

greenie

Green threads and coroutines in stable Rust

e_book_sync_library

Synchonize e-book with your local e-library

atomic-stamped-ptr

AtomicStampedPtr for x86_64

indexed-ring-buffer

An indexed multiple readable spsc ring buffer

try-mutex

Fast non-blocking mutex

xarc

xarc provides atomically swappable atomically refcounted smart pointers as a safer building block for lockfree algorithms than raw atomic pointers. Xarc is comparable to Arc but…

fifo

First-in-first-out lock-free ring-buffer like kfifo in Linux

rpool

Lock-free generic resource pool implementation

ping-pong-cell

An atomic cell for up to two threads

zhelezo

Extensible, Concurrency Focused Web Development in Rust

funfsm

An FSM library where the states are functions

async-parallel

deleted - email help@crates.io to claim this crate name

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.

rust_events

A flexible event-handling library, based on the C# delegate model

disrustor

This project is a port of the LMAX Disruptor to Rust

sched-clock

A timer for task scheduling

io_partition

A library allowing to use just a part of a Read + Seek object

bustle

Benchmarking harness for concurrent key-value collections

forkjoin

A work stealing fork-join parallelism library for Rust

monitor

Monitor synchronization construct

simple_parallel

Straight-forward functions and types for basic data parallel operations, including parallel maps, for loops and thread pools

conqueue

Yet another multi-producer, single-consumer queue (MPSC)

maybe-atomic

Versions of atomics whose atomic-ness can be toggled

locker

Simple named mutex/locker for rust-lang concurrency

eventbus

Safe, fast and concurrent event system, inspired by the MinecraftForge event bus

arcmutex

A convenience library for working with Arc<Mutex<T>>s

monotone

Library of counters and queues for coordination in distributed systems

zonyitoo/coio

Coroutine scheduler with non-blocking I/O support

zermelo

A library that retrieves a schedule from Zermelo

thread

rev_lines

Rust Iterator for reading files line by line with a buffer in reverse

pipelines

A tool for constructing multi-threaded pipelines of execution

canal

A library for multithreaded concurrency primitives, including queues and channels

latest

A channel-esque type that only stores the last value that was sent

shared-expiry-get

Simple concurrent async get with expiration for Rust

sleepfast

Sleep for very small amounts of time quickly

atomic-server

Create, share and standardize linked atomic data!

pipeliner

Provides a nice interface for parallel programming with iterators

pflock

A phase-fair reader-writer lock that reduces worst-case blocking for readers. Especially useful for multiprocessor real-time systems.

atomic_hooks_macros

Macros for CSS Styling for Seed web apps

bi

Simple kit for reading/writing resources

heartbeats-simple

Rust abstractions for heartbeats-simple-sys

overdose

Fast, Row Oriented, Kotlin, Scala-like dataframe

contrie

Concurrent map and set

krecik-cli

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

conman

Concurrency Manager and work item queue in pure safe rust

lockless

Composable, lock-free, allocation-light data structures

rayon-join-macro

A convenience n-nary macro around rayon::join()

sync_wrapper

A tool for enlisting the compiler’s help in proving the absence of concurrency

nature_demo_executor

Demo converter

atomic-batcher

A simple batching function that allows you to atomically batch a series of operations

rusty-variation

A library for deadlock-free session-typed communication

concurrent-event

An event system which invokes event handlers concurrently

grandma

A lock-free, eventually consistent, concurrent covertree

access-queue

limit the number of simultaneous accesses to a value

hurdles

Counter-based thread barrier

run-down

An implementation of run-down protection in rust

fused-reader

This crate provides fused reader type that if writer thread dies while holding armed fuse the reader will get BrokenPipe error

ditto

CRDTs for common data structures like maps, sets, vecs, strings, and JSON

finarc

Arc with finalizer called once last clone is dropped

shareable

Thread shareable objects using the minimal amount of synchronization

cueball-tcp-stream-connection

This is an implementation of the cueball Connection trait for TcpStream from the rust standard library

spmc

Simple SPMC channel

tokio-executor

Future execution primitives

counting-networks

Lock-free data structures for concurrent counting

rtic-core

Core abstractions of the Real-Time Interrupt-driven Concurrency framework

urcu-sys

System bindings for urcu (user-space rcu)

greentask

Library to use coroutines as green tasks

scheduled-executor

Single and multi-threaded task scheduler

ringtail

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

rtfm-core

Core abstractions of the Real Time For the Masses framework

reclaim

trait-based abstract interface for memory reclamation

fs3

Cross-platform file locks and file duplication

send-cell

Immutable memory region with runtime Send checking

evmap-derive

Derive macro for evmap::ShallowCopy

tange

Scalable Task-based Parallelism Framework

waker-fn

Convert closures into wakers

mpi-sys

Message Passing Interface bindings for Rust

herbert

simple actor management

ump

Micro message passing library for threads/tasks communication

poolite

A lite threadpool library

easy-parallel

Run closures in parallel

mrogalski-looper

Clean abstraction for a single-threaded event loop. Built as a lightweight wrapper around the std::sync::mpsc package.

std-semaphore

A counting, blocking sempahore extracted from rust 1.7.0

runloop

Cancelable non-blocking polling threads (with optional timeouts)

synchronoise

Synchronization primitives that build upon the standard library

slock

An async mutex that never deadlocks

ocl-interop

Creates an OpenCL Context with OpenGL Interop enabled

lockfreehashmap

A concurrent, lock-free hash map

dashcache

A simple, highly concurrent cache for hash-consing values

option-lock

A multi-purpose read/write lock for Option values

cache-padded

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

mpmc-scheduler

multi-mpmc, cancellable, scheduler with rate limiting

redlock

Implementation of the distributed locking mechanism built on top of Redis

smartpool

A very customizable, future-aware threadpool

ccl

Fast datastructures for use in highly concurrent systems

lock-free-stack

Lock-free (atomic-based) Collection which internally represent data as a Stack, and exposes an interface allowing to add elements, get size, and remove all giving a reverse-iterator

hazard

Hazard pointers

locklessness

Composable, lock-free, allocation-light data structures

transformable_channels

Rust channels are a convenient abstraction, but for many uses cases, they miss high-level transformations such as map, filter, … . This crate introduces them.

refptr

Inherently reference counted structs

joyent/cueball

A connection pool to manage connections to a multi-node service

context_bind

Simple M:N threading library. Should support Linux, MacOS, Free/OpenBSD, and Windows for x86/64, and aarch32/64

son_of_grid_engine

Interface with son of grid engine (formerly sun grid engine) to run rust programs on clusters

triomphe

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

atomic-ref2

Provides AtomicOptionRef and AtomicRef. Intended to map to java.util.concurrent.atomic.AtomicReference in Java.

par-map

Parallel map and flat_map

async-lock

Async synchronization primitives

sealrs

Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)

threadpool_scope

A library for adding scopes to the threadpool crate

lock-free-multi-producer-single-consumer-ring-buffer

A lock-free, multi-producer, single-consumer (MPSC) ring buffer. Optimized for sending and receiving ‘bursts’ of messages. Can also be used as a ring queue. It is a Rust port of Mindaugas Rasiukevicius’s ringbuf.

async-handle

A reference-counted async RwLock

ccl-crossbeam-epoch

Epoch-based garbage collection

conc

Hazard-pointer-based concurrent memory reclamation

semka

Semaphore implementation

rustc-rayon-core

Core APIs for Rayon - fork for rustc

parc

Rust crate for cancellable time based contracts in async/await

amadeus-aws

Harmonious distributed data analysis in Rust

file-lock

File locking via POSIX advisory record locks

qadapt-spin

Synchronization primitives based on spinning. They may contain data, are usable without std, and static initializers are available

td_rthreadpool

thread wrapper for Rust

dynpool

A thread manager that is lightweight, flexible, and rescalable

sync_splitter

Safely split a mutable slice in multiple threads at the same time

humthreads

Threads for humans

future-parking_lot

An “as simple as possible” Future implementation for parking_lot

cuckoocache

High performance concurrent cache

mozilla/sync-guid

Firefox Application Services

waker-queue

A queue with a waker attached. Low level plumbing.

futures-channel-preview

Channels for asynchronous communication using futures-rs

dir-lock

A simple file-system-based mutex

threads

Traits to abstract thread-pools

atomic-cli

CLI tool to create, store, query, validate and convert Atomic Data

tasks-framework

Actor-like Message processing framework inspired by the work of Stepan Koltsov

may_actor

Simple Actor library based on MAY

rayon-macro

Macros enabling parallelism using the rayon crate