Lib.rs

parking_lot

More compact and efficient implementations of the standard synchronization primitives

arboard

Image and text handling for the OS clipboard

lapin

AMQP client library

polling

Portable interface to epoll, kqueue, event ports, and IOCP

flume

A blazingly fast multi-producer channel

testcontainers

integration-testing against docker containers from within Rust

wait-timeout

wait on a child process with a timeout specified across Unix and Windows platforms

rtrb

A realtime-safe single-producer single-consumer ring buffer

alsa

Thin but safe wrappers for ALSA (Linux sound API)

rexpect

Interact with unix processes/bash the same way as pexpect or Don libes expect does

io-uring

The low-level io_uring userspace interface for Rust

leaky-bucket

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

fork

creating a new process detached from the controlling terminal (daemon)

cmd_lib

Common rust commandline macros and utils, to write shell script like tasks easily

triple_buffer

triple buffering, useful for sharing frequently updated data between threads

shared_child

using child processes from multiple threads

mea

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

saa

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

kovan

High-performance wait-free memory reclamation for wait-free data structures. Bounded memory usage, predictable latency.

async-once-cell

Async single assignment cells and lazy values

databricks-zerobus-ingest-sdk

A high-performance Rust client for streaming data ingestion into Databricks Delta tables using the Zerobus service

async-shutdown

one-stop solution for async graceful shutdown

maitake-sync

No-std async synchronization primitives from Maitake

aws-sdk-appconfigdata

AWS SDK for AWS AppConfig Data

coldsnap

command-line interface for uploading and downloading Amazon EBS snapshots

mmap-sync

package allowing sharing of data between processes in a wait-free and zero-copy fashion from mapped memory

pomodoro-cli

command line Pomodoro timer

procman

A process supervisor with a dependency DAG and a typed .pman language

tovuk

Deploy Rust workers, static frontends, and full-stack services to Tovuk

bide

Block until a target reaches a stable probe state

twilight-standby

filter wait for filtered incoming events for the Twilight ecosystem

spider_network_blocker

Web crawler network blocking urls and patterns

agent-offload

Launch coding agents in tmux panes and wait for completion

batch-aint-one

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

idr-ebr

An efficient concurrent ID to object resolver

process_control

Ergonomically run processes with limits

agari

A Riichi Mahjong hand calculator and scoring engine

switchy_async

Switchy Async runtime package

bochi

A CLI tool to interact with Android UI elements with CSS-like selectors

bonsai-bt

Behavior tree

tokio-process-tools

Correctness-focused async subprocess orchestration for Tokio: bounded output, multi-consumer streams, output detection, guaranteed cleanup and graceful termination

wg

Golang like WaitGroup implementation for sync/async Rust

tower-resilience

Composable resilience and fault-tolerance middleware for Tower services

bevy_defer

asynchronous runtime for executing async coroutines

night-fury-cli

CLI tool for night-fury-core browser automation

go-lib

rust native goroutines

gce-vm

A small command-line tool for managing a single Google Compute Engine VM you use as a development or work machine

wasmtime-wasi-io

wasi-io common traits to be shared among other wasi implementations

tskd

daemon for tsk processing

subprocess

Execution and control of child processes and pipelines

bevy_flurx

Allows you to use coroutine in Bevy

keepawake

Keep your computer awake

agent-term

Detached, observable subprocess runner for AI agents

locktick

Automated lock accounting & profiling

nils-macos-agent

CLI crate for nils-macos-agent in the nils-cli workspace

libdd-libunwind-sys

Rust bindings for using unwind library inside libdatadog

agent-status

Tmux-integrated indicator showing which AI coding agent sessions are waiting on user input

qubit-lock

Lock utilities library providing synchronous, asynchronous, and monitor-based locking primitives

bashtestmd

Compiles shell commands in .md files into Bash scripts for testing

async-pidfd

Process file descriptors (pidfd) for Linux

wasm_safe_thread

Cross-platform std::thread + std::sync replacement for native and wasm32

r68k

Motorola 68000 CPU emulator, ported from the battle-tested Musashi emulator

amity

Concurrency algorithms

stubborn-io

