Lib.rs

mongodb

The official MongoDB driver for Rust

tokio-metrics

Runtime and task level metrics for Tokio applications

serenity

Discord API

h3

An async HTTP/3 implementation

futures-executor

Executors for asynchronous tasks based on the futures-rs library

tokio-graceful

util for graceful shutdown of tokio applications

remoc

🦑 Remote multiplexed objects, channels, observable collections and RPC making remote interactions seamless. Provides multiple remote channels and RPC over TCP, TLS or any other transport.

interoptopus

The polyglot bindings generator for your library (C#, C, Python, ...). 🐙

agnostic-lite

agnostic-lite is an agnostic abstraction layer for any async runtime

tracing-loki

A tracing layer for shipping logs to Grafana Loki

r3bl_tui

TUI library to build modern apps inspired by React, Elm, with Flexbox, CSS, editor component, emoji support, and more

affinitypool

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

crb

CRB | Composable Runtime Blocks

hirun

A concurrent framework for asynchronous programming based on event-driven, non-blocking I/O mechanism

lua-astra

🔥 Blazingly Fast 🔥 runtime environment for Lua

spawns

Async runtime agnostic thread context task spawner for Rust

arceos-runlinuxapp

Run Linux ELF applications on ArceOS: loads and runs a user-space Linux app (compiled with musl libc) with ELF parsing, syscall handling, and multi-architecture support

typespec_client_core

Client runtime for TypeSpec-generated libraries

job

Async / distributed job runner

async-lsp

Asynchronous Language Server Protocol (LSP) framework based on tower

bevy_defer

asynchronous runtime for executing async coroutines

asupersync

Spec-first, cancel-correct, capability-secure async runtime for Rust

hannibal

A small actor library

bevy_tasks

A task executor for Bevy Engine

arceos-userprivilege

User privilege mode execution for ArceOS: loads and runs a user-space app with syscall handling

qldb

Driver for Amazon's QLDB Database implemented in pure rust

rudo-gc

A garbage-collected smart pointer with automatic cycle detection using BiBOP memory layout and Mark-Sweep collection

pumps

Eager streams for Rust

maiko

Lightweight event-driven actor runtime with topic-based pub/sub for Tokio

pubnub

SDK for Rust

fastmcp-core

Core types and context for FastMCP

tii

A Low-Latency Web Server

pipedream-rs

A typed, heterogeneous event relay with observable delivery, completion tracking, and lossless message routing

executor-core

A zero-cost task executor abstraction layer for Rust async runtimes

rust_di

DI — Dependency Injection for Rust

ll

rust logging library

fastmcp-protocol

MCP protocol types and JSON-RPC implementation

xai-sdk

xAI SDK

send_cells

Safe and unsafe cells implementing Send/Sync

agnostic

abstraction layer for any async runtime

flute

File Delivery over Unidirectional Transport (FLUTE)

xcodeai

Autonomous AI coding agent — zero human intervention, sbox sandboxed, OpenAI-compatible

bevy_behave

A behaviour tree plugin for bevy with dynamic spawning

some_executor

A trait for libraries that abstract over any executor

clockworker

A single-threaded async executor with EEVDF-based fair scheduling and pluggable task schedulers

rtos-trace

RTOS tracing trait

openclaw-search-tool

OpenClaw Research Tool — web search for AI agents via OpenRouter LLMs

tokio-par-util

running computations in parallel on top of Tokio

uni-stream

universal stream for TCP and UDP traffic and custom DNS resolution service

shellflip

Graceful process restarts in Rust

switchy_async

Switchy Async runtime package

await-tree

Generate accurate and informative tree dumps of asynchronous tasks

some_global_executor

Reference thread-per-core executor for the some_executor crate

a3s-flow

A3S workflow engine — JSON DAG execution for agentic workflows (Dify/n8n style)

oxide_core

Rust engine primitives for Oxide (store, snapshot streams, error model, optional persistence)

otel

Ergonomic macros for OpenTelemetry tracing in Rust

rayclaw

Multi-channel agentic AI runtime with tool-calling, memory, and scheduling

switchy_tcp

Switchy TCP Networking package

avx-runtime

AVX Runtime - Native async runtime built from scratch to replace Tokio with work-stealing scheduler, epoll/kqueue/IOCP, and zero-overhead futures

switchyard

Real-time compute focused async executor

bevy_mod_async

Ergonomic async tasks plugin for the Bevy game engine

hazarc

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

opentelemetry-instrumentation-tokio

OpenTelemetry instrumentation for Tokio runtime metrics

moosicbox_task

MoosicBox task utilities package

micropool

Low-latency thread pool with parallel iterators

aimdb-tokio-adapter

Tokio runtime adapter for AimDB - full-featured std async runtime support

allure-core

Core types and runtime for Allure test reporting

spawn_groups

Structured concurrency construct written in Rust, for Rustaceans

compact-waitgroup

A compact asynchronous WaitGroup synchronization primitive

tiktoklive

library. Use it to receive live stream events such as comments and gifts in realtime from TikTok LIVE No credentials are required.

fluxion-exec

Async stream subscribers and execution utilities for fluxion

editline

A platform-agnostic line editor with history and full editing capabilities

bevy_symbios_texture

Algorithmic texture generator for Bevy

async_nursery

Primitive for structured concurrency

open-agent-sdk

Production-ready Rust SDK for building AI agents with local OpenAI-compatible servers (LMStudio, Ollama, llama.cpp, vLLM). Features streaming, tools, hooks, retry logic, and comprehensive examples.

tokio-dtrace

DTrace probes for Tokio

ai-lib-rust

Protocol Runtime for AI-Protocol - A high-performance Rust reference implementation

axum-tasks

A lightweight background task queue for Axum applications

qusql-mysql

Async mysql connector

vec_parallel

Construct your Vec in parallel

aimdb-embassy-adapter

Embassy async runtime adapter for AimDB embedded targets

taskvisor

Event-driven task orchestration with restart, backoff, and user-defined subscribers

luminal_rt

A DLL-boundary safe async runtime with tokio-compatible API

hooch

A small async runtime that's been bootlegged for my projects

bhc-rts-scheduler

Work-stealing task scheduler for the BHC Runtime System

scuffle-context

Go-like context utilities for Rust

simboli_thread

Thread Pool Management

asyncs

async runtime agnostic facilities

flarrow-layout

flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications

blaze-ssl-async

Legacy SSLv3 bare minimum implementation

azure_iot_operations_mqtt

MQTT version 5.0 client library providing flexibility for decoupled asynchronous applications

multipool

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

windsock

database/service benchmarking framework

mqtt-service

This crates provide a convenient support for the MQTT Response-Pattern. It uses the rumqttc library to connect to the MQTT broker.

foxtive-cron

Foxtive Cron

mediagit-observability

Structured logging and observability for MediaGit

mielin-kernel

Core unikernel implementation providing the foundation for agent execution across heterogeneous hardware platforms

spawned-rt

Spawned Runtime

flatplay

CLI tool to build and run Flatpak applications

ringolo

An asynchronous runtime built on top of io-uring

scoped-join-set

A scoped variant of tokio::task::JoinSet for spawning non-'static futures

sigfinn

Lifecycle manager for spawning tasks

wq-zed

CQL (Cassandra Query Language) preview tool for Zed

atask

An async task implementation

uniflow

A unidirectional data flow state management library

zellij-runtime

An async runtime for zellij plugins

trash_parallelism

Azzybana Raccoon's comprehensive parallelism library

bye

graceful shutdown with no downtime

zed-todo-tree

Zed editor extension that provides syntax highlighting for TODO-style comments and integrates with the todo-tree CLI via tasks

any_spawner

Spawn asynchronous tasks in an executor-independent way

scope-spawn

structured concurrency management for tokio tasks

ato

A very minimal no-std async runtime

notizia

Frictionless message passing for the Tokio runtime

crossbus

A Platform-Less Runtime-Less Actor Computing Model

epox

An epoll driven async executor

yot_run

A work-stealing, multi-threaded async executor with non-blocking scheduling

tokio-interactive

Asynchronous Interactive Process Management with Tokio

task_pool

Flexible abstraction for task-based composable multithreading

sacp-cookbook

Cookbook of common patterns for building ACP components

qonductor

Qobuz Connect protocol

reovim-lsp

LSP client library for reovim text editor

watchable

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

flaglite

Official Rust SDK for FlagLite - Simple, fast feature flags

vexide-async

Tiny async executor for vexide

safina-async-test

Macro for running async tests - ARCHIVED: Code moved to safina crate

task_forge

A flexible and simple task pool for asynchronous execution

rust_rubka

interacting with Rubika Bot API

bluefin

An experimental, secure, P2P, transport-layer protocol

announcement

A runtime-agnostic oneshot broadcast channel

log_args

procedural macro to log function arguments using the tracing crate

buildxargs

xargs for BuildKit with docker buildx bake

rt-gate

A tiny wrapper for async runtimes

libindigo

Core API for developing INDIGO astronomy clients and devices

rustact

Async terminal UI framework inspired by React, built on top of ratatui and tokio

bounded-taskpool

Bounded taskpool with backpressure

async-log

Async tracing capabilities for the log crate

obsidian-scheduler

scheduling tasks with both callback and event-based timers

flat-drop

Wrapper that drops recursive objects iteratively to avoid stack overflows

dirnutek

A command-line tool for discovering web directories and files

slog-loggly

unofficial Loggly drain for the slog logging infrastructure in Rust

spotflow-logger

Unofficial logging crate with tracing API for Spotflow Observability Platform

rsevents-extra

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

tokio-task-supervisor

Tokio TaskTracker with built-in cancellation token management and coordinated shutdown

asupersync-conformance

Conformance test suite for async runtime specifications

hedged-rpc-client

High-performance Solana RPC client with request hedging for tail latency elimination

gravityfile-scan

File system scanning engine for gravityfile

xbp-monitoring

synthetic monitoring framework that simplifies and automates the entire process. Optionally used in conjuction as plugin to XBP base

nblock

Non-Blocking Runtime

lifeline

dependency injection library for asynchronous message-based applications

toki-no

A minimal and fast async runtime, written in pure Rust

poolparty

Added functionality for the futures::executor::ThreadPool futures executor

abort-on-drop

A wrapper of Tokio's JoinHandle that aborts the task when it's dropped, while still allowing it to be awaited for joining

tokio-task-tracker

graceful shutdown solution for tokio

tokio-context

Contexts for cancelling asynchronous tasks using tokio

embassy-traits

tokio-task-manager

Allow an async Tokio application to gracefully shutdown, waiting for all tasks to finish

knien

Typed RabbitMQ interfacing for async Rust

r-cache

in memory key value store. It is thread safe and values have expiry times

tiny-actor

A minimal actor framework for Rust

smartpoll

A 'Task' abstraction that simplifies polling futures

lustre-executor

A blazingly fast, minimal async executor with pluggable ID generation and I/O support

tokio-tasker

Lets you stop and join groups of Tokio tasks

revoke-trace

Distributed tracing with OpenTelemetry for Revoke framework

anytest

Run any test from your terminal

scoped_spawn

Full structured concurrency for asynchronous programming

bssh-russh

Temporary fork of russh with high-frequency PTY output fix (Handle::data from spawned tasks)

mini-tokio

basic asynchronous rust executor

ibapi

Interactive Brokers TWS API, providing a reliable and user friendly interface for TWS and IB Gateway. Designed with a focus on simplicity and performance.

exo_task

A lightweight async task executor for bare metal (or any) systems

barter

Framework for building high-performance live-trading, paper-trading and back-testing systems

cooper

in-process, async Actor library for Rust

broker-tokio

tokio for broker

async-io-pipe

Pipe your stdout/stderr together with asynchronous streams

disk_log

High Throughout, NonBlocking Disk-based logger

rustos

Writing an OS in Rust

specs-task

Fork-join multitasking for SPECS ECS

pomfrit

Prometheus metrics exporter with hot reload

async-dispatcher

async runtime based on a pluggable dispatcher

hyperfile-reactor

A lightweight task execution framework built on top of Tokio's LocalSet

zksync_concurrency

Structured concurrency framework

coap-server

Robust async CoAP server

task-collection

Types for managing and waiting on groups of tasks

object-storage

used to manipulate oss or cos

tokio-async-utils

Async utils such as TaskHandle type that aborts task on handle drop

basteh-redb

basteh based on redb

elisym-core

Rust SDK for AI agent interaction via Nostr with pluggable payment backends

tracing-loki-fmt

Grafana Loki tracing layer

avila-async

Revolutionary async runtime - Quantum, Neural Networks, Blockchain, Genetic Algorithms, Zero dependencies

local-runtime

Thread-local async runtime

sittard

Sans-IO tickless async runtime, fully deterministic

join_impl

join! macro

signet-cold-mdbx

MDBX table definitions for signet-cold storage

tasic

Tokio, Async_STD, Smol, Interface Crate

samod-core

the core library for the samod automerge-repo implementation

newton-prover-aggregator

newton prover aggregator utils

obix-macros

macros for obix crate

manul

Generic library for round-based protocols

cometd-client

Client for LongPolling CometD connections

smelter-job-manager

Smelter job orchestration framework