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