Async framework

Vert.x is a reactive polyglot framework and asynchronous programming library for the Java Virtual Machine. It functions as an event-driven networking framework and toolkit for building non-blocking applications. The system enables the development of high-concurrency network services and event-driven microservices. It supports the creation of reactive services using multiple languages running on the JVM. The framework covers a wide range of capabilities including the management of HTTP and TCP network protocols, non-blocking file system access, and the integration of reactive clients.

Asio is a C++ library for performing network and low-level I/O operations using a consistent asynchronous model that avoids blocking program execution. It provides a portable, cross-platform interface for network socket communication across different operating systems, and manages multiple asynchronous operations without requiring explicit thread management or locking. The library implements a proactor-based asynchronous model where operations post completion handlers to a queue for later execution, and wraps operating system I/O multiplexing mechanisms like epoll, kqueue, IOCP, and select in

Smol is a lightweight Rust asynchronous runtime and task executor. It provides a suite of foundational tools for scheduling and executing asynchronous futures, managing background workloads, and handling non-blocking network and file operations. The project includes a compatibility layer for adapting asynchronous types and execution contexts, enabling futures to run across different runtime ecosystems. It also features a mechanism to offload synchronous I/O and CPU-intensive operations to dedicated worker thread pools to prevent runtime stalls. Its capabilities cover non-blocking network I/O

async-std is a Rust asynchronous runtime and non-blocking I/O library. It serves as an asynchronous standard library, providing a set of alternatives to the core Rust library for managing concurrent tasks, networking, and file system access. The project implements a standard-library-mirrored API, offering asynchronous versions of existing synchronous types to maintain a familiar interface. This approach allows for asynchronous Rust development using an interface that reflects the ergonomics of the language's standard library. The runtime includes a task executor for scheduling and executing

libuv is a cross-platform asynchronous I/O library that provides an abstraction layer for event-driven networking, filesystem operations, and system signals. It utilizes a non-blocking event loop to coordinate asynchronous tasks and I/O events across different operating systems. The project features a unified interface for managing TCP, UDP, and DNS resolution, alongside an inter-process communication layer for sharing sockets via named pipes and Unix domain sockets. To prevent blocking the main execution loop, it includes a multi-platform thread pool for offloading computationally expensive

ReactPHP is an asynchronous runtime and event-driven I/O framework for PHP. It provides an environment for executing concurrent tasks through a central event loop implementation and reactor pattern, allowing applications to handle multiple operations without pausing the main execution thread. The project includes a specialized asynchronous socket library for TCP, UDP, and TLS communication, alongside a non-blocking HTTP server and client for streaming web requests and responses. Its capability surface covers asynchronous control flow via promises and fibers, non-blocking network connectivity

libco is a C++ coroutine library and user-space task orchestrator designed for cooperative multitasking and high-concurrency execution. It functions as a high-concurrency network framework and a synchronous-to-asynchronous wrapper that allows blocking system calls and socket functions to run asynchronously without modifying existing business logic. The project utilizes a specialized stack-copying context switching model to support millions of simultaneous TCP connections on a single machine. It includes a high-performance time wheel scheduler for managing asynchronous background jobs and dela

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

cppcoro is a C++ coroutine library and concurrency toolkit providing primitives for asynchronous tasks, lazy generators, and non-blocking execution. It functions as an asynchronous I/O framework for managing network sockets and file operations through an event loop. The library features a work-stealing thread pool for distributing tasks across multiple cores and a set of async generators for producing lazy sequences of values both synchronously and asynchronously. It includes a concurrency toolkit with async mutexes, latches, and shared tasks to coordinate multi-threaded execution. Its capab

EasySwoole is a high-performance asynchronous PHP framework designed for building event-driven networks and persistent memory applications. It functions as a toolkit for developing distributed microservices and asynchronous servers capable of handling concurrent HTTP, TCP, UDP, and WebSocket connections. The framework distinguishes itself through a persistent memory process execution mode that eliminates the overhead of repetitive file loading and invocation during request handling. It provides built-in support for distributed systems via remote procedure call implementations and service disc

Workerman is an event-driven asynchronous socket framework for PHP. It provides the core components necessary to build high-concurrency network servers, including an asynchronous TCP framework, a coroutine library for task management, and dedicated implementations for HTTP and WebSocket servers. The project enables the development of specialized network services using custom frame-based communication protocols. It supports both inbound concurrent server implementation and asynchronous outbound connectivity to remote services. The framework covers a broad range of network programming capabili

Tornado is a Python web framework and asynchronous networking library used to build scalable web applications and high-performance servers. It provides a non-blocking HTTP server capable of handling thousands of simultaneous connections. The project functions as a WebSocket server framework, enabling real-time bidirectional communication and persistent connections between clients and servers. It supports the implementation of custom networking protocols and high-performance networking services beyond standard HTTP. Its capabilities cover asynchronous web application development, concurrent A

Muduo is a C++11 event-driven network library and framework designed for building high-concurrency Linux servers. It provides a toolkit for implementing scalable network services and socket communication using non-blocking I/O and asynchronous event processing. The framework implements a multi-threaded TCP server architecture that distributes connection handling across multiple CPU threads to maximize server throughput. This is achieved through a one-loop-per-thread model and a reactor pattern implementation, which dispatch network events from a central demultiplexer to registered handler fun

libaco is a low-level C library for cooperative multitasking that provides a runtime for managing asymmetric coroutines. It functions as an execution context manager and stack memory allocator, allowing a single process to initialize independent execution units with private stacks and perform manual context switching via yield operations. The library distinguishes itself through its memory management and stability features, utilizing read-only guard pages at stack boundaries to trigger hardware faults upon stack overflow. It supports both private stack allocation and shared stack pooling to r

