-
mio
Lightweight non-blocking I/O
-
tower
modular and reusable components for building robust clients and servers
-
futures
streams featuring zero allocations, composability, and iterator-like interfaces
-
tonic
A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility
-
tokio-rustls
Asynchronous TLS/SSL streams for Tokio using Rustls
-
h2
An HTTP/2 client and server
-
mlua
High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Luau with async/await features and support of writing native Lua modules in Rust
-
futures-lite
Futures, streams, and async I/O combinators
-
rdkafka
Rust wrapper for librdkafka
-
async-io
Async I/O and timers
-
tower-http
Tower middleware and utilities for HTTP clients and servers
-
axum-server
High level server designed to be used with axum framework
-
async-stream
Asynchronous streams using async & await notation
-
pollster
Synchronously block the thread until a future completes
-
async-openai
OpenAI
-
futures-timer
Timeouts for futures
-
tokio-serial
A serial port implementation for tokio
-
bb8
Full-featured async (tokio-based) connection pool (like r2d2)
-
io-uring
The low-level
io_uringuserspace interface for Rust -
cucumber
testing framework for Rust, with async support. Fully native, no external test runners or dependencies.
-
scc
High-performance containers and utilities for concurrent and asynchronous programming
-
tokio-cron-scheduler
Schedule tasks on tokio using cron-like annotation, at an instant or repeat them at a fixed duration. Tasks can optionally be persisted using PostgreSQL or Nats.
-
futures-concurrency
Structured concurrency operations for async Rust
-
blocking
A thread pool for isolating blocking I/O in async programs
-
tarpc
An RPC framework for Rust with a focus on ease of use
-
tower-sessions
🥠 Sessions as a
towerandaxummiddleware -
prodash
A dashboard for visualizing progress of asynchronous and possibly blocking tasks
-
paho-mqtt
The Official Eclipse Paho MQTT Rust Client Library. This is a wrapper around the Paho C library
-
asynchronous-codec
encoding and decoding frames using
async/await -
keycloak
Admin REST API
-
gloo-timers
Convenience crate for working with JavaScript timers
-
gix-actor
A way to identify git actors
-
tracing-actix-web
Structured logging middleware for actix-web
-
minus
An asynchronous data feedable terminal paging library for Rust
-
async-task
Task abstraction for building executors
-
want
Detect when another Future wants a result
-
ractor
A actor framework for Rust
-
csv-async
CSV parsing for async
-
futures-locks
Futures-aware lock primitives
-
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.
-
diatomic-waker
An async, lock-free synchronization primitive for task wakeup
-
futures-buffered
future concurrency primitives with emphasis on performance and low memory usage
-
futures-signals
Zero cost FRP signals using the futures crate
-
apalis
extensible multithreaded background job processing for Rust
-
monoio
A thread per core runtime based on iouring
-
rskafka
A minimal Rust client for Apache Kafka
-
rustls-tokio-stream
AsyncRead/AsyncWrite interface for RustTLS on Tokio
-
madsim
Deterministic Simulator for distributed systems
-
tokio-graceful
util for graceful shutdown of tokio applications
-
maitake-sync
No-std async synchronization primitives from Maitake
-
web-push
Web push notification client with support for http-ece encryption and VAPID authentication
-
openraft
Advanced Raft consensus
-
triggered
Triggers for one time events between tasks and threads
-
tokio-graceful-shutdown
perform a graceful shutdown on a Tokio based service
-
failsafe
A circuit breaker implementation
-
stream-download
streaming content to a local cache
-
tokio-retry2
Extensible, asynchronous retry behaviours for futures/tokio
-
unicycle
A scheduler for driving a large number of futures
-
capnp-futures
async serialization for Cap'n Proto messages
-
triple_buffer
triple buffering, useful for sharing frequently updated data between threads
-
eventsource-stream
A basic building block for building an Eventsource from a Stream of bytes
-
eyeball
Add observability to your Rust types!
-
axum-streams
HTTP body streaming support for Axum: json/csv/protobuf/arrow/txt
-
kameo
Fault-tolerant Async Actors Built on Tokio
-
tokio-socks
Asynchronous SOCKS proxy support for Rust
-
rsmq_async
Async RSMQ port to rust. RSMQ is a simple redis queue system that works in any redis v2.4+. It contains the same methods as the original one in https://github.com/smrchy/rsmq
-
tower-lsp-server
Language Server Protocol implementation based on Tower
-
exponential-backoff
An exponential backoff generator with jitter
-
containerd-shim
containerd shim extension
-
futures-bounded
bounding futures in size and time
-
async-walkdir
Asynchronous directory traversal for Rust
-
async-shutdown
one-stop solution for async graceful shutdown
-
automerge
A JSON-like data structure (a CRDT) that can be modified concurrently by different users, and merged again automatically
-
tor-rpcbase
Low level functionality for Arti's RPC service
-
future-queue
Adapters to manage a queue of futures, where each future can have a different weight
-
service-async
A Service like tower in async style
-
async-global-executor
A global executor built on top of async-executor and async-io
-
twilight-standby
filter wait for filtered incoming events for the Twilight ecosystem
-
msquic
Microsoft implementation of the IETF QUIC protocol
-
rxrust
Reactive Extensions
-
swiftide
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
igd-next
Internet Gateway Protocol client
-
iroh-quinn-proto
State machine for the QUIC transport protocol
-
rocketmq-rust
Unofficial Rust implementation of Apache RocketMQ
-
tokio-pipe
Asynchronous pipe(2) library using tokio
-
kdbplus
Dual q/kdb+ interface for API to build a shared library and an IPC client
-
quinn-proto
State machine for the QUIC transport protocol
-
tokio-retry
Extensible, asynchronous retry behaviours for futures/tokio
-
pharos
Observer pattern which generates a futures 0.3 stream of events
-
dapr
Rust SDK for dapr
-
hannibal
A small actor library
-
ipc-queue
FIFO queue described in fortanix-sgx-abi used for asynchronous usercalls
-
ntex-h2
An HTTP/2 client and server
-
tokio-io-utility
Some helper functions for tokio::io
-
mio-serial
A serial port implementation for mio
-
futures-rustls
Asynchronous TLS/SSL streams for futures using Rustls
-
fn_graph
Runs interdependent logic concurrently, starting each function when predecessors have completed
-
deno_unsync
A collection of adapters to make working with Tokio single-threaded runtimes easier
-
motore
modular and reusable components for building robust clients and servers. Motore is greatly inspired by Tower.
-
crb
CRB | Composable Runtime Blocks
-
scoped-futures
imposing upper bounds on Future lifetimes
-
turmoil
Simulation testing framework for distributed systems
-
trait-variant
working with impl traits in Rust
-
rusty-penguin
A fast TCP/UDP tunnel, transported over HTTP WebSocket
-
stt-cli
Speech to text Cli using Groq API and OpenAI API
-
tokio_schedule
schedule tasks in tokio runtime
-
lamellar
asynchronous tasking runtime for HPC systems developed in RUST
-
async-executor
Async executor
-
nb
Minimal non-blocking I/O layer
-
fvm_shared
Filecoin Virtual Machine shared types and functions
-
cxx-async
interoperability between C++ coroutines and asynchronous Rust
-
polling
Portable interface to epoll, kqueue, event ports, and IOCP
-
tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
delay_timer
Time-manager of delayed tasks. Like crontab, but synchronous asynchronous tasks are possible, and dynamic add/cancel/remove is supported.
-
tmq
ZeroMQ bindings for Tokio
-
busybody
Service Container and Dependency injector crate
-
async-lsp
Asynchronous Language Server Protocol (LSP) framework based on tower
-
actix
Actor framework for Rust
-
poll-promise
Poll the result of an async operation in a game or immediate mode GUI
-
c-ares-resolver
An asynchronous DNS resolver, backed by c-ares
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
kafka
Rust client for Apache Kafka
-
common-multipart-rfc7578
multipart/form-data (RFC7578)
-
futuresdr
An Experimental Async SDR Runtime for Heterogeneous Architectures
-
tor-rtmock
Testing mock support for tor-rtcomapt
-
interruptible
Stops a future producer or stream from producing values when interrupted
-
rusty_pool
Self growing / shrinking
ThreadPoolimplementation based on crossbeam’s multi-producer multi-consumer channels that enables awaiting the result of a task and offers async support -
lockable
offers hash map, hash set and cache data structures where individual entries can be locked
-
rustix-uring
The low-level
io_uringuserspace interface for Rust -
mio-aio
POSIX AIO bindings for mio
-
aggligator
Aggregates multiple links (TCP or similar) into one connection having their combined bandwidth and provides resiliency against failure of individual links
-
pty-process
spawn commands attached to a pty
-
conogram
An async wrapper for Telegram Bot API
-
wg
Golang like WaitGroup implementation for sync/async Rust
-
hydra
A framework for writing fault tolerant, highly scalable applications with the Rust programming language
-
submap
B-Tree map for pub/sub services
-
tokio-rustls-acme
Automatic TLS certificate management using rustls
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
ws_stream_tungstenite
Provide AsyncRead/AsyncWrite over Tungstenite WebSockets
-
kcpserver
fast kcp server frame
-
async-bincode
Asynchronous access to a bincode-encoded item stream
-
async-object-pool
object pool implementation that uses asynchronous synchronization primitives only
-
hobo
frontend framework
-
peekable
reader and async reader, which enhance your network programming experience
-
executor-trait
A collection of traits to define a common interface across executors
-
tower-fallback
A Tower service combinator that sends requests to a first service, then retries processing on a second fallback service if the first service errors
-
rusty-sidekiq
sidekiq server and client using tokio
-
peace
zero stress automation
-
mobc
A generic connection pool with async/await support
-
scc2
High-performance containers and utilities for concurrent and asynchronous programming
-
rl-core
Core logic for a token-bucket rate-limiter
-
mcp-attr
declaratively building Model Context Protocol servers
-
compio
Completion based async runtime
-
twilight-http-ratelimiting
Discord REST API ratelimiter implementations for the Twilight ecosystem
-
local-waker
A synchronization primitive for thread-local task wakeup
-
aws-sdk-s3-transfer-manager
A high performance Amazon S3 transfer manager for Rust
-
kube-lease-manager
Ergonomic and reliable leader election using Kubernetes Lease API
-
reactive-mutiny
async Event-Driven Reactive Library with advanced & optimized containers (channels) and Stream executors
-
tigerbeetle-unofficial
Safe high level async bindings to tigerbeetle client library
-
unkey
An asynchronous Rust SDK for the Unkey API
-
mutringbuf
A lock-free single-producer, single-consumer (SPSC) ring buffer with in-place mutability, asynchronous support, and virtual memory optimisation
-
async-event
An efficient async condition variable for lock-free algorithms
-
dataloader
Facebook's DataLoader using async-await
-
ya-gcp
APIs for using Google Cloud Platform services
-
better-logger
Flexible sync/async logger with console, file, and HTTP output
-
citadel_logging
logging library for the Citadel Protocol
-
sipper
A type-safe future that can notify progress
-
async-recursion
Recursion for async functions
-
rustls-acme
TLS certificate management and serving using rustls
-
lemmy_db_views_actor
A link aggregator for the fediverse
-
safina
Safe async runtime
-
makepad-futures
Makepad futures
-
act_rs
Act.rs is an actor library built to be used with the standard library and Tokio
-
celery
Rust implementation of Celery
-
samsa
Rust-native Kafka/Redpanda protocol and client implementation
-
async-ringbuf
Async SPSC FIFO ring buffer
-
factorio-mlua
High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau with async/await features and support of writing native Lua modules in Rust. Fork with added Factorio Lua support
-
suppaftp-cli
FTP command line client, based on suppaftp
-
iroh-quinn-udp
UDP sockets with ECN information for the QUIC transport protocol
-
ferrisgram
An elegent rust client for the Telegram Bot API
-
ntex-io-uring
The low-level
io_uringuserspace interface for Rust -
tokio-rusqlite
Asynchronous handle for rusqlite library
-
apalis-sql
SQL Storage for apalis. Use sqlite, postgres and mysql for background job processing
-
tibco_ems
A high level API for the Tibco EMS
-
hyper-multipart-rfc7578
multipart/form-data (RFC7578) for Hyper
-
daktronics-allsport-5000
decoders for the Daktronics All Sport 5000's serial output
-
tiny_kafka
A tiny Kafka client library with producer and consumer functionalities
-
ginepro
A client-side gRPC channel implementation for tonic
-
mcp-runner
running and interacting with Model Context Protocol (MCP) servers locally
-
filebuffer
Fast and simple file reading
-
blockstore
An IPLD blockstore capable of holding arbitrary data indexed by CID
-
clamav-client
ClamAV client library with optional Tokio and async-std support
-
actix-web-flash-messages
Flash messages for actix-web applications
-
actix-rt
Tokio-based single-threaded async runtime for the Actix ecosystem
-
a10
io_uring library
-
axum-extra
Extra utilities for axum
-
next-gen
Safe generators on stable Rust
-
abscissa_tokio
Support for launching Tokio runtimes within Abscissa applications
-
google-places-api
Unofficial Google Places API for rust
-
faktory
API bindings for the language-agnostic Faktory work server
-
gcra
A basic implementation of GCRA algorithm for rate limiting
-
async_executors
Implements Spawn, SpawnLocal and SpawnHandle for commonly used executors
-
round-based
Driver for MPC protocols
-
fvm_actor_utils
Utils for authoring native actors for the Filecoin Virtual Machine
-
rocketmq-runtime
Unofficial Rust implementation of Apache RocketMQ
-
async-scoped
Spawn scoped (non 'static) asynchronous futures for async_std and tokio runtimes
-
hypercore
Secure, distributed, append-only log
-
pingora-timeout
Highly efficient async timer and timeout system for Tokio runtimes
-
syslog-rs
A native Rust implementation of the glibc/libc syslog
-
rsdns
DNS Client Library
-
call-agent
A multimodal chat API library with tool support, OpenAI API compatible
-
swiftide-agents
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
poster
MQTTv5 client library written in Rust
-
aqueue
fast speed thread safe async execute queue
-
rxr
Reactive extensions for event-driven applications
-
another-rxrust
A different implementation than
rxRustfor easier use ofReactiveXinRust -
scuffle-context
Go-like context utilities for Rust
-
fang
Background job processing library for Rust
-
async-graphql-actix-web
async-graphql for actix-web
-
futures-channel
Channels for asynchronous communication using futures-rs
-
async-ssh2-lite
Asynchronous ssh2
-
springtime-di
Dependency injection framework based on automatic component discovery and runtime autowiring
-
get_chunk
File iterator or stream with auto or manual chunk size selection
-
lcode
An application of terminal write leetcode.一个终端刷力扣的应用
-
orka
An asynchronous, pluggable, and type-safe workflow engine for Rust, designed for orchestrating complex multi-step business processes
-
poly-once
A thread-safe cell providing async and sync initialization primitives similar to OnceLock
-
ghost_actor
GhostActor makes it simple, ergonomic, and idiomatic to implement async / concurrent code using an Actor model
-
b2_backblaze
basic async library to upload small files to backblaze b2 service
-
futures-rx
Rx implementations for the futures crate
-
rust-parallel
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
ggapi
communicating with start.gg's API
-
tokio-eventfd
Linux eventfd for tokio
-
mini_exercism
Minimalistic Rust library to interact with the Exercism.org APIs
-
v_exchanges
Implementations of HTTP/HTTPS/WebSocket API methods for some crypto exchanges, using crypto-botters framework
-
rsactor
A Lightweight Rust Actor Framework with Simple Yet Powerful Task Control
-
tros
Your tros from tarantool TX thread to tokio(..and others!)
-
slice_ops
A selection of useful slice operations
-
stakker
A lightweight low-level single-threaded actor runtime
-
dptree
An asynchronous event dispatch mechanism for Rust
-
kompact
Kompics component model combined with the Actor model
-
floxide-macros-support
A directed graph workflow system in Rust
-
zc_buffer
High-Performance Rust Zero-Copy Inspired Buffer Library based on Bytes
-
futures-stream-ext
Asynchronous stream extensions for the futures(-core) crate
-
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
-
tiny-tokio-actor
tiny actor library on top of tokio
-
llm_client
easiest Rust interface for local LLMs
-
async-sleep
Async Sleep
-
product-os-crawler
Product OS : Crawler is a browser based cralwer that utilises Product OS : Browser to perform advanced url crawling leveraging headless browsing and automation
-
transform-stream
Lightweight async stream wrapper
-
sacs
Async Cron Scheduler for Tokio
-
xan-actor
Akka actor
-
reord
Run your tests multi-threaded, but in a reproducible way
-
ate
Distributed immutable data store with strong encryption and authentication
-
monzo-lib
async Monzo client in pure rust
-
actify
An intutive actor model with minimal boilerplate
-
multishot
An async, lock-free, reusable channel for sending single values to asynchronous tasks
-
gix-packetline-blocking
A duplicate of
gix-packetlinewith theblocking-iofeature pre-selected -
jsoncall
asynchronous JSON-RPC 2.0 library leveraging Rust's type system
-
futures-util
Common utilities and extension traits for the futures-rs library
-
ractor-supervisor
Supervisor module for ractor framework
-
rh2
An HTTP/2 client and server
-
genawaiter2
Stackless generators on stable Rust
-
spider_chromiumoxide_types
Contains the essential types necessary for using chromiumoxide
-
swimos_form
SwimOS Serialization and Deserialization
-
tsuki-scheduler
light wight, composable and extensible scheduler for every runtime
-
picokafka
Kafka library for tarantool-module based on librdkafka
-
tokise
An asynchronous runtime compatible with WebAssembly and non-WebAssembly targets
-
async_cache
Async refresh cache
-
tokio-par-util
running computations in parallel on top of Tokio
-
acton-reactive
Acton Reactive is the main crate of the Acton framework, designed for building reactive, event-driven, and asynchronous systems. It provides intuitive abstractions to make working with…
-
try-again
Retry synchronous and asynchronous operations
-
tower-actor
A
towermiddleware that creates aServiceby passing messages to an actor -
tokio-process-tools
Interact with processes spawned by tokio
-
hypercore-protocol
Replication protocol for Hypercore feeds
-
tokio-debouncer
A minimal async debouncer for signal batching in Tokio
-
bounded_join_set
A Concurrency-Limited JoinSet for Tokio
-
scoped-stream-sink
Easy way to make streams and sinks
-
async_pub_sub
aiming at making async pub-sub easier in Rust
-
async-dropper
The least-worst ad-hoc implementation of AsyncDrop as a Derive macro
-
deepseek-api
DeepSeek API SDK is a powerful Rust client library for interacting with the DeepSeek service
-
quick-protobuf-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and quick-protobuf
-
telers
An asynchronous framework for Telegram Bot API written in Rust
-
fundamentum-edge-daemon
The supported way to access Fundamentum's ecosystem from linux devices
-
crossmist
Efficient and seamless cross-process communication, both synchronously and asynchronously
-
rust-multipart-rfc7578_2
multipart/form-data (RFC7578)
-
nats-handling
async NATS client library
-
sse-stream
Conversion between http body and sse stream
-
notbot
Matrix chatbot, primarily used around the Warsaw Hackerspace channels and spaces
-
hakuban
Data-object sharing library
-
girlboss
async job manager with progress tracking
-
elegant-departure
simplify graceful shutdown
-
nsq-async-rs
An asynchronous Rust NSQ client library with support for concurrent message processing
-
hedwig
message bus for Rust
-
tokio-io-timeout
Tokio wrappers which apply timeouts to IO operations
-
io-tether
A small library for defining I/O types which reconnect on errors
-
coc-rs
wrapper around the Clash of Clans public API
-
certsd
automated, asynchronous LE certificate issuer
-
switchy_async_cargo
Cargo async linter package
-
async-utility
Collection of async utilities
-
postage
An async channel library
-
flourish
Convenient and full-featured signals for Rust
-
tokio-smoltcp
An asynchronous wrapper for smoltcp
-
ic-cdk-executor
Async executor for
ic-cdk -
event-notification
A modular event notification system with multi-channel support
-
async-openai-compat
OpenAI
-
keyring-lib
High-level, asynchronous API for keyring-rs, a cross-platform Rust library to manage credentials
-
ractor_actors
actors built with Ractor
-
xio
providing common functionality for file system operations and asynchronous file processing
-
dagrs
follows the concept of Flow-based Programming and is suitable for the execution of multiple tasks with graph-like dependencies. Dagrs has the characteristics of high performance and asynchronous execution…
-
queue_workers
A Redis-backed job queue system for Rust applications
-
tokio-stream
work with
Streamandtokio -
tipsy
Cross-platform IPC for Tokio
-
elfo
An asynchronous distributed actor framework with robust observability
-
reactio
Low-Latency Event Driven Nonblocking Reactor Pattern
-
async-event-emitter
Lightweight AsyncEventEmitter
-
iroh-gossip
gossip messages over broadcast trees
-
cancel-safe-futures
Alternative futures adapters that are more cancellation-aware
-
async-cuda
Async CUDA for Rust
-
cassette
single-future, non-blocking executor intended for building state machines
-
tower-sessions-sqlx-store
SQLx session stores for
tower-sessions -
async-broadcast
Async broadcast channels
-
async_cell
A Cell<Option<T>> that you can await on
-
rio-rs
Distributed stateful service framework
-
async-speed-limit
Asynchronously speed-limiting multiple byte streams
-
traitgate
A zero-dependency authorization mini-library powered by stateless traits and an ergonomic
AuthorizationDecisionenum -
apocalypse
actor framework for Rust
-
tokio_util_watchdog
A watchdog utility for tokio runtimes
-
serio
providing traits and utilities for typed IO using format agnostic serialization built on serde
-
vkapi2
vk api wrapper for rust
-
gem-rs
that serves as a wrapper around the Google Gemini API, providing support for streaming
-
maybe-once
A singleton. Maybe.
-
ckanaction
featuring an API wrapper of the CKAN Action v3 API
-
orengine
Optimized ring engine for Rust. It is a lighter and faster asynchronous library than tokio-rs, async-std, may, and even smol
-
legend-saga
working with RabbitMQ and asynchronous operations
-
cyper
HTTP client library based on compio and hyper
-
playground-api
API-binding for The Rust Playground
-
mpi-sys
Message Passing Interface bindings for Rust
-
async-socks5
An async/.await SOCKS5 implementation
-
command_timeout
A tokio friendly command exec with smart timeout
-
mountain-mqtt
A no_std compatible, async MQTT v5 client for tokio and embedded use
-
tokio-scheduler-rs
JobScheduler written with tokio runtime, automatic retry, hook and custom storage supported
-
yield-progress
Combined progress reporting and cooperative task yielding
-
fastimer
This crates implements runtime-agnostic timer traits and utilities
-
flatline
ssh-2.0 client library
-
latch
fast and efficent Latch supporting both sync and async modes
-
containerd-client
GRPC bindings to containerd APIs
-
ads_client
An asynchronous, non-blocking ADS client
-
kafru
Python Celery-inspired queuing library for Rust, using cron for scheduling and SurrealDB for storing queues, metrics, and schedules
-
vmc
Virtual Motion Capture protocol for virtual avatar tracking
-
rabbitmq-stream-protocol
AMQP 1.0 message codec
-
snakeice-rdkafka
Rust wrapper for librdkafka
-
async-io-mini
Async I/O fork for embedded systems
-
image_search
designed to search Google Images based on provided arguments
-
radio
Generic traits for embedded packet radio devices
-
rocketmq-remoting
Apache rocketmq remoting
-
mod-cli
A fully customizable, feature-rich CLI framework for Rust. Define commands, prefixes, styled output, and more—built for flexibility and speed.
-
async-blocking-stdio
std::io::std{in(), out(), err()} but async
-
wiremock_logical_matchers
Logical matchers for use with wiremock
-
est
Extensions for the rust Standard library and Tokio
-
neon-runtime
Bindings to the Node.js native addon API, used by the Neon implementation
-
truba
The minimal tokio runtime based actors for Rust
-
tokio-vsock
Asynchronous Virtio socket support for Rust
-
discro
DISCRete Observables for asynchronous Functional Reactive Programming (FRP)
-
hooch
A small async runtime that's been bootlegged for my projects
-
deduplicate
caching, asynchronous, request deduplication
-
asyncron
Executor agnostic task manager and async scheduler for Rust
-
mapped_futures
A collection of futures based on FuturesUnordered that supports insertion, removal and mutation of futures by key
-
async-anthropic
Anthropic Rust Client
-
mio_wasi
Lightweight non-blocking IO
-
event-driven-library
Event Driven Message Handling
-
safe-vk
create your own vk bot for conversations
-
xelf
A versatile Rust toolkit for self-use
-
ng-repo
Repository library of NextGraph, a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
actor-core-client
Rust client for ActorCore - the Stateful Serverless Framework for building AI agents, realtime apps, and game servers
-
tower-circuitbreaker
A circuit breaker middleware for Tower services
-
meltdown
A lightweight service manager to help with graceful shutdown of asynchronous applications
-
robotxt
Robots.txt (or URL exclusion) protocol with the support of crawl-delay, sitemap and universal match extensions
-
page-turner
A generic abstraction of APIs with pagination
-
mikrotik-rs
Asynchronous Rust library for interfacing with MikroTik routers
-
owned-future
Turn borrowed futures into owned futures
-
prk_eventbus
A lightweight, WebSocket-based event bus for Rust with SQLite persistence
-
bound
Wrap lock guards and other structs along with the locks or other data they are derived by shared reference from, in a struct you can pass around and store anywhere
-
httpwg-cli
A CLI able to run httpwg test cases (h2spec replacement)
-
async-rt
A small library designed to utilize async executors through an common API while extending features
-
streamunordered
An efficient async stream multiplexer
-
openrouter_api
client library for the OpenRouter API
-
mustang
Rust programs written entirely in Rust
-
lighthouse-client
Client SDK for Project Lighthouse
-
spotify-rs
wrapper for the Spotify API
-
irelia
wrapper around the native LoL APIs
-
futures-retry
Retry your Futures and Streams!
-
rspc-axum
Axum adapter for rspc
-
messagebus
allows intercommunicate with messages between modules
-
pi_async_buffer
Asynchronous Buffer for IO
-
rdkafka-sys
Native bindings to the librdkafka library
-
bp3d-net
Network utilities
-
smol
A small and fast async runtime
-
tokactor
A actor model framework wrapped around tokio
-
histlog
hdrhistogram crate, provides off-thread serialization of HdrHistogram interval logs to file
-
eventuals
Eventually consistent values
-
rasi-spec
The Official RASI Specification Test Suite
-
qbittorrent_rust
An asynchronous library to interface with the qbittorrent WeBUI API
-
bisync
write async-generic code
-
fama
Pipeline Manager
-
async-stripe-issuing
API bindings for the Stripe HTTP API
-
steady_state
Framework for building long running low latency actor based services on Linux. Provides visual telemetry to watch data flows between actors. Uses Erlang style supervisors to defend…
-
corcovado
Non-blocking IO library
-
async-lazy
A value which is initialized on the first access, with an async function
-
mangadex-desktop-api2
A Actix server for downloading manga, chapters, covers from Mangadex
-
rspack_futures
rspack futures
-
ruloom
A thin wrapper around 'corosensei' that provides support for stackful coroutines in Rust (like Loom in Java or goroutines in golang)
-
mail-message
A program for easy, quick, and fault tolerant sending of emails from the command line
-
kuri
An SDK for building MCP servers, focused on elegant developer experience, where tools and prompts are just plain old Rust functions
-
kioto-serial
Provide serial port I/O using tokio
-
tower-lsp-f
Language Server Protocol implementation based on Tower
-
async-native-tls
Native TLS using futures
-
actix-casbin
An Actix actor for casbin
-
process-lib
Cross-platform, asynchronous Rust library to run commands in pipelines
-
pin-utils
pinning
-
tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
wgpu-async
Converts some WGPU callback methods to async methods
-
rseip
Ethernet/IP (CIP) client in pure Rust
-
genawaiter
Stackless generators on stable Rust
-
bevy-async-runner
Bevy Async Runner simplifies working with asynchronous code in the Bevy game engine. It provides a mechanism to schedule and execute async tasks and provide their result to any system.
-
tools_interface
Abstractions of serveral Wikipedia/Wikimedia/Wikidata-related tools
-
tor-log-ratelim
Facility for rate-limiting log messages in Arti
-
v_queue
file based queue
-
acton-core
Acton Core provides the core functionality and abstractions used by the Acton Reactive crate. It includes the essential building blocks for creating reactive and distributed systems.
-
warp-rate-limit
Rate-limiting middleware for the Warp web framework
-
async-timeouts
An instrument to start async tasks after timeouts
-
s2n-tls-tokio
TLS streams for Tokio built on top of s2n-tls
-
ntex-polling
Portable interface to epoll, kqueue, event ports, and IOCP
-
async-io-bufpool
Efficient asynchronous I/O operations with minimal idle memory overhead
-
pinky-swear
Futures and async/await-ready Promises
-
coerce-redis
Redis actor persistence provider for Coerce. Supports event sourcing and snapshots
-
async-ffi
FFI-compatible
Futures -
aws-smithy-http-server-python
Python server runtime for Smithy Rust Server Framework
-
flarrow-url-default
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
pgp-lib
High-level, asynchronous API for rPGP, a pure Rust implementation of OpenPGP
-
agnostic-net
Agnostic abstraction layer of
std::netfor any async runtime -
firecracker-rs-sdk
🧨🦀🚀 The Firecracker Rust SDK. A pure Rust crate for interacting with Firecracker.
-
libublk
building linux block device in userspace
-
stilgar
A lightweight, no-fuss, drop-in replacement for Rudderstack
-
future-local-storage
An init-once-per-future cell for thread-local values
-
s3tui
TUI application for multiple s3 account operations
-
libsync
containing channels and other synchronisation object implementations
-
translators
Free Google Translator without API key and limits
-
tokio-shutdown
Wait for a stop signal across multiple threads
-
read_until_slice
AsyncBufRead::read_until extension to take a slice as a delimiter instead of a single u8
-
biscuit-actix-middleware
Biscuit middleware for actix-web
-
kameo_actors
actors for kameo
-
async-injector
Reactive dependency injection for Rust
-
wiremocket
Websocket mocking to test Rust applications
-
ssip-client-async
Client API for Speech Dispatcher
-
ffi_rpc
Use FFI with RPC
-
async_io_stream
IntoAsyncRead on steriods
-
fastcgi-client
Fastcgi client implemented for Rust
-
uactor
The fastest and most modular actor system that doesn't force you to pay for what you don't need
-
jni-utils
Extra Utilities for JNI in Rust
-
kwi-kraken-rest
Unofficial kraken trading platform REST API implementation
-
asteroid-mq
An embeddable message queue system
-
miow
A zero overhead I/O library for Windows, focusing on IOCP and async I/O abstractions
-
synchronized-writer
A tiny implement for synchronously writing data
-
citadel_types
Types for the citadel protocol
-
etcdv3client
etcdv3 client
-
whirlwind
Collection of thread-safe, asynchronous data structures
-
rusher
Pusher compatible pubsub service
-
wait
Syntactic sugar for calling async functions outside of an async context
-
senders_receivers
Senders/Receivers implementation for Rust
-
napi-calm-down
N-API bindings
-
waitgroup
Async waitgroup for a collection of task to finish
-
mal-api
An asynchronous MyAnimeList (MAL) API library for Rust
-
tokio-io-mock-fork
Enhanced tokio_test::io::Mock
-
qonduit
CQRS pattern
-
effectum
An embeddable task queue based on SQLite
-
marzban_api
async client which abstracts/simplifies the interactions with the Marzban panel API (https://github.com/Gozargah/Marzban)
-
rama-utils
rama
-
basu
Eventbus crate with sync and async features
-
libmqm-sys
IBM® MQ Interface (MQI), Programmable Command Format (PCF) and MQ Administration Interface (MQAI) bindings
-
async-borrow
Async compatible ownership semantics using futures instead of lifetimes
-
stopper
an async stream and future stopper mechanism
-
tokio-rayon
Mix async code with CPU-heavy thread pools using Tokio + Rayon
-
gql_client
Minimal GraphQL client for Rust
-
busstop
A command and query bus
-
async-codec
creating async codecs
-
interthread
Auto implementation of the Actor Model
-
odem-rs
Object-based Discrete-Event Modelling in Rust using async/await
-
async-atomic
Atomics which can be subscribed to and asynchronously notify when updated
-
mlua-codemp-patch
High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau with async/await features and support of writing native Lua modules in Rust
-
futures-scopes
Runtime agnostic, nestable, scopes for spawning non-static futures
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
fundamentum-sdk-api
HTTP client targeting Fundamentum IoT devices RestAPI
-
kuska-handshake
Secure Scuttlebutt handshake + boxstream library
-
ics-watcher
A lightweight crate for monitoring ICS files or links and detecting changes, additions, and removals
-
async_nursery
Primitive for structured concurrency
-
actix-mqtt-client
A MQTT client based on the actix framework
-
sn_sdkg
Safe Network Synchronous Distributed Key Generation: enables dealerless section key generation
-
request_coalescer
An asynchronous request coalescing library for Rust
-
reactor-trait
A collection of traits to define a common interface across reactors
-
threshold
data structures
-
viz-router
The router for Viz
-
tokio-util
Additional utilities for working with Tokio
-
axum-standardwebhooks
Axum extractor that verifies signature for Standard Webhooks
-
simple-pool
async pool for any kind of resources
-
pasts
Minimal and simpler alternative to the futures crate
-
log-tracing-layer
Build your own custom tracing layer
-
debounced
building delayed
Futures and debouncedStreams that wait a given duration before yielding the most recent item -
citadel_io
Underlying runtime for interfacing with I/O for std/wasm targets
-
async-rdma
async wrapper for RDMA ibvers lib
-
tonic-side-effect
Tower service that can monitor if a Tonic request frame was produced prior to error
-
ruchei
working with many streams
-
stackfuture
wrapper around futures that stores the wrapped future in space provided by the caller
-
reactivity
A lightweight library for reactive programming with signals in Rust
-
pierport
Urbit pier import protocol implementation
-
rustygram
minimal and blazing fast telegram notification framework for Rust
-
keen-retry
-- yet powerful -- zero-cost-abstractions & zero-copy lib for error handling & recovery
-
pochta
Addressable channel registry
-
hass-rs
An async websocket client for Home Assistant
-
retry-if
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
futures-batch
An adaptor that chunks up elements and flushes them after a timeout or when the buffer is full. (Formerly known as tokio-batch.)
-
nature
development support platform, it separates data definition from code, so it decouple the data from business system
-
batch-channel
async channel that reduces overhead by reading and writing many values at once
-
retry_macro
A set of declarative macros which retries executing a function upon failure
-
madsim-tokio
The
tokiosimulator on madsim -
enigmatick
social media platform that integrates with servers that implement the ActivityPub protocol (e.g., Mastodon)
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
pipebuf_rustls
PipeBuf wrapper for Rustls
-
super-visor
ordered startup and shutdown for long-running tokio processes
-
deluge
A highly concurrent stream library driving the underlying futures either concurrently or in parallel to process streaming operations as quickly as possible
-
async_tasks_recorder
A struct for recording execution status of async tasks with async methods
-
tc_nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
switchyard
Real-time compute focused async executor
-
patharg
Treat "-" (hyphen/dash) arguments as stdin/stdout
-
futures-executor
Executors for asynchronous tasks based on the futures-rs library
-
glommio
thread-per-core crate that makes writing highly parallel asynchronous applications in a thread-per-core architecture easier for rustaceans
-
tactix
Actor Model based on Tokio
-
fluvio-stream-dispatcher
Fluvio Event Stream access
-
monoio-codec
Codec for Monoio
-
infect
Intent/effect/task - A variation on the Model View Intent (MVI) and State Action Model (SAM) paradigms
-
pupactor
actor model library built with tokio
-
bb-downloader
async downloader for applications
-
hitomi_la
A hitomi.la API wrapper for Rust
-
agentctl
Tiny control-plane primitives for AI agents
-
event-listener
Notify async tasks or threads
-
heph
actor framework based on asynchronous functions
-
specto
A process watchdog with an optional output capturing rotated log file facility
-
bleasy
High-level BLE communication library
-
koibumi-socks
A minimal SOCKS5 client library
-
cbsk_socket_tokio
socket callback tool by tokio
-
ntex-neon
Async runtime for ntex
-
fluxor_cli
Fluxor CLI: a command-line tool that allows developers to quickly and efficiently create project starters for the Fluxor web framework
-
speedbump
An extensible rate limiting library
-
passivized_vault_client
Vault Client - initialize and monitor Hashicorp Vault nodes
-
async-reciprocals
asynchronous fallible conversion and reciprocals in Rust
-
architect-tonic
A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
taskline
distributed task queue for Rust
-
resident-utils
Resident program library
-
cache_loader_async
A thread safe loading cache with async loader functions based on tokio
-
drama
multitenant scheduler for the komora db project
-
linemux
providing asynchronous, multiplexed tailing for (namely log) files
-
jarust_plugins
A janus client SDK in Rust
-
upc
USB packet channel (UPC): provides a reliable, packet-based transport over USB
-
scylla-rs
An async ScyllaDB driver built on an actor-model framework
-
rusturn
TURN server and client
-
netgauze-rdkafka
Rust wrapper for librdkafka
-
madsim-rdkafka
The rdkafka simulator on madsim
-
awaitgroup
Wait for a collection of async tasks to finish
-
mio-pidfd
mio support for Linux's pidfd
-
xtra
A tiny actor framework
-
pistones
An wrapper for the Piston code execution engine
-
product-os-async-executor
Product OS : Async Executor provides a set of tools to handle async execution generically so that the desired async library (e.g. tokio, smol) to be used can be chosen at compile time.
-
futures-signals-ext
Extension to futures-signals: MutableOption with combinators, spawning, predicate driven selections from SignalVec
-
serial-thread
Asynchronous, multithreaded serial port communication library using mpsc::cjhannels or async-channels for efficient data handling
-
leptos_async_signal
Async signal for leptos Rust web framework
-
trovo
A trovo.live api & chat client written in and for rust
-
tokio-muxt
Timer for a limited set of events that multiplexes over a single tokio Sleep instance
-
nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
picomux
A protocol to multiplex multiple AsyncRead/Write streams over a single one, inspired by smux and http2
-
peace_params
Constraints and specifications for parameters for the peace automation framework
-
lichess-api
client for Lichess API v2.0.0
-
tonic-server-dispatch
A request-dispatch level for tonic-Server
-
nonblock
Read available data from file descriptors without blocking (e.g. sockets, streams, child stdout, named pipes)
-
windows-future
Windows async types
-
bsky-cli
CLI application for Bluesky using ATrium API
-
shenyu-client-rust
Apache ShenYu Rust client SDK
-
retrier
A wasm-compatible retry library for futures
-
trale
minimalistic Rust async executor using io_uring for efficient, correct task execution
-
safina-timer
Safe async timers - ARCHIVED: Code moved to
safinacrate -
async-rate-limit
Common traits for rate limiting and implementations in async contexts
-
actix-multipart-rfc7578
multipart/form-data (RFC7578) for Actix
-
kube-coordinate
Kubernetes leader election using the coordination.k8s.io API
-
stressed
Universal CLI stress tester for competitive programming
-
syndicate
Syndicated Actor model for Rust, including network communication and Dataspaces
-
call-recursion
Hack async to do recursion on the heap
-
didcomm-rs
DIDComm messaging v2 specifications implementation: https://identity.foundation/didcomm-messaging/spec/
-
flowrs-core
Core components of the flowrs framework for directed graph workflows
-
blec
cross-platform ble client library based on btleplug
-
zookeeper-async
An async ZooKeeper client
-
async-fs
Async filesystem primitives
-
slacktor
extremely fast, bare-bones, low-overhead, supervisorless, no-std actor library
-
mbp2
A common-utility library for federated projects
-
toni
Fast and modular web framework for scalable applications
-
process-stream
Thin wrapper around [
tokio::process] to make it streamable -
deepseek_rs
client library for the DeepSeek API
-
flo_binding
Declarative binding library for Rust
-
task_forge
A flexible and simple task pool for asynchronous execution
-
async-change-tracker
reactive change notifications using futures
-
some_executor
A trait for libraries that abstract over any executor
-
co_managed
Create managed sub coroutines. Managed sub coroutines will be cancelled when the parent exit
-
aeron-rpc
Deadly simple RPC framework built on top of Aeron and Tokio
-
swait
Blocking on Futures
-
handle
Trait for asynchronous context pipeline
-
async-scgi
Async SCGI Client & Server
-
async-graphql-tide
async-graphql for tide
-
zephyrus
A slash-command framework meant to be used with twilight
-
aws-multipart-upload
AWS S3 multipart upload sinks
-
async-shared-timeout
Async timeout that can be reset and shared
-
imdb-async
Opinionated and unopinionated async wrappers to efficiently retrieve and parse IMDB's dataset
-
ordered-stream
Streams that are ordered relative to external events
-
pyridis-api
iridis, with python
-
rio
GPL-3.0 nice bindings for io_uring. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
versatile-dataloader
An async data loader for Rust
-
vmcircbuffer
Double Mapped Circular Buffer
-
async_zmq
Async version for ZeroMQ bindings
-
tor-rtcompat
Compatibility layer for asynchronous runtimes, used by Tor
-
passfd
File descriptor passing
-
monoio-thrift
Thrift for Monoio
-
tempo-rs
& minimal client to connect and interact with RTE's 'Tempo Like Supply Contract' API
-
apis
Reactive, session-oriented, asynchronous process-calculus framework
-
timeout-iterator
TimeoutIterator is a wrapper over any iterator that adds peek_timeout and next_timeout functions. The canonical use-case is parsing multi-line free-form records (such as tailing a log fime)…
-
sids
sample actor-model scheme providing abstraction over actor types and messages that can be sent across threads
-
secret-lib
Cross-platform, asynchronous Rust library to retrieve secrets from different sources
-
futures-timeout
that provides timeouts for futures and streams
-
north-config
North config is a multi source configuration crate designed as part of the North Microservice Framework
-
compio-fs
Filesystem IO for compio
-
lifeline
dependency injection library for asynchronous message-based applications
-
async-openai-alt
OpenAI
-
ahrimq
A high-performance message queue service supporting pub/sub, normal messages, ordered messages, delayed messages and dead letter queues
-
tokio_wasi
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
stream_throttle
Stream combinator, to limit the rate at which items are produced
-
letslogic
providing interaction with the Let's Logic API
-
async-time-mock-tokio
Mockable time for use in async runtimes (tokio compatibility)
-
fil_actors_runtime
System actors for the Filecoin protocol
-
tokio-yamux
Yamux
-
ssec-core
streaming implementation of the SSEC file format
-
easy-schedule
A flexible task scheduler built on Tokio with multiple scheduling options and skip conditions
-
tokio-socketcan
Asynchronous Linux SocketCAN sockets with tokio
-
any_spawner
Spawn asynchronous tasks in an executor-independent way
-
socketioxide-emitter
Broadcast events across a Socketioxide cluster from any Rust process
-
passivized_docker_engine_client
Docker Engine Client - manage and run containers, images, and volumes
-
tokio-hrtime
Hires timers for tokio
-
daemon-base
A flexible and configurable Rust daemon library with lifecycle management, logging, callbacks, and optional async support. Works on Linux, macOS, and Windows.
-
streamline
Reversible futures::Stream-based state machines
-
webrtc-signal-server
General WebRTC signal server For Peer to Peer Communication
-
pacifica-rs
PacificA: Replication in Log-Based Distributed Storage Systems
-
persway
Sway IPC daemon
-
fourche
task queue named after a lion with forked tail (queue fourché), works with Redis
-
async-tensorrt
Async TensorRT for Rust
-
async-dropper-simple
struct-wrapper (i.e. AsyncDropper<T>) based implementation of AsyncDrop
-
automerge-test
testing automerge libraries
-
elevatorpro
TTK4145 Real-time Programming elevator project, Group 25, spring 2025
-
eventastic_postgres
An example postgres event store for eventastic
-
cyclic_pipe
providing fixed-size, buffer pre-allocated cyclic pipe which support multi-producer and multi-consumer concurrent access
-
async-compatibility-layer
an abstraction layer for using both async-std and tokio
-
deferred-future
模仿 jQuery.Deferred()，允许从 Future 实现类实例的外部对正在 pending 的 Future 对象进行 resolve 或 reject 处理。
-
baton
channel for receiving updates per field
-
retainer
Minimal async cache in Rust with support for key expirations
-
tokio-serde-cbor
Integration of serde_cbor into tokio-io, to allow sending CBOR encoded frames across network (and possibly through other transports)
-
makepad-futures-legacy
Makepad futures legacy
-
tokio-js-set-interval
Allows you to use
setInterval(callback, ms)andsetTimeout(callback, ms)as in Javascript inside atokioruntime. The library provides the macrosset_interval!(callback, ms)andset_timeout!(callback, ms) -
gimbal_async_cargo
Cargo async linter package
-
quickwit-actors
Actor framework used in quickwit
-
fundamentum-sdk-mqtt
MQTT client targeting Fundamentum IoT's MQTT broker
-
foctet-mux
Multiplexer for Foctet, enabling multiple streams over a single connection
-
wakerizer
Helpers for resources that may have multiple concurrent wakers
-
swimos_agent_protocol
SwimOS Agent Protocol
-
async-web-client
async web client helpers
-
eyeball-im
Observable collections based on the
imcrate -
decrypt-cookies
A decrypt browser crate
-
futures-io
The
AsyncRead,AsyncWrite,AsyncSeek, andAsyncBufReadtraits for the futures-rs library -
volo-thrift
Thrift RPC framework implementation of volo
-
mlua-luau-scheduler
Luau-based async scheduler, using mlua and async-executor
-
tower-batch-control
Tower middleware for batch request processing
-
supabase-rust-realtime
Realtime client for Supabase
-
voiceflousion
that provides toolkit for Voiceflow AI bots integrations and pre-built functionality for quick integration with popular messengers
-
notifier_hub
cannal subscribtion system
-
rxqlite-lite-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
cbsk_run
async pool tool
-
tinyudp
A tiny abstraction for UDP
-
messagepack-async
functional library for read/writing messagepack with tokio
-
minos
Authorization library
-
svix-webhook-with-clone
Svix webhooks API client with derive Clone added to Webhook struct
-
async_async_io
AsyncRead,AsyncWritetraits but withasync fnmethods -
mqtt-async-client
An MQTT 3.1.1 client written in Rust, using async functions and tokio
-
roux-stream
A streaming API for the roux Reddit client
-
pgboss
job queueing service
-
containerd-shim-protos
TTRPC bindings for containerd shim interfaces
-
slim-futures
Asynchronous tools that intends for smaller binary size
-
smolscale
A high-performance async-task scheduler
-
async_fsm
Async Finite State Machine
-
lua_actor
Lua Actor for Rust(sync/async)
-
cppstreams
C++ streams in rust
-
okkoi
-
knien
Typed RabbitMQ interfacing for async Rust
-
iroh-io
async local io
-
hexpm
client for the Hex package manager
-
riker-patterns
A collection of common actor patterns for Riker
-
array__ops
A selection of useful array operations
-
mm1-proto-system
M/M/1! Queueing, do you speak it?!
-
rspl
A stream processor language
-
circuit_breaker
Circuit Breaker pattern for building resilient and fault-tolerant systems
-
async-interval
Async Interval
-
realhydroper-lsp
Language Server Protocol implementation based on Tower
-
async_logger
Asyncronous logger allows writing arbitrary slices to a memory buffer, which then processed by a writer in it's own thread
-
notifies
various efficient async notifies
-
nosy
Change notification / observation / broadcast channels, with filtering and coalescing. no_std compatible.
-
swansong
Graceful Shutdown
-
mobc-surrealdb
Surrealdb support for the mobc connection pool
-
cobs-codec
COBS codec for Tokio
-
tinyogg
A very simple Ogg packet serializer and deserializer and a stream for writing data and encapsulating the data into Ogg streams
-
space-traders
Async SpaceTraders API client for Rust
-
starbase_events
Async and mutable event system
-
eureka-mmanager
An Actix actor collection for downloading manga, chapters, covers from Mangadex
-
gcp_access_token
pure rust implimentation to get google cloud access token for servers with service account credentials
-
jw_client
API wrapper for the JW Player media management API. List or stream library into native Rust structs and download renditions.
-
rust_generator
generator base on async rust! No experimental needed!
-
circulate
Lightweight PubSub framework that supports both sync and async
-
tbot
Make cool Telegram bots with Rust easily
-
mm1-sup
M/M/1! Queueing, do you speak it?!
-
tokio_gen_server
Elixir/Erlang-GenServer-like actor on the Tokio runtime
-
madruga
Retry resiliente com backoff
-
async-fuse
Helpers for fusing asynchronous computations
-
pipex
A functional pipeline macro for Rust combining sync, async, parallel, and streaming operations
-
yosemite
Asynchronous SAMv3 library
-
abyss-promise
[abyss] A simple promise implementation with adaptive threadpool support
-
typed-emitter
Typed Async event emitter
-
rendezvous
Easier rendezvous channels for thread synchronization
-
jira2
common
-
async-duplex-channel
An asynchronous duplex communication channel between multiple clients and a single responder in different asynchronous blocks
-
sluice
Efficient ring buffer for byte buffers, FIFO queues, and SPSC channels
-
noosphere-into
Transformations of Noosphere content into various target formats
-
k8s-cri
Bindings Kubernetes CRI
-
taski
async task DAG execution
-
pcap-async
Async/Stream Extensions for libpcap
-
lwactors
Lightweight actors for Rust using futures-rs
-
extra-result
Add extra methods to
Resultenum -
signalfut
A future similar to tokio::signal::unix::Signal, but can be used with all the runtimes
-
tarpc-copy
An RPC framework for Rust with a focus on ease of use
-
async-task-tracker
A task tracker used for waiting until tasks exit
-
gprs
A set of filtered and optimized Rust libraries creates a foundation for building modern web frameworks
-
tokio-zmq
Futures abstractions for ZeroMQ on the Tokio event-loop
-
swimos_recon
SwimOS Recon
-
act-locally
single-threaded async actors with ordinary functions as handlers and plainly typed messages
-
stop-token
Experimental cooperative cancellation for async Rust
-
pxl-rust
XCENA PXL Binding Library
-
specializer
Safe specialization on stable Rust with builder-like pattern
-
streamcatcher
A thread-safe, shared (asynchronous), almost-lockless stream buffer
-
synch
A basic asynchronous timer implementation that uses the cortex-m SysTick peripheral
-
dbus-async
Asynchronous DBus library
-
iroh-docs
Iroh sync
-
event_iterator
Asynchronous lending iterator
-
mfio
Flexible completion I/O primitives
-
webex
Interface to Webex Teams REST and WebSocket APIs
-
pingora-runtime
Multithreaded Tokio runtime with the option of disabling work stealing
-
ctrlgen
Generate enums for message-passing services
-
cbsk_socket_rayon
socket callback tool by rayon
-
py_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
par-stream
Asynchronous parallel streams analogous to rayon
-
actman
Async Actor Model Library in Rust
-
stund
An SSH tunnel maintenance daemon
-
hyperbee
Peer to Peer B-tree
-
brig
mar here, Briganteen—General Sir A. I. Magnus, the flapper-
-
mega_etl
A cloud-native ETL (Extract, Transform, Load) application framework based on the WasmEdge WebAssembly runtime for developers to filter, map, and transform data pipelines going into cloud databases
-
futuredsp
A signal processing library for SDR and real-time DSP
-
nebkor-maelstrom
synchronous client for creating Maelstrom distributed clients
-
stdin-nonblocking
Dependency-less non-blocking stdin reader using background threads. Supports streaming and immediate fallback defaults.
-
async-gate
A Tokio-powered asynchronous gate (analogous to a flag and highly inspired by Python’s
asyncio.Event, but can be waited for to become ‘false’ too) -
prin
reverse proxy terminal utility
-
overclock
A framework for building data-driven distributed systems
-
omp
Rust SDK for developing open.mp gamemodes
-
rspc
A blazing fast and easy to use TRPC server for Rust
-
crashdump_viewer_cli
A CLI tool to parse Erlang crashdumps
-
winctx
A minimal window context for Rust on Windows
-
async-stripe-misc
API bindings for the Stripe HTTP API
-
hydra-websockets
A websocket server for the hydra framework
-
actix-limitation
Rate limiter using a fixed window counter for arbitrary keys, backed by Redis for Actix Web
-
tokio-send-fd
A wrapper for tokio::net::UnixStream to send file descriptors
-
kafka-threadpool
An async rust threadpool for publishing messages to kafka using SSL (mTLS) or PLAINTEXT protocols
-
vss
A dead simple library to allow for easily reused shutdown signal handling
-
asyncute
(async execute) can execute async futures globally without per-executor queues
-
minipool
Lightweight, generic tokio-based pool implementation for Rust
-
tokio-nsq
NSQ client built on Tokio. Tokio NSQ aims to be a feature complete NSQ client implementation.
-
ractor_cluster
Distributed cluster environment of Ractor actors
-
pubnub
SDK for Rust
-
actix-daemon-utils
Daemon Utilities by actix
-
tokio_based
BASED Async Single-threaded Execution Dispatcher
-
bakkesmod
Rust SDK for writing BakkesMod plugins
-
crdt_tree
Tree Conflict-free Replicated Data Type (CRDT)
-
ksoft
KSoft.SI api wrapper written in pure Rust
-
upstox-rust-sdk
SDK to access Upstox's Uplink v2 APIs programmatically
-
crossbus
A Platform-Less Runtime-Less Actor Computing Model
-
rabbit_mqr
Extremely Simplified RabbitMQ Client
-
connect
message queue abstraction over async network streams
-
termusix
A terminal-based music player with a user-friendly terminal UI, built with Rust
-
task-supervisor
Tokio tasks Supervisor
-
tokio-stream_wasi
work with
Streamandtokio -
singleflight-async
Singleflight in async style
-
libmqm-constants
IBM® MQ Interface (MQI), Programmable Command Format (PCF) and MQ Administration Interface (MQAI) constant definitions
-
tokio-splice2
splice(2) in tokio
-
noveum-ai-gateway
A high-performance AI Gateway proxy for routing requests to various AI providers, offering seamless integration and management of multiple AI providers
-
openraft-memstore
A in-memory implementation of the
openraft::RaftStoragetrait -
simple-middleware
General purpose middleware crate
-
algoroutine
Light-weight algebraic effect(algebraic goroutine) in Rust
-
clia-async-openai
OpenAI (with rustls)
-
miau
Async aware and extensible layered configuration system
-
highroller
high-level rolling index that is thread-safe and guarantees cheap runtime-unique IDs
-
async_zip_futures
An asynchronous ZIP archive reading/writing crate using futures-rs
-
spin_on
inefficient Future executor
-
tub
Async Pool
-
craftio-rs
read & write packets defined in mcproto-rs to I/O sinks/sources
-
my-awesome-rabbitmq-lib
working with RabbitMQ and asynchronous operations
-
tasklet
An asynchronous task scheduling library
-
thread-waker
Waker implementation using current thread token
-
goods
Async assets system
-
baildon
B+Tree library
-
async-dispatcher
async runtime based on a pluggable dispatcher
-
hollywood
actor framework
-
woddle
An async, synchronized, database-backed Rust job scheduler
-
somen
An asynchronous parser combinator
-
any-mpsc
An mpsc that allows arbitrary types to be passed through
-
aj
Background Job based on Actix
-
xtor
Async Actor framework for Rust which is blazing fast and rock solid
-
navactor
A cli tool for creating and updating actors from piped input
-
actors-rs
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
aa-sms
Send messages from with Andrews & Arnold’s SMS API
-
collections-futures
working with futures through collections types
-
rx_rust_mp
A protoype implementation of the ReactiveX API in Rust using a message passing approach
-
reusable-box-future
A reusable
Pin<Box<dyn Future<Output = T> + Send>> -
anet_a2a_server
framework for building Agent-to-Agent (A2A) protocol services
-
peace_rt_model
Runtime data types for the peace automation framework
-
tokio-lxi
LXI protocol abstractions for Tokio
-
pi_async_transaction
Asynchronous abstraction for transactions
-
aws-parameters-and-secrets-lambda
Cache AWS Secrets Manager secrets in your AWS Lambda function
-
juggle
Async task switching for cooperative multitasking in single thread environments with no_std support
-
capp
Common things i use to build Rust CLI tools for web crawlers
-
shutdown-handler
A shutdown handler that allows all parts of an application to trigger a shutdown
-
moxie
Incremental runtime for interactive software
-
futures-map
Futures-based and hashmap-based alogrithms
-
par-dfs
Parallel, serial, and async dfs and bfs traversal
-
rust-paper
Rust Wallpaper manager from ( https://wallhaven.cc/ ) for Linux/UNIX only
-
linkd
actor model framework that takes inspiration from OTP in the erlang ecosystem
-
pyridis-examples
iridis, with python
-
gibbon
WIP implementation of Facebook's gorilla database in rust
-
booru-dl
A command line tool to download images and tags txt from booru
-
prokio
An asynchronous runtime compatible with WebAssembly and non-WebAssembly targets
-
agnostic
abstraction layer for any async runtime
-
fizyr-rpc
Native Rust implementation of the Fizyr RPC protocol
-
queen
message queue
-
syndicus
Publish/Subscribe with types for topics and subscriber (re)synchronisation
-
swimos_downlink
SwimOS Downlink Runtime
-
sparkle-convenience
A wrapper over Twilight designed to make it more convenient to use
-
multiqueue2
A fast mpmc broadcast queue
-
charred
char checking
-
aiven_rs
sdk to interact with aiven-cloud apis
-
sonor
controlling sonos speakers
-
tokio-agent
Agents are a simple abstraction around state, inspired by Elixir's Agent
-
heim
Cross-platform framework for system information
-
rblx-godot
Roblox To Godot Project, allowing you to run Roblox games inside Godot
-
async-mcp
Async Implementation of Model Context Protocol (MCP)
-
async-raft
An async implementation of the Raft distributed consensus protocol
-
pingora-cache
HTTP caching APIs for Pingora proxy
-
bevy_async_system
ability to wait for game status asynchronously
-
async-pipes
building concurrent data processing pipelines
-
cloudflare_dyndns
DynDNS client for Cloudflare
-
with-async-context
managing contextual data across async tasks
-
pub-sub-client
Google Cloud Pub/Sub client library
-
bunny-api-tokio
access to the Bunny CDN API asynchronously using tokio
-
gcal_rs
A blazingly fast, hand written Google calendar API in Rust
-
tasc
A minimnal, asynchronous threadpool
-
async-defer
Asynchronous Deferred Calls
-
swiftide-integrations
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
async_smux
Asynchronous smux multiplexing library
-
esrc
Primitives for implementing event sourcing and CQRS systems
-
axiom
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka
-
bing_client
Async reverse client for Bing copilot
-
io_uring_actor
Near-zero overhead pipelined io_uring api via actor model so you don't have to use Arc<Mutex<IOUring>>
-
tokio-graceful-shutdown-without-anyhow
perform a graceful shutdown on a Tokio based service
-
rs_ctx
Context propagation for rs framework
-
claude-client
client for the Anthropic Claude API
-
rocketmq-client-rust
Apache rocketmq client
-
dndx-fork-tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
libmqm-default
IBM® MQ Interface (MQI), Programmable Command Format (PCF) and MQ Administration Interface (MQAI) structure defaults
-
suika_utils
A small utility library for the suika web stack
-
async-cron-scheduler
Runtime-agnostic async task scheduler with cron expression support
-
product-os-browser
Product OS : Browser is a powerful browser controller that leverages headless browsing and provides automation tooling to not only read content but take actions defined via an instruction language
-
acton_test
Testing utilities for Acton agents, providing tools to help in the testing and validation of agent behavior
-
async_zip
An asynchronous ZIP archive reading/writing crate
-
switchy_async
Switchy Async runtime package
-
aoc_leaderbot_lib
Support library for aoc_leaderbot, an Advent of Code leaderboard-watching bot
-
miniloop
The simpliest async executor without heap memory allocation
-
aktors
Driver for derive-aktor
-
joyent-tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
dd-tracing-layer
Send your logs to Datadog
-
kapacitor-udf
creating Kapacitor User Defined Functions (UDFs)
-
proxy-scraper
command-line tool for scraping proxy information
-
hooch-http
HTTP addition to the hooch runtime
-
akinator-rs
wrapper around the undocumented Akinator API
-
rust-freely
An asynchronous wrapper for the WriteFreely/Write.as API
-
selecting
Cross-platform wrapper over select
-
tower-sesh
A Tower middleware for strongly typed, efficient sessions
-
torznab-toolkit
A safe, multi-threaded, async toolkit for adding Torznab APIs to programs
-
async_dag
An async task scheduling utilitiy
-
bp3d-threads
threading library intended to simplify concurrency in BP3D
-
simpl_actor
tokio actors
-
extend_mut
extending exclusive references
-
fure
Retrying futures using different policies
-
rants
An async NATS client library
-
dynalock
A lease based distributed locking algorithm with support for DynamoDB
-
vivian
(Vivian) of the Milky protocol
-
anthropic
SDK
-
luis_sys
FFI bindings for Microsoft LUIS API
-
hypixel_api
Generic wrapper around the hypixel api (automatic rate-limiting on client-side)
-
tokio-fastcgi
FastCGI handler (responder, authorizer, filter) library for Tokio
-
releez
run application release-checklist safely
-
lendpool
lock-free library for allowing safe and concurrent access to a group of objects
-
recall_fendermint_actor_blobs_shared
Shared resources for blobs
-
eventbuzz
A safe, fast, concurrent event publish/subscribe system based on tokio(async), inspired by Spring events
-
aoc_leaderboard
Strongly-typed wrapper for Advent of Code leaderboard data
-
tower-async
Tower Async is a library of modular and reusable components for building robust clients and servers. An "Async Trait" fork from the original Tower Library.
-
lictool
that will help you quickly add a spdx license to your project right from the command line
-
tonic-arcanyx-fork
A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility
-
futures-ratelimit
Bounded flavors of futures' FuturesUnordered and FuturesOrdered
-
async-tty
An asynchronous TTY library for Rust
-
tokio-wireguard
In-process WireGuard for Tokio
-
minior
Ergonomic Minio Client
-
futures-test-preview
Common utilities for testing components built off futures-rs
-
grizzly_scheduler
A scheduler for running async tasks using cron expressions. It is built on top of tokio. Tasks can be parallel or sequential. Fuzzy random offset can be added to the cron expression.
-
async-actor
actor framework for Rust
-
relearn
A Reinforcement Learning library
-
async_msp_cli
Async msp cli for iNav and BetaFlight
-
selectme
A fast and fair select! macro for asynchronous Rust
-
skrillax-stream
Combines skrillax-network crates to work nicely on top of a tokio tcp stream
-
fil_builtin_actors_builder
WASM builder for builtin Filecoin actors
-
register-count
Counting
Registers created by aCounter -
libaio-futures
Straightforward Linux AIO using Futures/async/await
-
witty-actors
Fork of quickwit-actors, Actor framework used in quickwit
-
tower-sessions-file-store
Store sessions for Tower Session store on the file system
-
async-os-pipe
Cross platform implementation of a bidirectional async pipe
-
fork_stream
Clone any stream
Swhere<S as Stream>::Item: Clone -
forked-tarpc
An RPC framework for Rust with a focus on ease of use
-
tk-listen
A set of helper futures allowing to listen TCP (or unix) socket with resource limits and proper error handling
-
async-tls
Asynchronous TLS/SSL streams using Rustls
-
uppercut
Small and simple actor model implementation
-
paho-mqtt-sys
Low-level, unsafe Rust wrapper for the Paho MQTT C Client Library. This is part of the official Eclipse Paho Rust Client Library
-
macroquad-platformer
Platformer physics for macroquad
-
futures-delay-queue
Async delay queue backed by async-std and futures-timer
-
jarust_rt
A janus client SDK in Rust
-
mini-c-ares-resolver
An asynchronous DNS resolver, backed by mini-c-ares
-
procsem
Semaphore used to lock thread/task-spanning sequence of operations
-
tokio-uring
io-uring support for the Tokio asynchronous runtime
-
nextgraph
client library. Nextgraph is a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
viaduct
A duplex communication channel between a parent and child process, using unnamed pipes
-
nanopore
A minimalist async runtime based on io_uring (Linux) and I/O rings (Windows)
-
noosphere-storage
Pluggable backing storage for the Rust Noosphere implementation
-
monoio-quiche
Asynchronous QUIC implementation for Monoio based on Quiche
-
acu
building asynchronous actors
-
spaad
Zero boilerplate actor systems with xtra
-
medea-reactive
Reactive mutable data containers
-
cb_fut
Call function that return value via callback without a callback
-
laststage
fast, durable, high concurrent HashMap
-
quick_crawler
QuickCrawler is a Rust crate that provides a completely async, declarative web crawler with domain-specific request rate-limiting built-in
-
must_future
A wrapper future marked must_use - mainly to wrap BoxFutures
-
odem-rs-sync
Model-time synchronization facilities of the ODEM-rs simulation framework
-
tokio-i3ipc
Bindings for i3 and tokio allowing async applications to communicate with i3 over it's IPC interface. Contains futures implementations and convenience functions for working with i3.
-
tokio-stdin-stdout
Thread- and future::sync::mpsc-based AsyncRead/AsyncWrite stdin/stdout with little buffering
-
lookit
Asynchronously connect to devices
-
yamaha-rcp
Remote control of Yamaha mixing consoles using TCP/IP networking
-
mikrotik_api
& minimal client to connect and interact with Mikrotik RouterOS API, usually exposed on port 8728
-
requiem
Actor framework for Rust
-
fluvio-async-tls
Asynchronous TLS/SSL streams using Rustls
-
actix-interop
Use async/await syntax with actix actors
-
wtx-ui
Different user interfaces for WTX
-
reducer
A predictable reactive framework for Rust apps
-
cancellation-token
C#'s CancellationToken API
-
phoenix_channels_client
async-ready client for Phoenix Channels in Rust
-
monoio-rustls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
stakker_mio
Mio I/O polling integration for the Stakker crate
-
synerlogikos
A high-level, generic, abstracted Rust library for building any integration. It is designed to abstract away common patterns found in all integrations multiple times.
-
yrs
High performance implementation of the Yjs CRDT
-
task-local
storage for asynchronous tasks
-
git-next-server-actor
Server actor for git-next, the trunk-based development manager
-
metatrait
RPITIT Monads
-
teloxide-core
Core part of the
teloxidelibrary - telegram bot API client -
fates
creating reactive declarations
-
zino-orm
ORM for zino
-
rublk
Rust ublk generic targets
-
future-utils
Extensions to Rust's Future and Stream traits
-
uringy
single-threaded concurrency runtime for Rust based on io_uring
-
oneshot-handshake
providing a symmetric one time use channel type
-
borrow_mutex
Async Rust Mutex which does not require wrapping the target structure
-
rt-local
Thread local asynchronous runtime working with platform-specific event loops
-
zippyst
Resolve zippyshare.com download links
-
hl7-mllp-codec
A Tokio codec for HL7 Minimal Lower Layer Message Transport protocol (MLLP)
-
erl_dist
Erlang Distribution Protocol
-
mio-extras
Extra components for use with Mio
-
coroutine-state
Inspect the state of a Future created by an async function
-
async-observable
Async & reactive synchronization model to keep multiple async tasks / threads partially synchronized
-
mqttc
client for the MQTT protocol
-
prevayler-rs
System prevalence in rust
-
pw-telegram-bot-fork
creating Telegram bots
-
mio-uds
Unix domain socket bindings for mio
-
funfsm
An FSM library where the states are functions
-
auto-future
For quickly making a struct into a future via an async fn
-
bader-db
Key-value cache RESP server with support for key expirations
-
proq
Idiomatic Async Prometheus Query (PromQL) Client for Rust
-
elfo-test
Test utils for the elfo system
-
mediator
pattern in Rust
-
tokio-tar
async TAR file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire…
-
rssafecircuit
implements a Circuit Breaker pattern with asynchronous support using Tokio, managing failure states and recovery strategies
-
curseforge
A straightforward asynchronous wrapper around the CurseForge Core API. Public API is subject to change before 1.0.0.
-
rtx
zero-cost runtime-abstraction intended for use by Rust libraries to enable the Freedom of Choice between asynchronous runtimes
-
xo-api-client
Unofficial crate for accessing Xen Orchestra through its API
-
async-app
ergonomic approach to implement applications spawning event loops
-
futures-http
http frameworks base on futures stream
-
stream-ext
An extension trait for Streams that provides a variety of convenient combinator functions
-
untokio
Automatically create tokio runtimes
-
floxide-timer
Timer node abstractions for the floxide framework
-
wait-for-me
Async CountDownLatch
-
again
wasm-compatible retry util for std library futures
-
tokio-snappy
Wrap rust-snappy as a async stream in tokio
-
async-gcode
An async gcode parser for no_std targets
-
zeroconf-tokio
Tokio-based wrapper around the zeroconf crate, which provides mDNS service discovery and registration capabilities
-
asynk-strim
Lightweight stream generator library
-
mm1-common
M/M/1! Queueing, do you speak it?!
-
awaitdrop
WaitGroup
-
async_message_dispatcher
dispatching messages to asynchronous handlers easier
-
gloo-events
Convenience crate for working with DOM event listeners
-
linked-futures
Link futures into a block, which stops all of the included futures when any of the futures complete
-
tokio-context
Contexts for cancelling asynchronous tasks using tokio
-
b2sum-rust
Computing The Blake2b Hash of Files with any given Digest Size
-
cdrs-tokio
Async Cassandra DB driver written in Rust
-
unblock
A thread pool for isolating blocking in async programs
-
pwner
Process Owner crate that allows ergonomic access to child processes
-
plumbing
An async abstraction to pipeline requests through a channel
-
bubbles
Bubble integration server for powder diffraction
-
ticque
Take a queue for a resource
-
rxqlite-sqlx-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
wasmflow-packet
encapsulating the message packets sent across Wasmflow components
-
futures-core
The core traits and types in for the
futureslibrary -
parallel-stream
Data parallelism library for async-std
-
async_closure
utilizes the nightly-only feature async_fn_in_trait to imitate async_closures
-
simple-delay-queue
delay queue for Tokio
-
proxycurl-linkedin-rs
client for the Proxycurl LinkedIn API
-
futures_codec
encoding and decoding frames using
async/await -
async-weighted-semaphore
An async weighted semaphore
-
plumb
A functional, async pipeline framework
-
visiting_ref
Container types that asynchronously return ownership of a value to another context upon exiting scope
-
async-graphql-warp
async-graphql for warp
-
kay
Experimental high-performance actor system framework for Rust
-
piston_rs
An async wrapper for the Piston code execution engine
-
callbag
spec for reactive/iterable programming
-
zeebe
client for defining, orchestrating, and monitoring business processes across microservices using Zeebe
-
terminusdm
Terminus Download Manager. Download files, resume interrupted downloads, and keep a history of your downloads - within terminal UI.
-
async-read-progress
Extension traits for inspecting
AsyncReadprogress -
xtra-addons
Add-on functionality (Broker, Registry) for crate xtra
-
foxhole-api
wrapper for the Foxhole War API
-
gentian
proc macro that transforms generators to state machines
-
peace_rt
Runtime logic for the peace automation library
-
safina-sync
Safe structs for sharing or sending data between async tasks - ARCHIVED: Code moved to
safinacrate -
orsomafo
Event dispatcher crate
-
crb-agent
CRB | Composable Runtime Blocks | Agent
-
rivulet
Asynchronous contiguous-memory streams
-
random-access-storage
Abstract interface to implement random-access instances
-
streammap-ext
StreamMap of Tokio with altered
nextthat returns when stream is dropped -
tokio-netstring-trait
A trait for tokios AsyncRead to easily read netstrings from streams
-
async-copy-progress
Asynchronous copying with progress callbacks
-
mosquitto-rs
An async MQTT client based on libmosquitto
-
coerce-k8s
Kubernetes discovery provider, automatically discover cluster peers hosted in Kubernetes, based on a configurable pod-selection label
-
zino-connector
Unified connector to data sources for zino
-
futures-diagnose
Wraps around a Spawn and provides lots of diagnostics
-
pinned
Synchronisation primitives for !Send tasks
-
anchor-chain
A statically typed async framework for building LLM-based applications
-
pausable_future
Pausable and resumable future, useful in background tasks
-
safina-threadpool
Safe thread pool - ARCHIVED: Code moved to
safinacrate -
side-futures
Send future for execution on the runtime that may be in a different thread
-
async-raft-ext
An async implementation of the Raft distributed consensus protocol.The ability of raft is enhanced while keeping the access interface unchanged for rnacos
-
slock
An async mutex that never deadlocks
-
pi_async_file
A async file tools library
-
amqprs
AMQP 0-9-1 client implementation for RabbitMQ
-
gloo-file
Convenience crate for working with JavaScript files and blobs
-
miku-h2
An HTTP/2 client and server
-
eyeball-im-util
eyeball-im -
xactor
actors framework based on async-std
-
dialectic
Transport-polymorphic, asynchronous session types for Rust
-
awaitable-bool
A Tokio-powered awaitable bool (analogous to a flag and highly inspired by Python’s
asyncio.Event, but can be waited for to become ‘false’ too) -
heph-inbox
Bounded capacity channel designed to be used as inbox for actors. Also supports one shot channels.
-
trillium-tokio
tokio runtime adapter for trillium.rs
-
sntpc
making SNTP requests
-
deadqueue
Dead simple async queue
-
gandi-v5-livedns-api
Gandi LiveDNS Api
-
cortex-client
API for Cortex, a powerful observable analysis and active response engine
-
felicia
service for accessing and sharing lists of bad actors
-
backstage
A framework for building data-driven distributed systems
-
puppet
actor framework which uses no dynamic dispatch or boxing
-
stream_lib
download differnt types of streams
-
zlink-tokio
zlink library for the Tokio runtime
-
agner
An actor toolkit inspired by Erlang/OTP
-
futures-time
async time combinators
-
tokio-tower
Bridging the protocol gap between Tokio and Tower
-
async-hofs
Various extention traits for providing asynchronous higher-order functions
-
scuffle-future-ext
working with futures
-
prost-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and prost
-
coachman
rust asynchronous task manager built on top of tokio framework
-
xilinx-dma
Userspace Xilinx AXI DMA Interface
-
tokio-stream-multiplexor
Stream Multiplexor for tokio with a tcp like interface
-
ethercat-device-control
A command line utility to control Ethercat devices
-
tokio-notify-aggregator
A tokio-based notify event aggregator
-
cooper
in-process, async Actor library for Rust
-
yaaf
Actor Framework
-
nova-r8
comprises Rust bindings for the Nova r8 game engine
-
lib3h_zombie_actor
lib3h actor request tracking module
-
clone-stream
Lazily clone streams
-
gcs-rsync
rsync support for gcs with higher perf than gsutil rsync
-
idb
A futures based crate for interacting with IndexedDB on browsers using webassembly
-
fred
An async client for Redis and Valkey
-
kvarn_async
Async utilities used in the Kvarn web server
-
compio-runtime
High-level runtime for compio
-
par_io
Parallel, async file I/O library with control over memory usage with no dependencies
-
async-stripe-treasury
API bindings for the Stripe HTTP API
-
tokio-io-compat
Compatibility wrapper around std io traits that implements tokio io traits
-
standardwebhooks
creating and verifying webhook signatures
-
pin-cell
A pin-safe cell
-
tokio_delayed_queue
Asynchronous delayed queue for Tokio runtime
-
saas-zmq
ZeroMQ tools by using Publish-Federation
-
pirates
async RPC lib
-
axum-core
Core types and traits for axum
-
multipart-rfc7578
multipart/form-data (RFC7578)
-
dstream
DelayedStream - delays items and drops same items coming within given interval
-
async-mavlink
An async adapter for mavlink conections
-
async_chanx
Implement
Sinkfor some channel implementations -
mcpx
SDK for the Model Context Protocol (MCP)
-
tenorite
A concurrency abstraction library. Provides a client-server model for asynchronous workers
-
waker-waiter
async runtimes interoperate with arbitrary futures
-
zebra-state
State contextual verification and storage code for Zebra
-
genawaiter2-macro
Convenience macros for generators (genawaiter2)
-
ref_count
Efficient, low-level asynchronous synchronization for real-time and embedded systems
-
deadpool-fantoccini
Dead simple async session pool for fantoccini
-
singleton-task
A singleton task based on tokio
-
async-signals
easier and safe Unix signal handling with async Stream
-
v_exchanges_adapters
Implementations of HTTP/HTTPS/WebSocket API methods for some crypto exchanges, using crypto-botters framework
-
bongonet-timeout
Highly efficient async timer and timeout system for Tokio runtimes
-
qbit-api-rs
A asynchronous Rust wrapper for qBittorrent Web API
-
tezaursapi
api wrapper for tezaurs.lv
-
sendgrid-async
An async-std based client for sending emails with SendGrid
-
lib-wc
Will's Programming Toolbox
-
limitation
A rate limiter using a fixed window counter for arbitrary keys, backed by Redis
-
borrow-count
Memory that can be shared with a smart pointer and then reaquired with a future
-
futures-finally
that executes a future after the completion of a future or stream regardless of the value or outcome
-
f289ctrl
Communication library for Fluke 289 digital multimeter
-
agnostic-process
Agnostic abstraction layer of
std::processfor any async runtime -
futures-test
Common utilities for testing components built off futures-rs
-
rosey-actors
Actor framework
-
deferred
help perform deferred execution of code logic
-
graceful-shutdown
Graceful Shutdown for async code
-
minactor
Minimal actor framework for Rust with tokio
-
oricalchum
A lightweight actor model
-
patoka
Try this if you can decompose your problem into actors
-
async_dataloader
Powerful tool for avoiding N+1 queries using async/await, based on the DataLoader pattern
-
async-time-mock-async-std
Mockable time for use in async runtimes (async-std compatibility)
-
paperless-rs
An asynchronous Rust library for the Paperless-ngx document manager
-
tokio-prepend-io
Wrapper types that prepends data when reading or writing with AsyncRead or AsyncWrite
-
podo-core-driver
Podo Driver FFI
-
cargo-daku
Daku API cargo plugin
-
arta-tokio
Async abstractions implementation for Tokio
-
thetvdb
API async client
-
rlua-async
Async support for rlua, via coroutines
-
futures-jsonrpcv2
Futures-based jsonrpc v2.0 crate
-
stow
Cloud storage abstraction package for Rust
-
happyeyeballs
Happy Eyeballs implementation in Tokio (not RFC compliant atm)
-
tomt_async
Primarily a dumping ground for personal async snippets that may be used in other ToMT projects. If this crate is useful to others please let us know.
-
kumoko
asynchronous server/client crate built on tokio for easy two-way streaming
-
epicenter
synchronous and asynchronous event dispatcher for Rust
-
recurring-tasks
Define tasks and run them in an app forever, ala cronjobs. And don't run already/still running tasks.
-
irc
usable, async IRC for Rust
-
async-trait-ext
a procedural macro for async traits
-
ftools
Functional utilities for Rust
-
futures-async-stream
Async stream for Rust and the futures crate
-
pi_futures
feature select
-
alith-client
The Easiest Rust Interface for Local LLMs, and an Interface for Deterministic Signals from Probabilistic LLM Vibes
-
tracing-actix
Allow tracing actor futures in actix
-
nolocal-block-on
futures_lite::future::block_on that can run without using thread-locals
-
onqueue
a lightweight, multithreaded task queue runner
-
async-unsync
asynchronous, unsynchronized (thread-local) channels and semaphores
-
msq
legacy Master Server Query Protocol
-
pyridis-message
iridis, with python
-
tokio-easy-timer
A tokio-based task scheduler, with a user-friendly API
-
tokio-util_wasi
Additional utilities for working with Tokio
-
ticker
Rate limited Iterators
-
troupe
modelling Rust applications with actors
-
async_singleflight
Async singleflight
-
futuristic
Extensions to the futures crate
-
kafka-rs
Native Rust Kafka client, built upon kafka-protocol-rs and Tokio
-
smol-potat
Proc macro for smol runtime
-
mycelium_lib
Mycelium DDM
-
rumq-cli
Commandline mqtt utilities to replace mosquitto_sub and mosquitto_pub
-
tabs
A collection of asynchronous task abstractions, based on tokio
-
tokio-stream-multiplexor-fork
Stream Multiplexor for tokio with a tcp like interface
-
napmap
Async HashMap that halts requester tasks until the requested data is accessible
-
hypixel
Rust wrapper for the Hypixel public API
-
acril-rt
A lightweight single-threaded runtime for Acril actors
-
elf_loader
A pure-rust library for loading all ELF format files from both memory and files
-
compio-driver
Low-level driver for compio
-
futures-io-preview
The
AsyncReadandAsyncWritetraits for the futures-rs library -
qp
Quick Pool: High Performance Async Generic Pool
-
stream-download-opendal
OpenDAL adapter for stream-download
-
mcprs
Model Context Protocol para Rust - Uma biblioteca unificada para comunicação com diferentes LLMs e APIs de IA
-
git-event
Customizable event handler for updates in remote git repositories
-
tokio-switching-sleep
A tokio Sleep with a switchable state
-
stream-broadcast
Runtime independent broadcast, which only polls it's underlying stream if no pending data is available
-
blocking-permit
Permits and a thread pool for blocking operations
-
mlua_actor
Lua Actor for Rust(sync/async)
-
scoped_tasks_prototype
A quick-and-dirty attempt to get scoped tasks in Rust
-
raftlog
distributed replicated log based on the Raft algorithm
-
yield-now
Wakes current task and returns Poll::Pending once
-
tracing-orchestra
Give me more instruments!
-
arti-rpcserver
Backend functionality for Arti's RPC service
-
future-bool
A bool one can await the changes
-
holidayapi_rust
A HolidayAPI library for Rust
-
tokio-lk
Futures-aware lock-by-id primitives
-
libmcaptcha
core of mCaptcha captcha system
-
smelling_salts
Abstraction over OS APIs to handle asynchronous device waking
-
rumpsteak
Session types for asynchronous communication between multiple parties
-
timer-lib
A feature-rich Rust library for creating and managing timers
-
alopecosa
Pure rust async Tarantool 1.6+ connector built on tokio
-
sprinter
Run parallel queued tasks
-
simple_futures
futures for use in async operations
-
ticked_async_executor
Local executor that runs woken async tasks when it is ticked
-
susync
An util crate to complete futures through a handle. Its main purpose is to bridge async Rust and callback-based APIs.
-
recall_fendermint_actor_bucket
Actor for bucket object storage
-
chunnel
Async mpmc(multi producer multi consumer) channel
-
futures_cbor_codec
A codec for framing an AsyncRead/AsyncWrite with cbor for all types that are serializable with serde
-
async-log
Async tracing capabilities for the log crate
-
simple-actor
Helper to write actor-based async code
-
waterark
Watermark for implementing optimistic SSI (Serializable Snapshot Isolation) transactions
-
test_executors
async executors for testing
-
gabelung
Branch an asynchronous stream of cloneable items into two
-
async-hid
A async library for interacting with HID devices
-
pinarcmutex
PinArcMutextype, for shared mutable access to pinned data -
nyantrack-common
Common data types and functionality for NyanTrack
-
async-file-lock
Asynchronous file lock that can auto lock and auto seek
-
flynn-openai
OpenAI
-
vesper
A slash-command framework meant to be used with twilight
-
rfm69-async
async driver for the rfm69 radio transceiver
-
bonsaimq
Message/job queue based on bonsaidb, similar to sqlxmq
-
reqchan
channel for requesting and receiving data. Each channel has only one requesting end, but it can have multiple responding ends. It is useful for implementing work sharing. The two ends…
-
bisky
Bluesky API library
-
oni
Later on, there will be a framework for mmo games
-
thread-async
Execute a task in a new thread and await the result asynchronously
-
async_io_utilities
An asynchronous IO utilities crate powered by
tokio -
tokio-beanstalkd
Asynchronous client library for interacting with Beanstalkd work queue
-
aector
Dynamic implementation of the actor model with a smart built-in testing framework
-
strawpoll
A wrapper to avoid spurious polling
-
taurus
A WIP roguelike game being developed in Rust
-
murray
A minimal actor definition macro using Tokio
-
maily
easy, quick, and fault tolerant sending of emails
-
parallel-future
fluent async task experiments
-
ianaio-timers
IanaIO crate for working with JavaScript timers
-
async-tun
Asynchronous allocation of TUN/TAP devices using async-std
-
clia_deepseek_rs
client library for the DeepSeek API (use rustls)
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
tokio-executor-trait
executor-trait implementation for tokio
-
compio-io
IO traits for completion based async IO
-
pyo3-anyio
PyO3 utility bindings for Anyio's event loop
-
srmw
Asynchronous single-reader, multi-writer
-
tyco
Macro for generating scoped TYped COntexts
-
futures-jsonrpc
Futures implementation for JSON-RPC
-
hackdose-server
A server to control smart plugs using data from smart meters
-
async-send-fd
A wrapper for async UnixStream's to send file descriptors
-
scipio
A set of utilities to allow one to write thread per core applications
-
futures-ticker
An asynchronous recurring time event
-
nsq-client
Rust client for the NSQ realtime message processing system
-
async-usercalls
An interface for asynchronous usercalls in SGX enclaves. This is an SGX-only crate, you should compile it with the
x86_64-fortanix-unknown-sgxtarget -
blockz-futures
working with futures for the tokio stack
-
relm
Asynchronous, GTK+-based, GUI library, inspired by Elm, written in Rust
-
gimbal_async
Gimbal Async runtime package
-
dbus-tokio
Makes it possible to use Tokio with D-Bus, which is a bus commonly used on Linux for inter-process communication
-
flv-future-aio
I/O futures for Fluvio project
-
lsp-codec
Tokio-compatible codec implementation for Language Server Protocol
-
async-signal
Async signal handling
-
aggligator-transport-websocket
Aggligator transport: WebSocket
-
textmode
terminal interaction library backed by a real terminal parser
-
async-psec
Asynchronous PSEC implementation
-
prost-stream
prost stream
-
pantry
Temporary storage for reusing values that may decay
-
streamtools
Additional stream combinators
-
stream-reconnect
Stream-wrapping traits/structs that automatically recover from potential disconnections/interruptions
-
ctp-futures
A short description of your crate
-
swarm-commander
Manage tons of commands asynchronously
-
futures-await-test
Async test support for Rust through a procedural macro. This crate defines the
#[async_test]attribute to make writing tests that use async/await easier. -
newsblur_api
NewsBlur-API
-
tokio-named-pipes
Windows named pipe bindings for tokio
-
bleak-rs
High-level BLE communication library
-
asyncio-utils
Support limit,skip on AsyncRead traits
-
actix-postgres
PostgreSQL integration for Actix framework
-
awaitable
type with input and output that can be stored in container
-
recall_fendermint_actor_eam
Builtin Ethereum address manager actor for IPC
-
async_io_crypto
handling AsyncRead with ciphering / deciphering
-
causality
Event Driven Architecture Traits
-
tokio-process-stream
that wraps a tokio::process into a tokio::stream
-
io_uring_buf_ring
Help user create and manage io-uring buffer-ring
-
ianaio-dialogs
Convenience crate for working with dialogs in browser
-
simplex-chat
API for the SimpleX Chat CLI
-
mrwei
that implements the common promise primitive for rust based on std future
-
capwriter
Fast saving and loading with annotating cap for vector and slice
-
indexed_db_futures
Future bindings for IndexedDB via web_sys
-
simple-async-pipe
Aims to provide a simple pipe-like functionality for async code
-
tokio-curl
asynchronous HTTP client using futures backed by libcurl
-
shs_async
Secret-handshake protocol (async)
-
service-io
Build your service-server fast, easy (and without hosting!)
-
async_progress
Create sync points across async tasks
-
rstreams
Async Stream-Processing toolkit with actor model flavor
-
ohos-nj-core
high level wrapper for Node N-API
-
rustpub
Activitypub types
-
partial-io
Helpers to test partial, interrupted and would-block I/O operations, with support for property-based testing through proptest and quickcheck
-
async-ctrlc
Async wrapper of
ctrlc -
set_timeout
allows efficiently executing futures after some delay has passed
-
monoio-compat
A compat wrapper for monoio
-
async-minecraft-ping
An async Rust client for the Minecraft ServerListPing protocol
-
future_handles
complete futures via handles
-
aggligator-transport-usb
Aggligator transport: USB
-
conva_ai
Rust SDK for using CONVA AI Copilots
-
actix-broker
Message broker for the Actix actor framework
-
stream-guard
RAII wrapper around Stream that invokes a custom action on drop
-
reception
creating TCP listeners that spawns clients providing model abstraction layer
-
gritlab
Gitlab rust API sdk
-
agency
A small async actor framework
-
elfo-configurer
Loads and distributes configs across the elfo system
-
nr-tracing-layer
Send your logs to New Relic
-
gloo-worker
Convenience crate for working with Web Workers
-
online
📶 Library to check your Internet connectivity
-
hls_lfcd_lds_driver
Rust driver for ROBOTIS HLDS HLS-LFCD-LDS (LDS-01)
-
agnostik
Executor Agnostic Runtime that can run your futures with your favourite Executor
-
tokio-transports
used for communication between processes
-
pingora-boringssl
BoringSSL async APIs for Pingora
-
actor-interfaces
I only uploaded this to crates.io because I was having some issues cross compiling with local dependencies. If anyone wants to use the name for something actually useful, DM me on github
-
what-the-async
runtime
-
fluxus-source-gharchive
A Fluxus source component for processing and analyzing GitHub Archive data streams, providing efficient access to historical GitHub event data
-
cold-io
Event driven network io
-
join
Macros which provide useful shortcut combinators, combine sync/async chains, support single and multi thread (sync/async) step by step execution of branches, transform tuple of results in result of tuple
-
task-exec-queue
A asynchronous task execution queue
-
completion
writing completion-based asynchronous code
-
futures-glib
Spawn futures on the glib event loop
-
iou
io_uring bindings
-
m3u8_downloader
Application m3u8_downloader allows to download m3u8 HLS streams by master playlist link
-
discern
implementing the Command Query Responsibility Segregation (CQRS) pattern
-
neo4rs
Rust driver for Neo4j
-
mini-tokio
basic asynchronous rust executor
-
tigerbeetle-unofficial-core
Safe low level callback-based async bindings to tigerbeetle client library
-
key-lock
mutual exclusion by keys
-
safina-net
Safe async network functions - ARCHIVED: Code moved to
safinacrate -
rad
A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
udp-stream
UdpSocket same as TcpStream
-
swiftide-docker-executor
A docker executor for swiftide agent tools
-
buffer-unordered-weighted
Stream::buffer_unordered where each future can have a different weight
-
stream-kmerge
K-way merge for streams
-
catalyzer
HTTP server framework
-
combadge
makes Rust Web Workers easy
-
stix
working with STIX 2.0 threat intelligence
-
select-next-any
Alternative to futures::StreamExt::select_next_some that returns the None variant
-
killswitch
used to broadcast a shutdown request
-
gearbox
Excessive tooling for Rust, boosting productivity and operations
-
crb-superagent
CRB | Composable Runtime Blocks | Agent Extensions
-
italo-api
Rust binding for Italo API
-
jelastic-rs
Rust wrapper for the Jelastic API
-
deadline
A one-macro crate to ensure assertions meet their deadlines
-
message_worker
Message Worker is a low-ish level library for Rust for the creation of event-listeners using futures and streams. Notably MW supports non-sync and non-send (i.e. non-thread-safe) contexts within listeners.
-
celery-rs-core
Core utilities for a celery client and worker in rust
-
tokio-tls-api
TLS/SSL streams for Tokio giving an implementation of TLS for nonblocking I/O streams
-
bytes-stream
functions to work with stream of bytes
-
async-tempfile
Automatically deleted async I/O temporary files
-
go-zoom-kinesis
A robust AWS Kinesis stream processor with checkpointing and retry capabilities
-
eventador
lock-free pub/sub event-bus with sync and async APIs
-
peace_cmd_rt
Runtime types for commands for the Peace framework
-
tokio_interval
基于Tokio实现了 setInterval(callback, ms) 和 setTimeout(callback, ms) 类似于Javascript的API
-
dslib
A simulation-based framework for teaching distributed systems
-
async-notify
A general version async Notify, like
tokioNotify but can work with any async runtime -
ws-gonzale
Naive websocket server implemented using async / await
-
tag_nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
ncu-rs
A stupid simple and fast cli for updating your package.json dependencies
-
lol-async
async html-rewriter
-
gearrs
An async Gearman client implementation in Rust
-
remote_config
Flexible crate for asynchronously loading configuration from remote source with caching and automatic revalidation
-
yaanhyy_rust
cargo mod example
-
noosphere-collections
Collection data types that are needed by an efficient implementation of Noosphere's IPLD data structures
-
alligator
getting the output value from a future
-
tokio-task-scheduler
A non-blocking task scheduler for Rust with fluent API, supporting interval-based and cron-like scheduling
-
futures-utils-lite
futures about utils in lite
-
turbocharger
Autogenerated async RPC bindings that instantly connect a JS frontend to a Rust backend service via WebSockets and WASM
-
bb8-bolt
A bolt-client adaptor for the bb8 connection pool
-
simple-process-stats
Get memory usage and CPU time on Linux and Windows
-
swimos_future
SwimOS Future Utilities
-
dwbhk
dwbhk-rs is a library for working with Discord Webhooks
-
otdb
An open trivia database API wrapper
-
swimos_rtree
SwimOS R-Tree
-
crb-file
CRB | Composable Runtime Blocks | File
-
fut_rwlock
A read-write lock that is read and written via Futures
-
maelstrom-node
Maelstrom Rust node framework
-
futures-state-stream
A version of the futures crate's Stream which returns state on completion
-
tokio-scoped
Scoped Runtime for tokio
-
tower-test
writing client and server
Servicetests -
suspend
A common mechanism for suspending a thread or a Future until notified
-
cmajor
Rust bindings for the Cmajor JIT engine
-
russh-agent
Asynchronous ssh-agent client
-
wai
Windowing And Input
-
async-rayon
Mix async code with CPU-heavy thread pools using Futures + Rayon
-
anotify
Async iNotify Filesystem Watcher
-
async-trait
Type erasure for async trait methods
-
svix
Svix webhooks API client and webhook verification library
-
rusty_falcon
Rust bindings for CrowdStrike Falcon API
-
izihawa-hyper-multipart
multipart/form-data for Hyper
-
akt
An actors library for Rust and Tokio designed to work with async / await message handlers out of the box
-
count-write
An io::Write wrapper counting the number of bytes written
-
apread
An activity pub feed reader for the command line
-
async_msp_lib
Async msp library for iNav and BetaFlight
-
tokio_dual_stack
Dual-stack TCP listener based on tokio
-
intercomm
Asynchronous inter-component communication library
-
cf-turnstile
client for Cloudflare Turnstile
-
spin_future
Convert synchronous functions into valid but inefficient futures
-
async-lease
Essentially a futures-oriented Arc<Mutex<Option<T>>>
-
tlfs-crdt
tlfs crdt implementation
-
threader
A performant multithreaded future executor and event loop
-
kvarn-quinn-proto
Temporary Kvarn fork: State machine for the QUIC transport protocol
-
loading-bytes
Load bytes from paths on native and WASM
-
termcandy
terminal GUI library
-
ardop_interface
Interface to the Amateur Radio Digital Open Protocol (ARDOP)
-
blocking_pool
A thread pool for running synchronous I/O in asynchronous applications
-
gen-stream
Generator-based streams for Rust and futures 0.3
-
async-ucx
Asynchronous Rust bindings to UCX
-
jittr
A binary heap based jitter buffer implementation for zero latency udp/rtp streams
-
async-timers
asynchronous timer primitives
-
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-xmpp
Asynchronous XMPP for Rust with tokio
-
bevy_impulse
Reactive programming and workflow execution for bevy
-
querent-synapse
bridge capable of handling and executing querent workflows and be able to respond to incoming events via callbacks. Acting like a synapse between querent and the outside world.
-
f1-api
F1 API is a client library for the telemetry API of the F1 video games by Codemasters. It uses asynchronous networking to decode the incoming UDP packets, and turns them into strongly typed Rust structs.
-
mio-wakeq
mio support for custom event queue via Waker
-
veilid-async-tls
Asynchronous TLS/SSL streams using Rustls
-
task_scope
asynchronous runtime extension for supporting Structured Concurrency with task spawning
-
openrazer
Asynchronous bindings to the OpenRazer daemon
-
async-mq
Zero-cost async-await abstraction of lapin AMQP client crate
-
messagebird-async
Wrapper around the message bird SMS API
-
tokio-task-tracker
graceful shutdown solution for tokio
-
rdma
Low-level RDMA API
-
init_system
Framework to wrap application init
-
fundamentum-edge-pfwd
The port forwarding tool for edge daemon
-
axum-sessions
🥠 Cookie-based sessions for Axum via async-session
-
bucket_dl
A multithreaded downloader with the purpose of faster downloads by splitting it into several requests, rebuilding the data client-side
-
adventure
your great adventure for the various type of requests
-
await-group
Golang like WaitGroup implementation
-
signalr_rs
SignalR client based on actix web client and async await
-
telegram-bot-ars
creating Telegram bots
-
discord_api
Interact with the Discord API from your shell
-
tauri-specta
Completely typesafe Tauri commands
-
dmds-tokio-fs
Dmds I/O handler interacts with the filesystem using Tokio
-
stream-operators
a collection of selected rxjs operators for rust standard Stream
-
riker-cqrs
Command Query Responsibility Separation for Riker applications
-
agzip
Async compatible gzip (de)compressor
-
alicemq
Wapper for the amqprs rabbitMQ library
-
cdp-html-shot
capturing HTML screenshots using CDP
-
flexi_func_declarative
exposes the fb! macro to create a function with a flexible signature
-
vampirc-io
asynchronous, non-blocking, UCI protocol–based communication between chess UIs and chess engines
-
sctp-proto
A pure Rust implementation of SCTP in Sans-IO style
-
somen-language
somen parser combinator for languages
-
twitchchat
interface to the irc-side of twitch's chat system
-
async_buf_reader_utils
Adds additional functionality to the async-std crate for BufReader
-
exit-future
Future that signals exit to many receivers
-
bluest
A cross-platform Bluetooth Low Energy (BLE) library
-
neo-email
The modern way to build emails services with Rust
-
future-by-example
Examples of common patterns using Future
-
uller
Generate/Donwload your links
-
derive-tokio-io
Derive AsyncRead and AsyncWrite
-
medina
An asynchronous web crawling engine
-
cu
Low level bindings to cuda apis
-
zino-http
HTTP requests and responses for zino
-
tokio-rustls-wasi
Asynchronous TLS/SSL streams for Tokio using Rustls
-
diath
light-weight library for communication between tokio async tasks
-
holly
A simplistic actor model library using futures
-
awaken
Coalescing cross-thread wakers for mio and io_uring
-
hentai
API wrapper for nhentai.net
-
rusty_tarantool
Tarantul async client based on tokio framework
-
async-throttle
Asynchronous Rate Limiting
-
tourniquet-tonic
Async native round-robin manager for remote services. Tonic integration.
-
tokio-async-drop
macro to enable async drop in a tokio multithreaded runtime
-
framed_aio
allows performing async io operations in a framed manner
-
async_counter
Counter that implements a future to await on specific value
-
tokiactor
tokio based Actor framework
-
tower-async-layer
Decorates a
Serviceto allow easy composition betweenServices. An “Async Trait” fork from the original Tower Library -
broadcaster
Broadcasting futures mpmc channel
-
kythera-actors
Kythera FVM WASM actor builder
-
futures-sink
The asynchronous
Sinktrait for the futures-rs library -
rmp-futures
Async Rust MessagePack and MessagePack-RPC
-
wasmflow-streams
encapsulating the message packets sent across Wasmflow components
-
forked_stream
Convert any Stream with cloneable items into a cloneable stream
-
asyncfd
Send and receive file descriptors over Unix domain sockets while maintaining Tokio AsyncRead and AsyncWrite
-
futures-yamux
The yamux protocol implementation, rewritten from the ground up
-
quinn
Versatile QUIC transport protocol implementation
-
serde-jsonlines
Read & write JSON Lines documents
-
tokio-reactor-trait
reactor-trait implementation for tokio
-
eventbus-tiny
A small, dependency-free crate that provides a multi-producer broadcast-consumer event bus
-
paranoid-hash
A Hashing Library For Those Paranoid With Their Security
-
izihawa-common-multipart
multipart/form-data
-
webrocket
A closure focused WebSocket server implementation
-
enjoin
Powerful syntax-level async join macro
-
async_tasks_state_map
A struct for recording execution status of async tasks with async methods
-
aredis
Redis client implemented in Rust
-
change_stream
A Stream that only emits if the value is different
-
vexide-async
The async executor at the core of vexide
-
swimos_messages
SwimOS Runtime Internal Messaging Protocol
-
ruchei-route
Sinks with routes
-
mysql_async
Tokio based asynchronous MySql client library
-
surge-ping
Asynchronous ICMP ping library
-
cerebrust
working with NeuroSky devices under Rust
-
tauri-plugin-persistence
A wrapper plugin for several persistence backends, focused on managing complex project folders with less boilerplate
-
task_yield
Executor-independent task yielding
-
serenity_ctrlc
Ctrl+C handler for serenity
-
git-cinnabar
git remote helper to interact with mercurial repositories
-
sparkle-impostor
A third party crate for Twilight to execute Discord webhooks that clone an existing message
-
tokio_telegraf
Minimal async rust wrapper for the telegraf/influxdb protocol, based on Tokio
-
shared_cell
Interior mutability between concurrent tasks on the same thread
-
fb_futures_01_ext
Extensions for future 0.1 crate
-
chikatetsu
An(other) actor framework for Tokio
-
smoltimeout
A way to poll a future until it or a timer completes
-
yew-interop
use javascript and css asynchrously in yew
-
gcp_auth
Google cloud platform (GCP) authentication using default and custom service accounts
-
fs
A Futures implementation for File System operations
-
django-query
Tools for mocking Django-style endpoints
-
chtsh
Rust CLI for interacting with https://cht.sh
-
archlinux-repo
Arch Linux repositories parser
-
axum-typed-websockets
axum::extract::ws with type safe messages
-
taos
Driver for TDengine - a timeseries database and analysis platform
-
atomic-waker
A synchronization primitive for task wakeup
-
aws-smithy-http-server
Server runtime for Smithy Rust Server Framework
-
asynciter
Asynchronous iterator
-
tokio-rusqlite-async-kanal
Asynchronous handle for rusqlite library
-
async-refresh
Create values that refresh automatically and asynchronously after a given duration
-
path-tree
lightweight high performance HTTP request router for Rust
-
activitystreams-traits
Traits for ActivityStreams 2.0 objects
-
rseip-cip
common industry protocol for rseip
-
futurify
Convert your sync functions into non-blocking thread futures
-
florescence
An experimental library exposing hybrid Raft and CRDT primitives
-
async-rx
functions for async reactive programming
-
vanilla_tokio_actor
Vanilla Tokio Actor
-
browse
fast crawling framework
-
recall_fendermint_actor_machine
Shared types for ADM machine actors
-
aggligator-transport-bluer
Aggligator transport: Bluetooth on Linux
-
mobc-forked
A generic connection pool with async/await support
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
async-result
wrapper providing a convenient way to await a result, built on futures-channel's oneshot channel
-
actix-signal
Manage the lifecycle of an actix actor with its address
-
specta
Easily export your Rust types to other languages
-
rmw_ttlmap
Minimal async cache in Rust with support for key expirations
-
sidekiq-rs
Sidekiq compatible server in Rust
-
polaris-specification
Service Governance Specification
-
real-async-trait
A proc macro that uses experimental features to work around type erasure for async traits
-
async-stripe-fraud
API bindings for the Stripe HTTP API
-
sync_stream
Aggregate multiple streams by polling stream items in order, keeping the consumption of multiple streams in sync
-
plunk
A fast, simple, and easy-to-work-with Rust SDK for Plunk — send emails without the hassle
-
nostd_async
An asyncronous runtime for a single-threaded no_std environment
-
eventific
that gives you the needed building blocks for event sourcing
-
hash_cons
A type-safe hash-cons library
-
tonic-middleware
Async middleware and interceptor for Tonic services
-
async-jobs
Asynchronous job orchestration for Rust
-
etcd-rs
etcd client for rust
-
thespis
The interface of the thespis actor model (contains only traits)
-
serial-io
A serial port implementation
-
async-cuda-npp
Async NVIDIA Performance Primitives for Rust
-
tokio-libtls
Tokio bindings for LibreSSL's libtls
-
wakerpool
lightweight object pool for lists of Wakers
-
countio
Byte counting for std::io::{Read, Write, Seek} and its async variants from futures and tokio
-
atcoder
A template for Rust project
-
openai-api
OpenAI API library for rust
-
openpgp-card-state
Experimental storage mechanism for openpgp-card device state
-
name-it
Give a name to async fn return types
-
ticks
ergonomic Rust wrapper for the TickTick Open API
-
rexa
GraphQL MongoDB API builder
-
async-ops
Use std::ops traits with Futures
-
puddle
object pool implementation that uses asynchronous synchronization primitives only
-
reactors
Performance-focused cross-platform asynchronous IO implementation
-
rocketmq-filter
A filter for RocketMQ messages
-
fb-api
Facebook Api abstraction for async rust
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
futures-cputask
Turn synchronous CPU-bound tasks into futures
-
crb-system
CRB | Composable Runtime Blocks | System Integration
-
agreed
Fork of async-raft, the Tokio-based Rust implementation of the Raft protocol
-
google-cloud-ai
A gRPC-based crate designed to interact with Google Cloud AI API
-
ns-env-config
An env_logger-inspired one-stop configuration for name resolution based on abstract-ns. Reduces boilerplate and provides standard way to configure DNS for applications via
RUST_NSenvironment variable. -
futures-test-sink
Test utilities for futures::sink
-
poolparty
Added functionality for the
futures::executor::ThreadPoolfutures executor -
jono_harvest
Post-process interface for completed jobs to Jono queues
-
async-stdio
Adapter for using async read/write streams in std::io contexts
-
tor-general-addr
Generalized socket address type used by Tor
-
tacacs-plus
An asynchronous, runtime-independent RFC8907 TACACS+ client
-
background-jobs-core
Core types for implementing an asynchronous jobs processor
-
yt-dlp
🎬️ A Rust library (with auto dependencies installation) for Youtube downloading
-
async-compat
Compatibility adapter between tokio and futures
-
ferris_chats_data
data structures for ferris_chat
-
bevy_flurx
Allows you to use coroutine in Bevy
-
x-bow
Precise State Management Library
-
pegy
A derive based parser generator
-
unsync
Unsynchronized synchronization primitives for async Rust
-
bridge_updater_lib
A helper library to get Tor bridges with ease
-
wgp
waitgroup implementation
-
srad
Sparkplug development framework
-
supplicant
Bindings for wpa_supplicant
-
limitation-actix-middleware
An Actix web middleware for rate limiting requests using a fixed window counter keyed on a header
-
npm-package
client for fetching metadata from the npm package
-
strife
A lightweight library for the Discord API
-
containerd-snapshots
Remote snapshotter extension for containerd
-
medusa-zip
A command-line interface to high-performance parallelized implementations of common zip file operations
-
RuStream
Self-hosted Streaming Engine, that can render media files via authenticated sessions
-
deadpool
Dead simple async pool
-
oidcrs
Full Spec Compliant OIDC Library
-
gifsicle
Bindings for gifsicle library. Supports lossy compression. GPL.
-
yozefu
CLI tool for Apache kafka. It allows you to navigate topics and search Kafka records.
-
rs-copier
Copy and move files asynchronously
-
back-to-the-future
Conversions between std::future::Future and futures::Future
-
async-xml
deserializing XML data asynchronously
-
archflow
Create a streamable Zip archive
-
shirabe-core
A Satori Bot Framework Core For Rust
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
limitr
offering various rate-limiting algorithms such as Token Bucket, Leaky Bucket, and more
-
ector
open source async, no-alloc actor framework for embedded devices
-
xdg-portal
implement for xdg-desktop-portal
-
parail
Easily switch between sequential and parallel
-
eventually-postgres
Event Store implementation using PostgreSQL for the Eventually crate
-
promise_out
promiseOut version for rust
-
tasky
fluent async task experiments
-
rqlite-ha421
An async implementation of a rqlite client
-
safina-executor
Safe async runtime executor - ARCHIVED: Code moved to
safinacrate -
futures-promises
Promises and Watched Variables for Futures
-
atomic-actor
An
Actorwithasync fnhandlers -
hydrolink
Lavalink client made with tokio independent of the Discord library, used in production by Hydrogen
-
rxqlite-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
iap
async google/apple receipt validation using hyper
-
task_pool
Flexible abstraction for task-based composable multithreading
-
handy_async
A handy library for describing asynchronous code declaratively
-
pending_unwind
converting unwindings into
pending -
rusty-api
A secure Rust API crate for rapid development, featuring HTTPS, authentication, privilege levels, and rate limiting
-
volo-macros
Volo's proc macros
-
browser-window
optionally async, optionally threadsafe, electron-like browser toolkit for Rust
-
dbq
Job queueing and processing library with queues stored in Postgres 9.5+
-
nbd-async
Block device drivers in userspace
-
viz-utils
Viz utils
-
uid-mux
Async multiplexing library with user provided stream ids
-
lagoinha
package that uses public APIs to fetch addresses using the Brazilian Postal Code (CEP). This package cuncurrenlty calls all the supported APIs and returns the first result.
-
projections
Macro-free pin projections because why not?
-
hash_events
An MPMC event system that allows for custom events. Events are emitted with a payload, and subscribers to that event are stream of payloads. For each event, all subscribers are triggered.
-
odem-rs-util
Model elements and statistical tooling for the ODEM-rs simulation framework
-
tokio-icmp-echo
Asynchronous ICMP pinging library
-
f189ctrl
Communication library for Fluke 189 digital multimeter
-
mongo_drop
An RAII to rollback MongoDB transactions on drop
-
bevy-tokio-tasks
integration of a Tokio runtime into a Bevy app for background processing
-
freestuffapi
Freestuffbot API
-
bongonet-boringssl
BoringSSL async APIs for Bongonet
-
vkteams-bot-cli
VK Teams Bot API CLI
-
heim-cpu
Cross-platform CPU information
-
lutetium
tokio based simple actor library
-
socks5-impl
Fundamental abstractions and async read / write functions for SOCKS5 protocol and Relatively low-level asynchronized SOCKS5 server implementation based on tokio
-
pipebuf_websocket
PipeBuf support for websockets
-
wasmcloud-example-httpserver
wasmcloud HttpServer interface
-
ockam_transport_core
Generic Transport primitives
-
extreme
Extremely boring async function runner. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
peace_fmt
Presentation and formatting support for the peace automation framework
-
contained-actors
contained is a research project implementing the proposed harmonic runtime for orchestrating cloud-native systems
-
socks5-server
Fine-grained relatively low-level asynchronized SOCKS5 server library based on tokio
-
safe-async-scoped
A minimal, safe library for scoped async tasks
-
pick_action_from_image
Pick an action from an image
-
local-runtime
Thread-local async runtime
-
agixt-sdk
Rust SDK for AGiXT - A powerful AI agent framework
-
async-read-length-limit
limit the size of an async read
-
eventsourcing
Event Sourcing for Rust
-
event-listener-strategy
Block or poll on event_listener easily
-
named-retry
retrying fallible asynchronous operations
-
aspartam
Minimalistic actor framework based on tokio, inspired by actix
-
viz-test
The core traits and types in for Viz
-
actix-raft
Raft distributed consensus protocol using the Actix actor framework
-
swarm-discovery
Discovery service for IP-based swarms
-
tidy-browser
Tidy up browser information
-
safina-select
Safe async select function, for awaiting multiple futures - ARCHIVED: Code moved to
safinacrate -
tokio-metrics-collector
collecting Prometheus-compatible metrics from Tokio runtime and tasks
-
felixs-tower-lsp
Language Server Protocol implementation based on Tower
-
sigio
signal-based async io
-
async-waitgroup
Golang like WaitGroup implementation that supports both sync and async Rust
-
some_local_executor
local executor
-
stateful_async_worker
Asynchronous stateful worker threads utilizable as futures
-
c-ares
wrapper for the c-ares library, for asynchronous DNS requests
-
tracing-layer-slack
Send filtered tracing events to Slack
-
kvarn-tokio-uring
Temporary Kvarn fork: io-uring support for the Tokio asynchronous runtime
-
swiftide-indexing
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
tokio-bin-process
run your application under a separate process with tokio tracing assertions when integration testing
-
vino-packet
encapsulating the message packets sent across Vino components
-
encrypted-dns
A modern encrypted DNS server (DNSCrypt v2, Anonymized DNSCrypt, DoH)
-
async-trait-sync
Fork of async-trait with support to Sync future
-
axum-router-plugin
Shared library-based plugins for Axum
-
schedule_recv
Create delayed and periodic Receivers
-
mio-misc
Miscellaneous components for use with Mio
-
tokio-anon-pipe
Asynchronous anonymous pipe for Windows
-
dbus-async-derive
Handler trait derive macro for dbus-async
-
scout
Friendly fuzzy finder for the command line
-
zino-storage
Files and storage services for zino
-
gdext_coroutines
Run Rust Async functions and Coroutines in Godot 4.2+ (through GDExtension), inspired on Unity's Coroutines design
-
sodium
FRP (Functional Reactive Programming)
-
akinator-py
Python bindings for akinator-rs
-
d3
A framework for server development
-
manual_future
A future that must be manually completed, similar to Java's CompletableFuture
-
tobytcp
A little library for sending messages over a tcp stream
-
mias_channel
that supports bi-directional channels by wrapping others
-
aktrs
An actor model framework for Rust
-
ledb-actix
LEDB Actor for Actix actor framework and storage REST-interface
-
amqp-client-rust
An asynchronous AMQP client library for Rust, designed for high-performance communication with RabbitMQ. Features include automatic queue and exchange management, message publishing, subscribing, and RPC support.
-
mini-telnet
Asynchronous minimal telnet library
-
v_exchanges_api_generics
A client for HTTP/HTTPS/WebSocket APIs
-
atticus
A mimimal API to create asynchronous actors
-
agnostic-lite
agnostic-liteis an agnostic abstraction layer for any async runtime -
settimeout
Creates a std::future::Future implementation to be ready at some point
-
signald-rust
interface with Signald
-
ratio-reactor
Setup WebWorkers as queueing job shop reactors in Yew WASM applications with different strategies
-
conquer-struct
macros to perform concurrent future resolution, while populating struct fields
-
asygnal
[WIP] Async-first signal handling, such as ctrl-c
-
futures-dagtask
DAG-based Task Queue
-
queued-task
concurrent queue task processing
-
puteketeke
An asynchronous runtime built on smol
-
elfo-utils
Some utils for the elfo system
-
isoprenoid
signals runtime framework backing flourish
-
attempt
do something over and over and over and over and
-
mqi
Idiomatic IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) APIs
-
kcr_kafka_strimzi_io
Kubernetes Custom Resource Bindings
-
relock
Distributed async locking using Redis
-
zipit
Create and stream zip archives on the fly
-
msft-runtime
Windows async helpers
-
bastor
A wrapper helps implementing actor with Bastion more easier with self-implemented state
-
wag
Go like sync.WaitGroup implementation in Rust. (sync/async)
-
dialectic-compiler
Session type macro compiler for the Dialectic crate
-
chokepoint
Generic stream transformer to simulate traffic / network congestion
-
valorant-assets-api
API Wrapper for valorant-api.com
-
rust-cli-commands
-
libevent
Rust bindings to the libevent async I/O framework
-
dav-server
Rust WebDAV server library. A fork of the webdav-handler crate.
-
tokio-rusqlite-new
Asynchronous handle for rusqlite library
-
activitystreams
A set of core types and traits for activitystreams data
-
tk-easyloop
A thread local loop and other loop helpers
-
ratsio
client library for NATS messaging system and NATS Event Streaming
-
heim-common
Common stuff shared across heim project crates
-
tokio-file
Asynchronous file I/O for Tokio
-
opencl-sys
OpenCL C FFI bindings for the Rust programming language
-
futures-dnsv2
A futures-based dns client implementation
-
actor
Actors traits
-
postgres_rustls
TLS support for tokio-postgres via tokio-rustls
-
hala-rs
Hala rust standard library facade
-
icanhazdadjoke-sdk
An SDK to interact with the icanhazdadjoke Dad Jokes API
-
merriam-webster-model
Models for the Merriam Webster's Dictionary API
-
fut-compat
Offers compatibility between the tokio and async_std runtimes
-
multiparty
zero copy streaming multipart decoder implementation
-
futures-task
Tools for working with tasks
-
ianaio-file
Convenience crate for working with JavaScript files and blobs
-
futures-boring
SSL streams for Futures built on top of the BoringSSL
-
bongonet-runtime
Multithreaded Tokio runtime with the option of disabling work stealing
-
improv
Actor microframework
-
waihona
rudimentary cloud storage capabilities across major cloud providers
-
packet-ipc
Share packets between services using servo ipc
-
dynamodb-mutex
Use Dymanodb mutex library
-
txn
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
futures-util-io-peek
AsyncPeek trait
-
nonblocking
stdin crate for Rust
-
bawawa
Opinionated set of tools to manage and compose process executions
-
tracing-actix-web2
Rust tracing adapter for Actix Web
-
openai-api-fork
OpenAI API library for rust
-
kvarn-quinn-udp
Temporary Kvarn fork: UDP sockets with ECN information for the QUIC transport protocol
-
tokio-utun
Utun bindings for Tokio
-
uds
A unix domain socket crate that supports abstract addresses, fd-passing and seqpacket sockets
-
crb-runtime
CRB | Composable Runtime Blocks | Runtime
-
mio-utun
Utun bindings for mio
-
c_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
component-future
implements the inner future protocol documented in the tokio docs
-
baildon-store
B+Tree CLI
-
bevy-async-ecs
Asynchronous interface for Bevy ECS
-
local-spawn-pool
Spawn
!Sendfutures in a pool and await for all of them to finish. Standalone alternative totokio::task::LocalSet. -
parabuild
A parallel build utility for template heavy projects
-
gpiocdev
Access GPIO lines on Linux using the GPIO character device
-
associated-async-io
Async IO traits that use futures instead of poll
-
webhdfs
Hadoop WebHDFS client library
-
tokio-jsonrpc
JSON RPC 2.0 for tokio
-
bacon-ls
Bacon Language Server
-
completion-io
Core traits and types for asynchronous completion-based I/O
-
libhoney-rust
sending data to Honeycomb
-
peace_item_tar_x
Manages extracting a tar file for the peace framework
-
coerce-rt
Async actor runtime
-
catty
Send and await a value asynchronously
-
compio-buf
Buffer trait for completion based async IO
-
pexels-cli
client for the Pexels API
-
async-component-components
async-component components
-
rexecutor
A robust job processing library
-
anthropic-types
Type definitions for Anthropic API communication
-
bbb_api_wrapper
A wrapper for BuiltByBit's Ultimate REST API
-
tokio-async-write-utility
Some helper functions for types impl AsyncWrite
-
epoxy_frp
The Reactive Glue for Frontend Applications
-
retry_async
retrying, with specific support for the Azure SDK for Rust (cf. https://github.com/Azure/azure-sdk-for-rust).
-
retry-strategy
A better asynchronous retry tool based on Tokio
-
quix
Distribution layer for actix
-
futures-cache
Futures-aware cache backed by sled
-
generic-api-client
A client for HTTP/HTTPS/WebSocket APIs
-
rust-concurrent
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
leaves
Distributed ID Allocator
-
situwaition
Run a closure continuously, until is succeeds or times out
-
twitch_api
talking with the new Twitch API aka. "Helix", EventSub and more!
-
twilight-http
Discord REST API client for the Twilight ecosystem
-
futures-zmq
Futures abstractions for ZeroMQ on any futures executor
-
hyper-futures
Compatibility layer for futures to use AsyncRead and AsyncWrite traits with hyper
-
gnostr-core
Replication protocol for Hypercore feeds
-
tokio-tasker
Lets you stop and join groups of Tokio tasks
-
async-component-winit
winit async-component wrapper
-
fd-queue
support fd passing on Unix sockets
-
todc-net
Algorithms for message-passing (HTTP) distributed systems
-
scrappy_do
A concurrent asynchronous webscraping framework
-
repsheet_etl
ETL tools for repsheet
-
async-exec
async task executor with a built-in HTTP task monitor
-
tbon
TinyChain Binary Object Notation is a compact and versatile stream-friendly binary serialization format
-
async-http1-lite
Asynchronous http1 stream
-
agner-helm
An actor toolkit inspired by Erlang/OTP (control panel)
-
async-spawner
executor independent task spawner
-
nasu
Command-line utility which poll on remote addresses in order to perform status checks periodically
-
thread_timer
cancelable timer with no external dependencies
-
tarpc-lib
An RPC framework for Rust with a focus on ease of use
-
deadpool-amqprs
Dead simple async pool for amqprs
-
libpool
threadpool from The Rust Programming Language
-
async-pipe
Creates an asynchronous piped reader and writer pair using tokio.rs
-
tokio-shared-rt
Allow
#[tokio::test]to use a shared runtime -
tokio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Tokio based on Rustls
-
cancellable
providing a generic cancellable utility
-
docker_engine_api
way to interact with the Docker Engine API
-
async-stream-packed
Asynchronous stream packed
-
waitlist
Keep track of an ordered list of Wakers to wake
-
wasm-bindgen-futures
Bridging the gap between Rust Futures and JavaScript Promises
-
deli
ergonomic way to define data models that are seamlessly converted into IndexedDB object stores, utilizing derive macros
-
async-nats-tokio-rustls-deps
Fork of Asynchronous TLS/SSL streams for Tokio using Rustls
-
interruptible_polling
General purpose polling tasks with RAII-driven fast clean exits
-
tokio-resource-pool
A generic resource pool for the Tokio ecosystem
-
oauth-lib
Asynchronous Rust library to deal with OAuth flows
-
rust-with-kafka-tls
Rust messaging with a Strimzi Kafka cluster secured with self-signed tls assets for encryption in transit with mTLS for client authentication
-
openssh-mux-client
openssh mux client
-
gritea
Gitea API sdk
-
async-stream-lite
Proc macro-free async/await Rust streams
-
lucia-apis
A set of API collections based on the lucia framework
-
blocksr
Drew's Rust library for (clang/objc) blocks
-
dabus
Dynamic Aplication Controll Bus - an asynchronous, event based module system for thoes who want to move fast and *not* break things
-
kapacitor-multi-indicator-stream-udf
A multi-indicator stream UDF for Kapacitor
-
deadpool-bolt
A bolt-client manager for the deadpool connection pool
-
netapp
A toolkit library for distributed software
-
signalwire
The unofficial SignalWire SDK for Rust
-
hitbox-actix
Asynchronous caching framework for Actix
-
net-queue
A framework to abstract network queues
-
multi_stream
Aggregate multiple streams of different types in a single stream with an item type that is a tuple of the incoming stream items
-
cap-async-std
Capability-based version of async-std
-
async-reactor-trait
reactor-trait implementation for async-io
-
crud_hyper
CRUD (Create, Read, Update, Delete) web application built using Rust’s
hyperlibrary. This project demonstrates how to implement basic CRUD operations with an in-memory database and… -
uring-fs
Truly asynchronous file operations using io-uring. Supports any async runtime. Linux only.
-
rustun
implementing STUN server and client asynchronously
-
qcongestion
Congestion control in QUIC, a part of gm-quic
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
bevy_async_task
Ergonomic abstractions to async programming in Bevy
-
async-dup
Duplicate an async I/O handle
-
actix-codec
Codec utilities for working with framed protocols
-
posturn
Build turn-based games with
asyncRust -
axum-serde
multiple serde-based extractors / responses for the Axum web framework, also offers a macro to easily customize extractors / responses
-
arta-async-std
Async abstractions implementation for async-std
-
paggo
A small, fast, and safe in-memory database
-
safina-async-test
Macro for running async tests - ARCHIVED: Code moved to
safinacrate -
pipebuf_mio
PipeBuf support for
miobyte-streams -
handy_io
A handy pattern and futures based asynchronous I/O library
-
async_object
Async Object wrapper
-
mm1-core
M/M/1! Queueing, do you speak it?!
-
edge-captive
Async +
no_std+ no-alloc implementation of a Captive Portal DNS -
rip-starttls
Sans I/O implementation of https://duesee.dev/p/avoid-implementing-starttls/
-
lease
Object pool that leases values and automatically returns them with async support
-
tor-rpc-connect
Common implementation logic for Arti RPC Connect points
-
eventually-redis
Event Store implementation using Redis, for Eventually crate
-
sampr
A message passing framework using actors
-
axum-flash
Web framework that focuses on ergonomics and modularity
-
mml-lib
Emacs MIME message Meta Language (MML)
-
gerevs
implementing general-purpose SOCKS5 proxy servers with asynchronous execution and flexible authentication methods
-
aldrin
Message bus for service-oriented RPC and interprocess communication
-
vru-cancel
Cancel tokio stream
-
tokio-task-manager
Allow an async Tokio application to gracefully shutdown, waiting for all tasks to finish
-
tokio-rusqlite-kanal-async-axuman
Asynchronous handle for rusqlite library
-
async-pidfd
Process file descriptors (pidfd) for Linux
-
madsim-real-tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
async-stripe-product
API bindings for the Stripe HTTP API
-
async-anyhow-logger
An easy crate for catching anyhow errors from an asynchronous function, and passing them to your logger
-
fluxus-sinks
Sink components for Fluxus stream processing engine
-
futures-async-combinators
toy futures combinators
-
luarmor
API wrapper for luarmor.net
-
reactive-messaging
Reactive client/server communications, focused on high performance
-
black-box
A minimal actor framework
-
diny
An asynchronous, alloc-free serialization framework
-
onetime
(aka. oneshot) async spsc channel
-
bongonet-rustls
RusTLS async APIs for Bongonet
-
deepwell
Wikijump API provider and database manager
-
interprocess
communication toolkit
-
retry_fn
retry function with versions for blocking or non-blocking, tokio or async-std
-
pingora-rustls
RusTLS async APIs for Pingora
-
carboxyl
functional reactive programming
-
async-http-client-lite
Asynchronous http client
-
springtime
Dependency injection based application bootstrapping and execution crate
-
toy-rpc-ha421
An async RPC that mimics golang net/rpc's usage and supports both async-std and tokio
-
shadocal
A blazingly fast, Google calendar (more in future) event formatter webserver tool
-
ruspiro-channel
Bare Metal Channel implementations for
no-stdenvironments, only requiring an allocator to be provided -
mutex-extra
RefMutex<T>that is similar toMutex<T>but isSyncandSendeven ifTisn’tSend -
shared_stream
easily cloneable streams
-
variable-len-reader
reading/writing variable length data. Support AsyncRead/AsyncWrite in tokio.
-
gwyh
sweet gossip library
-
tempest
Realtime message handling framework inspired by Apache Storm and built with Actix
-
async-net-mini
Async networking primitives for TCP/UDP/Unix communication for esp-idf
-
tarpc-bincode-transport
A bincode-based transport for tarpc services
-
swiftide-query
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
actix-storage-sled
actix-storage based on sled
-
bb8-ruarango
bb8 connection pooling impmentation for the ArangoDB database
-
email-lib
Cross-platform, asynchronous Rust library to manage emails
-
watchfile
An async utility trait to subscribe to file changes of a serializable file
-
gloo-dialogs
Convenience crate for working with dialogs in browser
-
crb-core-std
CRB | Composable Runtime Blocks | STD
-
embassy-time-driver
Driver trait for embassy-time
-
rotor
The mio-based framework for doing I/O in simple and composable way
-
compio-dispatcher
Multithreading dispatcher for compio
-
shutdown-async
Asynchronous Shutdown
-
futures-util-either
futures_util::future::Either Ext
-
brb
Byzantine Fault Tolerant (BFT) system for achieving network agreement over eventually consistent data-type algorithms such as CRDTs
-
swimos_route
SwimOS Routing Utilities
-
ockam_node
Ockam [Ockam][main-ockam-crate-link] Node and is intended for use by crates that provide features and add-ons to the main [Ockam][main-ockam-crate-link] library. The main [Ockam][main-ockam-crate-link]…
-
rt-local-core
Thread local asynchronous runtime working with platform-specific event loops
-
kay_codegen
Code generation for implementing kay actors
-
cortex-sources
Ready-made source implementations for various data inputs in the Cortex ecosystem
-
async-await
Just some macros to emulate the Async and Await :)
-
futures-option
Extension traits for dealing with optional futures and streams
-
mfio-netfs
mfio based network filesystem
-
aiur
Single threaded async executor with structured concurrency
-
axum-serveplus
High level server designed to be used with axum framework
-
asteroid-mq-model
Basic models for asteroid-mq
-
cucumber-codegen
Code generation for
cucumbercrate -
hyper_lua_actor
Binding of lua_actor & hyper
-
async-vfs-os
Async Virtual File System backed by OS File System
-
ockam_transport_websocket
WebSocket Transport for the Ockam Routing Protocol
-
fluvio-future
I/O futures for Fluvio project
-
tk-bufstream
A buffered stream backed by contiguous buffers (netbuf) for tokio
-
delay
A collection of trait and classes to make your thread wait (and timeout)
-
wookie
Async test/bench toolkit including single stepping executors. No-std compatible.
-
async-slot
An asynchronous (futures-based) channel that only preserves last value sent
-
doh-proxy
A DNS-over-HTTPS (DoH) and ODoH (Oblivious DoH) proxy
-
ruyi
An event-driven framework for non-blocking, asynchronous I/O in Rust
-
minirpc
A minimalist RPC framework
-
futures-fs
A Futures implementation for File System operations
-
libp2p-swarm-test
Test framework for code building on top of libp2p-swarm
-
potential
PubSub lib with sync and async API
-
stream_router
A Future aware router to dynamically route between Streams and Sinks
-
fibers_transport
Transport layer abstraction built on top of [
fibers] crate -
unsend
A thread unsafe runtime for thread unsafe people
-
async-global-executor-trait
executor-trait implementation for async-global-executor
-
hugging-face-client
rust implment of Hugging Face Hub API
-
workflow-async-trait
Type erasure for async trait methods (customized, see README.md notes)
-
riker-deadletter
A Dead Letters logger for Riker
-
streaming-platform
Data streaming platform and message broker with concurrent data transfer capabilities
-
thin_main_loop
Thin, cross-platform, main event loop. A building block for native GUI applications, among other use cases.
-
abs_art
ABStraction of Asynchronous RunTime
-
futures-await-test-preview
Async test support for Rust through a procedural macro. This crate defines the
#[async_test]attribute to make writing tests that use async/await easier. -
signals
A functional-reactive-like library for Rust that allows asynchronous chaining
-
futures-waitmap
future-based concurrent event waiting hashmap
-
tower-async-bridge
Bridges a
tower-asyncServiceto be used within atower(classic) environment, and also the other way around -
futures-enum
#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums
-
axum-tungstenite
WebSocket connections for axum directly using tungstenite
-
async-executor-trait
executor-trait implementation for async-std
-
verypoll
Very polling library
-
tower-sessions-sqlx-store-chrono
SQLx session stores for
tower-sessionsbut usingchronoinstead oftime -
decoyssh
A compact and portable SSH tarpit server
-
ex-futures
An extension of
futures -
actix-async-await
Experimental async/await support for Actix
-
apigpio
Raspberry PI GPIO access, via pigpiod; safe, async, Tokio
-
mio-byte-fifo
Concurrent non-blocking byte SPSC FIFO buffer intended for use in Mio poll
-
unix-udp-sock
async & sync UDP sockets supporting sendmsg/recvmsg and src IP manipulation
-
ultra-batch
Tokio-based library to batch and cache database queries or other data lookups
-
prometheus-hyper
small Tokio/Hyper server to run Prometheus metrics
-
async-drop-guard
offers hash map and cache data structures where individual entries can be locked
-
heim-sensors
Cross-platform sensors information
-
minehut
easy to use Rust wrapper for the Minehut API
-
futures-websocket
A futures-based websocket implementation
-
awaur
Asynchronous Web API Utilities for Rust
-
async-barrier
An async barrier
-
reacher-fast-socks5
Fast SOCKS5 client/server implementation written in Rust async/.await (tokio)
-
elk-mq
A Message Queue implementation in rust, using Redis as a communication medium
-
event-source
Zero cost async immediate event dispatching
-
b2sum-rs
Computing The Blake2b Hash of Files with any given Digest Size
-
bluer
official Rust interface to the Linux Bluetooth protocol stack (BlueZ)
-
context-logger
A lightweight, ergonomic library for adding structured context to your logs
-
agner-test-actor
An actor toolkit inspired by Erlang/OTP (test-actor)
-
elfo-network
Distributed actors for elfo
-
rust-gpt
interaction with the Completion/Chat OpenAI API
-
vkteams-bot
VK Teams Bot API client
-
tauri-plugin-polodb
A Tauri plugin to expose the PoloDB embedded database to applications
-
there
planning and executing commands on local and remote hosts
-
tokio-macros
Tokio's proc macros
-
scoped_spawn
Full structured concurrency for asynchronous programming
-
herbert
actor management
-
peace_item_file_download
Manages downloading a file for the peace framework
-
tokio-pty-process-stream
wraps tokio-pty-process in order to provide a simpler API as a single stream object
-
async-priority-queue
An async-aware priority queue
-
monoio-io-wrapper
A read/write wrapper to bridge sync and async io
-
mediatrix
Strongly typed, extensible event mediator
-
dioxus-query
Fully-typed, async, reusable cached state management for Dioxus 🧬
-
apt-cmd
Async library for interacting with apt commands
-
redis-asio
Asynchronous Redis driver based on tokio
-
compio-quic
QUIC for compio
-
async-openai-types
OpenAI
-
actix-ws-ng
WebSockets for Actix Web, without actors
-
makiko
Asynchronous SSH client library in pure Rust
-
intervalier
Interval events with handling notifications
-
stabilityai
stability.ai library based on OpenAPI spec
-
wnf
Safe bindings for the Windows Notification Facility
-
rabble
creating location transparent actor based systems
-
switchy_async_macros
Switchy Async macros package
-
awesome-operates
A reposity includs many common use code utils
-
ws-lite
Naive websocket server implemented using async / await
-
pingora-core
Pingora's APIs and traits for the core network protocols
-
gain-lep
Support for exposing Gain APIs via Lep
-
seal_rs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
odem-rs-meta
Language extensions for the ODEM-rs simulation framework
-
inklings
A unified Rust API for various Large Language Model (LLM) providers
-
baildon-glue
SQL Database
-
springtime-migrate-refinery
SQL migration framework based on dependency injection
-
islabtech-upw-sensor-v1
Rust client library for remote control of the ISLabTech UPW Sensor v1
-
hreq-h2
An HTTP/2.0 client and server
-
woven
set of async combinators, usable in a no_std environment
-
tokio-udp-framed
Based on UdpFramed from tokio-util but with some quality of life modifications to support shared ownership of
UdpSocketand to split Send/Recv into their own types -
waaaa
WebAssembly, Abstracted Away
-
async-raft2
An async implementation of the Raft distributed consensus protocol
-
event_handlers
A unified library for handling events
-
ockam_transport_ble
Bluetooth Low Energy (BLE) Transport for the Ockam Routing Protocol
-
async-gitlib
Asynchronous library with libgit2 artifacts
-
yap2p
Experimental yet another peer-to-peer library
-
basteh-redb
basteh based on redb
-
squinn
Versatile QUIC transport protocol implementation with SCION support
-
axum-session-manager
Session manager crate for Rust web framework 'Axum'
-
compio-signal
Signal handling for compio
-
librdkafka-sys
Native bindings to the librdkafka library
-
cloudwatch_logging
logging to AWS CloudWatch Logs
-
async-native-tls-2
Native TLS using futures
-
tmpdir
Useful to create temp directories and copy their contents on completion of some action. Tmp dirs will be created using [
env::temp_dir] with some random characters prefixed to prevent a name clash -
toy-async-runtime
Toy library to start to work with async rust, build for reckless person!
-
srad-client-rumqtt
Sparkplug Client implementation using Rumqtt
-
mcprotocol-rs
Model Context Protocol (MCP)
-
hydra-macros
Macros for the hydra framework
-
sendfile
wrapper around the sendfile(2) system call
-
reqwest-eventsource
Helper to build an Eventsource using reqwest
-
destream
async stream (de)serialization
-
rseip-eip
encapsulation protocol for rseip
-
eventbuzz_core
The core submodule of eventbuzz project
-
swimos_encoding
SwimOS Encoding Utlities
-
rollo
A Rust-based multiplayer framework
-
tokio-non-async
Helpers for dealing with tokio channels in non-async code
-
async-graphql-extension-apollo-tracing
An async_graphql extension to send traces & metrics to Apollo Studio
-
async-graphql-linera-derive
Macros for async-graphql
-
mio-timerfd
mio support for linux's timerfd
-
bolt-client
A client that sends messages using the Bolt protocol
-
http-lib
High-level, asynchronous API for ureq, a safe HTTP client
-
accumulate-api
Lower-level API for interfacing with the Accumulate Protocol via JSON-RPC
-
futures-stable-preview
futures which support internal references
-
simcore
A generic discrete-event simulation framework
-
ttl_cache_with_purging
A time-to-live (TTL) cache implementation with optional background purging for expired entries
-
must-done
An experimental Future that is guaranteed to be done
-
tokio-tls-gmssl
TLS/SSL streams for Tokio using native-tls giving an implementation of TLS for nonblocking I/O streams
-
duplexify
Combine a reader + writer into a duplex of Read + Write
-
gneiss-mqtt-aws
AWS IoT Core specific builders for asynchronous and threaded MQTT clients
-
kayrx
Framework
-
memphis-rust-community
Memphis Messaging Protocol
-
async-fetcher
Asynchronous multi-connection multi-download resumable HTTP file fetching state machine
-
swimos_client
SwimOS Client
-
wasmflow-traits
encapsulating the message packets sent across Wasmflow components
-
patchable-async-sleep
An async sleep function, patchable to the preferred runtime
-
cqrs-core
Core types and traits for cqrs
-
agreed-memstore
An in-memory implementation of the
agreed::RaftStoragetrait. Fork of async-raft’s memstore crate. -
hyper-serve
High level server designed to be used with axum framework
-
batch
Distributed task queue library based on RabbitMQ
-
tauri-wasm
The tauri framework library for pure rust frontend
-
streamify
Conversions from values to Stream
-
yaaral
async runtime abstraction library
-
futures-loco-protocol
Asynchronous Loco protocol stream for futures
-
gm-quic
An IETF quic transport protocol implemented natively using async Rust
-
cute-async
Cute async utilities
-
axum-messages
🛎️ One-time notification messages for Axum
-
tower-sessions-deadpool-sqlite-store
deadpool-sqlite session store for
tower-sessions -
ockam_transport_udp
UDP Transport for the Ockam Routing Protocol
-
jarust_interface
A janus client SDK in Rust
-
tower-pipeline
A Tower Service combinator that "pipelines" two services
-
sendblue
that provides an API client for interacting with the SendBlue REST API, enabling businesses to integrate iMessage and SMS services into their applications
-
rustmark
Extensible web application for serving Markdown-based content
-
crypsol_logger
Structured asynchronous logger for Rust services with an AWS CloudWatch backend
-
drop-awaiter
that allows you to asynchronously wait for something to be dropped
-
tokio-buf
Asynchronous stream of byte buffers
-
app-queue
In-app persistent queue for asynchronous jobs
-
st7735-async-low
Low-level async library for 4-wire serial ST7735
-
async-attributes
Experimental language-level polyfills for Async Rust
-
vertigo
Reactive Real-DOM library with SSR for Rust
-
windows-async
async executor for windows application using windows crate
-
srad-types
Sparkplug types and utilities
-
nb-executor
Single-future, #![no_std] executor based on event bitmasks
-
sqlxmq
A reliable job queue using PostgreSQL as a backing store
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
launchpadlib
accessing Launchpad.net
-
see-you-later
Delay and schedule async task
-
async-graphql-parser
GraphQL query parser for async-graphql
-
async-option
Essentially an asynchronous Async<Mutex<Option<T>>>
-
libmedusa-zip
High-performance parallelized implementations of common zip file operations
-
stream-future
Implement an async iterator with return value
-
monoio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
task-stream
a global task executor, run in
no_std -
syncthing
controlling syncthing file synchronization through its REST interface
-
connman
that abstracts the D-Bus layer
-
ded
Dead Easy Deduplication
-
winit-runtime
Async winit runtime
-
rusty-gql
Schema first GraphQL Library for Rust
-
async-fd-lock
Advisory cross-platform file locks using file descriptors with async support by spawning blocking tasks
-
linux-io-uring
The
io_uringlibrary for Rust -
streem
creating and consuming streams
-
async-stripe-webhook
API bindings for the Stripe HTTP API
-
memberlist-proto
Proto types and traits for the memberlist crate
-
async-i3ipc
Bindings for i3 and async-std allowing async applications to communicate with i3 over it's IPC interface. Contains futures implementations and convenience functions for working with i3.
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
ruw
Read-Update-Write
-
tokio-extra-macros
Extra proc macros for Tokio
-
bottle
Actor model framework for Rust
-
intersession-layer-messaging
A metastable messenger that allows reliability between peers when peers go offline, are unreliable, and facing intermittent network conditions between sessions
-
async-debug
Debug structs and enums containing values that require an async call to render
-
delete
Fast, easy deletion of files and folders with async and cross-platform support
-
tarpc-json-transport
A JSON-based transport for tarpc services
-
futuresdr-types
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
protwrap
Thin protocol wrapper for network applications
-
aalo
aka bevy-inspector-haalka, a bevy_ui-native inspector for Bevy
-
fundamentum-edge-mcu-http-client
An HTTP Client for provisioning EdgeMCU devices
-
specta-typescript
Export your Rust types to TypeScript
-
futures-mockstream
Minimal mockstream which implements futures async traits
-
openssh-sftp-protocol-error
Data format used to communicate with openssh mux server
-
poller
File I/O events library for Rust
-
tower-async-service
Trait representing an asynchronous, request / response based, client or server. An "Async Trait" fork from the original Tower Library
-
mobc-bolt
A bolt-client manager for the mobc connection pool
-
kabuki
Name reservation
-
apub-ingest
building activitypub servers
-
agnostic-io
agnostic-iodefines I/O traits in agnostic style for any async runtime -
tokio-timerfd
timerfd support for tokio
-
event_store
deal with every aspect of an eventstore
-
rocket-session-store
session library that can use a custom store
-
cannyls_rpc
RPC library for operating cannyls's devices from remote nodes
-
rusher-pubsub
Pusher compatible pubsub service
-
aster-proxy
A light, fast and powerful cache proxy written in Rust
-
tokio-rusqlite-axuman
Asynchronous handle for rusqlite library
-
cache-compute
implements request/async computation coalescing
-
catalyzer-utils
development easier
-
peace_data
Data model for the peace automation framework
-
waitfor
Retry a function until it succeeds, errors out, or a timeout/deadline is reached
-
futures-shuttle
Futures-aware shuttle synchronization object
-
posixmq
An idiomatic library for using posix message queues, with optional mio integration
-
tower-async-test
writing client and server
Servicetests. An “Async Trait” spiritual fork from the original tower-test Library -
crdb-client
Concurrently Replicated DataBase
-
openssh-sftp-client
Highlevel API used to communicate with openssh sftp server
-
tower-buffer
Buffer requests before dispatching to a
Service -
mogwai
The minimal, obvious, graphical, widget application interface
-
actix-server
General purpose TCP server built for the Actix ecosystem
-
stream-reduce
Fold a stream without an initial value
-
completeio
Completion based IO drivers and async runtime
-
futures-quic
quic protocol backed by Quiche
-
kapacitor-multi-indicator-batch-udf
A multi-indicator batch UDF for Kapacitor
-
suspend-channel
Channel and stream implementations
-
tokio-utils
Tools for asynchronous programming in Tokio applications
-
rustdtp
Cross-platform networking interfaces for Rust
-
citadel_pqcrypto
Lower-level cryptographic library for the Citadel Protocol
-
async-dashscope
client for DashScope API
-
fast_websocket_client
A blazing-fast, async-native WebSocket client for Rust, built on top of fastwebsockets and tokio
-
stick
Platform-agnostic asynchronous gamepad, joystick and flighstick library
-
simple-scheduler
Schedule periodic tasks to run asynchronously
-
tower-sessions-dynamodb-store
AWS DynamoDB session store. Not for direct use; see the
tower-sessionscrate for details. -
zino-auth
Authentication and authorization for zino
-
thalo_message_store
Thalo's message store built with sled
-
remcached
Caching system designed for efficient storage and retrieval of entities from remote repositories (REST APIs, Database, ...etc)
-
underway
⏳ Durable step functions via Postgres
-
fluxus-transformers
Transformer components for Fluxus stream processing engine
-
heim-virt
Cross-platform virtualization system detection
-
mioqu
queuing and processing background tasks
-
rs-firebase-admin-sdk
Firebase Admin SDK for Rust
-
batch-renamer
Framework and command line utilities for interactive renaming of a potentially large number of files
-
async-task-ffi
Task abstraction for building executors
-
bb8-mongodb
bb8 connection pooling impmentation for the MongoDB database
-
whorl
was created to teach you how async executors work in Rust
-
axum-prometheus
A tower middleware to collect and export HTTP metrics for Axum
-
tokio-websockets
High performance, strict, tokio-util based WebSockets implementation
-
skipdb-core
The core for
skipdbandasync-skipdbcrates -
redis-work-queue
A work queue, on top of a redis database, with implementations in Python, Rust, Go, Node.js (TypeScript) and Dotnet (C#)
-
netidx-protocols
Protocols built on top of netidx
-
tower-async-hyper
Bridges a
tower-asyncServiceto be used within ahyper(1.x) environment -
hop
Rust client library for the Api
-
actix-utils
Various utilities used in the Actix ecosystem
-
mlg
An asynchronous Log for Rust
-
dummy-waker
Get a
core::task::Wakerthat does absolutely nothing -
wtr-watcher
Filesystem watcher. Works anywhere. Simple, efficient and friendly.
-
stream-flatten-iters
Flattens a stream of iterators into one continuous stream
-
gidle_future
A future executor for the glib main loop idle time
-
worterbuch
A message broker / database hybrid
-
noosphere-fs
A high-level, FS-like view over Noosphere content
-
async-llm
OpenAI-compatible APIs
-
ruchei-callback
Callback traits for ruchei
-
d3-components
A framework for server development -- the component layer
-
peermerge
Manage JSON-like documents with multiple writers, without a central authority, using a P2P protocol
-
zino-extra
Extra utilities for zino
-
pagetop
Un entorno de desarrollo para crear soluciones web modulares, extensibles y configurables
-
june
ergonomic remote actors via actix and canary
-
tonic-mock
Test utilities for easy mocking tonic streaming interface
-
jsonrpc-rs
Futures base jsonrpc server/client framework
-
async-shell
Asynchronous process child wait
-
simple-async-local-executor
A single-threaded polling-based executor suitable for use in games, embedded systems or WASM
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
async-stripe-client-core
API bindings for the Stripe HTTP API
-
compio-process
Processes for compio
-
awaitable-error
Awaitable type with input and output that can be stored in container
-
tls-async
TLS support for AsyncRead/AsyncWrite using native-tls
-
delimiter-slice
Stream type for splitting a delimited stream
-
gimbal_async_macros
Gimbal Async macros package
-
carrot-cake
An a-peeling pub/sub framework
-
tasker_service
a service for executing time based commands
-
async-native-tls-alpn
Native TLS using futures
-
asteroid-mq-sdk
Rust SDK for asteroid-mq
-
ipc-orchestrator
Orchestion of command line processes for local dev usage with IPC communication
-
async-stdin
Asynchronously read from stdin
-
salvia
Incremental computing brought to async Rust
-
fs4
No libc, pure Rust cross-platform file locks. Original fs2, now supports async and replace libc by rustix.
-
ant-libp2p-swarm-test
Test framework for code building on top of libp2p-swarm
-
rio_rt
A minimal async runtime with an experimental ambition to be an portable and interoperable async runtime for Rust
-
viz-core
The core traits and types in for Viz
-
ntex-grpc
GRPC Client/Server framework
-
async-core
A standard for async runtimes
-
kvarn-quinn
Temporary Kvarn fork: Versatile QUIC transport protocol implementation
-
gmf
An RPC library using Glommio and Tonic. Note: This package only works on Linux.
-
throttled-reader
An io::Read proxy that limits calls to read()
-
elfo-telemeter
Collects and exposes metrics of the elfo system
-
stage
An ergonomic, composable Actor Model, designed for painless concurrency
-
implicit-await
Implicitly await calls returning Future impls
-
async-openai-wasm
OpenAI on WASM
-
clia-rcproxy
A lightweight, fast and powerful Redis Cluster Proxy written in Rust
-
garcon
A collection of trait and classes to make your thread or async function wait
-
prk_async_dataflow
An asynchronous dataflow processing library for Rust with SIMD-accelerated JSON parsing and AI agent capabilities
-
kowalski
A Rust-based agent for interacting with Ollama models
-
heim-disk
Cross-platform disk information
-
soketto
A websocket protocol implementation
-
arta
Async runtime abstractions library
-
iroh-quinn
Versatile QUIC transport protocol implementation
-
and-then-concurrent
Concurrent and-then combinator for Rust streams
-
netsim
Run tests in network-isolated threads. Intercept and meddle with their packets.
-
async_channel_io
AsyncReadandAsyncWriteimplementations forasync_channel -
zino-axum
Integrations with axum for zino
-
backdrop
Drop your large or complex objects in the background with Backdrop! (later, on another thread, or both! Fully customizable! Tokio supported!)
-
tokio-tungstenite-typed
tokio-tungstenite with type safe messages
-
stream-utils
Additional stream combinators
-
async-component
Zero overhead reactive programming
-
cassandra-cpp
A Cassandra CQL driver, built on top of the DataStax C++ driver for performance and functionality
-
waaa
WebAssembly, Abstracted Away
-
heim-process
Cross-platform processes information
-
rexie
futures based wrapper around IndexedDB that compiles to webassembly
-
qcow2-rs
read/write qcow2 image in async/await
-
async-subscription-map
Async bookkeeping datastructure for state subscriptions
-
async-cuda-core
Async CUDA streams and buffers for Rust
-
tower-sessions-seaorm-store
SeaORM session store for
tower-sessions -
async-watch
Async watch channel
-
abstract-ns
Abstract name service traits for use with futures (and tokio)
-
async-http-body
Agit init HttpBody Support Async Expressions
-
peace_item_sh_cmd
Manages running a shell command for the peace framework
-
stream-tungstenite
A streaming implementation of the Tungstenite WebSocket protocol
-
lstngrp
Groups listeners and connections with common data/logic
-
tourniquet-celery
Async native round-robin manager for remote services. celery integration.
-
serf
A decentralized solution for service discovery and orchestration that is lightweight, highly available, and fault tolerant
-
prefect
An embeddable task queue based on SQLite (renamed to effectum)
-
futuresdr-remote
Remote interaction library for FutureSDR
-
lrcall
procedure call framework that is compatible with local and remote procedure calls
-
futures-to-stream
Turn heterogeneous Futures of same associated Output type to a stream
-
koit
asynchronous, pure-Rust, structured, embedded database
-
motore-macros
Motore's proc macros
-
barrage
An async broadcast channel
-
local-pool-with-id
A minor variation on a LocalPool executor which exposes unique IDs for tracking future completion
-
num_stream
that provides a Stream that yields incrementing numbers at a specified interval
-
pea2pea
low-level, and customizable implementation of a TCP P2P node
-
smol-hyper
Integrations between smol and hyper
-
stalk
sending serialized data with tokio
-
json-array-stream
Incrementally reads a JSON array through an async stream
-
swimos_multi_reader
SwimOS Stream Aggregator
-
aldrin-test
Aldrin server and client tests
-
juniper
GraphQL server library
-
destream_json
decoding & encoding a JSON stream
-
noop-waker
A waker that does nothing
-
channels-io
Async agnostic/Sync IO & buffer management abstractions
-
mqtt-codec-kit
MQTT v3.1.1/v5.0 protocol async codec
-
robust_downloader
A robust, concurrent file downloader with retry capabilities and progress tracking
-
tokio-fd
Non-blocking Read and Write a Linux File Descriptor
-
async-metronome
Unit testing framework for async Rust
-
salvo-serde-util
serde util for salvo
-
arti-bench
benchmarking utility for Arti
-
thehive-client
Rust client for TheHive API, enabling programmatic management of alerts, cases, observables, tasks, and other security incident response entities
-
jonmo
Bevy-native functional reactive signals
-
ianaio-events
Convenience crate for working with DOM event listeners
-
actix-storage
General key value storage for actix-web
-
zstd-framed
zstd seekable format compression and decompression. Supports sync and async I/O
-
madsim-etcd-client
The etcd simulator on madsim
-
ara
Async random access I/O traits
-
worst-executor
A spin-loop like executor for async
-
indexed-db
Bindings to IndexedDB that default the transactions to aborting and can work multi-threaded
-
futures-stream-reader
Convert an [AsyncRead] into a [Stream] of byte chunks
-
qudp
High-performance UDP encapsulation for QUIC
-
futures-executor-preview
Executors for asynchronous tasks based on the futures-rs library
-
batched-fn
Middleware for serving deep learning models with batched prediction
-
elfo-dumper
Dumps messages of the elfo system on disk
-
stream_multiplexer
Combines many streams into a few
-
boluo-core
boluo的核心类型和特征
-
ekv
Key-value database for embedded systems, for raw NOR flash, using an LSM-Tree
-
uasync
fast, safe, async executor
-
async-timer
Timers for Rust async story
-
mercury
The official Rust client for the Mercury Parser
-
eventually
using Event Sourcing in Rust applications
-
async_main
Runtime-agnostic async main proc macro
-
form-data
AsyncRead/AsyncWrite/Stream
multipart/form-data -
swimos_agent
SwimOS Agent Implementation
-
ssdp-client
An asynchronous library for discovering, notifying and subscribing to devices and services on a network
-
swimos_meta
SwimOS Metadata API
-
async-ioutils
A collection of async utilities for I/O
-
logic-mesh
Control logic engine using event based and reactive blocks written in Rust
-
tokio-dbus
Pure Rust D-Bus implementation for Tokio
-
ferris_chats_server
This binary provides a server for ferris_chat
-
cyper-axum
axum adaptor based on cyper
-
axum-limit
A rate limiting library using token buckets, centered around extractor-based limits for async web applications
-
naumi
Lightweight and fast data transfer protocol. Fast de/serialization and tiny size!
-
spire
The flexible scraper framework powered by tokio and tower
-
signalr-client
calling SignalR hubs from a Rust cross-platform application, supporting WASM and non WASM targets
-
zino-openapi
OpenAPI support for zino
-
stream-cancel
interrupting asynchronous streams
-
libp2p-upnp
UPnP support for libp2p transports
-
comet-eventbus
strong-typed sync and asynchronous eventbus
-
mailfred
Process emails as an HTTP server
-
jackrabbit
Real-time Message Queue
-
ntex-io
encoding and decoding frames
-
grpcio
language implementation of gRPC, base on the gRPC c core library
-
swimos_errors
SwimOS Error Utilties
-
zino-actix
Integrations with actix-web for zino
-
linux-io-uring-sys
The
io_uringbindings for Rust -
libp2p-kad
Kademlia protocol for libp2p
-
smartpoll
A 'Task' abstraction that simplifies polling futures
-
qconnection
Encapsulation of QUIC connections, a part of gm-quic
-
digtask
Dig is a YAML-defined, OS-level task orchestrator. It can 'dig into' a specifed task, or 'dig out' a desired output file
-
hyper-http-proxy
A proxy connector for Hyper-based applications
-
shuller
Lib to get links to images for your favourite tags on rule34 and any
-
mpool
A generic connection pool
-
jarust_core
A janus client SDK in Rust
-
eventum
Asynchronous I/O Event manager
-
mysql_async_uu
Tokio based asynchronous MySql client library
-
thespis_impl
Reference implementation for the thespis actor model
-
async-entry
extended Tokio's proc macros
-
erkpht-tower
Tower is a library of modular and reusable components for building robust clients and servers
-
wtransport-proto
WebTransport (over HTTP3) protocol
-
stayalive
A collection of resilience patterns
-
light-magic
A lightweight, fast and easy-to-use implementation of a optionally encrypted/persistent in-memory database
-
genawaiter-macro
Convenience macros for generators (genawaiter)
-
koit-toml
asynchronous, pure-Rust, structured, embedded database
-
tokio-global
Global tokio runtime
-
samotop
SMTP server and library built on async-std
-
compio-tls
TLS adaptor with compio
-
zephyrus-macros
Procedural macros used by Zephyrus
-
smol-timeout2
A way to poll a future until it or a timer completes
-
alan-runtime
A runtime in Rust to run AGC or Alan Graphcode, alan's bytecode format
-
swiftide-macros
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
openssh-sftp-protocol
Data format used to communicate with openssh mux server
-
sigfinn
Lifecycle manager for spawning tasks
-
create-rspc-app
Get started with your next rspc app!
-
smol-executor-trait
executor-trait implementation for smol
-
bb8_surrealdb2
Surrealdb support for the async bb8 connection pool
-
eternal
Framework
-
gemini-client-api
Google Gemini API's all tools(code, search, function calling) even with streaming. Automatic context management!
-
tokio-iocp
IOCP support for the Tokio asynchronous runtime
-
srad-client
Types and traits for implementing Sparkplug Clients
-
tokio-channel
Channels for asynchronous communication using Tokio
-
toni-macros
Macros for Toni
-
specta-serde
Serde support for Specta
-
repeating_future
[RepeatingFuture] is a [Future] that can call an async function of an object over and over again
-
peace_cmd_model
Data types for commands for the Peace framework
-
async-graphql-value
GraphQL value for async-graphql
-
async-ping-cli
Async Ping Cli
-
openaction
creating plugins for the OpenAction API
-
async-macros
Macros for async-std
-
tower-sesh-core
Core components for
tower-seshand related crates -
folo
Runtime engine for Rust services
-
fmmap
A flexible and convenient high-level mmap for zero-copy file I/O
-
gen-z
Macro-free stream construction through asynchronous generators via an awaitable sender
-
kayrx-ui
Framework
-
scambio
Safe and efficient value exchanges between endpoint pairs
-
smol-macros
Macros for setting up a smol runtime
-
param
Param-style trait
-
tl-async-runtime
A bad runtime impl for educational purposes only
-
anthropic-sdk
Anthropic Rust SDK
-
sockit
A UDP socket that can read and write serializable data
-
micro_http_async
A small, lightweight and hassle-free crate using async to serve web pages or web apis with high performance and extremely low overhead
-
tonic-sysinfo
A gRPC service for monitoring system resources such as CPU, memory, and disk
-
logged-stream
Logging of all read/write operations, errors and drop of underlying IO object
-
multipart-rs
zero-allocation, streaming, async multipart reader & writer for Rust
-
extern_executor
Async executor which delegates futures polling to external event-loop
-
ohkami
Build web app in intuitive and declarative code
-
ntex-rt
ntex runtime
-
embassy-futures
no-std, no-alloc utilities for working with futures
-
fluxus-sources
Source components for Fluxus stream processing engine
-
tower-worker
Tower layers focused on wrapping services with asynchronous worker tasks that may also make requests to the wrapped service
-
edge-mqtt
Implements the embedded-svc MQTT traits on top of the rumqttc crate
-
mycorrh
fast concurrent messaging system for Rust
-
speed-rs-core
A core HTTP handling server library in Rust, providing low-level HTTP server implementation
-
yaar
asynchronous runtime optimized around configuration and no_std
-
swimos_utilities
SwimOS Time Utilities
-
txrx
take on the C++ unified executors proposal
-
tower-sessions-rusqlite-store
(tokio-)rusqlite session store for
tower-sessions -
mwmr
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
tonic-rpc
RPC library that uses native Rust types and is built on tonic
-
openraft-macros
Advanced Raft consensus
-
wcp-core
Core library for the White Cat Protocol (WCP), focusing on privacy, security, anonymity
-
async-stream-http-tunnel-grader
Asynchronous stream http tunnel grader
-
openai_responses
Rust SDK for the OpenAI Responses API
-
tokio-byteorder
Asynchronous library for reading/writing numbers in big-endian and little-endian
-
crdb-test-utils
Concurrently Replicated DataBase
-
heim-net
Cross-platform network information
-
tracing-appender
file appenders and making non-blocking writers
-
unisub
A Pub/Sub library for Rust backed by Postgres
-
mysql_async_wasi
Tokio based asynchronous MySql client library
-
elfo-pinger
Pings groups of the elfo system
-
async-graphql
A GraphQL server library implemented in Rust
-
madsim-macros
Madsim's proc-macro
-
toy-rpc
An async RPC that mimics golang net/rpc's usage and supports both async-std and tokio
-
v_rusty_tarantool
Tarantul async client based on tokio framework
-
psbus
Generic Publish / Subscribe model for application messaging
-
cassandra-protocol
Cassandra protocol implementation
-
plctag
wrapper of libplctag, with rust style APIs and useful extensions
-
igdb
Video Game Database Api
-
monolake
High Performance Proxy base on Monoio
-
madsim-tonic
The
tonicsimulator on madsim -
fieldset
Struct to enum derivation
-
tower-etag-cache
A tower middleware for implementing ETag-based HTTP caching
-
peace_rt_model_native
Runtime data types for the peace automation framework
-
tokio-compat-02
Tokio 0.2 compat utilities
-
async-utf8-decoder
Convert AsyncRead to incremental UTF8 string stream
-
tower-sessions-surrealdb-store
SurrealDB session store. Not for direct use; see the
tower-sessionscrate for details. -
rusher-server
Pusher compatible pubsub service
-
mcmc-rs
Minimal rust client for memcached
-
stream_generator
Allows to easily generate streams with async/await
-
openssh-sftp-client-lowlevel
Lowlevel utilities to communicate with openssh sftp server
-
async-compression
Adaptors between compression crates and Rust's modern asynchronous IO types
-
openssh-mux-client-error
openssh mux client
-
rspc-tauri
Tauri adapter for rspc
-
simple-async
Very simple async runtime for Rust
-
papaleguas
ACME client
-
crb-supervisor
CRB | Composable Runtime Blocks | Supervisor
-
async-fn-stream
Lightweight implementation of
async-streamwithout macros -
minechat-protocol
The MineChat protocol, enabling you chat with people over on Minecraft
-
swimos_trigger
SwimOS Asynchronous Trigger
-
tunein
client to fetch radio stations from TuneIn
-
fsdr-blocks
Building blocks for FutureSDR signal processing library for SDR and real-time DSP
-
opentls
TLS connections with OpenSSL
-
salvo-jwt-auth
Jwt auth support for salvo web server framework
-
memstore
An in-memory implementation of the
async-raft::RaftStoragetrait -
tokio-async-std
An async-std that can fit into tokio ecosystem straight ahead
-
tokio-lock
Access an object from a single Tokio task
-
rama-tls-rustls
tls implementations for rama using rustls
-
roundabout
An message oriented concurrent runtime
-
twilight-lavalink
Lavalink client for the Twilight ecosystem
-
juliex
a very basic future executor
-
taskwait
Runtime agnostic way to wait for a group of async tasks
-
ockam_transport_tcp
TCP Transport for the Ockam Routing Protocol
-
anansi
full-stack web framework for Rust
-
tower-balance
Balance load across a set of uniform services
-
couchbase
The official Couchbase Rust SDK
-
async-stripe-types
API bindings for the Stripe HTTP API
-
futuresdr-pmt
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
terracotta
Boilerplate webserver application based on Axum
-
suspend_fn
macro for implicit await
-
aggligator-monitor
Aggligator link monitor and speed test
-
async-thread
Futures version of std::thread
-
idb-sys
A callback based crate for interacting with IndexedDB on browsers using webassembly
-
peace_resource_rt
Runtime resources for the peace automation framework
-
rupnp
An asynchronous library for finding UPnP control points, performing actions on them and reading their service descriptions
-
async-backtrace
Efficient, logical 'backtraces' of async tasks
-
thalo_runtime
A high-performance event sourcing runtime utilizing WebAssembly an embedded event store
-
async-ready
Async readiness traits
-
hyper-proxy
A proxy connector for Hyper-based applications
-
betfair-stream-api
interacting with Betfair from Rust
-
tokio_safe_block_on
ability to execute async code from a sync context, without blocking a tokio core thread or busy looping the cpu
-
tubetti
Serve &[u8] data at a localhost url with minimal configuration
-
future_pubsub
A tokio based publish-subscibe channel
-
volo-http
HTTP framework implementation of volo
-
crb-routine
CRB | Composable Runtime Blocks | Routine
-
tower-sessions-file-based-store
File-based session store for
tower-sessions -
hydro
cooperative green tasks
-
bellande_mesh_sync
Advanced data synchronization system for distributed applications with algorithmic architecture
-
actix-service
Service trait and combinators for representing asynchronous request/response operations
-
daku
Interface to the Daku API
-
fauxgen
write your own generators in stable rust
-
tokio-serde
Send and receive Serde encodable types over the network using Tokio. This library is used as a building block for serialization format specific libraries
-
stream-body
An HttpBody implementation with efficient streaming support for the Rust HTTP library hyper
-
heph-rt
speciailised runtime for Heph's actor
-
agnostic-dns
agnostic-dnsis an agnostic abstraction layer overhickory-dns -
async-timer-rs
Hashed timer wheel implementation compatible with asynchronous tasks, support async_std/tokio and other futures base framework
-
ockam_transport_uds
Unix Domain Socket (UDS) Transport for the Ockam Routing Protocol
-
async-openai-wasi
Async bindings for OpenAI REST API based on OpenAPI spec
-
client-util
Help you to build requests and handle responses by several extension trait!
-
embedded-hal
A Hardware Abstraction Layer (HAL) for embedded systems
-
hitbox
Asynchronous caching framework in Rust
-
opp
🚧 OpenPlugin Protocol (WIP, nothing usable for now)
-
async-ioutil
A collection of Rust asynchronous I/O utilities
-
qevent
qlog implementation
-
rdbc-rs
Futures base Rust DataBase Connectivity (RDBC) library
-
surrealdb-async-graphql-axum
async-graphql for axum
-
netbeam
a pure-rust asynchronous network synchronization crate (using tokio) that recreates familiar asynchronous paradigms but in a network context
-
tower-sessions-redis-store
Redis session store for
tower-sessions -
wamp_async
An asynchronous WAMP implementation
-
tokio-test-shutdown-timeout
Tokio test attribute with a shutdown timeout
-
async_to_iter
Convert async functions to generators on stable Rust
-
core-futures-tls
A libcore wrapper allowing async/await to be used from no_std crates
-
async-stream-tls-upgrader
Asynchronous stream tls upgrader
-
libp2p
Peer-to-peer networking library
-
servo-websocket
A WebSocket (RFC6455) library for Rust
-
async-watch2
Async watch channel
-
oai_rs
An async rust library that's a wrapper for the OpenAI API
-
reqwest-retry-after
Retry-After header support for reqwest
-
aggligator-transport-webusb
Aggligator transport: WebUSB for targeting WebAssembly
-
aldrin-gen
Aldrin code generator
-
tinywake
A minimal, no_std-compatible waker implementation for Cortex-M async executors
-
wasm-agnostic
users who want to write async runtime-agnostic crate for wasm target
-
citadel_crypt
Higher-level cryptographic library for the Citadel Protocol
-
crb-actor
CRB | Composable Runtime Blocks | Actor
-
zino-channel
Cloud events and subscriptions for zino
-
aranya-runtime
The Aranya core runtime
-
futures-async-runtime-preview
Runtime for the async/await macros in the
futurescrate -
crb-agent-ext
CRB | Composable Runtime Blocks | Agent Ext
-
wtx-macros
Procedural macros for wtx
-
volo
high-performance and strong-extensibility Rust RPC framework that helps developers build microservices
-
msgtrans
Support for a variety of communication protocols such as TCP / QUIC / WebSocket, easy to create server and client network library
-
rados_hi
Opinionated high-level wrapper for librados (Ceph)
-
runtime-loop
Runtime loop for Rust
-
dialectic-tokio-mpsc
A backend for the Dialectic crate using Tokio's MPSC channels
-
plctag-async
async wrapper for libplctag
-
async-graphql-axum
async-graphql for axum
-
actix_async_handler
Support for async syntax for Actix
-
lspower
A lightweight framework for implementing LSP servers
-
crb-task
CRB | Composable Runtime Blocks | Task
-
tower-memlim
Tower based middleware layer to limit requests based on the host's computer memory usage
-
tower-redis
A Tower service for asynchronous Redis request/response performed over a managed, multplexed connection
-
embassy-executor
async/await executor designed for embedded usage
-
vesper-macros
Procedural macros used by Zephyrus
-
tonic-reflection
Server Reflection module of
tonicgRPC implementation -
alzheimer
Async implementation of brainfuck interpreter
-
memberlist-types
Types used in the memberlist crate
-
nostr-bot
Nostr bot library
-
ant-libp2p-dcutr
Direct connection upgrade through relay
-
openraft-sledstore
A sled based implementation of the
openraft::RaftStoragetrait -
quickie
low-level, and customizable implementation of a QUIC P2P node
-
tower-retry
Retry failed requests
-
async-transport
Asynchronous transports with ECN information
-
elfo-logger
Logs events of the elfo system
-
ntex-files
Static files support for ntex web
-
basteh
Generic kv storage with replaceable backend
-
compio-log
Log of compio
-
ntex-server
Server for ntex framework
-
mqtt-proto
MQTT v3.1/v3.1.1/v5.0 protocol sync/async codec
-
specta-jsdoc
Export your Rust types to JSDoc
-
tor-events
A typed event broadcasting framework for Arti
-
haalka
ergonomic reactive Bevy UI library powered by FRP signals
-
exo_task
A lightweight async task executor for bare metal (or any) systems
-
mirai
A Futures layer over Mio
-
mai
A higher-level mio interface
-
rama-proxy
proxy types and utilities for rama
-
embedded-platform
Holistic embedded device support in a batteries-included manner
-
madsim-tonic-build
Codegen module of
madsim-tonicsimulation implementation -
async-graphql-poem
async-graphql for poem
-
tcp-stream
std::net::TcpStream on steroids
-
tokio-dbus-macros
Pure Rust D-Bus implementation for Tokio
-
genawaiter2-proc-macro
procedural macro for generators (genawaiter2)
-
poem-openapi
OpenAPI support for Poem
-
tiny-jsonrpc
Json rpc lib based on reqwest
-
tower-batch
batch-toweris a Tower middleware that allows you to buffer requests for batch processing until the buffer reaches a maximum size OR a maximum duration elapses -
rust_transit
A broker-agnostic asynchronous event library
-
salvo-oapi
OpenApi support for Salvo web framework
-
nidrs-diesel
Nidrs & Diesel integration
-
async-retry
Async Retry
-
epics-ca
Client library for EPICS Channel Access protocol
-
rw-stream-sink
Adaptator between Stream/Sink and AsyncRead/AsyncWrite
-
continue
Swift-style continuation API
-
libp2p-yamux
Yamux multiplexing protocol for libp2p
-
pangotls
TLS Reverse Proxy using Tokio and Rustls
-
swimos_num
SwimOS Numeric Helper Macros
-
peace_cmd_ctx
Information such as which profile or flow a command is run for for the Peace framework
-
tower-sessions-libsql-store
A small library for using tower-sessions with libsql
-
asyncore
-
ezsockets
WebSockets server & client made easy
-
async-wsocket
A convenience library for using websockets both in native and WASM environments! Include embedded tor client support
-
wirebolt
Lightweight and performant TCP wrapper
-
firebase-rtdb
Firebase client for the Citadel Protocol
-
zino-ntex
Integrations with ntex for zino
-
leap_client_rs
Rust client library for the Leap Edge socket service
-
beul
It executes futures
-
emitter-rs
📢 Emitter RS is a lightweight EventEmitter implementation for Rust and Wasm
-
ironmq-client
IromMQ client library (AMQP 0.9)
-
fluxus-utils
components for Fluxus stream processing engine
-
rama-tls-boring
tls implementations for rama using boring
-
async-graphql-rocket
async-graphql for Rocket.rs
-
tasktrace
Logical 'backtraces' of async tasks
-
peace_rt_model_web
Web support for the peace automation framework
-
tonic-health
Health Checking module of
tonicgRPC implementation -
nervemq
Portable, SQS-compatible message queue backed by SQLite
-
tower-timeout
Apply a timeout to requests, ensuring completion within a fixed time duration
-
pulz-executor
Abstractions of some async runtimes
-
rexecutor-sqlx
A robust job processing library
-
viz
Fast, robust, flexible, lightweight web framework for Rust
-
zino-amis
UI generator for amis
-
actix-tls
TLS acceptor and connector services for Actix ecosystem
-
async-imap-lite
Asynchronous imap
-
hyper-proxy2
A proxy connector for Hyper-based applications
-
crb-pipeline
CRB | Composable Runtime Blocks | Pipeline
-
pingora
A framework to build fast, reliable and programmable networked systems at Internet scale
-
ohkami_openapi
OpenAPI types for Ohkami - intuitive and declarative web framework
-
rxqlite-tests-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
holiday_event_api
The Official Holiday and Event API for Rust
-
cyper-core
Core adaptors and services for compio running on hyper
-
qunreliable
Datagram transmission of gm-quic
-
clia-ntex-files
Static files support for ntex web
-
logimesh
RPC Microservice 2.0 framework
-
tinyio
A tiny Rust concurrency runtime library
-
architect-tonic-build
Codegen module of
tonicgRPC implementation -
tracing-async2
Generic tracing layer library for working with tracing events including for async work
-
salvo_extra
Salvo is a powerful web framework that can make your work easier
-
async-std-test
Alternate implementation of the #[async_std::test] macro
-
peace_webi_output
Web interface output for the peace automation framework
-
tower-load-shed
Immediately reject requests if the inner service is not ready. This is also known as load-shedding.
-
ntex-grpc-codegen
GRPC Client/Server framework (codegen)
-
ant-libp2p-kad
Kademlia protocol for libp2p
-
tower-reqwest
Adapter between reqwest and tower-http crates
-
rillrate-system
RillRate agent for system monitoring
-
aggligator-wrapper-tls
Aggligator transport wrapper: TLS
-
openssh-sftp-error
Error type used when communicating with openssh sftp server
-
embedded-hal-async
An asynchronous Hardware Abstraction Layer (HAL) for embedded systems
-
ws_stream_wasm
A convenience library for using websockets in WASM
-
wtransport
WebTransport (over HTTP3) protocol
-
serf-core
A decentralized solution for service discovery and orchestration that is lightweight, highly available, and fault tolerant
-
direct-executor
An executor that directly executes futures, suitable for embedded environments
-
task-executor
A task executor
-
hexput-runtime
WebSocket runtime server for Hexput AST processing
-
retty
— an asynchronous Rust networking framework that makes it easy to build protocols, application clients/servers
-
build_async
Rust Macros to Unify Synchronous and Asynchronous Codebases
-
libp2p-wasm-ext
Allows passing in an external transport in a WASM environment
-
just-watch
Async watch channel
-
tokio-metrics
Runtime and task level metrics for Tokio applications
-
aggligator-transport-tcp
Aggligator transport: TCP
-
futures-macro-await
Definition of the
await!macro for thefuturescrate -
fluxus-sink-telegram
A Telegram sink component for the Fluxus stream processing framework, enabling real-time message delivery to Telegram channels and chats
-
ruchei-extra
Stream/Sink wrapper with extra data, as used by ruchei
-
crdb-server
Concurrently Replicated DataBase
-
volo-grpc
gRPC framework implementation of volo
-
ohkami_lib
internal library for Ohkami - intuitive and declarative web framework
-
rama-haproxy
rama HaProxy support
-
misanthropic
An async, ergonomic, client for Anthropic's Messages API
-
socketioxide
Socket IO server implementation in rust as a Tower Service
-
edge-ws
Async +
no_std+ no-alloc implementation of the Websockets protocol -
hyper-server
High level server for hyper and tower
-
discv5
p2p discv5 discovery protocol
-
swimos_format
SwimOS Formatting Utilities
-
zino-chatbot
Unified access to chatbot services for zino
-
bongonet-openssl
OpenSSL async APIs for Bongonet
-
ntex-service
ntex service
-
crb-morph
CRB | Composable Runtime Blocks | Morph
-
peace_cli
Command line interface for the peace automation framework
-
citadel_user
User backend library for the Citadel Protocol
-
multitask
An executor for running async tasks
-
liburing
Rust liburing#24bd087 raw bindings with basic tests
-
yaar-reactor
Non-blocking IO abstractions for building executors
-
tokio_websocket_server
A robust WebSocket server implementation with TLS support built on Tokio
-
tracing-forest
Preserving contextual coherence among trace data from concurrent tasks
-
fetchy
Async HTTPS fetch API built on pasts
-
crdb-cache
Concurrently Replicated DataBase
-
rama-tower
tower support for rama
-
ant-libp2p-webtransport-websys
WebTransport for libp2p under WASM environment
-
poem-mcpserver
MCP Server implementation for Poem
-
completeq-rs
An alternative to passing messages between asynchronous tasks
-
aldrin-broker
Broker library of Aldrin, a message bus for service-oriented RPC and interprocess communication
-
async-rustls-stream
An async tls stream library based on rustls and futures-io. Both for server/client.
-
libp2p-websocket-websys
WebSocket for libp2p under WASM environment
-
tower-sessions-moka-store
Moka session store for
tower-sessions -
libp2p-dcutr
Direct connection upgrade through relay