io traits/structs that automatically recover from potential disconnections/interruptions

watchctl

Process supervisor with wait, watch, and retry phases

pv

Rust reimplementation of the unix pipeview (pv) utility

bistun-lms

thread-safe capability engine for resolving BCP 47 language tags into actionable rendering and parsing properties (directionality, morphology, segmentation). Features a wait-free, lock-free memory pool (ArcSwap)…

proc-cli

A semantic CLI tool for process management

riichienv-core

Japanese Mahjong (Riichi) game engine with MJAI protocol support

greentic-session

Greentic multi-tenant session manager with in-memory and Redis backends

wrightty

Unified CLI for Wrightty terminal automation — server, bridges, and client in one binary

qubit-event-bus

A lightweight, thread-safe in-process event bus for Rust

sideagent

Run another coding agent from your current session

atomic-wait

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

initium

Swiss-army toolbox for Kubernetes initContainers — wait-for, seed, render, fetch in a single static Rust binary

async-condvar-fair

Condition variables for async Rust

kovan-map

Lock-free concurrent hash maps using kovan memory reclamation

psctl

Process Control is an operator for related processes. It runs processes as an interdependent graph.

durable-execution-sdk

AWS Durable Execution SDK for Lambda Rust Runtime

viewpoint-core

High-level browser automation API for Viewpoint

velocityx

A production-ready Rust crate for lock-free concurrent data structures with performance monitoring

lock-db

Lock manager and deadlock detection for Rust databases - row/range locks, multiple granularities, and wait-for cycle detection

terminal-use

Headless virtual terminal for AI agents

reddb-io-wire

RedDB wire protocol vocabulary: connection-string parser, RedWire frames, payload codecs, topology, sanitizers, and replication messages

adk-browser

Browser automation tools for Rust Agent Development Kit (ADK-Rust) agents using WebDriver

tg-rcore-tutorial-ch5

Chapter 5 of rCore Tutorial: Process management with fork, exec and wait syscalls

ime_shift_fix

Protect IME mode while selecting text with Shift+Click on Windows

bevy_behave

A behaviour tree plugin for bevy with dynamic spawning

mosec

Model Serving made Efficient in the Cloud

durable-execution-sdk-testing

Testing utilities for AWS Durable Execution SDK

kithara-stream

Streaming source-to-bytes layer with sync Read+Seek for audio playback

ptywright

A cross-platform Rust CLI and library for driving interactive terminal applications through PTYs

holdon

Wait for anything. Know why if it doesn't.

mimic

A text / code playback tool

events

Async manual-reset and auto-reset event primitives

ara2

Rust client library for the Kinara ARA-2 neural network accelerator on NXP i.MX platforms

async-event

An efficient async condition variable for lock-free algorithms

pawl

A resumable step sequencer for multi-step workflows

zilliz

TUI and CLI tool for managing Zilliz Cloud clusters and Milvus operations

tg-ch5

Chapter 5 of rCore Tutorial: Process management with fork, exec and wait syscalls

ai-media-generator

AI image and video generation package for the ai-media CLI

sigchld

waiting for SIGCHLD from many threads at once

typed-ski

SKI calculus evaluator in Rust compiled to WASM

radiant-rs

Thread-safe Rust sprite rendering engine with a friendly API and custom shader support

pagetable

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

wasm_safe_mutex

A suite of WebAssembly-safe synchronization primitives that paper over platform-specific locking constraints

zag-orch

Orchestration library for zag — multi-session coordination for AI coding agents

kithara-storage

mmap-backed storage resource with random-access I/O

tripo-cli

Unofficial command-line client for the Tripo 3D Generation API

swmr-cell

A thread-safe single-writer multi-reader cell with wait-free reads and version-based garbage collection

elegant-departure

simplify graceful shutdown

ranged-mmap

Type-safe memory-mapped file library with lock-free concurrent writes to non-overlapping ranges

nap

Suspend-aware alternative to sleep for shell scripts etc

xutex

an extremely fast async mutex with alternative sync API

aiq

An intrusive list with lock-free insertion

oddio

Lightweight game audio library

mobc

A generic connection pool with async/await support