monoio is a high-performance asynchronous runtime and executor for Rust. It implements a thread-per-core concurrency model that pins tasks to specific CPU cores to eliminate synchronization overhead and data migration. The runtime leverages the io_uring interface to perform non-blocking system calls and reduce kernel-user mode memory copying. It utilizes a high-performance I/O driver and zero-copy TCP stream wrapping to manage data transfer via shared-memory buffers. The project provides capabilities for CPU core affinity management, low-latency system programming, and high-performance netwo

Netpoll is an event-driven network framework and non-blocking I/O library designed to manage concurrent TCP and Unix domain socket connections. It utilizes a non-blocking event loop to monitor file descriptors and trigger callbacks for read and write events, serving as a high-performance socket manager and TCP network poller. The framework optimizes throughput across CPU cores by distributing incoming network connections across multiple pollers. It implements zero-copy networking primitives, using linked buffers and specialized memory management to read and write data while minimizing memory

Swift NIO is a low-level, event-driven network framework for the Swift language. It serves as an asynchronous network protocol stack and I/O library designed to build high-performance network servers and clients that handle thousands of simultaneous connections. The framework functions as a high-concurrency network engine that dispatches events across multiple CPU cores. It enables the implementation of custom network protocols by processing raw bytes through a sequence of reusable data transformation handlers. The system provides capabilities for non-blocking I/O multiplexing, asynchronous

Actix Web is an asynchronous web framework designed for building high-performance network services. It provides a foundation for processing concurrent requests through a non-blocking execution model, utilizing an actor-based concurrency system to manage lightweight processes and message passing. The framework includes a low-level networking layer that handles the parsing and serialization of HTTP traffic according to standard specifications. The framework distinguishes itself through a type-safe routing engine that enforces strict data types at compile time, ensuring that request parameters a

Netty is an asynchronous network framework designed for building scalable protocol servers and clients. It utilizes an event-driven reactor pattern and a non-blocking input/output model to decouple connection handling from application logic, allowing for the development of responsive network services that manage high volumes of concurrent connections. The framework distinguishes itself through a modular pipeline-based processing chain that enables the implementation of custom binary or text-based protocols. It provides a pluggable transport abstraction that allows developers to switch between

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,

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

Message-io is an event-driven networking library written in Rust that provides a unified message-based API for building applications across multiple transport protocols. It allows developers to handle communication over TCP streams, UDP datagrams, and WebSocket connections through a single interface, while managing underlying network connections, message transport, and low-level socket asynchrony. The library utilizes a single-threaded event loop architecture to process incoming connections, disconnections, network messages, and internal signals on a dedicated thread, eliminating traditional

DotNetty is an asynchronous network framework and event-driven networking library for .NET. It is a port of the Netty architecture designed for building high-performance protocol servers and clients. The framework enables the development of network applications that handle concurrent connections and high-throughput data streaming without blocking execution threads. It supports the implementation of custom network protocols through defined encoding and decoding rules. The library utilizes a pipeline-based processing model and non-blocking I/O to manage network traffic. Its architecture incorp

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

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

Quasar is a JVM concurrency framework that implements the actor model and a lightweight thread library. It provides isolated execution units that communicate via asynchronous message passing to eliminate shared mutable state. The project distinguishes itself through a distributed actor system capable of operating across multiple cluster nodes with location-transparent registries and actor state migration. It utilizes a work-stealing fiber scheduler to manage millions of lightweight threads, allowing tasks to suspend during non-blocking I/O operations without stalling underlying system threads

libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP, WebSocket, and MQTT clients and servers. It provides a non-blocking event loop for managing network sockets, timers, and system signals across multiple threads. The project is distinguished by its integrated support for specialized network roles, including a full HTTP web server with RESTful routing and middleware, an MQTT messaging client for IoT communication, and the ability to implement SOCKS5 and HTTP proxies. It also features a reliable UDP implementation to ensure ordered

This project is an asynchronous network framework for Python that provides both a client and a server for HTTP communication. It is designed to handle high-concurrency network operations by leveraging cooperative multitasking, allowing for the management of thousands of simultaneous connections without the overhead of traditional thread-per-request models. The framework distinguishes itself through its focus on efficient resource management and persistent communication. It utilizes connection pooling to reuse network sockets, which reduces latency during sequential requests, and supports full

libwebsockets is an event-driven networking framework written in C. It provides a suite of tools for implementing HTTP servers and clients, WebSocket bidirectional communication, MQTT client messaging, and TLS-enabled socket encryption. The project distinguishes itself through a non-blocking event-loop architecture capable of scaling to high connection volumes by distributing network sessions across multiple service threads. It uses a protocol-based callback system and a pluggable event loop integration that allows the networking core to synchronize with external system event libraries. The

Grequests is an asynchronous HTTP client and wrapper for the Requests library that uses Gevent coroutines to execute multiple network requests concurrently. It utilizes a non-blocking connection pool to manage simultaneous outgoing requests and improve throughput compared to sequential execution. The library features an asynchronous response generator that yields HTTP responses as they complete, rather than waiting for an entire batch to finish. It provides a mechanism to limit the number of active connections to manage resource consumption and prevent destination servers from being overloade

PromiseKit is a future-based concurrency framework and promise library for Swift and Objective-C. It functions as an asynchronous workflow coordinator, representing the eventual result of an operation to simplify concurrency logic and replace nested callback structures. The framework enables the coordination of both sequential and parallel asynchronous tasks. It provides a structured pipeline for chaining operations, allowing the results of one task to be passed into the next and facilitating the execution of multiple operations simultaneously. The library includes a state-machine based reso