Awesome GitHub RepositoriesAsynchronous Programming

Tokio is an asynchronous runtime for the Rust programming language, designed to manage and execute concurrent tasks efficiently. It provides a multi-threaded execution environment that schedules lightweight tasks across available processor cores, utilizing a work-stealing scheduler to balance computational load. By employing a poll-based execution model and waker-based notifications, the runtime drives asynchronous operations forward without requiring active polling loops, ensuring efficient resource utilization. The project distinguishes itself through a comprehensive suite of tools for high

iii is a distributed service orchestrator and event-driven workflow engine designed to compose and manage cross-language functions and workers through a central execution engine. It functions as a multi-language service mesh and WebSocket service gateway, providing a persistent communication layer for remote service workers. The platform enables dynamic runtime extensions, allowing new workers and capabilities to be deployed and registered into a live environment without requiring system restarts. It distinguishes itself by offering machine-readable skill exposure and agent capability integra

uvloop is a high-performance replacement for the standard Python event loop. It functions as a drop-in substitute designed to accelerate asynchronous networking tasks and reduce latency in event-driven software systems. The project achieves its performance characteristics by utilizing a Cython-based extension module that wraps the libuv C library. By leveraging low-level system calls for event-driven input and output multiplexing, it manages concurrent network requests and subprocess execution with minimal overhead. The implementation supports scalable backend service development by handling

Trio is an asynchronous I/O runtime and concurrency library for Python. It provides a system for executing non-blocking network and disk operations through a centralized event loop and task scheduler. The library is built on a structured concurrency model, which ensures that asynchronous tasks are bound to a specific lifetime and cannot outlive the scope that started them. It utilizes a nursery-based task manager to track task lifecycles in a parent-child tree, preventing orphaned concurrent operations by requiring child tasks to be joined before their parent scope exits. The framework cover

Mio is a low-level I/O library for Rust that provides an event-driven framework for monitoring multiple network sockets and file descriptors. It acts as a portable wrapper for operating system native polling systems, including epoll, kqueue, and IOCP, allowing applications to trigger events when resources are ready for reading or writing without blocking the execution thread. The library provides a non-blocking socket interface for managing TCP, UDP, and Unix sockets. It distinguishes itself through a vectored I/O implementation, enabling scatter-gather reads and writes across multiple buffer

Gevent is a Python coroutine concurrency library and asynchronous task manager designed for high-concurrency I/O tasks. It provides a cooperative networking framework for building asynchronous TCP, UDP, and HTTP servers, as well as a WSGI web server implementation for hosting web applications. The project is distinguished by its standard library monkey-patching tool, which replaces blocking synchronous functions with cooperative versions to enable asynchronous behavior in third-party code. This allows for a cooperative multitasking workflow where the system yields execution during I/O waits t

Twisted is an event-driven networking engine for Python that provides a framework for building asynchronous network applications. At its core, it uses a reactor-based event loop to drive all input and output, dispatching callbacks in a single thread without blocking. The library implements a deferred promise chain for composing asynchronous logic, along with a protocol and factory pattern that separates connection state management from protocol handling, enabling reusable handlers for different network protocols. The framework supports multiple event loops across platforms, including select,

Zero-cost asynchronous programming in Rust

async-std 是一个 Rust 异步运行时和非阻塞 I/O 库。它作为一个异步标准库，提供了一组核心 Rust 库的替代方案，用于管理并发任务、网络和文件系统访问。 该项目实现了与标准库镜像的 API，提供现有同步类型的异步版本以保持熟悉的接口。这种方法允许使用反映语言标准库人体工程学的接口进行异步 Rust 开发。 该运行时包括一个用于跨多个线程调度和执行异步操作的任务执行器。其功能表面涵盖并发任务执行、非阻塞输入和输出操作以及常规运行时管理。

High level asynchronous concurrency and networking framework that works on top of either Trio or asyncio

Asyncer, async and await, focused on developer experience.

rust stackful coroutine library

Lightweight in-process concurrent programming

Fault-tolerant async actors for Rust that scale seamlessly

High-performance, Rust-based asynchronous task programming framework implementing Flow-Based Programming for scalable directed acyclic graph (DAG) task orchestration

Coroutine I/O for Rust

aiomisc - miscellaneous utils for asyncio

no longer maintained Scalable, coroutine-based, fibers/green-threads for Rust. (aka MIO COroutines).

Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust

Queue futures to run concurrently, in the order they're spawned, and with global and group limits.