caffeinate2

Caffeinate MacOS utility with more options. Temporarily prevent your system from sleeping.

adaptive_backoff

intelligently backing off rate limited or fallible resources

rustainers

opinionated way to run containers for tests

openstack-sdk-auth-websso

OpenStack SDK auth plugin for authenticating with a WebSSO method

varvedb

A high-performance, embedded, append-only event store for Rust

hazarc

A wait-free AtomicArc optimized for read-intensive use cases

i2pd-launch

Launches i2pd with clean state

fast-able

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

ferogram

Production-grade async Telegram MTProto client: updates, bots, flood-wait, dialogs, messages

mariadb_exporter

MariaDB metric exporter for Prometheus

tarry

Block until a condition holds, then print one compact verdict

commonware-estimator

Simulate mechanism performance under realistic network conditions

igor

Generic text-based vendoring

mailrs-delivery-executor

Group-commit delivery executor on top of mailrs-maildir 1.2's deliver_batch. Accumulates per-path delivery requests from concurrent async tasks (SMTP / LMTP / IMAP APPEND sessions)…

voidcrawl-mcp

Stdio MCP server exposing voidcrawl stealth headless Chrome to Claude Code and other MCP clients

gewe-cc

Claude Code 远程协作模式命令行工具

hiasync

Supports only single-threaded asynchronous runtime

docker_utils

integration testsing with Docker

agent-exec

Non-interactive agent job runner. Runs commands as background jobs and returns structured JSON on stdout.

mpv-client-cross

Bindings for libmpv client API that allow you to create plugins for MPV in Rust

safe-bump

Safe typed arena — zero unsafe, auto Drop, checkpoint/rollback, single-thread Arena + concurrent SharedArena

hyperchad_test_utils

MoosicBox HyperChad Test Utils package

spider_mcp

MCP (Model Context Protocol) server exposing Spider web crawler capabilities as tools

relentless

Composable retry policies for fallible operations and polling

gdext_coroutines

Run Rust Async functions and Coroutines in Godot 4.4+ (through GDExtension), inspired on Unity's Coroutines design

browser-test

Small helpers for async browser-driven integration tests

inferd-client

Rust client for the inferd local-inference daemon. NDJSON-over-IPC, admin event subscription, retry-and-wait helpers.

waitup

Wait for TCP ports and HTTP endpoints to be available. Essential for Docker, K8s, and CI/CD pipelines to ensure services are ready before proceeding.

reap-process

Watch a parent process and kill child processes when it dies (macOS)

wait-service

Wait Service is a pure rust program to test and wait on the availability of multiple services

dualcache-ff

A wait-free, high-performance concurrent cache optimized for extreme read-to-write ratios

dark-std

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

keepassxc-proxy-getpw

CLI tool to get passwords from a running KeePassXC instance

sem_safe

Safe usage of POSIX Semaphores (sem_post, sem_wait, etc)

service_utils

service integration testsing

aws_utils_athena

AWS Athena client utilities for Rust with query execution, streaming results, and comprehensive error handling

simple-queue

persistent queue implementation in Rust backed by PostgreSQL and tokio

mobile-use

Mobile UI automation CLI — inspect, interact with, and automate mobile app interfaces

vessel-pty

PTY-based runtime for orchestrating interactive terminal processes over Unix sockets

klieo-bus-nats

Production NATS JetStream + KV impls of klieo-core's bus traits

wait-for-gh-rate-limit

CLI that waits for GitHub rate limit to reset if you're out of requests

kill-desktop

Wait politetly for graphical applications to exit

rkusb

CLI tools for manipulating Rockchip devices

pim-bluetooth

Bluetooth transport implementation for the Proximity Internet Mesh

zart

Durable execution framework — multi-step workflows with persistence, retries, and observability

noworkers

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

go

A runtime-agnostic Go-style concurrency library for Rust

auto_pool

pool that returns items automatically after it's dropped

babysit

Wrap a shell command in a PTY and expose it to external AI agents (Claude / Codex) via subcommands

cluFlock

Installation and subsequent safe removal of flock locks for data streams

retry-if

A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff

async-foundation

