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 लाइब्रेरी है। यह एक एसिंक्रोनस स्टैंडर्ड लाइब्रेरी के रूप में कार्य करती है, जो समवर्ती कार्यों (concurrent tasks), नेटवर्किंग और फाइल सिस्टम एक्सेस को मैनेज करने के लिए कोर 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.