-
mio
Lightweight non-blocking I/O
-
tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
tokio-rustls
Asynchronous TLS/SSL streams for Tokio using Rustls
-
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
-
deadpool
Dead simple async pool
-
futures-timer
Timeouts for futures
-
polling
Portable interface to epoll, kqueue, event ports, and IOCP
-
futures
streams featuring zero allocations, composability, and iterator-like interfaces
-
async-task
Task abstraction for building executors
-
blocking
A thread pool for isolating blocking I/O in async programs
-
pollster
Synchronously block the thread until a future completes
-
bb8
Full-featured async (tokio-based) connection pool (like r2d2)
-
rdkafka
Rust wrapper for librdkafka
-
multer
An async parser for
multipart/form-datacontent-type in Rust -
async-broadcast
Async broadcast channels
-
async-std
Async version of the Rust standard library
-
interprocess
communication toolkit
-
tokio-serial
A serial port implementation for tokio
-
futures-concurrency
Structured concurrency operations for async Rust
-
suppaftp
A super FTP/FTPS client library for Rust
-
want
Detect when another Future wants a result
-
async_zip
An asynchronous ZIP archive reading/writing crate
-
async-process
Async interface for working with processes
-
io-uring
The low-level
io_uringuserspace interface for Rust -
amqprs
AMQP 0-9-1 client implementation for RabbitMQ
-
async-trait
Type erasure for async trait methods
-
tower-sessions
🥠 Sessions as a
towerandaxummiddleware -
paho-mqtt
The Official Eclipse Paho MQTT Rust Client Library. This is a wrapper around the Paho C library
-
keycloak
Admin REST API
-
ractor
A actor framework for Rust
-
cucumber
testing framework for Rust, with async support. Fully native, no external test runners or dependencies.
-
minus
An asynchronous data feedable terminal paging library for Rust
-
futures-locks
Futures-aware lock primitives
-
apalis
extensible multithreaded background job processing for Rust
-
monoio
A thread per core runtime based on iouring
-
actix
Actor framework for Rust
-
redis-async
An asynchronous futures based Redis client for Rust using Tokio
-
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
-
tokio-metrics
Runtime and task level metrics for Tokio applications
-
containerd-shim
containerd shim extension
-
asynchronous-codec
encoding and decoding frames using
async/await -
openraft
Advanced Raft consensus
-
local-channel
A non-threadsafe multi-producer, single-consumer, futures-aware, FIFO queue
-
failsafe
A circuit breaker implementation
-
futures-signals
Zero cost FRP signals using the futures crate
-
event-listener
Notify async tasks or threads
-
r2g_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
-
async-scoped
Spawn scoped (non 'static) asynchronous futures for async_std and tokio runtimes
-
tokio-graceful-shutdown
perform a graceful shutdown on a Tokio based service
-
tokio-graceful
util for graceful shutdown of tokio applications
-
unicycle
A scheduler for driving a large number of futures
-
futures-buffered
future concurrency primitives with emphasis on performance and low memory usage
-
eyeball
Add observability to your Rust types!
-
madsim
Deterministic Simulator for distributed systems
-
nb
Minimal non-blocking I/O layer
-
async-io
Async I/O and timers
-
stream-cancel
interrupting asynchronous streams
-
tor-rtcompat
Compatibility layer for asynchronous runtimes, used by Tor
-
fn_graph
Dynamically managed function graph execution
-
exponential-backoff
An exponential backoff generator with jitter
-
ws_stream_tungstenite
Provide AsyncRead/AsyncWrite over Tungstenite WebSockets
-
motore
modular and reusable components for building robust clients and servers. Motore is greatly inspired by Tower.
-
rxrust
Reactive Extensions
-
future-queue
Adapters to manage a queue of futures, where each future can have a different weight
-
async-shutdown
one-stop solution for async graceful shutdown
-
rusty_falcon
Rust bindings for CrowdStrike Falcon API
-
pty-process
spawn commands attached to a pty
-
hirun
A concurrent framework for asynchronous programming based on event-driven, non-blocking I/O mechanism
-
service-async
A Service like tower in async style
-
kameo
Fault-tolerant Async Actors Built on Tokio
-
tokio-native-tls
TLS/SSL streams for Tokio using native-tls giving an implementation of TLS for nonblocking I/O streams
-
async-walkdir
Asynchronous directory traversal for Rust
-
mio-serial
A serial port implementation for mio
-
fluvio-future
I/O futures for Fluvio project
-
kdbplus
Dual q/kdb+ interface for API to build a shared library and an IPC client
-
swiftide
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
futures-lite
Futures, streams, and async I/O combinators
-
lamellar
asynchronous tasking runtime for HPC systems developed in RUST
-
swiftide-integrations
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
tmq
ZeroMQ bindings for Tokio
-
calloop
A callback-based event loop
-
pharos
Observer pattern which generates a futures 0.3 stream of events
-
async-speed-limit
Asynchronously speed-limiting multiple byte streams
-
ipc-queue
FIFO queue described in fortanix-sgx-abi used for asynchronous usercalls
-
rocketmq-rust
Unofficial Rust implementation of Apache RocketMQ
-
wasm-bindgen-futures
Bridging the gap between Rust Futures and JavaScript Promises
-
crb
CRB | Composable Runtime Blocks
-
cxx-async
interoperability between C++ coroutines and asynchronous Rust
-
tokio-retry
Extensible, asynchronous retry behaviours for futures/tokio
-
poem-openapi
OpenAPI support for Poem
-
actix-web-flash-messages
Flash messages for actix-web applications
-
futures-bounded
bounding futures in size and time
-
scoped-futures
imposing upper bounds on Future lifetimes
-
syslog-rs
A native Rust implementation of the glibc/libc syslog
-
fvm_shared
Filecoin Virtual Machine shared types and functions
-
c-ares-resolver
An asynchronous DNS resolver, backed by c-ares
-
hydra
A framework for writing fault tolerant, highly scalable applications with the Rust programming language
-
safina
Safe async runtime
-
futures-rustls
Asynchronous TLS/SSL streams for futures using Rustls
-
reactive-mutiny
async Event-Driven Reactive Library with advanced & optimized containers (channels) and Stream executors
-
scc2
High-performance containers and utilities for concurrent and asynchronous programming
-
fang
Background job processing library for Rust
-
tokio_schedule
schedule tasks in tokio runtime
-
triggered
Triggers for one time events between tasks and threads
-
async-native-tls
Native TLS using futures
-
kafka
Rust client for Apache Kafka
-
tls-api
TLS API without implementation
-
faktory
API bindings for the language-agnostic Faktory work server
-
stream_throttle
Stream combinator, to limit the rate at which items are produced
-
dataloader
Facebook's DataLoader using async-await
-
conogram
An async wrapper for Telegram Bot API
-
trait-variant
working with impl traits in Rust
-
tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
partial-io
Helpers to test partial, interrupted and would-block I/O operations, with support for property-based testing through proptest and quickcheck
-
tor-rpcbase
Low level functionality for Arti's RPC service
-
async-tempfile
Automatically deleted async I/O temporary files
-
crosstown_bus
Event Bus with RabbitMQ for Rust
-
futures-rx
Rx implementations for the futures crate
-
interruptible
Stops a future producer or stream from producing values when interrupted
-
filebuffer
Fast and simple file reading
-
binary-stream
Binary stream reader and writer
-
mml-lib
Emacs MIME message Meta Language (MML)
-
a10
io_uring library
-
async-ssh2-lite
Asynchronous ssh2
-
another-rxrust
A different implementation than
rxRustfor easier use ofReactiveXinRust -
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
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
async-recursion
Recursion for async functions
-
stakker
A lightweight low-level single-threaded actor runtime
-
gix-actor
A way to identify git actors
-
deno_unsync
A collection of adapters to make working with Tokio single-threaded runtimes easier
-
poster
MQTTv5 client library written in Rust
-
twilight-http-ratelimiting
Discord REST API ratelimiter implementations for the Twilight ecosystem
-
celery
Rust implementation of Celery
-
pexels-cli
client for the Pexels API
-
runtimelib
Jupyter runtime library
-
async-lsp
Asynchronous Language Server Protocol (LSP) framework based on tower
-
executor-trait
A collection of traits to define a common interface across executors
-
tiny_kafka
A tiny Kafka client library with producer and consumer functionalities
-
compio
Completion based async runtime
-
aqueue
fast speed thread safe async execute queue
-
round-based
Driver for MPC protocols
-
ractor-supervisor
Supervisor module for ractor framework
-
lazy-pool
Experimental lazy object pool
-
daktronics-allsport-5000
decoders for the Daktronics All Sport 5000's serial output
-
dynosaur
Dynamic dispatch for return position impl traits and async in Rust
-
call-agent
A multimodal chat API library with tool support, OpenAI API compatible
-
tiny-tokio-actor
tiny actor library on top of tokio
-
delay_timer
Time-manager of delayed tasks. Like crontab, but synchronous asynchronous tasks are possible, and dynamic add/cancel/remove is supported.
-
ghost_actor
GhostActor makes it simple, ergonomic, and idiomatic to implement async / concurrent code using an Actor model
-
ferrisgram
An elegent rust client for the Telegram Bot API
-
blockstore
An IPLD blockstore capable of holding arbitrary data indexed by CID
-
rs-event-emitter
simulate promise implementation for rust
-
async-fn-stream
Lightweight implementation of
async-streamwithout macros -
popol
Minimal non-blocking I/O
-
hypercore
Secure, distributed, append-only log
-
multishot
An async, lock-free, reusable channel for sending single values to asynchronous tasks
-
async-ringbuf
Async SPSC FIFO ring buffer
-
rxr
Reactive extensions for event-driven applications
-
peace_item_model
Data types for resource interactions for the Peace framework
-
async-graphql-actix-web
async-graphql for actix-web
-
countio
Byte counting for std::io::{Read, Write, Seek} and its async variants from futures and tokio
-
deduplicate
caching, asynchronous, request deduplication
-
swiftide-agents
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
poll-promise
Poll the result of an async operation in a game or immediate mode GUI
-
tigerbeetle-unofficial
Safe high level async bindings to tigerbeetle client library
-
wg
Golang like WaitGroup implementation for sync/async Rust
-
tokio-retry2
Extensible, asynchronous retry behaviours for futures/tokio
-
rust-parallel
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
tokio-stream
work with
Streamandtokio -
apis
Reactive, session-oriented, asynchronous process-calculus framework
-
open-coroutine
efficient and generic stackfull-coroutine library
-
turmoil
Simulation testing framework for distributed systems
-
get_chunk
File iterator or stream with auto or manual chunk size selection
-
krecik
Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL
-
lcode
An application of terminal write leetcode.一个终端刷力扣的应用
-
genawaiter
Stackless generators on stable Rust
-
tros
Your tros from tarantool TX thread to tokio(..and others!)
-
mobc
A generic connection pool with async/await support
-
hypercore-protocol
Replication protocol for Hypercore feeds
-
pi-async-rt
Based on future (MVP), a universal asynchronous runtime and tool used to provide a foundation for the outside world
-
crossmist
Efficient and seamless cross-process communication, both synchronously and asynchronously
-
mail-message
A program for easy, quick, and fault tolerant sending of emails from the command line
-
yt-dlp
⚙️ A Rust library (with auto dependencies downloading) for yt-dlp 🎬️
-
ya-gcp
APIs for using Google Cloud Platform services
-
napi-calm-down
N-API bindings
-
flourish
Convenient and full-featured signals for Rust
-
irelia
wrapper around the native LoL APIs
-
rocketmq-client-rust
Apache rocketmq client
-
fvm_actor_utils
Utils for authoring native actors for the Filecoin Virtual Machine
-
tokio-io-utility
Some helper functions for tokio::io
-
actix-multipart-rfc7578
multipart/form-data (RFC7578) for Actix
-
ractor_actors
actors built with Ractor
-
kube-lease-manager
Ergonomic and reliable leader election using Kubernetes Lease API
-
rocketmq-filter
A filter for RocketMQ messages
-
okstd
The standard library that's ok
-
lazy_async_promise
Primitives for lazily getting data from futures with tokio for immediate mode guis
-
tokio-pipe
Asynchronous pipe(2) library using tokio
-
futuresdr
An Experimental Async SDR Runtime for Heterogeneous Architectures
-
peekable
reader and async reader, which enhance your network programming experience
-
async_cache
Async refresh cache
-
debounced
building delayed
Futures and debouncedStreams that wait a given duration before yielding the most recent item -
fundamentum-edge-daemon
The supported way to access Fundamentum's ecosystem from linux devices
-
containerd-client
GRPC bindings to containerd APIs
-
dptree
An asynchronous event dispatch mechanism for Rust
-
ate
Distributed immutable data store with strong encryption and authentication
-
mio_wasi
Lightweight non-blocking IO
-
springtime-di
Dependency injection framework based on automatic component discovery and runtime autowiring
-
ollie
An abstraction layer on top of lapin, to align with traditional HTTP API routing
-
pijul
A distributed version control system
-
array__ops
A selection of useful array operations
-
async-cuda
Async CUDA for Rust
-
b2_backblaze
basic async library to upload small files to backblaze b2 service
-
llm_client
easiest Rust interface for local LLMs
-
local-waker
A synchronization primitive for thread-local task wakeup
-
async-dropper
The least-worst ad-hoc implementation of AsyncDrop as a Derive macro
-
async-object-pool
object pool implementation that uses asynchronous synchronization primitives only
-
genawaiter2
Stackless generators on stable Rust
-
openrouter_api
client library for the OpenRouter API
-
tcpclient
Asynchronous tcpclient based on aqueue actor
-
futures-util
Common utilities and extension traits for the futures-rs library
-
drop-stream
A stream that wraps another stream with a closure that is called once it is dropped
-
postage
An async channel library
-
async-io-mini
Async I/O fork for embedded systems
-
async_smux
Asynchronous smux multiplexing library
-
rust-utils
Various utility routines used in the rust programs I have written
-
certsd
automated, asynchronous LE certificate issuer
-
mapped_futures
A collection of futures based on FuturesUnordered that supports insertion, removal and mutation of futures by key
-
stilgar
A lightweight, no-fuss, drop-in replacement for Rudderstack
-
distributed-scheduler
A distributed cronjob library
-
mikrotik-rs
Asynchronous Rust library for interfacing with MikroTik routers
-
kompact
Kompics component model combined with the Actor model
-
netidx-protocols
Protocols built on top of netidx
-
tokio-scheduler-rs
JobScheduler written with tokio runtime, automatic retry, hook and custom storage supported
-
async_cell
A Cell<Option<T>> that you can await on
-
nuclei
Proactive IO & runtime system
-
async-event-emitter
Lightweight AsyncEventEmitter
-
monzo-lib
async Monzo client in pure rust
-
tokio-process-tools
Interact with processes spawned by tokio
-
lighthouse-client
Client SDK for Project Lighthouse
-
keyring-lib
High-level, asynchronous API for keyring-rs, a cross-platform Rust library to manage credentials
-
tokio-io-timeout
Tokio wrappers which apply timeouts to IO operations
-
rdkafka-sys
Native bindings to the librdkafka library
-
cancel-safe-futures
Alternative futures adapters that are more cancellation-aware
-
gprs
A set of filtered and optimized Rust libraries creates a foundation for building modern web frameworks
-
rabbit-auto
Wrappers for lapin publishers and consumers
-
firecracker-rs-sdk
🧨🦀🚀 The Firecracker Rust SDK. A pure Rust crate for interacting with Firecracker.
-
fama
Pipeline Manager
-
glommio
thread-per-core crate that makes writing highly parallel asynchronous applications in a thread-per-core architecture easier for rustaceans
-
interthread
Auto implementation of the Actor Model
-
taskline
distributed task queue for Rust
-
eureka-mmanager
An Actix actor collection for downloading manga, chapters, covers from Mangadex
-
keen-retry
-- yet powerful -- zero-cost-abstractions & zero-copy lib for error handling & recovery
-
coc-rs
wrapper around the Clash of Clans public API
-
stopper
an async stream and future stopper mechanism
-
decoyssh
A compact and portable SSH tarpit server
-
mini_exercism
Minimalistic Rust library to interact with the Exercism.org APIs
-
z_osmf
z/OSMF Client
-
girlboss
async job manager with progress tracking
-
quick-protobuf-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and quick-protobuf
-
rs_ctx
Context propagation for rs framework
-
flatline
ssh-2.0 client library
-
async_executors
Implements Spawn, SpawnLocal and SpawnHandle for commonly used executors
-
scoped-stream-sink
Easy way to make streams and sinks
-
notifier_hub
cannal subscribtion system
-
libuv-sys-lite
Tiny, raw bindings to libuv without linking to it
-
nebkor-maelstrom
synchronous client for creating Maelstrom distributed clients
-
apalis-sql
SQL Storage for apalis. Use sqlite, postgres and mysql for background job processing
-
kube-coordinate
Kubernetes leader election using the coordination.k8s.io API
-
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…
-
monoio-codec
Codec for Monoio
-
effectum
An embeddable task queue based on SQLite
-
unkey
An asynchronous Rust SDK for the Unkey API
-
async-socks5
An async/.await SOCKS5 implementation
-
reactio
Low-Latency Event Driven Nonblocking Reactor Pattern
-
peace_cli
Command line interface for the peace automation framework
-
crb-agent
CRB | Composable Runtime Blocks | Agent
-
actix-casbin
An Actix actor for casbin
-
futures-scopes
Runtime agnostic, nestable, scopes for spawning non-static futures
-
bb8-lapin
r2d2-lapin, but for async tokio based connections
-
my-awesome-rabbitmq-lib
working with RabbitMQ and asynchronous operations
-
minior
Ergonomic Minio Client
-
tokio-test
Testing utilities for Tokio- and futures-based code
-
xelf
A versatile Rust toolkit for self-use
-
swiftide-query
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
wgpu-async
Converts some WGPU callback methods to async methods
-
tor-rtmock
Testing mock support for tor-rtcomapt
-
pgp-lib
High-level, asynchronous API for rPGP, a pure Rust implementation of OpenPGP
-
embedded-runtime
A tiny async runtime for embedded devices
-
async-borrow
Async compatible ownership semantics using futures instead of lifetimes
-
truba
The minimal tokio runtime based actors for Rust
-
synchronized-writer
A tiny implement for synchronously writing data
-
asteroid-mq
An embeddable message queue system
-
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
-
kioto-serial
Provide serial port I/O using tokio
-
s3tui
TUI application for multiple s3 account operations
-
messagebus
allows intercommunicate with messages between modules
-
c-ares
wrapper for the c-ares library, for asynchronous DNS requests
-
discro
DISCRete Observables for asynchronous Functional Reactive Programming (FRP)
-
tipsy
Cross-platform IPC for Tokio
-
gasket
Staged Event-Driven Architecture (SEDA) framework
-
tower-sessions-redis-store
Redis session store for
tower-sessions -
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.
-
elfo
An asynchronous distributed actor framework with robust observability
-
freedom-api
Freedom API for Rustaceans
-
sipper
A type-safe future that can notify progress
-
async-mcp
Async Implementation of Model Context Protocol (MCP)
-
tokio-par-util
running computations in parallel on top of Tokio
-
async-transmit
Trait for transmitting data to peers asynchronously
-
winctx
A minimal window context for Rust on Windows
-
async-change-tracker
reactive change notifications using futures
-
retry-if
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
batch-channel
async channel that reduces overhead by reading and writing many values at once
-
danube-client
The async client for Danube Messaging Broker platform
-
scuffle-context
Go-like context utilities for Rust
-
ntex-grpc
GRPC Client/Server framework
-
eventuals
Eventually consistent values
-
ethercat-device-control
A command line utility to control Ethercat devices
-
sn_sdkg
Safe Network Synchronous Distributed Key Generation: enables dealerless section key generation
-
next-gen
Safe generators on stable Rust
-
futures-retry
Retry your Futures and Streams!
-
infect
Intent/effect/task - A variation on the Model View Intent (MVI) and State Action Model (SAM) paradigms
-
stackfuture
wrapper around futures that stores the wrapped future in space provided by the caller
-
restate-sdk
Restate SDK for Rust
-
whirlwind
Collection of thread-safe, asynchronous data structures
-
mal-api
An asynchronous MyAnimeList (MAL) API library for Rust
-
tower-batch-control
Tower middleware for batch request processing
-
process-lib
Cross-platform, asynchronous Rust library to run commands in pipelines
-
splaycast
Stream-specific broadcast channel
-
ruloom
A thin wrapper around 'corosensei' that provides support for stackful coroutines in Rust (like Loom in Java or goroutines in golang)
-
etcdv3client
etcdv3 client
-
rio
GPL-3.0 nice bindings for io_uring. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
delouse
will expose opinionated debugging stubs most useful for tokio based async programs
-
async-time-mock-smol
Mockable time for use in async runtimes (smol compatibility)
-
ics-watcher
A lightweight crate for monitoring ICS files or links and detecting changes, additions, and removals
-
agnostic
A Sans-I/O abstraction layer for any async runtime
-
future-local-storage
An init-once-per-future cell for thread-local values
-
est
Extensions for the rust Standard library and Tokio
-
apocalypse
actor framework for Rust
-
async-shared-timeout
Async timeout that can be reset and shared
-
rseip
Ethernet/IP (CIP) client in pure Rust
-
upc
USB packet channel (UPC): provides a reliable, packet-based transport over USB
-
async_io_stream
IntoAsyncRead on steriods
-
deepseek_rs
client library for the DeepSeek API
-
qbittorrent_rust
An asynchronous library to interface with the qbittorrent WeBUI API
-
recurring-tasks
Define tasks and run them in an app forever, ala cronjobs. And don't run already/still running tasks.
-
fundamentum-sdk-mqtt
MQTT client targeting Fundamentum IoT's MQTT broker
-
some_executor
A trait for libraries that abstract over any executor
-
async-ffi
FFI-compatible
Futures -
meltdown
A lightweight service manager to help with graceful shutdown of asynchronous applications
-
co_managed
Create managed sub coroutines. Managed sub coroutines will be cancelled when the parent exit
-
tokio-shutdown
Wait for a stop signal across multiple threads
-
brig
mar here, Briganteen—General Sir A. I. Magnus, the flapper-
-
basu
Eventbus crate with sync and async features
-
vkapi2
vk api wrapper for rust
-
async_zmq
Async version for ZeroMQ bindings
-
pgboss
job queueing service
-
miow
A zero overhead I/O library for Windows, focusing on IOCP and async I/O abstractions
-
translators
Free Google Translator without API key and limits
-
streamunordered
An efficient async stream multiplexer
-
godot_tokio
The tokio-async runtime wrapped in a gdextention object to be used as an engine singleton in your gdext project
-
pin-utils
pinning
-
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
-
senders_receivers
Senders/Receivers implementation for Rust
-
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.)
-
cache_loader_async
A thread safe loading cache with async loader functions based on tokio
-
fastimer-driver
implements a timer driver that can work with any async runtime scheduler
-
elegant-departure
simplify graceful shutdown
-
duplicate-checker
A duplicate file checker
-
named-retry
retrying fallible asynchronous operations
-
futures-signals-ext
Extension to futures-signals: MutableOption with combinators, spawning, predicate driven selections from SignalVec
-
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.
-
commonware-log
Commit to a secret log and agree to its hash
-
simple-git
git interface for gix suitable for async context (with tokio)
-
vmcircbuffer
Double Mapped Circular Buffer
-
tools_interface
Abstractions of serveral Wikipedia/Wikimedia/Wikidata-related tools
-
xjbutil
A xjbly created utility library for my own use
-
fil_actors_runtime
System actors for the Filecoin protocol
-
tokio-io-rewind
rewind tokio::io::AsyncRead and tokio::io::AsyncWrite streams
-
rspack_futures
rspack futures
-
hedwig
message bus for Rust
-
sacs
Async Cron Scheduler for Tokio
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
async-codec
creating async codecs
-
tokise
An asynchronous runtime compatible with WebAssembly and non-WebAssembly targets
-
disintegrate
build event-sourced applications
-
prin
reverse proxy terminal utility
-
rusturn
TURN server and client
-
constellation-rs
Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs
-
resident-utils
Resident program library
-
pierport
Urbit pier import protocol implementation
-
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
-
bisync
write async-generic code
-
transform-stream
Lightweight async stream wrapper
-
nosy
Change notification / observation / broadcast channels, with filtering and coalescing. no_std compatible.
-
aranya-policy-ifgen
Tools for generating Rust interfaces to Aranya Policies
-
async-tls
Asynchronous TLS/SSL streams using Rustls
-
coasys_juniper
GraphQL server library
-
futures-timeout
that provides timeouts for futures and streams
-
stressed
Universal CLI stress tester for competitive programming
-
automerge_repo
automerge-repo
-
tokio-muxt
Timer for a limited set of events that multiplexes over a single tokio Sleep instance
-
gem-rs
that serves as a wrapper around the Google Gemini API, providing support for streaming
-
uactor
The fastest and most modular actor system that doesn't force you to pay for what you don't need
-
tokio-rayon
Mix async code with CPU-heavy thread pools using Tokio + Rayon
-
eventbuzz
A safe, fast, concurrent event publish/subscribe system based on tokio(async), inspired by Spring events
-
nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
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)…
-
tubetti
Serve &[u8] data at a localhost url with minimal configuration
-
xscript
writing robust shell-script-like programs and running commands with ease
-
libmqm-default
IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) structure defaults
-
aggligator-transport-bluer
Aggligator transport: Bluetooth on Linux
-
rasi-mio
a rasi drivers implementation base on mio
-
openraft-memstore
A in-memory implementation of the
openraft::RaftStoragetrait -
rustix-uring
The low-level
io_uringuserspace interface for Rust -
remi
🐻❄️🧶 Asynchronous Rust crate to handle communication between applications and object storage providers
-
abscissa_tokio
Support for launching Tokio runtimes within Abscissa applications
-
read_until_slice
AsyncBufRead::read_until extension to take a slice as a delimiter instead of a single u8
-
letslogic
providing interaction with the Let's Logic API
-
kafka-threadpool
An async rust threadpool for publishing messages to kafka using SSL (mTLS) or PLAINTEXT protocols
-
containerd-shim-protos
TTRPC bindings for containerd shim interfaces
-
cbsk_socket_tokio
socket callback tool by tokio
-
shutdown
can be used to gracefully exit (part of) a running program
-
mm1-node
M/M/1! Queueing, do you speak it?!
-
kuska-handshake
Secure Scuttlebutt handshake + boxstream library
-
async-injector
Reactive dependency injection for Rust
-
awak
A small async runtime for Rust
-
pubnub
SDK for Rust
-
polkadot-omni-node
Generic binary that can run a parachain node with u32 block number and Aura consensus
-
hyperbee
Peer to Peer B-tree
-
actix-rt
Tokio-based single-threaded async runtime for the Actix ecosystem
-
mulligan
A flexible retry library for Rust async operations with configurable backoff strategies and jitter
-
pistones
An wrapper for the Piston code execution engine
-
async-scgi
Async SCGI Client & Server
-
deno_os
OS specific APIs for Deno
-
async-tensorrt
Async TensorRT for Rust
-
ipc-rpc
A wrapper over servo/ipc-channel which provides many high level features
-
cassette
single-future, non-blocking executor intended for building state machines
-
tokio-rusqlite-new
Asynchronous handle for rusqlite library
-
linemux
providing asynchronous, multiplexed tailing for (namely log) files
-
makepad-futures-legacy
Makepad futures legacy
-
wait
Syntactic sugar for calling async functions outside of an async context
-
tokio_kcp
A kcp implementation for tokio
-
async-oneshot-channel
async oneshot channel implementation
-
stream-wave-parser
The
stream-wave-parseris a crate that treats a stream from WAVE file -
serial-thread
Asynchronous, multithreaded serial port communication library using mpsc::cjhannels or async-channels for efficient data handling
-
wired_handler
Wired's handler library
-
proptest_async
proptest macro supporting async tests
-
scylla-rs
An async ScyllaDB driver built on an actor-model framework
-
rustygram
minimal and blazing fast telegram notification framework for Rust
-
peace_resource_rt
Runtime resources for the peace automation framework
-
bus_queue
Lock-free Bounded non-Blocking Pub-Sub Queue
-
futures-map
Futures-based and hashmap-based alogrithms
-
haalka_futures_signals_ext
vendored version of MoonZoon's futures_signals_ext, as it is yet to be released as a crate
-
lemmy_db_views_actor
A link aggregator for the fediverse
-
madsim-rdkafka
The rdkafka simulator on madsim
-
kafru
Python Celery-inspired queuing library for Rust, using cron for scheduling and SurrealDB for storing queues, metrics, and schedules
-
napi_ext
Extends napi-rs with the ability to run local futures
-
rendezvous
Easier rendezvous channels for thread synchronization
-
futures-io
The
AsyncRead,AsyncWrite,AsyncSeek, andAsyncBufReadtraits for the futures-rs library -
rocketmq-runtime
Unofficial Rust implementation of Apache RocketMQ
-
procsem
Semaphore used to lock thread/task-spanning sequence of operations
-
async_async_io
AsyncRead,AsyncWritetraits but withasync fnmethods -
bounded_join_set
A Concurrency-Limited JoinSet for Tokio
-
ctf-pwn
Pwn utilities for Rust
-
crb-send
CRB | Composable Runtime Blocks | Send
-
vss
A dead simple library to allow for easily reused shutdown signal handling
-
rust-paper
Rust Wallpaper manager from ( https://wallhaven.cc/ ) for Linux/UNIX only
-
socksv5
SOCKS v4a and v5 basic building blocks to build your own async SOCKS application
-
termusix
A terminal-based music player with a user-friendly terminal UI, built with Rust
-
screeps-async
Tick-aware Async runtime for Screeps
-
reactor-trait
A collection of traits to define a common interface across reactors
-
dusk-node-data
Types used for interacting with Dusk node
-
async-executor
Async executor
-
replay-channel
A broadcast channel where new receivers replay all past messages before receiving new ones
-
ocpp-client
OCPP Client Implementation. Use this library to implement an OCPP charge point
-
monoio-compat
A compat wrapper for monoio
-
tokactor
A actor model framework wrapped around tokio
-
php-tokio
Use any async Rust library from PHP!
-
coerce-redis
Redis actor persistence provider for Coerce. Supports event sourcing and snapshots
-
singleflight-async
Singleflight in async style
-
extend_mut
extending exclusive references
-
bsky-cli
CLI application for Bluesky using ATrium API
-
kapacitor-udf
creating Kapacitor User Defined Functions (UDFs)
-
redis-work-queue
A work queue, on top of a redis database, with implementations in Python, Rust, Go, Node.js (TypeScript) and Dotnet (C#)
-
task_forge
A flexible and simple task pool for asynchronous execution
-
tower-memlim
Tower based middleware layer to limit requests based on the host's computer memory usage
-
spawns
Async runtime agnostic thread context task spawner for Rust
-
thread-waker
Waker implementation using current thread token
-
async-rdma
async wrapper for RDMA ibvers lib
-
decrypt-cookies
A decrypt browser crate
-
deferred-future
模仿 jQuery.Deferred()，允许从 Future 实现类实例的外部对正在 pending 的 Future 对象进行 resolve 或 reject 处理。
-
livekit-runtime
Async runtime compatibility layer for LiveKit
-
ordered-stream
Streams that are ordered relative to external events
-
timer-lib
A feature-rich Rust library for creating and managing timers
-
persway
Sway IPC daemon
-
pi_async
Based on future (MVP), a universal asynchronous runtime and tool used to provide a foundation for the outside world
-
ector
open source async, no-alloc actor framework for embedded devices
-
tokio-send-fd
A wrapper for tokio::net::UnixStream to send file descriptors
-
fb_futures_ext
future crate extensions
-
wasmedgeup
An installer for the Wasmedge runtime and plugins
-
mio-pidfd
mio support for Linux's pidfd
-
tokio-hrtime
Hires timers for tokio
-
hakuban
Data-object sharing library
-
woddle
An async, synchronized, database-backed Rust job scheduler
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
mosquitto-rs
An async MQTT client based on libmosquitto
-
jni-utils
Extra Utilities for JNI in Rust
-
futures-boring
SSL streams for Futures built on top of the BoringSSL
-
signal-hook-tokio
Tokio support for signal-hook
-
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) -
esrc
Primitives for implementing event sourcing and CQRS systems
-
gcp_access_token
pure rust implimentation to get google cloud access token for servers with service account credentials
-
async-rate-limit
Common traits for rate limiting and implementations in async contexts
-
async_counter
Counter that implements a future to await on specific value
-
async-defer
Asynchronous Deferred Calls
-
native_messaging
Async implementation of MDN native messaging. Provides the ability to install host manifest.
-
asynk
Multithread asynchronous runtime and reactor
-
hass-rs
An async websocket client for Home Assistant
-
wae
Async executor that use Winit event loop
-
eyeball-im
Observable collections based on the
imcrate -
borrow_mutex
Async Rust Mutex which does not require wrapping the target structure
-
yaaral
async runtime abstraction library
-
zephyrus
A slash-command framework meant to be used with twilight
-
smol-potat
Proc macro for smol runtime
-
spin_on
inefficient Future executor
-
wasmcloud-interface-factorial
Interface library for the wasmcloud factorial capability, wasmcloud:example:factorial
-
kioto-uring-executor
multi-threaded wrapper around tokio-uring
-
ractor_cluster
Distributed cluster environment of Ractor actors
-
patharg
Treat "-" (hyphen/dash) arguments as stdin/stdout
-
asynclog
asynchronous log library
-
rocketmq-common
Apache rocketmq common
-
tokio-task-scheduler
A non-blocking task scheduler for Rust with fluent API, supporting interval-based and cron-like scheduling
-
rmp-futures
Async Rust MessagePack and MessagePack-RPC
-
upstox-rust-sdk
SDK to access Upstox's Uplink v2 APIs programmatically
-
n0-future
Number 0's way of doing rust futures. Re-exports what we think are useful abstractions and good implementations.
-
pinky-swear
Futures and async/await-ready Promises
-
zookeeper-async
An async ZooKeeper client
-
orsomafo
Event dispatcher crate
-
lsp-async-stub
An LSP server stub for futures
-
kx-utils
Common utils incubator
-
busstop
A command and query bus
-
alicemq
Wapper for the amqprs rabbitMQ library
-
rabbit_mqr
Extremely Simplified RabbitMQ Client
-
mpi-sys
Message Passing Interface bindings for Rust
-
futures-test
Common utilities for testing components built off futures-rs
-
actix-mqtt-client
A MQTT client based on the actix framework
-
tokio-tower
Bridging the protocol gap between Tokio and Tower
-
par-stream
Asynchronous parallel streams analogous to rayon
-
gh-pinned-rs
Fetch pinned repositories from github
-
pochta
Addressable channel registry
-
tokio-stomp-rs
Asynchronous streaming STOMP client fork
-
coroutine-state
Inspect the state of a Future created by an async function
-
torznab-toolkit
A safe, multi-threaded, async toolkit for adding Torznab APIs to programs
-
send-future
Ergonomic and performant fix for https://github.com/rust-lang/rust/issues/96865
-
notify-future
Support asynchronous notification completion future
-
pasts
Minimal and simpler alternative to the futures crate
-
act_rs
Act.rs is an actor library built to be used with the standard library and Tokio
-
dwn
Decentralized Web Node
-
monoio-rustls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
async-rate-limiter
Implements a token bucket algorithm that can be used to limit API access frequency. Written in pure Rust.
-
minos
Authorization library
-
handle
Trait for asynchronous context pipeline
-
bb8-valkey
A connection pool for Valkey
-
tokio-socketcan
Asynchronous Linux SocketCAN sockets with tokio
-
ksoft
KSoft.SI api wrapper written in pure Rust
-
secret-lib
Cross-platform, asynchronous Rust library to retrieve secrets from different sources
-
aws-parameters-and-secrets-lambda
Cache AWS Secrets Manager secrets in your AWS Lambda function
-
diazene
Actor for Rust (with Tokio)
-
tower-sessions-rusqlite-store
(tokio-)rusqlite session store for
tower-sessions -
ultra-batch
Tokio-based library to batch and cache database queries or other data lookups
-
openaction
creating plugins for the OpenAction API
-
ringlog
A fast and lightweight non-blocking logging framework
-
readwrite
Combine Read and Write into a single Read+Write object
-
slim-futures
Asynchronous tools that intends for smaller binary size
-
aoc_leaderbot_lib
Support library for aoc_leaderbot, an Advent of Code leaderboard-watching bot
-
short_future
Future with shorter lifetime for async closures
-
typed-emitter
Typed Async event emitter
-
ply_jobs
ability to run background jobs on a schedule
-
tbot
Make cool Telegram bots with Rust easily
-
tokio-lxi
LXI protocol abstractions for Tokio
-
cancellation-token
C#'s CancellationToken API
-
synch
A basic asynchronous timer implementation that uses the cortex-m SysTick peripheral
-
tower-lsp-f
Language Server Protocol implementation based on Tower
-
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.
-
async-time-mock-async-std
Mockable time for use in async runtimes (async-std compatibility)
-
tokio_delayed_queue
Asynchronous delayed queue for Tokio runtime
-
tokio_gen_server
Elixir/Erlang-GenServer-like actor on the Tokio runtime
-
webex
Interface to Webex Teams REST and WebSocket APIs
-
tor-log-ratelim
Facility for rate-limiting log messages in Arti
-
lichess-api
client for Lichess API v2.0.0
-
asynk-strim
Lightweight stream generator library
-
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…
-
multi-readers
Combining multiple readers
-
lua_actor
Lua Actor for Rust(sync/async)
-
background-jobs-sled
Sled storage backend for background-jobs
-
piscina
generic pool that supports both sync and async
-
parquet-format-async-temp
Temporary crate containing thrift library + parquet definitions compiled to support read+write async
-
capp
Common things i use to build Rust CLI tools for web crawlers
-
stream-reconnect
Stream-wrapping traits/structs that automatically recover from potential disconnections/interruptions
-
pegy
A derive based parser generator
-
async_shared
signal implementation
-
re_byte_size
Calculate the heap-allocated size of values at runtime
-
flurx
Create reactive asynchronous data flow
-
tokio-zmq
Futures abstractions for ZeroMQ on the Tokio event-loop
-
libublk
building linux block device in userspace
-
git-next-server-actor
Server actor for git-next, the trunk-based development manager
-
suika_utils
A small utility library for the suika web stack
-
moro-local
Experimental structured concurrency support for async Rust (similar to trio's nurseries). Works with non-Send futures on stable Rust.
-
dafny-runtime
runtime support library for Rust code gerated from Dafny
-
tonic-side-effect
Tower service that can monitor if a Tonic request frame was produced prior to error
-
async_sync
handling asynchronous and synchronous operations seamlessly
-
isoprenoid
signals runtime framework backing flourish
-
zeroconf-tokio
Tokio-based wrapper around the zeroconf crate, which provides mDNS service discovery and registration capabilities
-
xtra
A tiny actor framework
-
async-graphql-tide
async-graphql for tide
-
mlua-luau-scheduler
Luau-based async scheduler, using mlua and async-executor
-
corcovado
Non-blocking IO library
-
tokio-serde-cbor
Integration of serde_cbor into tokio-io, to allow sending CBOR encoded frames across network (and possibly through other transports)
-
aa-sms
Send messages from with Andrews & Arnold’s SMS API
-
async-observable
Async & reactive synchronization model to keep multiple async tasks / threads partially synchronized
-
passivized_vault_client
Vault Client - initialize and monitor Hashicorp Vault nodes
-
callback-result
Assists in converting the callback function's method of obtaining results into the await method
-
tokio-util
Additional utilities for working with Tokio
-
rspl
A stream processor language
-
eventastic_postgres
An example postgres event store for eventastic
-
event_iterator
Asynchronous lending iterator
-
monoio-thrift
Thrift for Monoio
-
cyberex
Utilities Library
-
stund
An SSH tunnel maintenance daemon
-
platoon
An experimental mini async runtime
-
agnostik
Executor Agnostic Runtime that can run your futures with your favourite Executor
-
pcap-async
Async/Stream Extensions for libpcap
-
miniloop
The simpliest async executor without heap memory allocation
-
aoc_leaderboard
Strongly-typed wrapper for Advent of Code leaderboard data
-
async-unsync
asynchronous, unsynchronized (thread-local) channels and semaphores
-
noosphere-collections
Collection data types that are needed by an efficient implementation of Noosphere's IPLD data structures
-
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.
-
crossword_generator
generating crossword from provided words
-
stop-token
Experimental cooperative cancellation for async Rust
-
knien
Typed RabbitMQ interfacing for async Rust
-
messagepack-async
functional library for read/writing messagepack with tokio
-
ng-repo
Repository library of NextGraph, a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
libevent-sys
Rust FFI bindings to the libevent library
-
async-fs
Async filesystem primitives
-
scipio
A set of utilities to allow one to write thread per core applications
-
async_zip_futures
An asynchronous ZIP archive reading/writing crate using futures-rs
-
aiven_rs
sdk to interact with aiven-cloud apis
-
baildon
B+Tree library
-
futures-executor
Executors for asynchronous tasks based on the futures-rs library
-
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.
-
shadocal
A blazingly fast, Google calendar (more in future) event formatter webserver tool
-
v_exchanges
Implementations of HTTP/HTTPS/WebSocket API methods for some crypto exchanges, using crypto-botters framework
-
miau
Async aware and extensible layered configuration system
-
async-wormhole
Async calls across non-async functions
-
moxie
Incremental runtime for interactive software
-
tokio-nats
Async-await ready NATS library
-
tcp-channel-client
Asynchronous tcpclient based on aqueue actor
-
swiftide-indexing
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
msft-runtime
Windows async helpers
-
sonor
controlling sonos speakers
-
sodium
FRP (Functional Reactive Programming)
-
fil_builtin_actors_builder
WASM builder for builtin Filecoin actors
-
bb8_surrealdb2
Surrealdb support for the async bb8 connection pool
-
night
A scalable Task Queue for executing asynchronous tasks in topological order
-
dialectic-compiler
Session type macro compiler for the Dialectic crate
-
google-cloud-ai
A gRPC-based crate designed to interact with Google Cloud AI API
-
async-select
select!multiplex asynchronous futures simultaneously -
maelstrom-util
by non-WASM Maelstrom libraries and binaries
-
tactix
Actor Model based on Tokio
-
pollable-map
Utilites for storing futures and streams in as a pollable map
-
cb_fut
Call function that return value via callback without a callback
-
selectme
A fast and fair select! macro for asynchronous Rust
-
any-mpsc
An mpsc that allows arbitrary types to be passed through
-
futures_ringbuf
Mock Type implementing AsyncRead/AsyncWrite for testing and examples
-
tub
Async Pool
-
peace_flow_model
Flow data model for the peace automation framework
-
clia-rcproxy
A lightweight, fast and powerful Redis Cluster Proxy written in Rust
-
lending-stream
A lending version of Stream
-
async-utf8-decoder
Convert AsyncRead to incremental UTF8 string stream
-
acu
building asynchronous actors
-
peace-performance
osu! pp & stars calculation. Peace edition
-
rx_rust_mp
A protoype implementation of the ReactiveX API in Rust using a message passing approach
-
foreback
Future adapters for running aditional work in the background
-
async_logger
Asyncronous logger allows writing arbitrary slices to a memory buffer, which then processed by a writer in it's own thread
-
textmode
terminal interaction library backed by a real terminal parser
-
kumoko
asynchronous server/client crate built on tokio for easy two-way streaming
-
oneshot-handshake
providing a symmetric one time use channel type
-
sn_consensus
Safe Network Membership: Enables nodes to dynamically join and leave a section
-
rocketmq-remoting
Apache rocketmq remoting
-
stdout-channel
Write stdout to an async queue
-
pwner
Process Owner crate that allows ergonomic access to child processes
-
trale
minimalistic Rust async executor using io_uring for efficient, correct task execution
-
yamaha-rcp
Remote control of Yamaha mixing consoles using TCP/IP networking
-
hypixel_api
Generic wrapper around the hypixel api (automatic rate-limiting on client-side)
-
sparkle-convenience
A wrapper over Twilight designed to make it more convenient to use
-
wrtc
Wrapper around webrtc-rs library, focused on developer experience
-
prometheus-utils
built on top of the prometheus crate
-
mm1
M/M/1! Queueing, do you speak it?!
-
pupactor
actor model library built with tokio
-
kafka-rs
Native Rust Kafka client, built upon kafka-protocol-rs and Tokio
-
luis_sys
FFI bindings for Microsoft LUIS API
-
fure
Retrying futures using different policies
-
cbsk_socket_rayon
socket callback tool by rayon
-
rustygear
Client library for communicating via the gearman protocol
-
async_tasks_recorder
A struct for recording execution status of async tasks with async methods
-
taskalicious
Common Rust task workers
-
didcomm-rs
DIDComm messaging v2 specifications implementation: https://identity.foundation/didcomm-messaging/spec/
-
ptask
Spawning parasitic tasks
-
agnostic-dns
agnostic-dnsis a Sans-I/O abstraction layer overhickory-dns -
tokio-file
Asynchronous file I/O for Tokio
-
akinator-rs
wrapper around the undocumented Akinator API
-
actix-daemon-utils
Daemon Utilities by actix
-
iroh-io
async local io
-
scuffle-future-ext
working with futures
-
ads_client
An asynchronous, non-blocking ADS client
-
proxy-scraper
command-line tool for scraping proxy information
-
nsq-client
Rust client for the NSQ realtime message processing system
-
future-metrics
Instrument futures with execution metrics
-
tk-listen
A set of helper futures allowing to listen TCP (or unix) socket with resource limits and proper error handling
-
felicia
service for accessing and sharing lists of bad actors
-
io_uring_buf_ring
Help user create and manage io-uring buffer-ring
-
goods
Async assets system
-
compio-driver
Low-level driver for compio
-
adventure
your great adventure for the various type of requests
-
ksqldb
A thin wrapper around the KSQL DB REST API to make it more ergonomic to work with
-
apalis-cron
extensible library for cron-like job scheduling for rust
-
packet-ipc
Share packets between services using servo ipc
-
thin_main_loop
Thin, cross-platform, main event loop. A building block for native GUI applications, among other use cases.
-
cbsk_run
async pool tool
-
agixt-sdk
Rust SDK for AGiXT - A powerful AI agent framework
-
futures-yamux
The yamux protocol implementation, rewritten from the ground up
-
axum-limit
A rate limiting library using token buckets, centered around extractor-based limits for async web applications
-
collections-futures
working with futures through collections types
-
stakker_mio
Mio I/O polling integration for the Stakker crate
-
zeebest
An unofficial zeebe client for the future!
-
borrow-count
Memory that can be shared with a smart pointer and then reaquired with a future
-
io_uring_actor
Near-zero overhead pipelined io_uring api via actor model so you don't have to use Arc<Mutex<IOUring>>
-
wiremock_logical_matchers
Logical matchers for use with wiremock
-
maily
easy, quick, and fault tolerant sending of emails
-
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
-
ruchei
working with many streams
-
bipe
asynchronous I/O pipe
-
telegram-bot-ars
creating Telegram bots
-
swimos_trigger
SwimOS Asynchronous Trigger
-
webhttp
-
polly-scheduler
A robust task scheduling system leveraging Tokio, with built-in fault tolerance, persistence, and recovery capabilities to ensure seamless task management and execution
-
metatrait
RPITIT Monads
-
mini-c-ares-resolver
An asynchronous DNS resolver, backed by mini-c-ares
-
tourniquet
Async native round-robin manager for remote services
-
arangoq
An AQL query builder layer and ArangoDb client for rust
-
hollywood
actor framework
-
pingora-timeout
Highly efficient async timer and timeout system for Tokio runtimes
-
negahban
🧐 A simple file watcher, based on
notify, designed to be fast, easy-to-use and async friendly -
dioxus-v04-optional-hooks
Optional futures for Dioxus 0.4.0-0.4.3
-
curseforge
A straightforward asynchronous wrapper around the CurseForge Core API. Public API is subject to change before 1.0.0.
-
extreme
Extremely boring async function runner. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
pi_async_buffer
Asynchronous Buffer for IO
-
inklings
A unified Rust API for various Large Language Model (LLM) providers
-
event-source
Zero cost async immediate event dispatching
-
realhydroper-lsp
Language Server Protocol implementation based on Tower
-
ruva
Event Driven Message Handling
-
baton
channel for receiving updates per field
-
reusable-box-future
A reusable
Pin<Box<dyn Future<Output = T> + Send>> -
ticks
ergonomic Rust wrapper for the TickTick Open API
-
futures-delay-queue
Async delay queue backed by async-std and futures-timer
-
flo-state
Lightweight actor library
-
winmsg-executor
Per-thread async rust executor for windows
-
ticque
Take a queue for a resource
-
legend-saga
working with RabbitMQ and asynchronous operations
-
merge-streams
Merge multiple streams into one
-
async_msp_cli
Async msp cli for iNav and BetaFlight
-
libaio-futures
Straightforward Linux AIO using Futures/async/await
-
hydra-websockets
A websocket server for the hydra framework
-
tokio_wasi
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
act-locally
single-threaded async actors with ordinary functions as handlers and plainly typed messages
-
pirates
async RPC lib
-
abstract-ns
Abstract name service traits for use with futures (and tokio)
-
makepad-futures
Makepad futures
-
handoff
An unbuffered, asynchronous, single-producer/single-consumer channel
-
sc2
StarCraft II Client API
-
tokio_based
BASED Async Single-threaded Execution Dispatcher
-
async-sleep
Async Sleep
-
agnostic-process
Sans-I/O abstraction layer of
std::processfor any async runtime -
async-blocking-stdio
std::io::std{in(), out(), err()} but async
-
agner-sup
An actor toolkit inspired by Erlang/OTP (supervisors)
-
cannyls_rpc
RPC library for operating cannyls's devices from remote nodes
-
mamenoki
Complete implementation of a Beanstalkd client based on the Tokio runtime
-
lifeline
dependency injection library for asynchronous message-based applications
-
conva_ai
Rust SDK for using CONVA AI Copilots
-
dialectic
Transport-polymorphic, asynchronous session types for Rust
-
futures-core
The core traits and types in for the
futureslibrary -
async-rt
A small library designed to utilize async executors through an common API while extending features
-
naumi
Lightweight and fast data transfer protocol. Fast de/serialization and tiny size!
-
compio-net
Networking IO for compio
-
rocketmq-client-v4
rocket mq rust client for remote protocol. works on rocket mq V4
-
io-tether
A small library for defining I/O types which reconnect on errors
-
madsim-real-tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
awaitable
type with input and output that can be stored in container
-
logic-mesh
Control logic engine using event based and reactive blocks written in Rust
-
cntrlr
async embedded framework
-
metalmq
server
-
stream_router
A Future aware router to dynamically route between Streams and Sinks
-
xilinx-dma
Userspace Xilinx AXI DMA Interface
-
graceful-shutdown
Graceful Shutdown for async code
-
tiny_future
Condvarbased future with automatic cancellation on drop -
lookit
Asynchronously connect to devices
-
l337
connection pooler
-
fork_stream
Clone any stream
Swhere<S as Stream>::Item: Clone -
tenorite
A concurrency abstraction library. Provides a client-server model for asynchronous workers
-
starbase_events
Async and mutable event system
-
discern
implementing the Command Query Responsibility Segregation (CQRS) pattern
-
async-nats-tokio-rustls-deps
Fork of Asynchronous TLS/SSL streams for Tokio using Rustls
-
deluge
A highly concurrent stream library driving the underlying futures either concurrently or in parallel to process streaming operations as quickly as possible
-
libmqm-sys
IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) bindings
-
roux-stream
A streaming API for the roux Reddit client
-
event-listener-strategy
Block or poll on event_listener easily
-
futures-ratelimit
Bounded flavors of futures' FuturesUnordered and FuturesOrdered
-
terminusdm
Terminus Download Manager. Download files, resume interrupted downloads, and keep a history of your downloads - within terminal UI.
-
async-minecraft-ping
An async Rust client for the Minecraft ServerListPing protocol
-
read-progress-stream
Stream reader wrapper that tracks the number of bytes read
-
murray
A minimal actor definition macro using Tokio
-
local-runtime
Thread-local async runtime
-
async-sse
Async Server Sent Event parser and encoder
-
callbag
spec for reactive/iterable programming
-
lazy_async_pool
An asyncronous object pool that generates objects on the fly
-
fastimer
This crates implements runtime-agnostic timer traits and utilities
-
radix-router
Rust port of httprouter
-
test_executors
async executors for testing
-
msq
legacy Master Server Query Protocol
-
tempo-rs
& minimal client to connect and interact with RTE's 'Tempo Like Supply Contract' API
-
tierkreis-runtime
Runtime implementation for the tierkreis quantum-classical hybrid workflow orchestration tool
-
thread-executor
Lightweight futures executor using std::thread::park
-
ruchei-route
Sinks with routes
-
prost-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and prost
-
pptr
Type-Driven Asynchronous Actor Runtime
-
parity-runtime
Tokio runtime wrapper
-
mqtt_actor
An mqtt adapters (from port and adapters) to be used with actix actors
-
backie
Background task processing for Rust applications with Tokio, Diesel, and PostgreSQL
-
prevayler-rs
System prevalence in rust
-
zookeeper-cache
ZooKeeper client cache
-
futures_cbor_codec
A codec for framing an AsyncRead/AsyncWrite with cbor for all types that are serializable with serde
-
async-recorder
Store records without waiting for your persistence backend
-
async_singleflight
Async singleflight
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
viaduct
A duplex communication channel between a parent and child process, using unnamed pipes
-
tokio-graceful-shutdown-without-anyhow
perform a graceful shutdown on a Tokio based service
-
vesper
A slash-command framework meant to be used with twilight
-
auto-future
For quickly making a struct into a future via an async fn
-
ref_count
Efficient, low-level asynchronous synchronization for real-time and embedded systems
-
futuristic
Extensions to the futures crate
-
async-xml
deserializing XML data asynchronously
-
rust-concurrent
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
mediator
pattern in Rust
-
tokio-shared
Share tokio Runtime bwtween dylibs
-
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. -
retrier
A wasm-compatible retry library for futures
-
queen
message queue
-
safina-timer
Safe async timers - ARCHIVED: Code moved to
safinacrate -
madsim-tokio
The
tokiosimulator on madsim -
rants
An async NATS client library
-
untokio
Automatically create tokio runtimes
-
async-task-tracker
A task tracker used for waiting until tasks exit
-
tokio-async-drop
macro to enable async drop in a tokio multithreaded runtime
-
napmap
Async HashMap that halts requester tasks until the requested data is accessible
-
passivized_docker_engine_client
Docker Engine Client - manage and run containers, images, and volumes
-
carboxyl
functional reactive programming
-
futures-ticker
An asynchronous recurring time event
-
tokio-uring
io-uring support for the Tokio asynchronous runtime
-
smoltimeout
A way to poll a future until it or a timer completes
-
cassandra-protocol
Cassandra protocol implementation
-
tobytcp
A little library for sending messages over a tcp stream
-
async-notify
A general version async Notify, like
tokioNotify but can work with any async runtime -
pw-telegram-bot-fork
creating Telegram bots
-
in-keys
utilizing streams in a convenient
Terminalconstruct -
plumbing
An async abstraction to pipeline requests through a channel
-
blocker
Block rust futures to create a synchronous wrapper around an asynchronous api
-
io_tee
Tee Read, BufRead, and Seek instances to a writer
-
rust-rsm
RSM:A Realtime Software Middleware framework. Asynchronous, event driven framework
-
async-gcode
An async gcode parser for no_std targets
-
linked-futures
Link futures into a block, which stops all of the included futures when any of the futures complete
-
async-dropper-simple
struct-wrapper (i.e. AsyncDropper<T>) based implementation of AsyncDrop
-
pausable_future
Pausable and resumable future, useful in background tasks
-
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 -
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…
-
alan-runtime
A runtime in Rust to run AGC or Alan Graphcode, alan's bytecode format
-
smol
A small and fast async runtime
-
peace_webi_components
Web interface components for the peace automation framework
-
wasmflow-packet
encapsulating the message packets sent across Wasmflow components
-
tracing-orchestra
Give me more instruments!
-
tauri-specta
Completely typesafe Tauri commands
-
situwaition
Run a closure continuously, until is succeeds or times out
-
visiting_ref
Container types that asynchronously return ownership of a value to another context upon exiting scope
-
maelstrom-node
Maelstrom Rust node framework
-
hls_lfcd_lds_driver
Rust driver for ROBOTIS HLDS HLS-LFCD-LDS (LDS-01)
-
aggligator-transport-usb
Aggligator transport: USB
-
split-stream-by
Stream extension crate for splitting a Stream into two per a predicate
-
tokio-socks
Asynchronous SOCKS proxy support for Rust
-
this-state
way to store state in a thread-safe manner as well as a way to asynchronously wait for state changes
-
async-waitgroup
Golang like WaitGroup implementation that supports both sync and async Rust
-
tokio-lk
Futures-aware lock-by-id primitives
-
async-mq
Zero-cost async-await abstraction of lapin AMQP client crate
-
async-fuse
Helpers for fusing asynchronous computations
-
tokio-bitstream-io
Tokio port of bitstream-io: Library for reading/writing un-aligned values from/to streams in big-endian and little-endian formats
-
stow
Cloud storage abstraction package for Rust
-
waitgroup
Async waitgroup for a collection of task to finish
-
async-mavlink
An async adapter for mavlink conections
-
smolscale
A high-performance async-task scheduler
-
task-collection
Types for managing and waiting on groups of tasks
-
rumqttlog
kafka inspired rumqtt's mqtt commitlog
-
async-lazy
A value which is initialized on the first access, with an async function
-
waterark
Watermark for implementing optimistic SSI (Serializable Snapshot Isolation) transactions
-
eyeball-im-util
eyeball-im -
aral
Async Runtime Aggregation Layer
-
dabus
Dynamic Aplication Controll Bus - an asynchronous, event based module system for thoes who want to move fast and *not* break things
-
async-copy-progress
Asynchronous copying with progress callbacks
-
nolocal-block-on
futures_lite::future::block_on that can run without using thread-locals
-
moeval
a toy interpreter
-
streammap-ext
StreamMap of Tokio with altered
nextthat returns when stream is dropped -
async-ctrlc
Async wrapper of
ctrlc -
csv-async
CSV parsing for async
-
genawaiter2-macro
Convenience macros for generators (genawaiter2)
-
app_ctx
An AppCtx implementation in Rust, like ApplicationContext in SpringBoot
-
io-pipe
A fast and thread-safe library for creating multi-writer and single-reader pipelines in Rust
-
fb_futures_01_ext
Extensions for future 0.1 crate
-
tracing-actix
Allow tracing actor futures in actix
-
must_future
A wrapper future marked must_use - mainly to wrap BoxFutures
-
snarc
Sendable Non-Atomically Reference Counted
-
shutdown-handler
A shutdown handler that allows all parts of an application to trigger a shutdown
-
act-zero
Ergonomic actor system
-
rumpsteak
Session types for asynchronous communication between multiple parties
-
interruptible_polling
General purpose polling tasks with RAII-driven fast clean exits
-
test-with-tokio
attribute macro for tests using tokio with cases and async guards
-
circulate
Lightweight PubSub framework that supports both sync and async
-
activitystreams-types
Base types from the Activity Streams spec
-
rip-starttls
Sans I/O implementation of https://duesee.dev/p/avoid-implementing-starttls/
-
saas-zmq
ZeroMQ tools by using Publish-Federation
-
bp3d-threads
threading library intended to simplify concurrency in BP3D
-
heph
actor framework based on asynchronous functions
-
gentian
proc macro that transforms generators to state machines
-
async-gen
Async generator in stable rust using async/await
-
streamline
Reversible futures::Stream-based state machines
-
actix-interop
Use async/await syntax with actix actors
-
stream-broadcast
Runtime independent broadcast, which only polls it's underlying stream if no pending data is available
-
pantry
Temporary storage for reusing values that may decay
-
rio_rt
A minimal async runtime with an experimental ambition to be an portable and interoperable async runtime for Rust
-
heph-inbox
Bounded capacity channel designed to be used as inbox for actors. Also supports one shot channels.
-
speedracer
racing futures and ranking the results
-
futures_codec
encoding and decoding frames using
async/await -
islabtech-upw-sensor-v1
Rust client library for remote control of the ISLabTech UPW Sensor v1
-
parallel-stream
Data parallelism library for async-std
-
selecting
Cross-platform wrapper over select
-
slings
A small async runtime based on io-uring for Rust
-
rabbit_borough
Create a RabbitMQ consumer project with minimal effort, by bypassing templating, configuration and complicated resiliency logic
-
mpc-bench
Multi-party computation experimentation library
-
simple-scheduler
Schedule periodic tasks to run asynchronously
-
deadqueue
Dead simple async queue
-
try-again
Retry synchronous and asynchronous operations
-
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
-
chunnel
Async mpmc(multi producer multi consumer) channel
-
async-send-fd
A wrapper for async UnixStream's to send file descriptors
-
tokio-stdin-stdout
Thread- and future::sync::mpsc-based AsyncRead/AsyncWrite stdin/stdout with little buffering
-
multiqueue2
A fast mpmc broadcast queue
-
blec
cross-platform ble client library based on btleplug
-
dstream
DelayedStream - delays items and drops same items coming within given interval
-
tokio-switching-sleep
A tokio Sleep with a switchable state
-
bongonet-boringssl
BoringSSL async APIs for Bongonet
-
dyn-future
Convenient and fast dynamic Futures for Rust
-
stream_generator
Allows to easily generate streams with async/await
-
js-sys-futures
working with the futures and js-sys crates
-
coachman
rust asynchronous task manager built on top of tokio framework
-
side-futures
Send future for execution on the runtime that may be in a different thread
-
piston_rs
An async wrapper for the Piston code execution engine
-
tasc
A minimnal, asynchronous threadpool
-
streamcatcher
A thread-safe, shared (asynchronous), almost-lockless stream buffer
-
swarm-commander
Manage tons of commands asynchronously
-
supply-chain-trust-example-crate-000054
Lightweight non-blocking I/O
-
async-hid
A async library for interacting with HID devices
-
heim-cpu
Cross-platform CPU information
-
timeware
timer used to schedule execution of closures at a given timestamp
-
specta
Easily export your Rust types to other languages
-
openai-api
OpenAI API library for rust
-
tokio-libtls
Tokio bindings for LibreSSL's libtls
-
async-log
Async tracing capabilities for the log crate
-
pi_async_file
A async file tools library
-
key-lock
mutual exclusion by keys
-
limitation
A rate limiter using a fixed window counter for arbitrary keys, backed by Redis
-
zeebe
client for defining, orchestrating, and monitoring business processes across microservices using Zeebe
-
quick_crawler
QuickCrawler is a Rust crate that provides a completely async, declarative web crawler with domain-specific request rate-limiting built-in
-
deferred
help perform deferred execution of code logic
-
xtra-addons
Add-on functionality (Broker, Registry) for crate xtra
-
pakr-fsm
Template to implement finite-state-machines
-
deadpool-lapin
Dead simple async pool for lapin
-
proxycurl-linkedin-rs
client for the Proxycurl LinkedIn API
-
futures-net
The futures-net library
-
teloxide-core
Core part of the
teloxidelibrary - telegram bot API client -
bean_factory
bean factory,support inject reference bean
-
tokio-childstream
Convert a tokio::process::Child into a Stream for stdout, stderr, and exit events
-
futures-sink
The asynchronous
Sinktrait for the futures-rs library -
happyeyeballs
Happy Eyeballs implementation in Tokio (not RFC compliant atm)
-
crb-download
CRB | Composable Runtime Blocks | Downloader
-
random-access-storage
Abstract interface to implement random-access instances
-
zellij-utils
Zellij client and server
-
pingora-rustls
RusTLS async APIs for Pingora
-
maybe-future
Future that can be None
-
async-variadic
async variadic functions in Rust with trait bounds
-
async_monad
Asynchronous monad for rust
-
nextgraph
client library. Nextgraph is a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
susync
An util crate to complete futures through a handle. Its main purpose is to bridge async Rust and callback-based APIs.
-
loading-bytes
Load bytes from paths on native and WASM
-
spekt
std::future::Future and Result-based testing trait for managing the lifecycle of stateful, asynchronous tests
-
poison_pill
A tiny wrapper for managing children in async environment
-
bastor
A wrapper helps implementing actor with Bastion more easier with self-implemented state
-
mio-wakeq
mio support for custom event queue via Waker
-
futures-websocket
A futures-based websocket implementation
-
spawns-compat
Async runtime detections for thread context task spawner
-
sigio
signal-based async io
-
nonblock
Read available data from file descriptors without blocking (e.g. sockets, streams, child stdout, named pipes)
-
haiyuu
experimental actor-like library
-
gritlab
Gitlab rust API sdk
-
monoio-native-tls
Asynchronous TLS streams wrapper for Monoio based on NativeTLS
-
zstd-framed
zstd seekable format compression and decompression. Supports sync and async I/O
-
evdev-shortcut
Global shortcuts using evdev
-
rtx
zero-cost runtime-abstraction intended for use by Rust libraries to enable the Freedom of Choice between asynchronous runtimes
-
enstream
Conversion from Future to Stream
-
contained-actors
contained is a research project implementing the proposed harmonic runtime for orchestrating cloud-native systems
-
async-stream-lite
Proc macro-free async/await Rust streams
-
rs1541
Rust bindings and helper functions for accessing Commodore disk drives
-
blocking-permit
Permits and a thread pool for blocking operations
-
crown
jewel of rust libraries
-
viz-utils
Viz utils
-
bufstream
Buffered I/O for streams where each read/write half is separately buffered
-
fut_rwlock
A read-write lock that is read and written via Futures
-
rlua-async
Async support for rlua, via coroutines
-
gcal_rs
A blazingly fast, hand written Google calendar API in Rust
-
async_dataloader
Powerful tool for avoiding N+1 queries using async/await, based on the DataLoader pattern
-
puff-rs
Puff - Deep Stack Python Runtime and GraphQL library
-
acril-rt
A lightweight single-threaded runtime for Acril actors
-
async-select-all
A futures library adapter for selecting over a list of futures
-
csnmp
Community-based async (Tokio) SNMP client library
-
gossip-relay-picker
A relay picker for nostr, used by gossip
-
epicenter
synchronous and asynchronous event dispatcher for Rust
-
spaad
Zero boilerplate actor systems with xtra
-
rtbase
async runtime base code
-
stream-kmerge
K-way merge for streams
-
io-tubes
functionality like pwntools tube for async io in rust
-
salvia
Incremental computing brought to async Rust
-
git-event
Customizable event handler for updates in remote git repositories
-
srmw
Asynchronous single-reader, multi-writer
-
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…
-
hypixel
Rust wrapper for the Hypixel public API
-
verge
An experimental actor library
-
embedded-io-convert
Convert embedded-io-async types back to futures ones (nightly only)
-
fundamentum-sdk-api
HTTP client targeting Fundamentum IoT devices RestAPI
-
futures-diagnose
Wraps around a Spawn and provides lots of diagnostics
-
async-http1-lite
Asynchronous http1 stream
-
eventsource-stream
A basic building block for building an Eventsource from a Stream of bytes
-
dwbhk
dwbhk-rs is a library for working with Discord Webhooks
-
patoka
Try this if you can decompose your problem into actors
-
alopecosa
Pure rust async Tarantool 1.6+ connector built on tokio
-
switchboard
Enables inter-process communiucation via queues and wakers
-
slog-scope-futures
slog-scope for
Futures -
gidle_future
A future executor for the glib main loop idle time
-
raftlog
distributed replicated log based on the Raft algorithm
-
buffer-unordered-weighted
Stream::buffer_unordered where each future can have a different weight
-
enfync
Environment-friendly async utilities
-
simple_futures
futures for use in async operations
-
tokio-rusqlite
Asynchronous handle for rusqlite library
-
swimos_messages
SwimOS Runtime Internal Messaging Protocol
-
rust-moysklad
Framework for moy sklad
-
toy-async-runtime
Toy library to start to work with async rust, build for reckless person!
-
reactors
Performance-focused cross-platform asynchronous IO implementation
-
terrars-integrations-github
Pre-generated Terrars Github bindings
-
async-raft
An async implementation of the Raft distributed consensus protocol
-
laizy
stable and thread-safe implementation of a lazy value
-
fsdr-blocks
Building blocks for FutureSDR signal processing library for SDR and real-time DSP
-
fluvio-async-tls
Asynchronous TLS/SSL streams using Rustls
-
mikrotik_api
& minimal client to connect and interact with Mikrotik RouterOS API, usually exposed on port 8728
-
tower-util
working with
Service -
abcperf-minbft
Integration of MinBFT into ABCperf
-
async-anyhow-logger
An easy crate for catching anyhow errors from an asynchronous function, and passing them to your logger
-
blockz-futures
working with futures for the tokio stack
-
hybrid-logical-clock
Hybrid Logical Clocks for distributed systems
-
rocketmq-store
Storage layer for Apache RocketMQ in Rust
-
rusty_tarantool
Tarantul async client based on tokio framework
-
tokio-easy-timer
A tokio-based task scheduler, with a user-friendly API
-
dyn-timeout
Dynamic timeout, cancel, add and remove time before a callback execution
-
rad
A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
tokio-process-stream
that wraps a tokio::process into a tokio::stream
-
async-refresh
Create values that refresh automatically and asynchronously after a given duration
-
mak
but mak it faster
-
lelet
golang like task executor
-
stream-guard
RAII wrapper around Stream that invokes a custom action on drop
-
paperless-rs
An asynchronous Rust library for the Paperless-ngx document manager
-
async-jobs
Asynchronous job orchestration for Rust
-
aggligator-wrapper-tls
Aggligator transport wrapper: TLS
-
flo_stream
Pubsub and related streams for Rust futures
-
syndicate
Syndicated Actor model for Rust, including network communication and Dataspaces
-
cs-utils
Common utilities
-
signalr_rs
SignalR client based on actix web client and async await
-
unblock
A thread pool for isolating blocking in async programs
-
multiqueue
A fast mpmc broadcast queue
-
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
-
russh-agent
Asynchronous ssh-agent client
-
pseudoterminal
A cross-platform pseudoterminal implementation with async support
-
qp
Quick Pool: High Performance Async Generic Pool
-
signalfut
A future similar to tokio::signal::unix::Signal, but can be used with all the runtimes
-
cortex-sources
Ready-made source implementations for various data inputs in the Cortex ecosystem
-
actix-signal
Manage the lifecycle of an actix actor with its address
-
ndless-async
Ndless-specific integration with async/await for the TI-Nspire
-
tokio-duplex
Combine seperate
AsyncReadandAsyncWritetypes into a singleAsyncRead + AsyncWritetype -
raft-lite
understandable implementation of Raft consensus algorithm
-
intercomm
Asynchronous inter-component communication library
-
mrwei
that implements the common promise primitive for rust based on std future
-
newsblur_api
NewsBlur-API
-
clap-and-async-test
Is a example to use clap with tokio and futures, how run concurrently some functions with a loop inside
-
mini-c-ares
A minimal Rust wrapper for the c-ares library, for asynchronous DNS requests, based on rust-c-ares
-
boomerang_builder
The Reactor assembly API for Boomerang
-
future-clicker
Reimplementation of manual_future without using
futuresunstable -
terminal-wait-exit
wait user exit terminal, like Ctrl+C
-
background-jobs-tokio
in-process jobs processor based on Tokio
-
reception
creating TCP listeners that spawns clients providing model abstraction layer
-
promise
future/promise library for rust
-
mm1-common
M/M/1! Queueing, do you speak it?!
-
tokio-socketcan-bcm
Asynchronous Linux SocketCAN - Broadcast Manager support (BCM) with tokio
-
tokio-scoped
Scoped Runtime for tokio
-
nyantrack-common
Common data types and functionality for NyanTrack
-
rxqlite-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
async-signal
Async signal handling
-
rust_howto
A documentation summary and a compendium of snippets and recipes for the Rust language and ecosystem. Everything you need for day-to-day Rust coding, all in one place.
-
futwaiter
The container of Future's that has the ability to complete them all at once
-
futures-zmq
Futures abstractions for ZeroMQ on any futures executor
-
openraft-rocksstore
A rocksdb based implementation of the
openraft::RaftStoragetrait -
async-compatibility-layer
an abstraction layer for using both async-std and tokio
-
async-actor
actor framework for Rust
-
simple-async-pipe
Aims to provide a simple pipe-like functionality for async code
-
arti-rpcserver
Backend functionality for Arti's RPC service
-
interval_future
Wraps a synchronous, waker-less polling function in an interval-based future
-
wag
Go like sync.WaitGroup implementation in Rust. (sync/async)
-
safina-threadpool
Safe thread pool - ARCHIVED: Code moved to
safinacrate -
eventador
lock-free pub/sub event-bus with sync and async APIs
-
actix-storage-sled
actix-storage based on sled
-
crate-test-xxx
test crate
-
andiskaz
A convenience library for writing games and other apps in TUI
-
ert
A combinator to control future execution order
-
eventually-postgres
Event Store implementation using PostgreSQL for the Eventually crate
-
rt-local
Thread local asynchronous runtime working with platform-specific event loops
-
gabelung
Branch an asynchronous stream of cloneable items into two
-
async-file-lock
Asynchronous file lock that can auto lock and auto seek
-
async_chanx
Implement
Sinkfor some channel implementations -
arta-tokio
Async abstractions implementation for Tokio
-
cdrs-tokio
Async Cassandra DB driver written in Rust
-
space-traders
Async SpaceTraders API client for Rust
-
ringbuf-rs
in-memory ringbuf implementation
-
bb8-bolt
A bolt-client adaptor for the bb8 connection pool
-
zookeeper-cache-rust
ZooKeeper client cache
-
mlua_actor
Lua Actor for Rust(sync/async)
-
sidekiq-rs
Sidekiq compatible server in Rust
-
callback-future
Adapter between callbacks and futures
-
lib3h_zombie_actor
lib3h actor request tracking module
-
kompact-component-derive
A derive macro for Kompact component definitions
-
rmw_ttlmap
Minimal async cache in Rust with support for key expirations
-
service-io
Build your service-server fast, easy (and without hosting!)
-
peachy
async task manager, similar to thread pool but cooler and for structs
-
f289ctrl
Communication library for Fluke 289 digital multimeter
-
stellwerksim
Rust SDK for StellwerkSim
-
rustpub
Activitypub types
-
change_stream
A Stream that only emits if the value is different
-
completion
writing completion-based asynchronous code
-
napi_async_local
Extends napi-rs with the ability to run local futures
-
tokio-stomp
Asynchronous streaming STOMP client
-
tokio_interval
基于Tokio实现了 setInterval(callback, ms) 和 setTimeout(callback, ms) 类似于Javascript的API
-
gcs-rsync
rsync support for gcs with higher perf than gsutil rsync
-
peermerge
Manage JSON-like documents with multiple writers, without a central authority, using a P2P protocol
-
fut-compat
Offers compatibility between the tokio and async_std runtimes
-
rs-copier
Copy and move files asynchronously
-
fb-api
Facebook Api abstraction for async rust
-
atcoder
A template for Rust project
-
futures-io-preview
The
AsyncReadandAsyncWritetraits for the futures-rs library -
dbus-async
Asynchronous DBus library
-
scoped_async_spawn
spawn non-static futures
-
stackful
Bridge between sync and async
-
tag_nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
retry_future
Retry futures mechanism
-
safina-select
Safe async select function, for awaiting multiple futures - ARCHIVED: Code moved to
safinacrate -
hala-io
hala asynchronous io programming primitive types
-
tourniquet-celery
Async native round-robin manager for remote services. celery integration.
-
gcp_auth
Google cloud platform (GCP) authentication using default and custom service accounts
-
italo-api
Rust binding for Italo API
-
strawpoll
A wrapper to avoid spurious polling
-
webrocket
A closure focused WebSocket server implementation
-
qcow2-rs
read/write qcow2 image in async/await
-
axiom
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka
-
histlog
hdrhistogram crate, provides off-thread serialization of HdrHistogram interval logs to file
-
linkd
actor model framework that takes inspiration from OTP in the erlang ecosystem
-
future-combinator-params
functions to inject extra arguments between futures combinators Then/AndThen
-
select-next-any
Alternative to futures::StreamExt::select_next_some that returns the None variant
-
discord_api
Interact with the Discord API from your shell
-
mio-uds
Unix domain socket bindings for mio
-
future_handles
complete futures via handles
-
messagebird-async
Wrapper around the message bird SMS API
-
samotop
SMTP server and library built on async-std
-
futures-stream-ext
Asynchronous stream extensions for the futures(-core) crate
-
quickwit-actors
Actor framework used in quickwit
-
kythera-fvm
Core implementation of the Kythera FVM
-
qbit-api-rs
A asynchronous Rust wrapper for qBittorrent Web API
-
futures-util-either
futures_util::future::Either Ext
-
lnd_grpc_rust
An async library implementing LND RPC via tonic_openssl and prost
-
futures-test-preview
Common utilities for testing components built off futures-rs
-
tokio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Tokio based on Rustls
-
page-turner
A generic abstraction of APIs with pagination
-
glib-signal
GObject signal bindings
-
alligator
getting the output value from a future
-
hooch
A small async runtime that's been bootlegged for my projects
-
joyent-tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
yaanhyy_rust
cargo mod example
-
tokio-nsq
NSQ client built on Tokio. Tokio NSQ aims to be a feature complete NSQ client implementation.
-
tower-actor
A
towermiddleware that creates aServiceby passing messages to an actor -
termion-input-tokio
An adapter that exposes termion's input and key event iterators as asynchronous streams
-
cancellable
providing a generic cancellable utility
-
containerd-snapshots
Remote snapshotter extension for containerd
-
heim-common
Common stuff shared across heim project crates
-
deploy
The
deploylibrary to aide writing and debugging of distributed programs, as well as tooling to run them across a cluster -
log-tracing-layer
Build your own custom tracing layer
-
medina
An asynchronous web crawling engine
-
broker-tokio
tokio for broker
-
vexide-async
The async executor at the core of vexide
-
tidy-browser
Tidy up browser information
-
rfm69-async
async driver for the rfm69 radio transceiver
-
releez
run application release-checklist safely
-
async-cuda-npp
Async NVIDIA Performance Primitives for Rust
-
salvo-serde-util
serde util for salvo
-
atticus
A mimimal API to create asynchronous actors
-
agreed
Fork of async-raft, the Tokio-based Rust implementation of the Raft protocol
-
wgp
waitgroup implementation
-
taps
taps (Tokio Asynchronous Pub/Sub) is an in-process async message broker that can be used for messaging between spawned tokio tasks
-
delimiter-slice
Stream type for splitting a delimited stream
-
relm
Asynchronous, GTK+-based, GUI library, inspired by Elm, written in Rust
-
sync_stream
Aggregate multiple streams by polling stream items in order, keeping the consumption of multiple streams in sync
-
async-rayon
Mix async code with CPU-heavy thread pools using Futures + Rayon
-
future-by-example
Examples of common patterns using Future
-
awaitgroup
Wait for a collection of async tasks to finish
-
promises
Effective, simple, lightweight Javascript promises in Rust
-
async_closure
utilizes the nightly-only feature async_fn_in_trait to imitate async_closures
-
allochronic-util
Private utility crate for allochronic and khonsulabs
-
broadcaster
Broadcasting futures mpmc channel
-
async_msp_lib
Async msp library for iNav and BetaFlight
-
retry_fn
retry function with versions for blocking or non-blocking, tokio or async-std
-
stream-ext
An extension trait for Streams that provides a variety of convenient combinator functions
-
ardop_interface
Interface to the Amateur Radio Digital Open Protocol (ARDOP)
-
oc-wasm-futures
Futures that allow async/await to be used in OC-Wasm for a more ergonomic experience
-
amqp
AMQP/RabbitMQ protocol client
-
xactor
actors framework based on async-std
-
embedded-executor
Embedded systems-friendly
Futuresexecutor -
tokio-rustls-wasi
Asynchronous TLS/SSL streams for Tokio using Rustls
-
enjoin
Powerful syntax-level async join macro
-
tinkoffpay
tinkoff integration (the seller receives a link to the payment form and redirect the buyer to it); NB: with callback method
-
jarust
A janus client SDK in Rust
-
hermod
futures-based RSS/Atom library
-
restartables
Future that restarts an inner future if it doesn't meet a condition
-
libp2p
Peer-to-peer networking library
-
parallel-future
fluent async task experiments
-
cf-turnstile
client for Cloudflare Turnstile
-
async-read-progress
Extension traits for inspecting
AsyncReadprogress -
rexecutor-sqlx
A robust job processing library
-
heim-sensors
Cross-platform sensors information
-
catty
Send and await a value asynchronously
-
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) -
try_future
Convenient short-hand for returning early from
futures-based functions -
augrim
consensus algorithms implemented in Rust
-
typout
Command-line typewriter output stream
-
sched-clock
A timer for task scheduling
-
medea-reactive
Reactive mutable data containers
-
taski
async task DAG execution
-
async-lease
Essentially a futures-oriented Arc<Mutex<Option<T>>>
-
serenity_ctrlc
Ctrl+C handler for serenity
-
peace_webi_model
Web interface data types for the peace automation framework
-
sender-sink
classes for working with tokio UnboundedSender and the Sink trait
-
fluke-io-uring-async
An abstraction on top of io-uring
-
scoped_tasks_prototype
A quick-and-dirty attempt to get scoped tasks in Rust
-
c_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
futures-time
async time combinators
-
starstruck
A game building utility that is made to be simple to use while still providing great performance
-
futura
Helpers for working with futures
-
future-utils
Extensions to Rust's Future and Stream traits
-
nakadion
Types for interacting with the Nakadi Event Broker
-
wookie
Async test/bench toolkit including single stepping executors. No-std compatible.
-
go-zoom-kinesis
A robust AWS Kinesis stream processor with checkpointing and retry capabilities
-
scd4x-rs
query SCD4x sensors over I²C
-
anotify
Async iNotify Filesystem Watcher
-
rusty-gql
Schema first GraphQL Library for Rust
-
north-config
North config is a multi source configuration crate designed as part of the North Microservice Framework
-
batchloader
A type-safe async request batcher based on facebook's dataloader
-
txn
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
cooper
in-process, async Actor library for Rust
-
rivulet
Asynchronous contiguous-memory streams
-
swimos_future
SwimOS Future Utilities
-
croissant
A scheduling library
-
dynamodb-mutex
Use Dymanodb mutex library
-
xo-api-client
Unofficial crate for accessing Xen Orchestra through its API
-
simple-tokio-watchdog
Pretty simple but bulletproof watchdog actor
-
futures-async-stream
Async stream for Rust and the futures crate
-
wd_event
event system
-
async-timers
asynchronous timer primitives
-
ssip-client-async
Client API for Speech Dispatcher
-
gen-stream
Generator-based streams for Rust and futures 0.3
-
tokio-stomp-2
Unofficial successor to Asynchronous streaming STOMP client
-
cdp-html-shot
capturing HTML screenshots using CDP
-
swiftide-docker-executor
A docker executor for swiftide agent tools
-
smelling_salts
Abstraction over OS APIs to handle asynchronous device waking
-
aktors
Driver for derive-aktor
-
stream-operators
a collection of selected rxjs operators for rust standard Stream
-
stateful_async_worker
Asynchronous stateful worker threads utilizable as futures
-
browser-window
optionally async, optionally threadsafe, electron-like browser toolkit for Rust
-
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
-
wasmflow-streams
encapsulating the message packets sent across Wasmflow components
-
async-ops
Use std::ops traits with Futures
-
rustmark
Extensible web application for serving Markdown-based content
-
idb
A futures based crate for interacting with IndexedDB on browsers using webassembly
-
scuttlebutt
interface for kubernetes events
-
tokio-agent
Agents are a simple abstraction around state, inspired by Elixir's Agent
-
bears
wrapper for the Bureau of Economic Analysis (BEA) REST API
-
connection-utils
Connection related utilities
-
mqttc
client for the MQTT protocol
-
async-result
wrapper providing a convenient way to await a result, built on futures-channel's oneshot channel
-
pick_action_from_image
Pick an action from an image
-
tokio-named-pipes
Windows named pipe bindings for tokio
-
jenner
Tools for working with generators to work with both iterators and streams
-
sctp-proto
A pure Rust implementation of SCTP in Sans-IO style
-
qsdr-benchmarks
Benchmarks for qsdr experimental high-performance SDR runtime
-
stream-download
streaming content to a local cache
-
uds
A unix domain socket crate that supports abstract addresses, fd-passing and seqpacket sockets
-
encrypted-dns
A modern encrypted DNS server (DNSCrypt v2, Anonymized DNSCrypt, DoH)
-
overclock
A framework for building data-driven distributed systems
-
simple-middleware
General purpose middleware crate
-
set_timeout
allows efficiently executing futures after some delay has passed
-
amqp-lapin-helper
rust lapin helper
-
suppaftp-cli
FTP command line client, based on suppaftp
-
emitter_runtime
Runtime support for rs-event-emitter
-
otdb
An open trivia database API wrapper
-
tokio_telegraf
Minimal async rust wrapper for the telegraf/influxdb protocol, based on Tokio
-
unsend
A thread unsafe runtime for thread unsafe people
-
tokio-uring-rustls
Integrate rustls into tokio-uring
-
elf_loader
A pure-rust library for loading ELF dynamic libraries from both memory and files
-
epoxy_streams
Base streams implementation for the
epoxy_frplibrary. Please use epoxy_frp instead. -
hydrolink
Lavalink client made with tokio independent of the Discord library, used in production by Hydrogen
-
async_progress
Create sync points across async tasks
-
django-query
Tools for mocking Django-style endpoints
-
jittr
A binary heap based jitter buffer implementation for zero latency udp/rtp streams
-
thread_runner
executing tasks concurrently
-
orengine
Optimized ring engine for Rust. It is a lighter and faster asynchronous library than tokio-rs, async-std, may, and even smol
-
lunatic-distributed
Node to node communication
-
cloudflare_dyndns
DynDNS client for Cloudflare
-
asyncs
async runtime agnostic facilities
-
elfo-test
Test utils for the elfo system
-
unsync
Unsynchronized synchronization primitives for async Rust
-
noosphere-core
Core data types of the Rust Noosphere implementation
-
futures-finally
that executes a future after the completion of a future or stream regardless of the value or outcome
-
openai-api-fork
OpenAI API library for rust
-
safina-executor
Safe async runtime executor - ARCHIVED: Code moved to
safinacrate -
woven
set of async combinators, usable in a no_std environment
-
fbinit-tokio
detail of fbinit crate
-
eventific
that gives you the needed building blocks for event sourcing
-
rexer
Async I/O multiplexing library for rust
-
repsheet_etl
ETL tools for repsheet
-
futures-promises
Promises and Watched Variables for Futures
-
tokio-executor-trait
executor-trait implementation for tokio
-
tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
tokio-task-queue
Execute futures from a stream of futures in order in a Tokio task
-
genserver
Elixir inspired async actor library
-
thread-async
Execute a task in a new thread and await the result asynchronously
-
awesome-operates
A reposity includs many common use code utils
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
projections
Macro-free pin projections because why not?
-
swimos_byte_channel
SwimOS Byte Channel
-
dnsaur
An asynchronous DNS stub resolver
-
remote_config
Flexible crate for asynchronously loading configuration from remote source with caching and automatic revalidation
-
foxhole-api
wrapper for the Foxhole War API
-
async-zeroconf
Async library for wrapping Zeroconf implemenations for use with Tokio
-
sparkle-impostor
A third party crate for Twilight to execute Discord webhooks that clone an existing message
-
image_search
designed to search Google Images based on provided arguments
-
par_io
Parallel, async file I/O library with control over memory usage with no dependencies
-
oricalchum
A lightweight actor model
-
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
-
futures-task
Tools for working with tasks
-
tokio-netstring-trait
A trait for tokios AsyncRead to easily read netstrings from streams
-
back-to-the-future
Conversions between std::future::Future and futures::Future
-
gnostr-core
Replication protocol for Hypercore feeds
-
agnostic-io
agnostic-iodefines I/O traits in Sans-I/O style for any async runtime -
tokio-pty-process-stream
wraps tokio-pty-process in order to provide a simpler API as a single stream object
-
yew-interop
use javascript and css asynchrously in yew
-
ruw
Read-Update-Write
-
mailbox_processor
A small little actor abstraction inspired by the FSharp Mailbox Processor which in turn was inspired by erlang
-
geph4-aioutils
geph4
-
streamtools
Additional stream combinators
-
async_tasks_state_map
A struct for recording execution status of async tasks with async methods
-
underway
⏳ Durable step functions via Postgres
-
libsync
containing channels and other synchronisation object implementations
-
settimeout
Creates a std::future::Future implementation to be ready at some point
-
rseip-cip
common industry protocol for rseip
-
iterstream
Converts Iterator into real asynchronous Stream
-
vkteams-bot-cli
VK Teams Bot API CLI
-
tokio-tasks
Task managment for tokio
-
async-openai
OpenAI
-
suspend
A common mechanism for suspending a thread or a Future until notified
-
bluest
A cross-platform Bluetooth Low Energy (BLE) library
-
lwactors
Lightweight actors for Rust using futures-rs
-
async_io_utilities
An asynchronous IO utilities crate powered by
tokio -
tokio-xmpp
Asynchronous XMPP for Rust with tokio
-
file-kitty
A versatile file manipulation toolkit with async support
-
async-handle
A reference-counted async RwLock
-
pipestream
Async support for pipe or something has file descriptor
-
hyper-multipart-rfc7578
multipart/form-data (RFC7578) for Hyper
-
puteketeke
An asynchronous runtime built on smol
-
execution-engine
Toca Execution Engine implemented using Futures and async/await
-
compio-runtime
High-level runtime for compio
-
mutex-extra
RefMutex<T>that is similar toMutex<T>but isSyncandSendeven ifTisn’tSend -
hentai
API wrapper for nhentai.net
-
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.
-
dbus-async-derive
Handler trait derive macro for dbus-async
-
futures-cache
Futures-aware cache backed by sled
-
crypto-auditing
Client library for crypto-auditing project
-
futuresdr-types
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
af-core
A core library and async runtime for Rust applications
-
mfio
Flexible completion I/O primitives
-
duplexify
Combine a reader + writer into a duplex of Read + Write
-
hitbox-actix
Asynchronous caching framework for Actix
-
lemmy_apub_lib
A link aggregator for the fediverse
-
tl-async-runtime
A bad runtime impl for educational purposes only
-
mio-signals
handling signals with Mio
-
salvo-oapi
OpenApi support for Salvo web framework
-
init_system
Framework to wrap application init
-
nasu
Command-line utility which poll on remote addresses in order to perform status checks periodically
-
specta-typescript
Export your Rust types to TypeScript
-
simple_spawn_blocking
spawning blocking tasks more ergonomic
-
openraft-rocksstore-compat07
A example v07 compatible implementation of the
openraft::RaftStoragetrait -
rsdns
DNS Client Library
-
tracing-layer-slack
Send filtered tracing events to Slack
-
serial-io
A serial port implementation
-
heph-rt
speciailised runtime for Heph's actor
-
streamify
Conversions from values to Stream
-
register-count
Counting
Registers created by aCounter -
rexecutor
A robust job processing library
-
icanhazdadjoke-sdk
An SDK to interact with the icanhazdadjoke Dad Jokes API
-
async-native-tls-alpn
Native TLS using futures
-
async-native-tls-2
Native TLS using futures
-
async-ringbuffer
A nonblocking spsc ring buffer with fixed capacity
-
lapin-tower-worker
Framework for building AMQP workers with lapin and tower
-
mysql_async
Tokio based asynchronous MySql client library
-
tower-limit
Limit maximum request rate to a
Service -
compio-fs
Filesystem IO for compio
-
requiem
Actor framework for Rust
-
amqp-manager
Lapin wrapper that encapsulates the use of connections/channels and creation of amqp objects
-
conquer-struct
macros to perform concurrent future resolution, while populating struct fields
-
v_queue
file based queue
-
ebus
Basic Event Bus implementation
-
dummy-waker
Get a
core::task::Wakerthat does absolutely nothing -
tower-pipeline
A Tower Service combinator that "pipelines" two services
-
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.
-
euklid
CRDT
-
tower-sessions-sqlx-store
SQLx session stores for
tower-sessions -
mailfred
Process emails as an HTTP server
-
async-dispatcher
async runtime based on a pluggable dispatcher
-
atomic-waker
A synchronization primitive for task wakeup
-
plctag-async
async wrapper for libplctag
-
tripwire
makes futures pre-emptible
-
baildon-store
B+Tree CLI
-
poolparty
Added functionality for the
futures::executor::ThreadPoolfutures executor -
tokio-global
Global tokio runtime
-
osaka
async for rust without the noise
-
asygnal
[WIP] Async-first signal handling, such as ctrl-c
-
neo-email
The modern way to build emails services with Rust
-
iou
io_uring bindings
-
tokio-anon-pipe
Asynchronous anonymous pipe for Windows
-
vino-packet
encapsulating the message packets sent across Vino components
-
monoio-io-wrapper
A read/write wrapper to bridge sync and async io
-
async-openai-wasm
OpenAI on WASM
-
epoxy_frp
The Reactive Glue for Frontend Applications
-
edge-nal
Hosts a bunch of traits which are not yet available in the embedded-nal-async crate
-
tezaursapi
api wrapper for tezaurs.lv
-
eventsourcing
Event Sourcing for Rust
-
slice_ops
A selection of useful slice operations
-
openrazer
Asynchronous bindings to the OpenRazer daemon
-
ockam
End-to-end encryption and mutual authentication for distributed applications
-
async-hofs
Various extention traits for providing asynchronous higher-order functions
-
futures-state-stream
A version of the futures crate's Stream which returns state on completion
-
tokio-task-tracker
graceful shutdown solution for tokio
-
quicksink
Create a Sink from some value and a closure returning a Future
-
futures-cputask
Turn synchronous CPU-bound tasks into futures
-
fluke-maybe-uring
Replicates some tokio-uring types to allow building code without it
-
ipc-orchestrator
Orchestion of command line processes for local dev usage with IPC communication
-
bongonet-runtime
Multithreaded Tokio runtime with the option of disabling work stealing
-
tokio-reactor-trait
reactor-trait implementation for tokio
-
akinator-py
Python bindings for akinator-rs
-
completeio
Completion based IO drivers and async runtime
-
tokio-stream_wasi
work with
Streamandtokio -
intervalier
Interval events with handling notifications
-
limitr
offering various rate-limiting algorithms such as Token Bucket, Leaky Bucket, and more
-
ferris_chats_data
data structures for ferris_chat
-
todc-net
Algorithms for message-passing (HTTP) distributed systems
-
spin_future
Convert synchronous functions into valid but inefficient futures
-
sntpc
making SNTP requests
-
blocking_pool
A thread pool for running synchronous I/O in asynchronous applications
-
gandi-v5-livedns-api
Gandi LiveDNS Api
-
streams
A collection of stream-extensions that are missing in the
futurescrate -
simplex-chat
API for the SimpleX Chat CLI
-
mqi
Idiomatic IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) APIs
-
bawawa
Opinionated set of tools to manage and compose process executions
-
rust-runc
consuming the runc binary in your Rust applications
-
pinarcmutex
PinArcMutextype, for shared mutable access to pinned data -
tk-easyloop
A thread local loop and other loop helpers
-
syncthing
controlling syncthing file synchronization through its REST interface
-
fundamentum-edge-pfwd
The port forwarding tool for edge daemon
-
tokio-stomp-rs-rs
Asynchronous streaming STOMP client fork
-
asynciter
Asynchronous iterator
-
atomic-actor
An
Actorwithasync fnhandlers -
manual_future
A future that must be manually completed, similar to Java's CompletableFuture
-
jstime_core
JS Runtime
-
minehut
easy to use Rust wrapper for the Minehut API
-
retry_async
retrying, with specific support for the Azure SDK for Rust (cf. https://github.com/Azure/azure-sdk-for-rust).
-
peace_cli_model
Command line interface data types for the peace automation framework
-
async-cron-scheduler
Runtime-agnostic async task scheduler with cron expression support
-
flysystem
A filesystem abstraction layer for Rust
-
bevy-tokio-tasks
integration of a Tokio runtime into a Bevy app for background processing
-
async-pipe
Creates an asynchronous piped reader and writer pair using tokio.rs
-
signals
A functional-reactive-like library for Rust that allows asynchronous chaining
-
tokio-shared-udp-socket
Easily share a UDP socket between different futures in tokio
-
async-graphql-relay
Relay support for async-graphql
-
retry-strategy
A better asynchronous retry tool based on Tokio
-
rust-cli-commands
-
asyncfd
Send and receive file descriptors over Unix domain sockets while maintaining Tokio AsyncRead and AsyncWrite
-
tokio-lock
Access an object from a single Tokio task
-
lsp-codec
Tokio-compatible codec implementation for Language Server Protocol
-
elfo-configurer
Loads and distributes configs across the elfo system
-
tokio-transports
used for communication between processes
-
mobc-forked
A generic connection pool with async/await support
-
futures-mockstream
Minimal mockstream which implements futures async traits
-
watchfile
An async utility trait to subscribe to file changes of a serializable file
-
mini-tokio
basic asynchronous rust executor
-
paggo
A small, fast, and safe in-memory database
-
rexa
GraphQL MongoDB API builder
-
crb-superagent
CRB | Composable Runtime Blocks | Agent Extensions
-
fates
creating reactive declarations
-
ockam_node_no_std
Ockam library types that do not need
std -
dtbh_interface
Interface library for the automated scanner
-
ferris_chats_server
This binary provides a server for ferris_chat
-
async-rx
functions for async reactive programming
-
indexed_db_futures
Future bindings for IndexedDB via web_sys
-
tus_async_client
native async client library to interact with *tus* enabled endpoints
-
tempest
Realtime message handling framework inspired by Apache Storm and built with Actix
-
deadpool-bolt
A bolt-client manager for the deadpool connection pool
-
swimos_downlink
SwimOS Downlink Runtime
-
stick
Platform-agnostic asynchronous gamepad, joystick and flighstick library
-
riker-cqrs
Command Query Responsibility Separation for Riker applications
-
async-io-traits
Async versions of io traits
-
rasio-mio
a RASIO drivers implementation base on mio
-
deadline
A one-macro crate to ensure assertions meet their deadlines
-
bililive
stream-based bilibili live client library
-
patchable-async-sleep
An async sleep function, patchable to the preferred runtime
-
lease
Object pool that leases values and automatically returns them with async support
-
mio-anonymous-pipes
Asynchronous wrapper for windows synchronous pipes
-
process-stream
Thin wrapper around [
tokio::process] to make it streamable -
hl7-mllp-codec
A Tokio codec for HL7 Minimal Lower Layer Message Transport protocol (MLLP)
-
prokio
An asynchronous runtime compatible with WebAssembly and non-WebAssembly targets
-
client-handle
A macro to generate client handles when using multithreaded / asynchronous code
-
email-lib
Cross-platform, asynchronous Rust library to manage emails
-
eventually-redis
Event Store implementation using Redis, for Eventually crate
-
aggligator
Aggregates multiple links (TCP or similar) into one connection having their combined bandwidth and provides resiliency against failure of individual links
-
mountain-mqtt
A no_std compatible, async MQTT v5 client for tokio and embedded use
-
bleasy
High-level BLE communication library
-
kvarn-tokio-uring
Temporary Kvarn fork: io-uring support for the Tokio asynchronous runtime
-
gmf
An RPC library using Glommio and Tonic. Note: This package only works on Linux.
-
rust-stream-ext-concurrent
Concurrent behavior extensions for any futures::stream::Stream objects
-
leaves
Distributed ID Allocator
-
tokio-prepend-io
Wrapper types that prepends data when reading or writing with AsyncRead or AsyncWrite
-
heim-disk
Cross-platform disk information
-
black-box
A minimal actor framework
-
mycelium_lib
Mycelium DDM
-
volo-macros
Volo's proc macros
-
batch-renamer
Framework and command line utilities for interactive renaming of a potentially large number of files
-
itla
ITLA (micro laser) non-blocking control library using embedded-hal
-
async_timing_util
tokio async functions for waiting until even intervals (on 1 min, 5 min, 30 min, etc), or waiting until a specified timestamp
-
f189ctrl
Communication library for Fluke 189 digital multimeter
-
futures-shuttle
Futures-aware shuttle synchronization object
-
gpiocdev
Access GPIO lines on Linux using the GPIO character device
-
rt-local-core
Thread local asynchronous runtime working with platform-specific event loops
-
libpool
threadpool from The Rust Programming Language
-
safe-vk
create your own vk bot for conversations
-
xtor
Async Actor framework for Rust which is blazing fast and rock solid
-
pingora-runtime
Multithreaded Tokio runtime with the option of disabling work stealing
-
makiko
Asynchronous SSH client library in pure Rust
-
archlinux-repo
Arch Linux repositories parser
-
whorl
was created to teach you how async executors work in Rust
-
tokio-resource-pool
A generic resource pool for the Tokio ecosystem
-
futures-loco-protocol
Asynchronous Loco protocol stream for futures
-
async-codec-lite
Adaptors from AsyncRead/AsyncWrite to Stream/Sink using futures
-
async-stream-http-tunnel-grader
Asynchronous stream http tunnel grader
-
stream-utils
Additional stream combinators
-
gen-z
Macro-free stream construction through asynchronous generators via an awaitable sender
-
smol-hyper
Integrations between smol and hyper
-
ex-futures
An extension of
futures -
channels-io
Async agnostic/Sync IO & buffer management abstractions
-
ekv
Key-value database for embedded systems, for raw NOR flash, using an LSM-Tree
-
async-read-util
A collection of utilities for working with AsyncRead
-
futures-util-io-peek
AsyncPeek trait
-
oauth-lib
Asynchronous Rust library to deal with OAuth flows
-
dbus-tokio
Makes it possible to use Tokio with D-Bus, which is a bus commonly used on Linux for inter-process communication
-
assets
asynchronous asset management
-
gmqtt-client
MQTTv5 client
-
monoio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
acton_test
Testing utilities for Acton agents, providing tools to help in the testing and validation of agent behavior
-
elfo-utils
Some utils for the elfo system
-
safina-net
Safe async network functions - ARCHIVED: Code moved to
safinacrate -
tower-fallthrough-filter
A Tower middleware that gives controll to a defined service if the filter matches and otherwise falls through to the inner service
-
tracing-appender
file appenders and making non-blocking writers
-
tarpc
An RPC framework for Rust with a focus on ease of use
-
py_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
futures-rate
easy tools to help Rust applications guide critical resources or code paths from being overwhelmed
-
lunatic-registry-api
Lunatic host functions for registering named processes
-
async-compat
Compatibility adapter between tokio and futures
-
axum-server
High level server designed to be used with axum framework
-
futures-async-combinators
toy futures combinators
-
trillium-tokio
tokio runtime adapter for trillium.rs
-
tracing-durations-export
Record and visualize parallelism of tracing spans
-
Agentic-rs
agentspackage provides a set of tools for creating and managing agents capable of processing text and performing specified tasks based on a given role. It leverages asynchronous… -
async_message_dispatcher
dispatching messages to asynchronous handlers easier
-
local-spawn-pool
Spawn
!Sendfutures in a pool and await for all of them to finish. Standalone alternative totokio::task::LocalSet. -
stomp
A full STOMP 1.2 client implementation. Allows programs to interact with message queueing services like ActiveMQ and RabbitMQ.
-
futures-option
Extension traits for dealing with optional futures and streams
-
volo-grpc
gRPC framework implementation of volo
-
actix-raft
Raft distributed consensus protocol using the Actix actor framework
-
gritea
Gitea API sdk
-
actix-async-await
Experimental async/await support for Actix
-
retainer
Minimal async cache in Rust with support for key expirations
-
gearbox
Excessive tooling for Rust, boosting productivity and operations
-
egg-mode-extras
Rate-limited streams and other helpers for egg-mode
-
agnostic-lite
agnostic-liteis a Sans-I/O abstraction layer for any async runtime -
lib-wc
Will's Programming Toolbox
-
async-graphql-derive
Macros for async-graphql
-
rxqlite-lite-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
online
📶 Library to check your Internet connectivity
-
runtime-loop
Runtime loop for Rust
-
rs-car-ipfs
rs-car wrapper to read files from IPFS trustless gateways
-
async-task-ffi
Task abstraction for building executors
-
aral-runtime-noop
Aral Runtime for noop
-
tower-buffer
Buffer requests before dispatching to a
Service -
ratchet_rs
Async WebSocket implementation
-
tokio-async-std
An async-std that can fit into tokio ecosystem straight ahead
-
some_local_executor
local executor
-
reactive-messaging
Reactive client/server communications, focused on high performance
-
promising-future
Promise/Future pairs
-
tower-sesh-core
Core components for
tower-seshand related crates -
abs_art
ABStraction of Asynchronous RunTime
-
component-future
implements the inner future protocol documented in the tokio docs
-
cucumber-codegen
Code generation for
cucumbercrate -
redis-asio
Asynchronous Redis driver based on tokio
-
forceps
async & on-disk database
-
libuio
A io_uring based async framework designed for high performance networking on linux
-
gneiss-mqtt
Asynchronous and threaded MQTT(5) clients
-
agner-actors
An actor toolkit inspired by Erlang/OTP (actors)
-
blocksr
Drew's Rust library for (clang/objc) blocks
-
async-stream-tls-upgrader
Asynchronous stream tls upgrader
-
kompact-actor-derive
A derive macro for Kompact Actors
-
mio-utun
Utun bindings for mio
-
june
ergonomic remote actors via actix and canary
-
activitystreams-traits
Traits for ActivityStreams 2.0 objects
-
wait-for-me
Async CountDownLatch
-
rustls-acme
TLS certificate management and serving using rustls
-
catalyzer
HTTP server framework
-
medusa-zip
A command-line interface to high-performance parallelized implementations of common zip file operations
-
actix-broker
Message broker for the Actix actor framework
-
worst-executor
A spin-loop like executor for async
-
rocket-session-store
session library that can use a custom store
-
fd-queue
support fd passing on Unix sockets
-
tower-async-hyper
Bridges a
tower-asyncServiceto be used within ahyper(1.x) environment -
coerce-k8s
Kubernetes discovery provider, automatically discover cluster peers hosted in Kubernetes, based on a configurable pod-selection label
-
spawn_groups
Structured concurrency construct written in Rust, for Rustaceans
-
async-http-body
Agit init HttpBody Support Async Expressions
-
message-sink
Message framing for AsyncRead + AsyncWrite
-
tower-sessions-dynamodb-store
AWS DynamoDB session store. Not for direct use; see the
tower-sessionscrate for details. -
ginepro
A client-side gRPC channel implementation for tonic
-
charred
char checking
-
async-raft2
An async implementation of the Raft distributed consensus protocol
-
tokio-utun
Utun bindings for Tokio
-
thespis
The interface of the thespis actor model (contains only traits)
-
interprocess-docfix
Interprocess communication toolkit. Docs fixed.
-
posturn
Build turn-based games with
asyncRust -
app-queue
In-app persistent queue for asynchronous jobs
-
tokio-async-write-utility
Some helper functions for types impl AsyncWrite
-
local-pool-with-id
A minor variation on a LocalPool executor which exposes unique IDs for tracking future completion
-
compio-buf
Buffer trait for completion based async IO
-
tokio-rustls-acme
Automatic TLS certificate management using rustls
-
cute-async
Cute async utilities
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
sealrs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
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. -
tokio-context
Contexts for cancelling asynchronous tasks using tokio
-
gdext_coroutines
Run Rust Async functions and Coroutines in Godot 4.2+ (through GDExtension), inspired on Unity's Coroutines design
-
incoming
Trait for taking ownership of a stream of incoming connections
-
async_repeat
Retry futures mechanism
-
tor-general-addr
Generalized socket address type used by Tor
-
rust-multipart-rfc7578_2
multipart/form-data (RFC7578)
-
safina-async-test
Macro for running async tests - ARCHIVED: Code moved to
safinacrate -
must-done
An experimental Future that is guaranteed to be done
-
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.
-
async-component-components
async-component components
-
async_object
Async Object wrapper
-
stewart-utils
Small common utilities for stewart
-
pinned
Synchronisation primitives for !Send tasks
-
asyncs-sync
Asynchronous runtime agnostic synchronization utilities
-
mediatrix
Strongly typed, extensible event mediator
-
bottle
Actor model framework for Rust
-
prk_async_dataflow
An asynchronous dataflow processing library for Rust with SIMD-accelerated JSON parsing and AI agent capabilities
-
killswitch
used to broadcast a shutdown request
-
async-drop-guard
offers hash map and cache data structures where individual entries can be locked
-
tokio-mockstream
A fake stream for testing network applications backed by buffers
-
grpcio
language implementation of gRPC, base on the gRPC c core library
-
bongonet-rustls
RusTLS async APIs for Bongonet
-
tokio-extra-macros
Extra proc macros for Tokio
-
ianaio-file
Convenience crate for working with JavaScript files and blobs
-
orcinus
async-ready mysql protocol implementation / wrapper libraries
-
wtx
A collection of different transport implementations and related tools focused primarily on web technologies
-
nanopore
A minimalist async runtime based on io_uring (Linux) and I/O rings (Windows)
-
tor-rpc-connect
Common implementation logic for Arti RPC Connect points
-
cocoro
A more type-safe take on Rust stackless coroutines
-
kay
Experimental high-performance actor system framework for Rust
-
swait
Blocking on Futures
-
again
wasm-compatible retry util for std library futures
-
serviceless
actor model in rust, like actix
-
tk-bufstream
A buffered stream backed by contiguous buffers (netbuf) for tokio
-
real-async-trait
A proc macro that uses experimental features to work around type erasure for async traits
-
futures-async-runtime-preview
Runtime for the async/await macros in the
futurescrate -
stun-client
async_std based asynchronous STUN client library
-
dioxus-query
Fully-typed, async, reusable cached state management for Dioxus 🧬
-
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
-
implicit-await
Implicitly await calls returning Future impls
-
client-util
Help you to build requests and handle responses by several extension trait!
-
oneshot-broadcast
channel that broadcasts a value once without cloning it
-
agent_rt
agent scheduling
-
mofo
Multiple Ongoing Futures Object - an abstraction for easily managing ongoing child tasks with futures
-
garcon
A collection of trait and classes to make your thread or async function wait
-
bevy_async_system
ability to wait for game status asynchronously
-
bonsaimq
Message/job queue based on bonsaidb, similar to sqlxmq
-
and-then-concurrent
Concurrent and-then combinator for Rust streams
-
mias_channel
that supports bi-directional channels by wrapping others
-
limited-join
A zero-dependency crate providing a join future with limited concurrency
-
async-graphql-viz
async-graphql for viz
-
simple-actor
Helper to write actor-based async code
-
handy_async
A handy library for describing asynchronous code declaratively
-
st7735-async-low
Low-level async library for 4-wire serial ST7735
-
svix-webhook-with-clone
Svix webhooks API client with derive Clone added to Webhook struct
-
mio-extras
Extra components for use with Mio
-
peace_webi
Web interface for the peace automation framework
-
futures-stable-preview
futures which support internal references
-
async-attributes
Experimental language-level polyfills for Async Rust
-
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
-
noosphere-fs
A high-level, FS-like view over Noosphere content
-
sampr
A message passing framework using actors
-
keclc-httpauth
HttpAuth support for Kayrx web
-
jsonrpc-rs
Futures base jsonrpc server/client framework
-
tower-sessions-surrealdb-store
SurrealDB session store. Not for direct use; see the
tower-sessionscrate for details. -
rqlite-ha421
An async implementation of a rqlite client
-
akt
An actors library for Rust and Tokio designed to work with async / await message handlers out of the box
-
azur
A no_std Rust crate that implements an executor/reactor and futures using io_uring
-
async-ioutils
A collection of async utilities for I/O
-
smol-macros
Macros for setting up a smol runtime
-
riker-patterns
A collection of common actor patterns for Riker
-
ctrlgen
Generate enums for message-passing services
-
jarust_rt
A janus client SDK in Rust
-
task-exec-queue
A asynchronous task execution queue
-
pipebuf_rustls
PipeBuf wrapper for Rustls
-
async-shell
Asynchronous process child wait
-
reqwest-streams
HTTP body streaming support for reqwest: JSON/CSV/Protobuf and others
-
hyper_lua_actor
Binding of lua_actor & hyper
-
zippyst
Resolve zippyshare.com download links
-
rados_hi
Opinionated high-level wrapper for librados (Ceph)
-
stalk
sending serialized data with tokio
-
bader-db
Key-value cache RESP server with support for key expirations
-
async-entry
extended Tokio's proc macros
-
cloudflare-workers-kv-sdk-rs
Unofficial Cloudflare Workers KV SDK for Rust-Lang
-
streem
creating and consuming streams
-
aster-proxy
A light, fast and powerful cache proxy written in Rust
-
async-weighted-semaphore
An async weighted semaphore
-
cache-compute
implements request/async computation coalescing
-
async-http-client-lite
Asynchronous http client
-
agreed-memstore
An in-memory implementation of the
agreed::RaftStoragetrait. Fork of async-raft’s memstore crate. -
fibers_tasque
A
tasqueextension specialized forfibers -
tokio-macros
Tokio's proc macros
-
vertigo
Reactive Real-DOM library with SSR for Rust
-
tractor
Actor system modelled after Pony's actors
-
async-subscription-map
Async bookkeeping datastructure for state subscriptions
-
tower-amqp
Framework for building AMQP workers with tower
-
minicoro-sys
rust binding to minicoro
-
cargo-daku
Daku API cargo plugin
-
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.
-
awaitable-error
Awaitable type with input and output that can be stored in container
-
tokio-futures-respawn
function to respawn failed long running tasks
-
async-resource
Async resource pool
-
futures-test-sink
Test utilities for futures::sink
-
fil_actors_runtime_v10
System actors for the Filecoin protocol
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
veilid-async-tls
Asynchronous TLS/SSL streams using Rustls
-
tokio-tls-gmssl
TLS/SSL streams for Tokio using native-tls giving an implementation of TLS for nonblocking I/O streams
-
async-pidfd-next
Process file descriptors (pidfd) for Linux
-
northstar-rcon-client
Asynchronous RCON client for the Northstar mod
-
plumb
A functional, async pipeline framework
-
future-result
An ideomatic way of mapping a Result to a Future of Result
-
tower-sessions-sqlx-store-chrono
SQLx session stores for
tower-sessionsbut usingchronoinstead oftime -
yield-now
Wakes current task and returns Poll::Pending once
-
callysto-avro
Avro serde for Callysto Stream Processing Framework
-
tonic-middleware
Async middleware and interceptor for Tonic services
-
async-llm
OpenAI-compatible APIs
-
pipebuf_mio
PipeBuf support for
miobyte-streams -
tigerbeetle-unofficial-core
Safe low level callback-based async bindings to tigerbeetle client library
-
sn_data_types
Safe Network Data Types
-
background-jobs-core
Core types for implementing an asynchronous jobs processor
-
jelastic-rs
Rust wrapper for the Jelastic API
-
fibers_inotify
A futures friendly inotify wrapper for fibers crate
-
fourche
task queue named after a lion with forked tail (queue fourché), works with Redis
-
tokio-util_wasi
Additional utilities for working with Tokio
-
bookkeeper-client
Async rust client for Apache BookKeeper
-
async-middleware
async monad(ish) middleware in Rust using tuples and async trait transforms
-
noosphere-ipfs
An interface for an IPFS client
-
puppet
actor framework which uses no dynamic dispatch or boxing
-
common-multipart-rfc7578
multipart/form-data (RFC7578)
-
asyncore
-
signalwire
The unofficial SignalWire SDK for Rust
-
spmc-logger
A single-producer multi-consumer persistent logger
-
openssh-sftp-protocol-error
Data format used to communicate with openssh mux server
-
strife
A lightweight library for the Discord API
-
telers
An asynchronous framework for Telegram Bot API written in Rust
-
wasmflow-traits
encapsulating the message packets sent across Wasmflow components
-
async_dag
An async task scheduling utilitiy
-
izihawa-common-multipart
multipart/form-data
-
crossbus
A Platform-Less Runtime-Less Actor Computing Model
-
proxied
Asynchronous client connector for proxies
-
coerce-rt
Async actor runtime
-
uller
Generate/Donwload your links
-
deli
ergonomic way to define data models that are seamlessly converted into IndexedDB object stores, utilizing derive macros
-
openssh-mux-client
openssh mux client
-
kvarn_async
Async utilities used in the Kvarn web server
-
tokio-hglib
Tokio-based async client library for Mercurial command server
-
async-graphql-axum-wasi
async-graphql for axum
-
arti-bench
benchmarking utility for Arti
-
personio-rs
Async Rust client for the Personio HR management system
-
mobc-bolt
A bolt-client manager for the mobc connection pool
-
heim-virt
Cross-platform virtualization system detection
-
nr-tracing-layer
Send your logs to New Relic
-
yaaf
Actor Framework
-
tower-balance
Balance load across a set of uniform services
-
async-graphql-extension-apollo-tracing
An async_graphql extension to send traces & metrics to Apollo Studio
-
asyncio-utils
Support limit,skip on AsyncRead traits
-
tokio-udev
Non-blocking/Asynchronous Tokio support for udev device events
-
vru-cancel
Cancel tokio stream
-
lunatic-messaging-api
Lunatic host functions for message sending
-
shared_stream
easily cloneable streams
-
async-openai-compat
OpenAI
-
signald-rust
interface with Signald
-
deploy-common
Common components for the
deployandfabriccrates -
aggligator-monitor
Aggligator link monitor and speed test
-
libp2p-dns
DNS transport implementation for libp2p
-
bb8-ruarango
bb8 connection pooling impmentation for the ArangoDB database
-
noosphere-into
Transformations of Noosphere content into various target formats
-
tokio-takconnect
Asynchronous Playtak client
-
tokio-shield
Prevent futures from being aborted by wrapping them in tasks
-
rtix
Actors with generators. Name up for grabs until I do something with it, or rust supports proper coroutines
-
smol-timeout2
A way to poll a future until it or a timer completes
-
hyper-futures
Compatibility layer for futures to use AsyncRead and AsyncWrite traits with hyper
-
troupe
modelling Rust applications with actors
-
elk-mq
A Message Queue implementation in rust, using Redis as a communication medium
-
aral-runtime-tokio
Aral Runtime for tokio
-
bongonet-timeout
Highly efficient async timer and timeout system for Tokio runtimes
-
attempt
do something over and over and over and over and
-
tes3mp-plugin
Stubs for creating a TES3MP server plugin
-
continue
Swift-style continuation API
-
dndx-fork-tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
async-throttle
Asynchronous Rate Limiting
-
greenthread-future
Convert closures to futures based on greenthread on bare-metal (no_std + no_alloc)
-
supplicant
Bindings for wpa_supplicant
-
starpu-sys
Low-level bindings to the StarPU runtime
-
futures-utils-lite
futures about utils in lite
-
swimos_runtime
SwimOS Agent & Downlink Runtime
-
uringy
single-threaded concurrency runtime for Rust based on io_uring
-
fred
An async client for Redis and Valkey
-
associated-async-io
Async IO traits that use futures instead of poll
-
core-futures-tls
A libcore wrapper allowing async/await to be used from no_std crates
-
dydx
dYdX v4 asynchronous client
-
etcd-rs
etcd client for rust
-
linux-io-uring
The
io_uringlibrary for Rust -
rusher
Pusher compatible pubsub service
-
stream-future
Implement an async iterator with return value
-
atm-async-utils
implementing and testing futures::Sink and futures::Stream related code
-
actix-server
General purpose TCP server built for the Actix ecosystem
-
spotify-rs
wrapper for the Spotify API
-
ero
Erlang-inspired framework for organizing async code in a fault-tolerant way
-
async-option
Essentially an asynchronous Async<Mutex<Option<T>>>
-
async-gitlib
Asynchronous library with libgit2 artifacts
-
hala-future
hala asynchronous programming primitive types
-
maudit_rolldown_utils
Fork of Rolldown for the Maudit project until Rolldown is published on crates.io
-
futures-stream-select-ext
futures::stream::select Ext
-
sfio-tokio-ffi
An oo-bindgen model for using Tokio in an FFI environment
-
elfo-telemeter
Collects and exposes metrics of the elfo system
-
deadpool-amqprs
Dead simple async pool for amqprs
-
tokio-timerfd
timerfd support for tokio
-
suspend-channel
Channel and stream implementations
-
folo
Runtime engine for Rust services
-
rseip-eip
encapsulation protocol for rseip
-
luarmor
API wrapper for luarmor.net
-
relock
Distributed async locking using Redis
-
derive-tokio-io
Derive AsyncRead and AsyncWrite
-
async-read-length-limit
limit the size of an async read
-
rosey-actors
Actor framework
-
async-dup
Duplicate an async I/O handle
-
serio
providing traits and utilities for typed IO using format agnostic serialization built on serde
-
stream-flatten-iters
Flattens a stream of iterators into one continuous stream
-
feature-extension-for-async-std
Feature extension for async-std
-
volo-thrift
Thrift RPC framework implementation of volo
-
kad
A generic / futures based implementation of the Kademlia Distributed Hash Table (DHT)
-
specta-serde
Serde support for Specta
-
completeq-rs
An alternative to passing messages between asynchronous tasks
-
remcached
Caching system designed for efficient storage and retrieval of entities from remote repositories (REST APIs, Database, ...etc)
-
one_for_one
supervize spawn'ed async tasks
-
vanilla_tokio_actor
Vanilla Tokio Actor
-
peace_webi_output
Web interface output for the peace automation framework
-
unix-udp-sock
async & sync UDP sockets supporting sendmsg/recvmsg and src IP manipulation
-
async-compression
Adaptors between compression crates and Rust's modern asynchronous IO types
-
async_event_streams
Asynchronous Events Pub/Sub Library
-
futures-length-delimited-frame
Frame a stream of bytes based on a length prefix
-
busybody
Service Container and Dependency injector crate
-
futures-stream-reader
Convert an [AsyncRead] into a [Stream] of byte chunks
-
serf
A decentralized solution for service discovery and orchestration that is lightweight, highly available, and fault tolerant
-
booru-dl
A command line tool to download images and tags txt from booru
-
v_exchanges_api_generics
A client for HTTP/HTTPS/WebSocket APIs
-
evermore
allowing you to run an fixed number of asynchronous task repeatedly until a shutdown signal is sent out
-
chikatetsu
An(other) actor framework for Tokio
-
edge-dhcp
Async +
no_std+ no-alloc implementation of the DHCP protocol -
kay_codegen
Code generation for implementing kay actors
-
mold2d
platformer game library in Rust
-
waker-set
waker set
-
lutetium
tokio based simple actor library
-
waitfor
Retry a function until it succeeds, errors out, or a timeout/deadline is reached
-
async-trait-ext
a procedural macro for async traits
-
flynn-openai
OpenAI
-
safina-sync
Safe structs for sharing or sending data between async tasks - ARCHIVED: Code moved to
safinacrate -
futuresdr-pmt
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
v_exchanges_adapters
Implementations of HTTP/HTTPS/WebSocket API methods for some crypto exchanges, using crypto-botters framework
-
noop-waker
A waker that does nothing
-
minimal-executor
A minimal executor for asynchronous tasks based on the futures-rs library
-
opentls
TLS connections with OpenSSL
-
ntex-files
Static files support for ntex web
-
ws-gonzale
Naive websocket server implemented using async / await
-
basteh
Generic kv storage with replaceable backend
-
async-cuda-core
Async CUDA streams and buffers for Rust
-
async-graphql-value
GraphQL value for async-graphql
-
beul
It executes futures
-
dd-tracing-layer
Send your logs to Datadog
-
aspartam
Minimalistic actor framework based on tokio, inspired by actix
-
asteroid-mq-model
Basic models for asteroid-mq
-
txrx
take on the C++ unified executors proposal
-
tokio-compat-02
Tokio 0.2 compat utilities
-
posixmq
An idiomatic library for using posix message queues, with optional mio integration
-
zephyrus-macros
Procedural macros used by Zephyrus
-
tokio-task-manager
Allow an async Tokio application to gracefully shutdown, waiting for all tasks to finish
-
agilulf_protocol
Agilulf Protocol serializer and deserializer
-
threaded_logger
An asynchronous logger wrapper
-
json-array-stream
Incrementally reads a JSON array through an async stream
-
aldrin
Message bus for service-oriented RPC and interprocess communication
-
async_main
Runtime-agnostic async main proc macro
-
num_stream
that provides a Stream that yields incrementing numbers at a specified interval
-
eventually
using Event Sourcing in Rust applications
-
async-rustls-stream
An async tls stream library based on rustls and futures-io. Both for server/client.
-
tokiactor
tokio based Actor framework
-
retry-if-macro
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
takyon
single threaded async runtime
-
async-global-executor-trait
executor-trait implementation for async-global-executor
-
tokio-fastcgi
FastCGI handler (responder, authorizer, filter) library for Tokio
-
tower-sesh
A Tower middleware for strongly typed, efficient sessions
-
rxqlite-sqlx-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
cynthia
A high performance asynchronous programming runtime for Rust
-
docker_engine_api
way to interact with the Docker Engine API
-
nats-handling
async NATS client library
-
chtsh
Rust CLI for interacting with https://cht.sh
-
puddle
object pool implementation that uses asynchronous synchronization primitives only
-
nature
development support platform, it separates data definition from code, so it decouple the data from business system
-
rabble
creating location transparent actor based systems
-
sched-callback
async callback scheduling
-
crb-actor
CRB | Composable Runtime Blocks | Actor
-
fil_actors_runtime_v9
System actors for the Filecoin protocol
-
aector
Dynamic implementation of the actor model with a smart built-in testing framework
-
jstream-ext
adds some extra extensions to futures Stream traits
-
async-core
A standard for async runtimes
-
iroh-quinn
Versatile QUIC transport protocol implementation
-
futures-to-stream
Turn heterogeneous Futures of same associated Output type to a stream
-
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.
-
async-openai-alt
OpenAI
-
libevent
Rust bindings to the libevent async I/O framework
-
sendblue
that provides an API client for interacting with the SendBlue REST API, enabling businesses to integrate iMessage and SMS services into their applications
-
its_ok_to_be_block_on
A minimal implementation of block_on, to execute futures in a syncronous context
-
async-graphql
A GraphQL server library implemented in Rust
-
casus
containing a handful of event-based async primitives
-
compio-tls
TLS adaptor with compio
-
async-diesel
Integrate Diesel into async-std cleanly and efficiently
-
rdbc-rs
Futures base Rust DataBase Connectivity (RDBC) library
-
rasi-ext
includes extend features or experimental features that are useful for asynchronous programming
-
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) -
waitlist
Keep track of an ordered list of Wakers to wake
-
holidayapi_rust
A HolidayAPI library for Rust
-
tokio-dbus
Pure Rust D-Bus implementation for Tokio
-
photonio
A runtime for asynchronous applications
-
actix-ws-ng
WebSockets for Actix Web, without actors
-
jarust_plugins
A janus client SDK in Rust
-
async-reactor-trait
reactor-trait implementation for async-io
-
tasky
fluent async task experiments
-
reqwest-eventsource
Helper to build an Eventsource using reqwest
-
egui_task_manager
Manage asynchronous easily
-
wasmcloud-interface-sleepy
Interface for interacting with the sleepy capability provider
-
tower-async-bridge
Bridges a
tower-asyncServiceto be used within atower(classic) environment, and also the other way around -
rotor
The mio-based framework for doing I/O in simple and composable way
-
stream-reduce
Fold a stream without an initial value
-
peace_rt
Runtime logic for the peace automation library
-
async-tick
tick clock
-
comet-eventbus
strong-typed sync and asynchronous eventbus
-
compio-io
IO traits for completion based async IO
-
crb-agent-ext
CRB | Composable Runtime Blocks | Agent Ext
-
barrage
An async broadcast channel
-
specta-jsdoc
Export your Rust types to JSDoc
-
ockam_transport_uds
Unix Domain Socket (UDS) Transport for the Ockam Routing Protocol
-
pyo3-anyio
PyO3 utility bindings for Anyio's event loop
-
linux-io-uring-sys
The
io_uringbindings for Rust -
compio-dispatcher
Multithreading dispatcher for compio
-
toni-macros
Macros for Toni
-
async-stream-packed
Asynchronous stream packed
-
bevy_impulse
Reactive programming and workflow execution for bevy
-
ockam_transport_websocket
WebSocket Transport for the Ockam Routing Protocol
-
futurify
Convert your sync functions into non-blocking thread futures
-
pipebuf_websocket
PipeBuf support for websockets
-
async-priority-queue
An async-aware priority queue
-
vmc
Virtual Motion Capture protocol for virtual avatar tracking
-
axum-router-plugin
Shared library-based plugins for Axum
-
fs4
No libc, pure Rust cross-platform file locks. Original fs2, now supports async and replace libc by rustix.
-
libp2p-swarm
The libp2p swarm
-
aral-runtime-async-std
Aral Runtime for async-std
-
noosphere-storage
Pluggable backing storage for the Rust Noosphere implementation
-
improv
Actor microframework
-
rust-gpt
interaction with the Completion/Chat OpenAI API
-
mysql_async_uu
Tokio based asynchronous MySql client library
-
aligne
A small crate using tokio to synchronize asynchronous request/response with Ids
-
tower-sessions-file-store
Store sessions for Tower Session store on the file system
-
tabs
A collection of asynchronous task abstractions, based on tokio
-
aktrs
An actor model framework for Rust
-
bytes-stream
functions to work with stream of bytes
-
tower-retry
Retry failed requests
-
waker-waiter
async runtimes interoperate with arbitrary futures
-
tower-make
Trait aliases for Services that produce specific types of Responses
-
agner-init-ack
An actor toolkit inspired by Erlang/OTP (init-ack)
-
relay
A lightweight oneshot Future channel
-
volo
high-performance and strong-extensibility Rust RPC framework that helps developers build microservices
-
compio-signal
Signal handling for compio
-
tasktrace
Logical 'backtraces' of async tasks
-
clia-ntex-files
Static files support for ntex web
-
memstore
An in-memory implementation of the
async-raft::RaftStoragetrait -
mqtt-channel-client
MQTT client that communicates over Tokio channels
-
misskey-util
High-level API for the misskey-rs library
-
form-data
AsyncRead/AsyncWrite/Stream
multipart/form-data -
tokio-beanstalkd
Asynchronous client library for interacting with Beanstalkd work queue
-
streaming-platform
Data streaming platform and message broker with concurrent data transfer capabilities
-
tls-async
TLS support for AsyncRead/AsyncWrite using native-tls
-
delay
A collection of trait and classes to make your thread wait (and timeout)
-
lazy-queue
Futures-driven lazy queue processing
-
async-stdin
Asynchronously read from stdin
-
chokepoint
Generic stream transformer to simulate traffic / network congestion
-
await_macros
Macros that expand to
(expr).await -
task_yield
Executor-independent task yielding
-
tokio-task-pool
Task pool for Tokio Runtime
-
bidirectional-channel
A channel where receivers can respond to a message, and senders can wait for a response
-
async-macros
Macros for async-std
-
agner-reg
An actor toolkit inspired by Erlang/OTP (reg)
-
tokio-iocp
IOCP support for the Tokio asynchronous runtime
-
mysql_async_wasi
Tokio based asynchronous MySql client library
-
mwmr
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
switchyard
Real-time compute focused async executor
-
seal_rs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
stry-evermore
allowing you to run an fixed number of asynchronous task repeatedly until a shutdown signal is sent out
-
pin-cursor
!Unpin I/O backend for async-std
-
peace_rt_model
Runtime data types for the peace automation framework
-
async-component
Zero overhead reactive programming
-
async-zmq-types
Types and traits to create a generic interface over asynchronous zmq implementations
-
peace_webi_rt
Web interface runtime data types for the peace automation framework
-
kyansel
Cancellable future. Provide a future as argument and the current future will cancel if the provided future resolves first
-
futures-waitmap
future-based concurrent event waiting hashmap
-
wtr-watcher
Filesystem watcher. Works anywhere. Simple, efficient and friendly.
-
embassy-futures
no-std, no-alloc utilities for working with futures
-
sendgrid-async
An async-std based client for sending emails with SendGrid
-
fastcgi-client
Fastcgi client implemented for Rust
-
heim-net
Cross-platform network information
-
scoped_spawn
Full structured concurrency for asynchronous programming
-
future-bool
A bool one can await the changes
-
trovo
A trovo.live api & chat client written in and for rust
-
generic-api-client
A client for HTTP/HTTPS/WebSocket APIs
-
file-descriptors
Wrapper around the common kinds of (mostly Linux) file descriptors, including sockets, pipes, FIFOs, terminals, serial ports, character devices, epoll, POSIX message queues, timerfd…
-
htmxtools
A lightweight Rust crate for working with HTMX headers, specifically designed to integrate seamlessly with axum
-
async-imap-lite
Asynchronous imap
-
windows-async
async executor for windows application using windows crate
-
carrot-cake
An a-peeling pub/sub framework
-
qunreliable
Unreliable transmission of gm-quic
-
param
Param-style trait
-
agner
An actor toolkit inspired by Erlang/OTP
-
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.
-
monolake
High Performance Proxy base on Monoio
-
taskwait
Runtime agnostic way to wait for a group of async tasks
-
what-the-async
runtime
-
elfo-dumper
Dumps messages of the elfo system on disk
-
relaxed_channel
Wrapper around async-channel, more performant on heavy pipelines
-
genawaiter-macro
Convenience macros for generators (genawaiter)
-
cf-pty-process-alpha
the tab multiplexer fork of tokio-pty-process. Interact with a child process through a pseudo-TTY, asynchronously using Tokio
-
agency
A small async actor framework
-
multipart-rs
zero-allocation, streaming, async multipart reader & writer for Rust
-
async-thread
Futures version of std::thread
-
causality
Event Driven Architecture Traits
-
eventbuzz_core
The core submodule of eventbuzz project
-
mobc-lapin
RabbitMQ support for the async mobc connection pool
-
toy-rpc
An async RPC that mimics golang net/rpc's usage and supports both async-std and tokio
-
workflow-async-trait
Type erasure for async trait methods (customized, see README.md notes)
-
elfo-logger
Logs events of the elfo system
-
mio-timerfd
mio support for linux's timerfd
-
irc
usable, async IRC for Rust
-
switch-resume
Delimited async continuations
-
libp2p-relay
Communications relaying for libp2p
-
nidrs-diesel
Nidrs & Diesel integration
-
ffi_rpc
Use FFI with RPC
-
eventual
Future & Stream abstraction
-
ws_stream_wasm
A convenience library for using websockets in WASM
-
aggligator-transport-webusb
Aggligator transport: WebUSB for targeting WebAssembly
-
lspower
A lightweight framework for implementing LSP servers
-
surrealdb-async-graphql-axum
async-graphql for axum
-
holly
A simplistic actor model library using futures
-
async-mesos
An asynchronous client for Mesos HTTP scheduler API
-
tower-sessions-libsql-store
A small library for using tower-sessions with libsql
-
alzheimer
Async implementation of brainfuck interpreter
-
backstage
A framework for building data-driven distributed systems
-
socketioxide-parser-common
Common parser for the socketioxide protocol
-
b_stb
that efficiently converts Hyper response bodies and async streams into strings or bytes
-
mezzenger-channel
mezzenger transport over futures channels
-
koibumi-socks
A minimal SOCKS5 client library
-
tcp-channel-server
rust tcp channel server frame
-
tower-sessions-moka-store
Moka session store for
tower-sessions -
thetvdb
API async client
-
absinthe
Are you an Actor & Async junkie? Then your app needs some Absinthe!
-
aldrin-broker
Broker library of Aldrin, a message bus for service-oriented RPC and interprocess communication
-
reqwest-retry-after
Retry-After header support for reqwest
-
lucia-apis
A set of API collections based on the lucia framework
-
mfio-rt
mfio based async runtime
-
felixs-tower-lsp
Language Server Protocol implementation based on Tower
-
futures-enum
#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums
-
async-ready
Async readiness traits
-
aredis
Redis client implemented in Rust
-
actix-codec
Codec utilities for working with framed protocols
-
async-graphql-rocket
async-graphql for Rocket.rs
-
airlock
no_std async communication
-
build_async
Rust Macros to Unify Synchronous and Asynchronous Codebases
-
heim-runtime
Runtime shims for heim crate
-
merge-io
Merge two separate
AsyncReadandAsyncWriteobjects into a single I/O stream -
RobotS
Actor framework
-
deadpool-fantoccini
Dead simple async session pool for fantoccini
-
mio-misc
Miscellaneous components for use with Mio
-
throttled-reader
An io::Read proxy that limits calls to read()
-
async_buf_reader_utils
Adds additional functionality to the async-std crate for BufReader
-
repeating_future
[RepeatingFuture] is a [Future] that can call an async function of an object over and over again
-
pulz-executor
Abstractions of some async runtimes
-
tokio-io-compat
Compatibility wrapper around std io traits that implements tokio io traits
-
jackrabbit
Real-time Message Queue
-
async-tun
Asynchronous allocation of TUN/TAP devices using async-std
-
vesper-macros
Procedural macros used by Zephyrus
-
motore-macros
Motore's proc macros
-
tower-timeout
Apply a timeout to requests, ensuring completion within a fixed time duration
-
agner-test-actor
An actor toolkit inspired by Erlang/OTP (test-actor)
-
socksv5_future
Socks v5 futures for Server and Client
-
tower
modular and reusable components for building robust clients and servers
-
async-events-emitter
providing an implementation of an event handling system
-
tacacs-plus
An asynchronous, runtime-independent RFC8907 TACACS+ client
-
ratchet_ext
WebSocket extensions for Ratchet
-
actor
Actors traits
-
geese_executor
Asynchronous executor with Geese event system integration
-
ntex-rt
ntex runtime
-
tokio-tasker
Lets you stop and join groups of Tokio tasks
-
spawns-core
Async runtime agnostic thread context task spawner for Rust
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
stream_multiplexer
Combines many streams into a few
-
tokio-utils
Tools for asynchronous programming in Tokio applications
-
framed_aio
allows performing async io operations in a framed manner
-
asteroid-mq-sdk
Rust SDK for asteroid-mq
-
task-stream
a global task executor, run in
no_std -
wasm-agnostic
users who want to write async runtime-agnostic crate for wasm target
-
compio-process
Processes for compio
-
future_pubsub
A tokio based publish-subscibe channel
-
async-await
Just some macros to emulate the Async and Await :)
-
tower-sessions-file-based-store
File-based session store for
tower-sessions -
gloo-timers
Convenience crate for working with JavaScript timers
-
axum-sessions
🥠 Cookie-based sessions for Axum via async-session
-
futuresdr-remote
Remote interaction library for FutureSDR
-
scambio
Safe and efficient value exchanges between endpoint pairs
-
winit-runtime
Async winit runtime
-
netbeam
a pure-rust asynchronous network synchronization crate (using tokio) that recreates familiar asynchronous paradigms but in a network context
-
agner-helm
An actor toolkit inspired by Erlang/OTP (control panel)
-
actix-storage-dashmap
actix-storage based on dashmap
-
zusammen
Download files in parallel
-
celery-rs-core
Core utilities for a celery client and worker in rust
-
ruchei-callback
Callback traits for ruchei
-
core-futures-stateless
Workaround for no_std async-await that doesn't store task contexts
-
svix
Svix webhooks API client and webhook verification library
-
flo_binding
Declarative binding library for Rust
-
http-lib
High-level, asynchronous API for ureq, a safe HTTP client
-
edge-nal-std
A STD implementation of edge-nal based on
async-io -
uring-fs
Truly asynchronous file operations using io-uring. Supports any async runtime. Linux only.
-
crb-pipeline
CRB | Composable Runtime Blocks | Pipeline
-
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.
-
libp2p-webtransport-websys
WebTransport for libp2p under WASM environment
-
zonyitoo/coio
Coroutine scheduler with non-blocking I/O support
-
tonic-health
Health Checking module of
tonicgRPC implementation -
manual-executor
Async executor with manual waking
-
mini-telnet
Asynchronous minimal telnet library
-
o5m-stream
streaming async o5m decoder
-
jarust_interface
A janus client SDK in Rust
-
madsim-tonic
The
tonicsimulator on madsim -
cyper
HTTP client library based on compio and hyper
-
clia-ntex-files-mod
A mod to ntex-files, supporting '.' leading
-
plctag
wrapper of libplctag, with rust style APIs and useful extensions
-
async-dashscope
client for DashScope API
-
crdb-test-utils
Concurrently Replicated DataBase
-
axum-messages
🛎️ One-time notification messages for Axum
-
futures-macro-await
Definition of the
await!macro for thefuturescrate -
async-ucx
Asynchronous Rust bindings to UCX
-
stream-map-any
Allows merging async Streams of different output type
-
sigfinn
Lifecycle manager for spawning tasks
-
task-executor
A task executor
-
async_io_crypto
handling AsyncRead with ciphering / deciphering
-
poem-grpc
GRPC support for Poem
-
flv-future-aio
I/O futures for Fluvio project
-
futuredsp
A signal processing library for SDR and real-time DSP
-
ruchei-extra
Stream/Sink wrapper with extra data, as used by ruchei
-
tangle
Future implementation for Rust
-
async-std-test
Alternate implementation of the #[async_std::test] macro
-
nodecraft
Crafting seamless node operations for distributed systems, which provides foundational traits for node identification and address resolution
-
websocket_toolkit
A WebSocket toolkit for Rust, enabling efficient real-time communication with flexible reconnection and message handling capabilities
-
rupnp
An asynchronous library for finding UPnP control points, performing actions on them and reading their service descriptions
-
tokio-dbus-macros
Pure Rust D-Bus implementation for Tokio
-
rillrate-system
RillRate agent for system monitoring
-
stage
An ergonomic, composable Actor Model, designed for painless concurrency
-
pingora-openssl
OpenSSL async APIs for Pingora
-
swiftide-core
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
shutdown-async
Asynchronous Shutdown
-
aggligator-transport-websocket
Aggligator transport: WebSocket
-
aio_event
A tokio event like asyncio event in python
-
async-executor-trait
executor-trait implementation for async-std
-
redeez
queueing system for Redis
-
aiur
Single threaded async executor with structured concurrency
-
async-watch
Async watch channel
-
rseip-core
core module for rseip
-
async-utils
nothing to see here yet :)
-
drop-awaiter
that allows you to asynchronously wait for something to be dropped
-
uid-mux
Async multiplexing library with user provided stream ids
-
tokio-non-async
Helpers for dealing with tokio channels in non-async code
-
specta-util
High-level utilities for working with Specta
-
tower-service
Trait representing an asynchronous, request / response based, client or server
-
bp3d-net
Network utilities
-
tokio-eventfd
Linux eventfd for tokio
-
fil_actors_runtime_v8
System actors for the Filecoin protocol
-
fizyr-rpc
Native Rust implementation of the Fizyr RPC protocol
-
turbocharger
Autogenerated async RPC bindings that instantly connect a JS frontend to a Rust backend service via WebSockets and WASM
-
gain-lep
Support for exposing Gain APIs via Lep
-
tokio-buf
Asynchronous stream of byte buffers
-
awaken
Coalescing cross-thread wakers for mio and io_uring
-
futures-macro-await-preview
Definition of the
await!macro for thefuturescrate -
mio-byte-fifo
Concurrent non-blocking byte SPSC FIFO buffer intended for use in Mio poll
-
tor-events
A typed event broadcasting framework for Arti
-
jarust_transport
A janus client SDK in Rust
-
async-transport
Asynchronous transports with ECN information
-
name_locker
interface for asynchronous name lockers, that can run an async task with lock on a given name
-
elfo-pinger
Pings groups of the elfo system
-
nephele
A high performance asynchronous programming runtime for Rust
-
arta-async-std
Async abstractions implementation for async-std
-
twitchchat
interface to the irc-side of twitch's chat system
-
smartpoll
A 'Task' abstraction that simplifies polling futures
-
thespis_impl
Reference implementation for the thespis actor model
-
async-bincode
Asynchronous access to a bincode-encoded item stream
-
light-magic
A lightweight, fast and easy-to-use implementation of a optionally encrypted/persistent in-memory database
-
tokio01-test
Testing utilities for Tokio and futures-based code
-
liburing
Rust liburing#24bd087 raw bindings with basic tests
-
tokio-into-sink
convert a tokio::io::AsyncWrite into a futures::Sink for bytes
-
ant-libp2p-webtransport-websys
WebTransport for libp2p under WASM environment
-
tower-load-shed
Immediately reject requests if the inner service is not ready. This is also known as load-shedding.
-
hydro
cooperative green tasks
-
async-ioutil
A collection of Rust asynchronous I/O utilities
-
aurora-streams
managing publish-subscribe channels using Tokio message passing channels
-
dmds-tokio-fs
Dmds I/O handler interacts with the filesystem using Tokio
-
uasync
fast, safe, async executor
-
crb-morph
CRB | Composable Runtime Blocks | Morph
-
crb-task
CRB | Composable Runtime Blocks | Task
-
ws-lite
Naive websocket server implemented using async / await
-
tokio-channel
Channels for asynchronous communication using Tokio
-
peace_item_tar_x
Manages extracting a tar file for the peace framework
-
nostd_async
An asyncronous runtime for a single-threaded no_std environment
-
wasm_main_executor
Run futures from web workers on the main browser thread
-
netsim
Run tests in network-isolated threads. Intercept and meddle with their packets.
-
socketioxide-parser-msgpack
Msgpack parser for the socketioxide protocol
-
psbus
Generic Publish / Subscribe model for application messaging
-
gwyh
sweet gossip library
-
mpool
A generic connection pool
-
tokio-periodic
Cross-platform, mostly-0-cost asynchronous periodic timers
-
nb-executor
Single-future, #![no_std] executor based on event bitmasks
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
nervemq
Portable, SQS-compatible message queue backed by SQLite
-
somen
An asynchronous parser combinator
-
cqrs-core
Core types and traits for cqrs
-
fieldset
Struct to enum derivation
-
tauri-plugin-rspc
Tauri adapter for rspc
-
ratchet_fixture
Ratchet fixture
-
futures-executor-preview
Executors for asynchronous tasks based on the futures-rs library
-
prefect
An embeddable task queue based on SQLite (renamed to effectum)
-
d3
A framework for server development
-
tokio-blocking
A thin wrapper to provide a simple interface to insert blocking operations between non-blocking operations in the context of futures
-
hop
Rust client library for the Api
-
async-graphql-warp
async-graphql for warp
-
diath
light-weight library for communication between tokio async tasks
-
constellation-internal
Common components for the
constellationframework -
nonblocking
stdin crate for Rust
-
misanthropic
An async, ergonomic, client for Anthropic's Messages API
-
libp2p-uds
Unix domain sockets transport for libp2p
-
compio-macros
Proc macro of compio
-
completion-io
Core traits and types for asynchronous completion-based I/O
-
peace_item_file_download
Manages downloading a file for the peace framework
-
tokio_safe_block_on
ability to execute async code from a sync context, without blocking a tokio core thread or busy looping the cpu
-
crdb-client
Concurrently Replicated DataBase
-
actm
Tiny async actors framework for rust
-
prodash
A dashboard for visualizing progress of asynchronous and possibly blocking tasks
-
async_channel_io
AsyncReadandAsyncWriteimplementations forasync_channel -
dialectic-tokio-mpsc
A backend for the Dialectic crate using Tokio's MPSC channels
-
monoio-macros
Monoio proc macros
-
mercury
The official Rust client for the Mercury Parser
-
asynchronous
Promises Q style , async and event loops
-
tonic-web
grpc-web protocol translation for tonic services
-
libp2p-floodsub
Floodsub protocol for libp2p
-
stream-body
An HttpBody implementation with efficient streaming support for the Rust HTTP library hyper
-
actix-web-async-await
preview of Actix with async/await support
-
openssh-sftp-protocol
Data format used to communicate with openssh mux server
-
tower-http
Tower middleware and utilities for HTTP clients and servers
-
feature-extension-for-wasm-bindgen-futures
Feature extension for wasm-bindgen-futures
-
mlg
An asynchronous Log for Rust
-
tower-worker
Tower layers focused on wrapping services with asynchronous worker tasks that may also make requests to the wrapped service
-
yaar
asynchronous runtime optimized around configuration and no_std
-
ruyi
An event-driven framework for non-blocking, asynchronous I/O in Rust
-
async-watch2
Async watch channel
-
shuller
Lib to get links to images for your favourite tags on rule34 and any
-
tokio-fd
Non-blocking Read and Write a Linux File Descriptor
-
peace_item_sh_cmd
Manages running a shell command for the peace framework
-
mirai
A Futures layer over Mio
-
ara
Async random access I/O traits
-
bevy_flurx
Allows you to use coroutine in Bevy
-
tokio-dbus-xml
Pure Rust D-Bus implementation for Tokio
-
archflow
Create a streamable Zip archive
-
rustun
implementing STUN server and client asynchronously
-
mai
A higher-level mio interface
-
async-timer-rs
Hashed timer wheel implementation compatible with asynchronous tasks, support async_std/tokio and other futures base framework
-
task_scope
asynchronous runtime extension for supporting Structured Concurrency with task spawning
-
crb-supervisor
CRB | Composable Runtime Blocks | Supervisor
-
async-spawner
executor independent task spawner
-
actix-files
Static file serving for Actix Web
-
actix-tls
TLS acceptor and connector services for Actix ecosystem
-
actix-service
Service trait and combinators for representing asynchronous request/response operations
-
armature
An event-driven stateful actor framework for Rust
-
agnostic-net
Sans-I/O abstraction layer of
std::netfor any async runtime -
smol-executor-trait
executor-trait implementation for smol
-
ant-libp2p-swarm
The libp2p swarm
-
crdb-server
Concurrently Replicated DataBase
-
async-graphql-parser
GraphQL query parser for async-graphql
-
arta
Async runtime abstractions library
-
safe-async-scoped
A minimal, safe library for scoped async tasks
-
pollster-macro
Proc-macro crate for pollster
-
gloo-events
Convenience crate for working with DOM event listeners
-
async-graphql-poem
async-graphql for poem
-
dialectic-null
A no-op backend for the Dialectic crate, intended for benchmarking and testing
-
compio-log
Log of compio
-
futures-mpsc
A futures aware, bounded, MPSC channel with back pressure support
-
openssh-sftp-client-lowlevel
Lowlevel utilities to communicate with openssh sftp server
-
v_rusty_tarantool
Tarantul async client based on tokio framework
-
fmmap
A flexible and convenient high-level mmap for zero-copy file I/O
-
sendfile
wrapper around the sendfile(2) system call
-
bevy_async_task
Ergonomic abstractions to async programming in Bevy
-
libp2p-dcutr
Direct connection upgrade through relay
-
extern_executor
Async executor which delegates futures polling to external event-loop
-
pingora
A framework to build fast, reliable and programmable networked systems at Internet scale
-
kcp-rs
KCP Stream Protocol
-
fil_actors_runtime_v11
System actors for the Filecoin protocol
-
vkteams-bot
VK Teams Bot API client
-
crb-core
CRB | Composable Runtime Blocks | Core
-
juggle
Async task switching for cooperative multitasking in single thread environments with no_std support
-
ntex-io
encoding and decoding frames
-
uring
Pure Rust library for io_uring