Foundational async primitives for Rust - timers, networking, and common utilities

pressakey

Cross-platform terminal app that waits until a user presses a key

spawn_groups

Structured concurrency construct written in Rust, for Rustaceans

vterm-rs

PTY orchestrator that lets AI agents drive real terminals

midi-flux-bridge

Bridges tensor-midi timing schedules to FLUX coordination bytecode

nblf-queue

Atomic, wait-free MPMC queues based on the nblfq algorithm

omango

Concurrency collections

tmux-claude-queue

A waiting-queue for multi-pane Claude Code + tmux workflows

puprs

Puppeteer-inspired high-level browser automation SDK for Rust

tg-rcore-tutorial-ch5-yks23

rCore Tutorial ch5 (fork/exec/wait), fork suffix yks23 for crates.io

compact-waitgroup

A compact asynchronous WaitGroup synchronization primitive

seedance

Generate video with ByteDance Seedance 2.0 from the terminal. Agent-friendly.

dutils

I am speed

qr-transfer

File transfer over QR codes — stop-and-wait ARQ in the terminal

camel-bridge

Bridge process lifecycle management for rust-camel (spawn, health, download)

jsph-tg-rcore-tutorial-ch5-t1l3

Chapter 5 of rCore Tutorial: Process management with fork, exec and wait syscalls

standby

A world-class cross-platform time management tool for sleep, timeout, and wait operations with full POSIX compliance and GNU coreutils compatibility

minimal_signals

small API for working with Unix signals

rewatch

File watch and restart tool — a smarter cargo-watch alternative for AI coding agents. Waits for you (or a trigger file) instead of rebuilding on every save.

rosist-sallina-tg-rcore-tutorial-T1L3

Student AI4OSE lab crate for Chapter 5 of rCore Tutorial: Process management with fork, exec and wait syscalls

rt-history

An RT-safe history log with error checking

cdDB

A high-performance asynchronous tiered storage engine for cold data acceleration

waitfree-sync

A collection of wait-free data structures

tg-rcore-tutorial-ch5-Charlie-exercise

Chapter 5 of rCore Tutorial: Process management with fork, exec and wait syscalls

proa

Manage Kubernetes sidecar container lifecycle

tg-rcore-tutorial-ch5-T1L3

Chapter 5 T1L3 of rCore Tutorial: Process management with fork, exec and wait syscalls

CreateProcessW

Create and handle processes on Windows using the Win32 API

clasp-test-utils

Test utilities for CLASP protocol crates

jb

Background job manager for AI agents

ferrous-browser

Fast, async Rust browser automation via the Chrome DevTools Protocol — no Node.js required

ghtool

A command-line tool for interacting with Github API with some specialized features oriented around Checks

floopfloop

