-
parking_lot
More compact and efficient implementations of the standard synchronization primitives
-
spin
Spin-based synchronization primitives
-
async-lock
Async synchronization primitives
-
event-listener
Notify async tasks or threads
-
kanal
The fast sync and async channel that Rust deserves
-
critical-section
Cross-platform critical section
-
embassy-sync
no-std, no-alloc synchronization primitives with async support
-
hdf5
Thread-safe Rust bindings for the HDF5 library
-
hdf5-metno
Thread-safe Rust bindings for the HDF5 library
-
internment
Easy interning of data
-
rxrust
Reactive Extensions
-
async-once-cell
Async single assignment cells and lazy values
-
sieve-cache
SIEVE cache replacement policy with thread-safe wrappers
-
lockfree-object-pool
A thread-safe object pool collection with automatic return and attach/detach semantics
-
concread
Concurrently Readable Data-Structures for Rust
-
pinned-init
facilitate safe pinned initialization
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
maitake-sync
No-std async synchronization primitives from Maitake
-
acpi
A pure-Rust library for interacting with ACPI
-
iroh-quinn
Versatile QUIC transport protocol implementation
-
throttle-server
Provide semaphores for distributed systems via an http interface
-
mea
A runtime-agnostic library providing essential synchronization primitives for asynchronous Rust programming
-
embassy-rp
Embassy Hardware Abstraction Layer (HAL) for the Raspberry Pi RP2040 or RP235x microcontroller
-
shuttle
testing concurrent Rust code
-
saa
Word-sized low-level synchronization primitives providing both asynchronous and synchronous interfaces
-
guardian
owned mutex guards for refcounted mutexes
-
rtic
Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems
-
mutex
An abstraction over closure-based mutexes
-
syslog-rs
A native Rust implementation of the glibc/libc/windows syslog client and windows native log for logging
-
libcryptsetup-rs
High level Rust bindings for libcryptsetup
-
nrf-modem
Async modem api for the nRF91xx
-
async-dup
Duplicate an async I/O handle
-
keepcalm
shared types for multi-threaded programs
-
arceos_posix_api
POSIX-compatible APIs for ArceOS modules
-
rust-key-paths
Keypaths for Rust: Static dispatch implementation (rust-keypaths) and legacy dynamic dispatch (key-paths-core). Type-safe, composable access to nested data structures.
-
edge-mdns
Async +
no_std+ no-alloc implementation of an mDNS responder -
cdns-rs
A native Sync/Async Rust implementation of client DNS resolver
-
amity
Concurrency algorithms
-
axlibc
ArceOS user program library for C apps
-
piper
Async pipes, channels, mutexes, and more
-
embedded-hal-bus
Bus/Device connection mechanisms for embedded-hal, a Hardware Abstraction Layer (HAL) for embedded systems
-
bach
Discrete-event simulation environment for async workflows
-
safina
Safe async runtime
-
cargo-mutants
Inject bugs and see if your tests catch them
-
azalea
A framework for creating Minecraft bots
-
lock_api
Wrappers to create fully-featured Mutex and RwLock types. Compatible with no_std.
-
bevy_platform
common platform agnostic APIs, as well as platform-specific features for Bevy Engine
-
rlsf
Real-time dynamic memory allocator based on the TLSF algorithm
-
cargo-check-deadlock
Detect deadlocks in Rust source code at compile time using Petri nets
-
happylock
Free deadlock prevention
-
ndata
Thread-safe, self-owned JSON-like data with manual garbage collection
-
port-expander
Abstraction for I2C port-expanders
-
instance-copy-on-write
A MT-safe copy-on-write implementation for the data structures
-
vhost-user-backend
A framework to build vhost-user backend service daemon
-
fibre
High-performance, safe, memory-efficient sync/async channels built for real-time, low-overhead communication in concurrent Rust applications
-
freertos-rust
Create to use FreeRTOS in rust projects. The freertos-cargo-build crate can be used to build and link FreeRTOS from source inside build.rs
-
a653rs
Arinc653 abstraction library for hypervisor independent partition programming
-
ibu
high throughput binary encoding genomic sequences
-
db-rs
fast, embedded, transactional, key value store
-
sugars
An useful collection of macros to make tasks easier
-
rl-core
Core logic for a token-bucket rate-limiter
-
csv_lib
parsing CSV files using memory-mapped I/O, with low alloc, and AVX2/NEON support
-
flipperzero
Flipper Zero
-
named-lock
Cross-platform implementation of cross-process named locks
-
swmr-cell
A thread-safe single-writer multi-reader cell with wait-free reads and version-based garbage collection
-
webrtc-util
WebRTC.rs stack
-
osal-rs
Operating System Abstraction Layer for Rust with support for FreeRTOS and POSIX
-
iceoryx2-pal-concurrency-sync
iceoryx2: [internal] low-level basic building blocks to implement posix mutex, condition variables etc
-
rtsc
Real-time Synchronization Components
-
matrix-sdk-ui
GUI-centric utilities on top of matrix-rust-sdk (experimental)
-
wasm_safe_mutex
A suite of WebAssembly-safe synchronization primitives that paper over platform-specific locking constraints
-
intern-arc
An interner that deallocates unused values
-
linked
Create families of linked objects that can collaborate across threads while being internally single-threaded
-
async-condvar-fair
Condition variables for async Rust
-
html2pdf-api
Thread-safe headless browser pool for high-performance HTML to PDF conversion with native Rust web framework integration
-
env-lock
Set and lock environment variables for tests
-
tracing-mutex
Ensure deadlock-free mutexes by allocating in order, or else
-
uefi-async
A lightweight asynchronous executor for UEFI environments
-
messaging_thread_pool
aiding the creation of typed thread pool of objects that is communicated with via channels
-
mcslock
Mellor-Crummey and Scott contention-free lock for mutual exclusion, referred to as MCS lock
-
cargo-perf
Preventive performance analysis for Rust - catch anti-patterns before production
-
mutex-traits
An abstraction over closure-based mutexes
-
deloxide
scrubs your threads clean by detecting deadlocks in real time—keeping your system smooth, safe, and corrosion-free. 🦀🧼🔒
-
async-mutex
Async mutex
-
xutex
an extremely fast async mutex with alternative sync API
-
futures-locks
Futures-aware lock primitives
-
crossync
A fast concurrent programming suite for Rust
-
no_deadlocks
A Runtime Deadlock Debugger
-
sadi
Semi-Automatic Dependency Injector
-
lockable
offers hash map, hash set and cache data structures where individual entries can be locked
-
anapaya-quinn
Anapaya's fork of the versatile QUIC transport protocol implementation
-
desync
A hassle-free data type for asynchronous programming
-
rust_web_crawler
A short summary of what your crate does
-
yaque
disk-backed persistent queue for Rust
-
tg-ch8
Chapter 8 of rCore Tutorial: Concurrency with threads, mutex, semaphore and condvar
-
http-type
comprehensive Rust library providing essential types for HTTP operations. Includes core HTTP abstractions (request/response, methods, status codes, versions), content types, cookies…
-
tg-ch6
Chapter 6 of rCore Tutorial: File system with easy-fs and virtio block device
-
easy_prefs
simplest to use API we could think of to persist prefs to disk. Basically wrap a macro around a struct (see syntax), then data is saved when you write to it. Performant, testable, thread safe…
-
vrc-get-litedb
reimplementation of LiteDB made for vrc-get
-
wd_tools
tools for rust
-
rustics
statistic library for performance analysis
-
k8s-controller
lightweight framework for writing kubernetes controllers
-
swmr-epoch
Single-writer multi-reader epoch-based garbage collection system with minimal locking
-
async-event
An efficient async condition variable for lock-free algorithms
-
wdk-mutex
An idiomatic Rust mutex type for Windows kernel driver development
-
oxidart
A very fast Tree that support get/set/del/ttl operations some variant
-
hazarc
A wait-free AtomicArc optimized for read-intensive use cases
-
autd3-link-soem
autd3 link using SOEM
-
rust_tokio_kcp
A kcp implementation for tokio
-
kanal-plus
Fork of kanal with extra features (drain_into_blocking, into_stream)
-
generic-container
Abstract over "containers" that hold a T, such as a T itself, Box<T>, or Arc<Mutex<T>>
-
rdl-gluon
Git-based configuration management and storage abstraction
-
feagi-state-manager
Runtime state management for FEAGI - cross-platform, RTOS-compatible
-
fluxion-core
Core traits and types for ordered stream processing
-
sanitizers
Interfaces and FFI bindings for the sanitizers interfaces
-
ccutils
Collection of utils from the CylonCore project
-
rx-rust
Reactive Programming in Rust inspired by ReactiveX https://reactivex.io/
-
threadsafe_zmq
Thread-safe ZeroMQ wrapper with sync and async support
-
c-scape
A libc bottom-half implementation in Rust
-
fast-stm
Performance-focused implementation of software transactional memory. Allows composable atomic operations
-
tool-orchestrator
Rhai-based tool orchestration for AI agents - implements Anthropic's programmatic tool calling pattern
-
memkit
Deterministic, intent-driven memory allocation for systems requiring predictable performance
-
waybackend-scanner
Waybackend implementation of wayland-scanner
-
signaled
A lightweight reactive programming library for Rust, providing a signal-slot mechanism
-
prun
Run 🍺
-
corroded-rs
that bypasses Rust's safety features
-
lfrlock
A Lock-Free Read Lock where reads never block and writes are serialized using Mutex
-
mambo_map
lightweight, simple, minimally blocking multithreaded hashtable
-
axstd
ArceOS user library with an interface similar to rust std
-
moto-hses-client
Async UDP client for Yaskawa High-Speed Ethernet Server (HSES) communication
-
ruapc-bufpool
A high-performance memory pool using buddy memory allocation algorithm for efficient fixed-size buffer management
-
thread-share
safe and efficient data sharing between threads with zero-copy operations, change detection, and enhanced thread management
-
mintex
minimal mutex
-
disrupt-rs
Concurrent Ringbuffer inspired by the LMAX Disruptor
-
reord
Run your tests multi-threaded, but in a reproducible way
-
axsync
ArceOS synchronization primitives
-
gstuff
Small macro and trinkets that make my life easier
-
docsrs-mcp
MCP server for Rust crate documentation from docs.rs
-
tracy-client-sys
Low level bindings to the client libraries for the Tracy profiler
-
rav1d-disjoint-mut
A provably safe abstraction for concurrent disjoint mutable access to contiguous storage
-
range-lock
Range lock for std::vec::Vec
-
lockmap
A high-performance, thread-safe HashMap implementation for Rust that provides fine-grained locking at the key level
-
aws-ssm-bridge
implementing AWS Systems Manager Session Manager protocol
-
termocast
A terminal-based weather application
-
rater
High-performance, lock-free, thread-safe rate limiter using token bucket algorithm with per-IP rate limiting support
-
fluxion-runtime
Runtime abstraction for async Rust streams
-
synchrony
that provides both sync and unsync versions of common synchronization primitives
-
wasefire-sync
Portable non-blocking mutex
-
cancel-safe-futures
Alternative futures adapters that are more cancellation-aware
-
rustix-futex-sync
Linux futex-based synchronization
-
evcxr_repl
A REPL for Rust
-
tanim-cli
Render typst files to video in command line
-
engineioxide
Engine IO server implementation in rust as a Tower Service
-
pid-allocator
PID allocator for no_std environment
-
cynosure
High performance data structures & primitives from beyond the Blackwall
-
stupid_utils
that provides some simple and maybe stupid or useful tools
-
filelock
Cross-platform file locking library for Rust
-
metrique-aggregation
working with unit of work metrics - aggregation
-
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
-
pin-list
A safe
Pin-based intrusive doubly linked list -
rex-sm
Hierarchical state machine
-
interlock
Readers-writer locks designed for locking intervals
-
ZHRXXLib
some simple yet useful functions
-
wrapit
A lightweight Rust crate that wraps any variable using interior mutability (
RefCell,Mutex, orRwLock) for ergonomic shared mutation -
fmutex
Cross-platform mutual exclusion across processes on a file or path
-
linux-bzimage-setup
The linux bzImage setup binary
-
k-lock
A fast mutex for short critical sections
-
sovran-typemap
A thread-safe heterogeneous container with type-safety
-
steppe
Follow the progress of a task easily
-
stable-acpi
A pure-Rust stable library for interacting with ACPI
-
tokio-debouncer
A minimal async debouncer for signal batching in Tokio
-
maybe-fut
build totally interoperable async/sync Rust code
-
esp-wifi
A WiFi, Bluetooth and ESP-NOW driver for use with Espressif chips and bare-metal Rust
-
r3
R3-OS: Experimental static component-oriented RTOS for deeply embedded systems
-
aranya-fast-channels
High throughput, low latency encryption protected by Aranya Policy
-
mc-sgx-tstdc
Rust wrappers around SGX synchronization primitives
-
tui_lib
Be the base of a Tui Operation
-
rust-keypaths
A static dispatch, faster alternative to rust-key-paths - Type-safe, composable keypaths for Rust with superior performance
-
ratio-clone
cheap-to-clone types and wrappers for expensive to clone and compare datatypes
-
lilos
A tiny embedded OS based around Futures and async
-
async-rwlock
Async reader-writer lock
-
prism3-concurrent
Concurrent utilities library providing thread pools, task scheduling, synchronization primitives and other concurrent programming tools
-
global_counter
Global, thread-safe counters
-
one-shot-mutex
One-shot locks that panic instead of (dead)locking on contention
-
nexus-slot
High-performance SPSC conflation slot for latest-value-wins scenarios
-
mielin-kernel
Core unikernel implementation providing the foundation for agent execution across heterogeneous hardware platforms
-
range-mutex
A
Mutex<[T]>-like type, that allows locking different ranges separately -
writecell
Shareable string writers using internal mutability
-
quork
A collection of small things that don't deserve their own crate
-
rlock
Redis-backed lock library providing both async and sync Mutex, RwLock, and others
-
keyed-lock
A keyed lock for synchronization
-
sarlacc
Thread-safe lock-free interning of data
-
sync-arena
thread-safe arena allocator
-
phprs
A PHP interpreter with build/package manager written in Rust
-
synchronized-writer
A tiny implement for synchronously writing data
-
os-trait
Traits used to adapter different embedded RTOS
-
c2pa-c-ffi
C language FFI base for c2pa crate to create bindings
-
esp-radio
A WiFi, Bluetooth and ESP-NOW driver for use with Espressif chips and bare-metal Rust
-
daemon_forge
A robust, cross-platform library for daemonizing Rust applications
-
watch
A synchronous message passing channel that only retains the most recent value
-
quinn-jls
Versatile QUIC transport protocol implementation
-
per-thread-mutex
Synchronization lock designed for wrapping thread-unsafe C libraries
-
avr-oxide
An extremely simple Rusty operating system for AVR microcontrollers
-
manually-static
ManualStaticthat is a wrapper which allows to manually manage'staticlifetimes. It is unsafe but withdebug_assertionsit panics when the usage is wrong -
distributed-lock-mongo
MongoDB backend for distributed locks using atomic updates and TTL indexes
-
medi-rs
mediator library for Rust
-
carboxyl
functional reactive programming
-
sharded_mutex
No per-object memory overhead locks. Pseudo atomic ops for Copy/PartialEq types.
-
unsend
A thread unsafe runtime for thread unsafe people
-
bolt
The package provides a hierarchical read-write lock
-
hurry
Convenient macros for creating pointer types (Box, Rc, Arc, etc.)
-
orchestrator_lock
A Mutex whose access order is managed by a separate thread
-
rs-eda
rust EDA event-driven framework
-
cortex-m-rtic
Real-Time Interrupt-driven Concurrency (RTIC): a concurrency framework for building real-time systems
-
wait_on_address
Cross-platform atomic wait and wake (aka futex) functionality
-
sync-no-std
Cross-platform interface to the synchronization primitives
-
procref
Cross-platform process reference counting for shared service lifecycle management
-
netbeam
a pure-rust asynchronous network synchronization crate (using tokio) that recreates familiar asynchronous paradigms but in a network context
-
moz-cli-version-check
Opt-in version checking library for Mozilla CLI tools
-
ruspiro-lock
Providing Spinlock, Semaphore and mutual exclusive data access for cross core usage on Raspberry Pi
-
roughage
AsyncPipeline, a deadlock-free replacement for buffered streams -
nar_dev_utils
用于NARS相关项目开发的实用工具包
-
local_async_utils
single-threaded async programming
-
tank-tests
Test suide for drivers of Tank: the Rust data layer. This is intended to be used by drivers to implement common unit tests.
-
someday
Lock-free MVCC primitive
-
rc-u8-reader
A tiny implement for reading
u8data from a reference counted instance -
picopub
A sync/async pub-sub library with bounded queues and backpressure using Mutex and Condvar
-
antidote
Poison-free versions of the standard library Mutex and RwLock types
-
thread_cell
Safe, Send + Sync access to !Send/!Sync data by isolating it on a dedicated thread and interacting with it through message passing. Perfect for Rc, RefCell, and other single-threaded types.
-
talloc
A fast, consistant, and flexible
no_std-compatible allocator -
fraktor-utils-core-rs
Portable no_std toolbox primitives for the fraktor actor runtime
-
access-cell
A cell that allows re-entrant mutable access without deadlock
-
freertos-next
Create to use FreeRTOS in rust projects. The freertos-build crate can be used to build and link FreeRTOS from source inside build.rs
-
ralloc
An efficient alternative platform-agnostic allocator
-
lockless-datastructures
A bunch of lockless datastructures
-
edos_rt
edos runtime helpers
-
distributed-lock-mysql
MySQL backend for distributed locks using GET_LOCK/RELEASE_LOCK functions
-
fast-async-mutex
lib which provide asynchronous locking mechanisms (Mutex, RwLock, OrderedMutex and OrderedRwLock)
-
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
-
clhlock
Craig and, indenpendently, Magnussen, Landin, and Hagersten queue lock for mutual exclusion, referred to as CLH lock
-
lamlock
MCS-style flat-combining mutex with panic-awareness
-
usync
fast, drop-in, synchronization primitives
-
nospin
containing an embedded version of a Mutex which can be used in
no_stdprojects which are single-threaded -
esp-sync
Synchronization primitives for Espressif devices
-
distributed-lock-postgres
PostgreSQL backend for distributed locks using advisory locks
-
distributed-lock-file
File system backend for distributed locks using OS-level file locking
-
unlock
Instrumented synchronization primitives helping you to unlock performance issues
-
td_rthreadpool
thread wrapper for Rust
-
lock-hierarchy
Prevent dead locks by enforcing lock hierarchies
-
mbarc-map
Minimally-blocking, Atomic Reference Counted Map
-
easy_mutex
A cloneable mutex wrapper that simplifies everyday use
-
rusturnate
A sync or async mutex, with or without timeouts
-
little-sync
A little rust crate that provides fastest sync types such as Mutex, RwLock and other
-
mutex_trait2
Generic mutex trait
-
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.
-
tg-sync
Synchronization primitives for rCore tutorial OS, including mutex, semaphore, and condvar
-
classic-sync
ReentrantLock, Semaphore and CyclicBarrier using Classic Linux Mutex systems
-
syncrs
spinlock-based syncronization primitives for no_std enviroments
-
armc
that facilitates Mutex access to variables
-
mutex-trait
Foundational mutex trait and helpers
-
re_mutex
A wrapper around
parking_lot::Mutexuseful for debugging deadlocks -
dir-lock
file-system-based mutex
-
slock
An async mutex that never deadlocks
-
lazy_mut
Alternative to LazyLock<Mutex<T>>
-
borrow_mutex
Async Rust Mutex which does not require wrapping the target structure
-
sync_2
A little crate providing a Rust implemented Mutex and RwLock
-
cooptex
Deadlock free Mutexes
-
remutex
Recursive mutex, adapted from Rust's standard library
-
embedded_mutex
A minimal, no_std, non-blocking mutex for embedded Rust
Try searching with DuckDuckGo or on crates.io.