-
tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
futures
An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces
-
actix
Actor framework for Rust
-
tokio-io
Core I/O primitives for asynchronous I/O in Rust
-
tokio-core
Core I/O and event loop primitives for asynchronous I/O in Rust. Foundation for the rest of the tokio crates.
-
mio
Lightweight non-blocking IO
-
fibers
A Rust library to execute a number of lightweight asynchronous tasks (a.k.a, fibers) based on futures and mio
-
tokio-signal
An implementation of an asynchronous Unix signal handling backed futures
-
tokio-rustls
Asynchronous TLS/SSL streams for Tokio using Rustls
-
tokio-reactor
Event loop that drives Tokio I/O resources
-
fred
A Redis client for Rust built on Futures and Tokio
-
redis-async
An asynchronous futures based Redis client for Rust using Tokio
-
tokio-process
An implementation of an asynchronous process management backed futures
-
tokio-tcp
TCP bindings for tokio
-
tokio-current-thread
Single threaded executor which manage many tasks concurrently on the current thread
-
tokio-codec
Utilities for encoding and decoding frames
-
buf_redux
Drop-in replacements for buffered I/O in
std::iowith extra features -
tokio-uds
Unix Domain sockets for Tokio
-
mio-uds
Unix domain socket bindings for mio
-
tokio-sync
Synchronization utilities
-
nb
Minimal non-blocking I/O layer
-
futures-preview
An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces
-
tokio-fs
Filesystem API for Tokio
-
ldap3
Pure-Rust LDAPv3 Client
-
mio-extras
Extra components for use with Mio
-
runtime
Empowering everyone to build asynchronous software
-
tokio-udp
UDP bindings for tokio
-
tokio-buf
Asynchronous stream of byte buffers
-
tk-listen
A set of helper futures allowing to listen TCP (or unix) socket with resource limits and proper error handling
-
protobuf_codec
Encoders and decoders for Protocol Buffers based on bytecodec crate
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
c-ares-resolver
An asynchronous DNS resolver, backed by c-ares
-
tokio-async-await
Experimental async/await support for Tokio
-
tokio-modbus
Tokio-based Modbus library
-
futures-retry
Retry your Futures and Streams and Sinks!
-
tokio-zmq
Provides Futures abstractions for ZeroMQ on the Tokio event-loop
-
frappe
Functional Reactive Programming library for Rust
-
corona
Coroutine and Async/Await support for tokio-based futures
-
stund
An SSH tunnel maintenance daemon
-
tokio-io-pool
Alternative tokio thread pool for executing short, I/O-heavy futures efficiently
-
tokio-serial
A serial port implementation for tokio
-
tokio-dns-unofficial
Unofficial extension to tokio to provide asynchronous DNS resolution
-
futures-await-await-macro
Definition of the
await!macro for thefutures-awaitcrate -
stream-cancel
A library for interrupting asynchronous streams
-
tokio-stdin-stdout
Thread- and future::sync::mpsc-based AsyncRead/AsyncWrite stdin/stdout with little buffering
-
async-ready
Async readiness traits
-
nsq-client
Rust client for the NSQ realtime message processing system
-
handy_async
A handy library for describing asynchronous code declaratively
-
thin_main_loop
Thin, cross-platform, main event loop. A building block for native GUI applications, among other use cases.
-
futures-fs
A Futures implementation for File System operations
-
pharos
Observer pattern which generates a futures 0.3 stream of events
-
synchronized-writer
A tiny implement for synchronously writing data
-
lua_actor
Lua Actor for Rust(sync/async)
-
borrow-bag
A type-safe, heterogeneous collection with zero-cost add and borrow
-
nbchan
Highly optimized non-blocking communication channels
-
luis_sys
FFI bindings for Microsoft LUIS API
-
tower
Tower is a library of modular and reusable components for building robust clients and servers
-
relay
A lightweight oneshot Future channel
-
mio-st
Single threaded, lightweight non-blocking IO
-
rustun
A library for implementing STUN server and client asynchronously
-
riker-default
Riker’s default Model and modules providing core services
-
c-ares
A Rust wrapper for the c-ares library, for asynchronous DNS requests
-
telegrambot
Telegram bot api
-
conch-runtime
A library for evaluating/executing programs written in the shell programming language
-
signals
A functional-reactive-like library for Rust that allows asynchronous chaining
-
futures-locks
Futures-aware lock primitives
-
futures-signals
Zero cost FRP signals using the futures crate
-
ex-futures
An extension of
futures -
messagebird-async
Wrapper around the message bird SMS API
-
reqchan
This is a 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 of the channel are asynchronous with respect to each other, so it is kinda nonblocking. However, if multiple responding ends try to respond to the same request, only one will succeed; the rest will return errors.
-
futures-await
Async/await syntax for Rust through a procedural macro. This crate defines the
#[async]macro for functions, theawait!macro for function bodies, and intends to be used with thefuturescrate on crates.io as well. -
queen-io
I/O library for Rust
-
implicit-await
Implicitly await calls returning Future impls
-
async-datagram
Async datagram traits
-
abstract-ns
Abstract name service traits for use with futures (and tokio)
-
futures-zmq
Provides Futures abstractions for ZeroMQ on any futures executor
-
tower-buffer
Buffer requests before dispatching to a
Service -
tokio-file-unix
Asynchronous support for epollable files via Tokio on Unix-like platforms
-
async-bincode
Asynchronous access to a bincode-encoded item stream
-
epoxy_frp
The Reactive Glue for Frontend Applications
-
tokio-beanstalkd
Asynchronous client library for interacting with Beanstalkd work queue
-
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.
-
futures-jsonrpc
Futures implementation for JSON-RPC
-
actix-redis
Redis integration for actix framework
-
tls-async
TLS support for AsyncRead/AsyncWrite using native-tls
-
capnp-futures
async serialization for Cap’n Proto messages
-
tsukuyomi-macros
Procerual macros for Tsukuyomi
-
sidekiq
Rust Sidekiq Client
-
iota-lib-rs
A rust implementation of the IOTA API
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
zeebest
An unofficial zeebe client for the future!
-
streamunordered
An efficient async stream multiplexer
-
back-to-the-future
Conversions between std::future::Future and futures::Future
-
seq_io
Fast FASTA and FASTQ readers
-
ready
Async ready states
-
tokio-retry
Extensible, asynchronous retry behaviours for futures/tokio
-
data-buffer
A simple low-level data buffer type useful for IO and in homogeneous collections
-
opentracing-rs
opentracing for rust
-
tsukuyomi-internal
internal crate for Tsukuyomi
-
async-lease
Essentially a futures-oriented Arc<Mutex<Option>>
-
tokio-resource-pool
A generic resource pool for the Tokio ecosystem
-
implicit-await-macro
#[implicit_await] procedural macro implementation
-
tg_botapi
Telegram Bot Api library
-
mio-aio
POSIX AIO bindings for mio
-
runtime-native
A cross-platform asynchronous runtime
-
stream_throttle
Provides a Stream combinator, to limit the rate at which items are produced
-
tokio-lock
Access an object from a single Tokio task
-
td_revent
Event library for Rust, Async IO similar to libevent
-
async-await
Just some macros to emulate the Async and Await :)
-
runtime-raw
Traits to implement custom Runtimes
-
amy
Polling and Registration abstractions around kqueue and epoll for multithreaded async network programming
-
reool
An asynchrounous connection pool for Redis based on tokio and redis-rs
-
futures-rustls
Asynchronous TLS/SSL streams for Future using Rustls
-
heim-disk
Cross-platform disk information
-
futures-enum
#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite)] for enums
-
tiny-broke
tiny broke is an async messages broker based on øMQ, rpc-like
-
telegram-bot
A library for creating Telegram bots
-
tokio-utun
Utun bindings for Tokio
-
gen-stream
Generator-based streams for Rust and futures 0.3
-
runtime-tokio
A Tokio-based asynchronous runtime
-
packet-ipc
Share packets between services using servo ipc
-
telegram-bot-fork
A library for creating Telegram bots
-
dataloader
Rust implementation of Facebook’s DataLoader using futures and tokio-core
-
tokio-qapi
QEMU QMP and Guest Agent API tokio adapter
-
thruster-async-await
An async await shim for the thruster web framework
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
domain-resolv
An asynchronous DNS stub resolver
-
tsukuyomi-service
Abstraction of service layer in Tsukuyomi, based on tower-service
-
promising-future
Implementation of Promise/Future pairs
-
tokio-file
Asynchronous file I/O for Tokio
-
heim-cpu
Cross-platform CPU information
-
runtime-attributes
Proc Macro attributes for the Runtime crate
-
mio-byte-fifo
Concurrent non-blocking byte SPSC FIFO buffer intended for use in Mio poll
-
tk-pool
Generic connection pool for tokio
-
heim-host
Cross-platform host information
-
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. -
deferred
Rust crate to help perform deferred execution of code logic
-
libzmq
A strict subset of ØMQ with a high level API
-
future-utils
Extensions to Rust’s Future and Stream traits
-
await_macros
Macros that expand to
(expr).await -
holly
A simplistic actor model library using futures
-
mio-utun
Utun bindings for mio
-
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. -
dkregistry
A pure-Rust asynchronous library for Docker Registry API
-
stun3489
An implementation of STUN (RFC 3489) using tokio
-
shs_async
Secret-handshake protocol (async)
-
mdrv
Modular driver based on Mio for managing multiple connections over different protocols
-
futures-async-runtime-preview
Runtime for the async/await macros in the
futurescrate -
lazy-queue
Futures-driven lazy queue processing
-
nvimpam
A neovim rpc plugin providing folding for PAMCRASH files
-
gj
Event loop and promises
-
async-zmq-types
Types and traits to create a generic interface over asynchronous zmq implementations
-
gw2rs
A Rust library for the Guild Wars 2 API
-
futuristic
Extensions to the futures crate
-
kompact
Kompact is a Rust implementation of the Kompics component model combined with the Actor model
-
kompact-component-derive
A derive macro for Kompact component definitions
-
heim-memory
Cross-platform memory information
-
kompact-actor-derive
A derive macro for Kompact Actors
-
fastlog
A high performance asynchronous logger
-
rustmann
Rust/Tokio client for Riemann
-
future-by-example
Examples of common patterns using Future
-
mimo
Asynchronous backup
-
stund_protocol
The client/server protocol used by the “stund” program
-
finchers-ext
Extensions for constructing Endpoints
-
futures_codec
Utilities for encoding and decoding frames using
async/await -
heim
Cross-platform framework for system information
-
tokio-os-timer
Timer facilities for Tokio based on OS-level primitives
-
futures-glib
Spawn futures on the glib event loop
-
socksv5_future
Socks v5 futures for Server and Client
-
io-uring
Wrapper providing a safe and simple way to access liburing-sys features
-
tokio-bincode
Bincode based
tokio-codecadapter -
heim-derive
Derive macros for heim crates
-
thunks
Asynchronous composer for Rust
-
hermod
A rust futures-based RSS/Atom library
-
rotor-tools
Various utility things for comfortable writing of application and protocols using rotor library
-
rados_hi
Opinionated high-level wrapper for librados (Ceph)
-
io-synesthesist
ffi library of write(2) and lseek(2)/read(2)
-
cancellable-timer
A timer that can be interrupted
-
tk-sendfile
A high-performance file serving library. Serves files in special IO threads. In this version it uses normal file reading, but we will optimize using
sendfileon supported systems as quick as tokio allows us to do that. -
nanoleaf
Asynchronous client library for interacting with NanoLeaf devices
-
tsukuyomi-juniper
Components for integrating GraphQL endpoints into Tsukuyomi
-
async-option
Essentially an asynchronous Async<Mutex<Option>>
-
noob
A WIP futures-based Discord bot library
-
futures2
Enables depending on futures 0.2 and futures 0.1 in the same crate
-
future_pubsub
A tokio based publish-subscibe channel
-
tokio-channel
Channels for asynchronous communication using Tokio
-
ruyi
An event-driven framework for non-blocking, asynchronous I/O in Rust
-
tokio-memcache
Tokio memcache client. WIP
-
tokio-lxi
LXI protocol abstractions for Tokio
-
frame
Convert between streams of bytes and streams of structs
-
tokio-shared-udp-socket
Easily share a UDP socket between different futures in tokio
-
tk-easyloop
A thread local loop and other loop helpers
-
tsukuyomi-cors
CORS support for Tsukuyomi
-
tokio-redis-pool
A Redis connection pool for the Tokio ecosystem
-
data_tracker
tracks changes to data and notifies listeners
-
enum_future
A simple macro for creating
Future-implementing enums containing futures -
starstruck
A game building utility that is made to be simple to use while still providing great performance
-
waitout
Awaits the completion of multiple async tasks
-
tsukuyomi-session
Session support for Tsukuyomi
-
tmp_mio
Temporary fork of the mio crate with windows bug fix