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 ist eine asynchrone Rust-Laufzeitumgebung und eine Bibliothek für nicht-blockierende I/O. Sie dient als asynchrone Standardbibliothek und bietet eine Reihe von Alternativen zur Rust-Kernbibliothek für das Management paralleler Aufgaben, Netzwerke und Dateisystemzugriffe. Das Projekt implementiert eine API, die die Standardbibliothek spiegelt, und bietet asynchrone Versionen existierender synchroner Typen, um ein vertrautes Interface beizubehalten. Dieser Ansatz ermöglicht asynchrone Rust-Entwicklung mit einem Interface, das die Ergonomie der Standardbibliothek der Sprache widerspiegelt. Die Laufzeitumgebung enthält einen Task-Executor für das Scheduling und die Ausführung asynchroner Operationen über mehrere Threads hinweg. Ihr Funktionsumfang deckt die parallele Task-Ausführung, nicht-blockierende Ein- und Ausgabevorgänge sowie das allgemeine Laufzeitmanagement ab.

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.