Official Rust SDK for the FloopFloop API (https://www.floopfloop.com)

nexo-taskflow

Long-running multi-step task orchestration runtime for Nexo agents

retry-spinner

Retry a command with live output forwarding, spinner wait, and optional timeout

chenzt23-tg-rcore-tutorial-ch5-t2l4

Chapter 5 of rCore Tutorial: Process management with fork, exec and wait syscalls

seher-cr

A wrapper for the CodeRabbit CLI that automatically retries on rate limit errors

jsph-tg-rcore-tutorial-ch5-smp

Chapter 5 of rCore Tutorial with SMP: Process management with fork, exec and wait syscalls on multiple harts

tower-shot

A high-performance, atomic-backed rate limiting middleware for tower

scuffle-signal

Ergonomic async signal handling

ritlers

A task-length aware rate limiter that waits for tasks to finish before counting them against the rate limit

named_pipe

Wrapper for overlapped (asyncronous) IO of Windows's named pipes

browser-commander

Universal browser automation library that supports multiple browser engines with a unified API

opensesame

Cross-platform library for opening files in text editors with line:column positioning

wait_utils

implementing wait loops using varies wait strategies

latches

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

trackone-pod-fw

Pod firmware-side helpers and utilities for TrackOne

wait-for-them

Waits for TCP ports to be opened or for 200 status on http(s) urls

cond_sync

Hides the boilerplate code needed with std::sync::Condvar

aerosol

dependency injection for Rust

agent-switcher

Tmux popup TUI for switching between waiting AI coding agent sessions

gabriel2

Indeed, an actor library based on Tokio, written in Rust

code-steps

Notebook-style code step display with syntax highlighting, breakpoints, and theme support for Rust

interrupt

voltiq-perf

Runtime performance / memory profiling engine for voltiq (launch + attach)

vigem-client

ViGEm client API in pure Rust

bankr-agent-api

Rust client library for the Bankr Agent API

termwright

Playwright-like automation framework for terminal TUI applications

tg-rcore-tutorial-ch5-T3L5

Chapter 5 T3L5 of rCore Tutorial: Process management with fork, exec and wait syscalls

atomic-waitgroup

A waitgroup implementation supports async with advanced features

batchy

Transparently batch concurrent requests into efficient bulk operations

lm3630a

embedded-hal driver for LM3630A LED driver

queueing-theory

Queueing theory in Rust — M/M/1, M/M/c, Erlang, Jackson networks, priority queues. Model capacity before you build.

spider_cli

The fastest web crawler CLI written in Rust

pantograph

Wait-free channels

async_timing_util

tokio async functions for waiting until even intervals (on 1 min, 5 min, 30 min, etc), or waiting until a specified timestamp

hourglass-rs

A time abstraction crate for testing time-dependent code

svgtail

a minimal SVG viewer

portzap

A fast, cross-platform port management tool. Kill, list, and watch processes on network ports.

fast-smr

Toward fast, wait-free, portable, and robust memory reclamation

tauri-plugin-agent-control

Dev-only HTTP bridge for observing and controlling Tauri webviews — like Chrome DevTools Protocol, but for Tauri

evtcall

Rust Event Driven Framework

subms-spsc-ring-buffer

submillisecond.com cookbook recipe - concurrency: subms-spsc-ring-buffer. Wait-free SPSC ring buffer with cache-line padded counters and opposite-index caching; sub-50ns enqueue/dequeue on sibling cores.

claude-authorize

Automates the OAuth Authorize button click for claude login

brb-cli

Tired of babysitting commands for hours? Brb will notify you when that commands done

rmux-sdk

Public, daemon-backed Rust SDK for the RMUX terminal multiplexer (facade, ensure-session, snapshots, events, detach helpers)

chenhe-tg-rcore-tutorial-ch8

Chapter 8 of rCore Tutorial: Concurrency with threads, mutex, semaphore and condvar

vibeflow

GPU-accelerated Linux terminal emulator that knows when your AI tool is waiting on you

hypnus

Memory Obfuscation in Rust

dozr

A flexible sleep-like command-line utility for pausing execution with fun timing features

twisterad

Rotate twister ads

oxidebot

A lightweight yet powerful chatbot framework

browsr-client

Client for driving Browsr browser automation over HTTP or stdout transports

wait_on_address

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

wait

Syntactic sugar for calling async functions outside of an async context

microlock

waiting: Small locks and other timing things!

wait-file

cli utility to monitor for changes in one or multiple files

rbot

programming robots in Bot Beats

agent-terminal

TUI testing tool for autonomous agent-driven terminal application testing

cache-lease

Redis-backed distributed cache stampede prevention with leases, fencing tokens, SWR, and tagging

cpu

phantom-core

Core types and protocol for phantom

cyclotrace

A high-performance, wait-free ring buffer in Rust. Supports SPMC with peek-based semantics instead of destructive consumption.

compio-process

Processes for compio

philiprehberger-safe-shutdown

Graceful shutdown coordination with timeout support for Rust

motosan-agent-subagent

Session-scoped subagent registry for motosan-agent-loop. Spawn, message, and wait on long-lived child agents from a parent agent's tool calls.

mongodb_cwal

A native MongoDB driver for those who can't wait any longer (CWAL)

acme-validation-propagation

Waiting for propagation of acme validation record

vsleep

A verbose, visual replacement for the Unix sleep command

waitpid-any

Wait for any PID, an extension to waitpid(2)

waitx

A lightweight & low-latency, pure signaling primitive