Projects sharing features with Muduo

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

evpp is a C++ network library and framework designed for building high-performance network services using TCP, UDP, and HTTP protocols. It provides an asynchronous event loop to manage nonblocking I/O operations and concurrent network connections across multiple threads. The framework includes specialized tools for asynchronous DNS resolution and a system for asynchronous task scheduling using a managed thread pool. It also features a nonblocking HTTP server and client with integrated connection pooling. The project covers low-level transport layer connectivity for TCP and UDP, as well as hi

gnet is a high-performance event-driven networking framework for Go, designed for building scalable TCP, UDP, and Unix socket servers. It functions as a non-blocking socket manager and multi-reactor network engine that handles thousands of simultaneous connections with low memory overhead. The framework distinguishes itself by using a multi-reactor architecture that distributes I/O across multiple event loops pinned to operating system threads to minimize context switching. It employs edge-triggered polling to reduce system call frequency and utilizes elastic ring-buffers to minimize allocati

This project is a C++ TCP server framework and educational socket programming guide. It provides a high-performance network library focused on event-driven architecture, implementing a reactor pattern to handle thousands of simultaneous client connections. The framework is distinguished by its multi-threaded event loop, which utilizes a main-sub reactor coordination model to distribute network events across a worker thread pool. It includes an abstraction layer for non-blocking socket I/O and event multiplexing via the epoll system call, decoupling network transport from application business

EventMachine is a reactor-pattern network framework for Ruby that provides an asynchronous I/O library for performing non-blocking network and file operations. It functions as a network server framework used to build scalable TCP and UDP servers and clients that process multiple simultaneous requests. The framework implements a concurrency model that dispatches network events to registered handlers using a single-threaded event loop. This approach allows for the management of high-concurrency network connections without the overhead of multi-threaded programming. The library covers the devel

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

libzmq is a C++ based asynchronous messaging engine and networking core designed for routing non-blocking messages between distributed nodes. It functions as a distributed message queue that implements the ZMTP wire-format framing protocol to standardize how data moves across different network transport layers. The library provides a multi-transport abstraction that allows a single interface to route data across TCP, IPC, and in-process memory. It incorporates a cryptographic layer to encrypt and authenticate transmissions between nodes and employs topology-based messaging patterns, such as p

uWebSockets is a high-performance networking engine providing an HTTP web server and a WebSocket server framework. It implements a multi-threaded event loop architecture to deploy isolated application instances across multiple CPU cores and includes an SSL/TLS network layer for secure, encrypted communication. The project features a dedicated WebSocket pub/sub engine for distributing messages to specific groups of connected clients. It optimizes network throughput through syscall corking to reduce kernel overhead and employs payload compression to minimize data transfer sizes. The system cov

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

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.

Boost is a collection of portable, high-performance source libraries that extend the C++ standard library. It provides a wide range of reusable components, data structures, and algorithms designed to add capabilities to the base language across different platforms. The project is distinguished by its extensive focus on compile-time template metaprogramming and generic programming. It implements advanced architectural patterns such as policy-based design, concept-based type validation, and the use of SFINAE for conditional template resolution to minimize runtime overhead. The library covers a

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

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

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

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

Libevent is a cross-platform library that provides a mechanism for executing callback functions when specific events occur on file descriptors, signals, or timers. It functions as a network event loop framework, enabling the development of applications that manage concurrent network connections and non-blocking input and output operations within a single execution context. The library distinguishes itself by providing a portable abstraction layer that automatically selects the most efficient system-level event notification mechanism available on the host operating system. It includes thread-s

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

C++ is a high-level HTTP client library and wrapper for libcurl. It provides a C++ interface for making network requests, managing network sessions, and implementing data transfers. The library distinguishes itself by offering an asynchronous HTTP client capable of executing non-blocking requests via callback interfaces. It also functions as a multipart form uploader for transmitting files and structured data, as well as an SSE stream handler for processing real-time server-sent events over persistent connections. Its broader capabilities cover secure web communication through SSL encryption

ZLMediaKit is a high-concurrency streaming engine designed to function as a protocol gateway and media server. It provides a native development kit for embedding streaming and transcoding capabilities directly into custom applications, supporting the ingestion, distribution, and recording of live video feeds across various network protocols. The platform distinguishes itself through a high-performance architecture that bridges legacy surveillance protocols with modern web-compatible streaming standards. It utilizes a thread-per-core execution model and zero-copy buffer management to maintain

Memcached is a high-performance, distributed, in-memory key-value storage and request routing engine. It functions as a volatile data store designed to accelerate dynamic applications by caching objects in RAM, thereby reducing backend database load and providing sub-millisecond response times. The system utilizes a specialized architecture that organizes memory into fixed-size slabs to minimize fragmentation and maximize throughput for high-concurrency workloads. The project distinguishes itself through a multi-threaded, lock-friendly design that scales across CPU cores and supports complex

Proxygen is a collection of C++ libraries for building high-performance HTTP servers and clients. It provides a protocol parser that converts raw network bytes into high-level transaction objects and includes a network stack for processing web traffic over the QUIC transport protocol. The project implements a layered protocol abstraction and a QUIC-based transport integration to support multiple versions of the HTTP standard, including HTTP/3. It utilizes state-machine based parsing and an event-driven I/O loop to manage concurrent network connections. The library covers asynchronous buffer

This is a header-only C++ library and asynchronous network framework used to implement WebSocket clients and servers. It provides a full implementation of the WebSocket protocol, including handshakes, subprotocol negotiation, and frame parsing. The framework is distinguished by a policy-based transport layer and template-driven protocol negotiation, allowing the underlying network implementation to be swapped between raw buffers, streams, or custom policies. It supports per-message deflate compression to reduce data transmission volume and integrates Transport Layer Security for encrypted bid

Beast is a C++ library for implementing low-level HTTP and WebSocket clients and servers. It functions as an asynchronous networking framework designed to compose non-blocking I/O operations and layered stream stacks for managing concurrent network traffic, specifically utilizing the Boost.Asio asynchronous model. The library provides a comprehensive implementation of the HTTP/1.1 and WebSocket protocols. For HTTP, it includes primitives for parsing and serializing messages with support for chunked transfer encoding, incremental body reading, and request pipelining. Its WebSocket implementati

Good Game, Peace Out Rollback Network SDK

Workflow is an asynchronous C++ task engine designed for building distributed systems and high-performance network services. It provides a framework for orchestrating complex sequences of network, file, and computational operations, allowing developers to compose these tasks into parallel workflows. The library functions as a toolkit for implementing scalable servers and clients for protocols such as HTTP, Redis, MySQL, and Kafka. It distinguishes itself through a task-based concurrency model that manages non-blocking operations and coordinates service discovery, load balancing, and traffic r

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

This library provides a framework for building event-driven, non-blocking network applications in PHP. It enables the development of asynchronous TCP and TLS servers and clients that manage multiple concurrent connections without stalling the main execution thread. By utilizing an event-loop architecture, the library handles network operations and data exchange through asynchronous streams, ensuring that the application remains responsive during high-throughput tasks. The project distinguishes itself through its integration with operating system primitives, such as raw file descriptors and Un