Open-source alternatives to Evpp

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

aiohttp is an asynchronous networking framework for Python that provides both an HTTP client and an HTTP server. It utilizes the asyncio library to handle network requests and server-side routing through a non-blocking event loop. The framework includes a dedicated toolkit for establishing persistent bidirectional communication channels, enabling the implementation of both WebSocket servers and clients for real-time data exchange. It covers a broad range of asynchronous network programming capabilities, including the development of web servers with customizable routing and the ability to sen

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

Vibora is an asynchronous Python web framework and built-in HTTP server designed for building high-performance web applications. It utilizes an asynchronous event loop and coroutines to process network requests and serve responses without requiring external server wrappers. The project features a high-performance asynchronous schema validator for request integrity, a non-blocking template engine with support for hot-reloading, and a WebSocket communication server for bidirectional real-time data exchange. The framework covers a broad range of capabilities, including modular route management

This project is a technical study and analysis guide focused on the internal architecture of Node.js. It provides an in-depth examination of the runtime, focusing on how the engine manages memory handles, executes asynchronous operations, and implements core module logic. The guide specifically analyzes the integration of native C++ classes and functions into JavaScript and documents the behavior of the libuv event loop. It includes detailed references for optimizing performance by identifying V8 compiler bailouts and profiling execution to improve resource efficiency. The material covers a

Kore is an event-driven web and WebSocket server framework designed for building high-performance web services and APIs in C or Python. It functions as a secure, concurrent application framework that utilizes non-blocking I/O and isolated worker processes to handle high-concurrency traffic. The project is distinguished by a security-first architecture that features OS-level process sandboxing, privilege separation, and the isolation of private encryption keys into dedicated processes. It enables zero-downtime deployments through dynamic module hot-reloading and provides automated TLS certific

pysheeet is a technical reference library providing a curated collection of code snippets and implementation patterns for advanced Python development, system integration, and high-performance computing. It serves as a comprehensive guide for implementing low-level network programming, native C extensions, and asynchronous and concurrent programming. The project provides specialized frameworks for the development and deployment of large language models, including tools for distributed GPU inference and high-performance serving. It also includes detailed patterns for high-performance computing

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

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

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

AndroidAsync is a non-blocking networking library for Android that provides asynchronous sockets, HTTP clients, and servers based on Java NIO. It serves as a toolkit for managing raw TCP socket connections and bidirectional data streams using an asynchronous input and output architecture. The library includes a dedicated WebSocket framework for establishing persistent full-duplex communication channels between Android clients and servers. It also enables the hosting of a lightweight asynchronous HTTP server directly on an Android device to handle incoming network traffic. Its broader capabil

Reactor is a reactive streams library and framework for building asynchronous data pipelines. It provides a system for coordinating execution contexts via an asynchronous event-loop manager, alongside a set of reactive abstractions for implementing high-performance TCP, UDP, QUIC, and HTTP services. The project includes a specialized testing tool for verifying the timing and order of asynchronous data flows and a bill of materials to synchronize compatible versions of core reactive libraries and networking add-ons. Its capability surface covers non-blocking network services, demand-based bac

cpr is a C++ networking library that provides a high-level HTTP request client. It functions as a wrapper around libcurl to simplify the process of sending and receiving data from web servers, specifically managing GET and POST calls and multipart form uploads. The library provides both synchronous and asynchronous execution models, allowing network requests to run on background threads to prevent application freezing. It integrates with the C++ Standard Library to map low-level pointers to standard strings and containers, utilizing RAII for automatic resource management. The project covers

This is a header-only C++ library that provides implementations for HTTP clients, HTTP servers, and a WebSocket framework. It allows for the creation of network services and the consumption of remote APIs without requiring a separate compilation step or external binary linking. The project features backend-agnostic TLS integration for secure HTTPS and WSS communication and employs a thread-pool model to process concurrent requests. It distinguishes itself with a full-duplex WebSocket state-machine and a middleware-based request pipeline that supports regular-expression path routing. The libr

This is a non-blocking network client for Java applications that provides asynchronous HTTP request capabilities and bidirectional WebSocket connectivity. It leverages a Netty-based architecture to handle high volumes of network input and output. The library utilizes native transport abstractions such as Epoll, KQueue, and io_uring to reduce system latency. It supports HTTP/2 multiplexing to run multiple concurrent request-response streams over a single connection and provides automatic response body decompression for various formats. Core capabilities cover the management of complex network

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

The C++ REST SDK is a library for asynchronous HTTP and RESTful communication in native C++ applications. It provides a non-blocking network client for sending requests and receiving responses, a JSON parser for serializing and deserializing data, and a WebSocket client library for real-time, full-duplex communication. The project includes a dedicated OAuth2 authentication client to manage access tokens and authorization flows for secure communication with protected cloud resources. It utilizes a task-based asynchronous model to coordinate background operations and keep application interfaces

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

h2o is a high-performance content delivery server and HTTP/3 web server. It functions as a network gateway and reverse proxy that forwards client requests to upstream servers to manage traffic flow and load. The project distinguishes itself as a protocol fuzzing tool, utilizing a testing framework to execute automated stress tests against network protocols to identify memory leaks and crashes. The server provides capabilities for secure web traffic management through encrypted data transmission and high-performance web serving across HTTP/1, HTTP/2, and HTTP/3. It includes tools for server r

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

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

KCP is a low-latency transport protocol and reliability layer designed to provide TCP-like guaranteed delivery and ordering over UDP. It implements an automatic repeat request protocol to minimize network jitter and delays, prioritizing timeliness over bandwidth efficiency. The project distinguishes itself through a pluggable congestion controller and flow control logic, allowing the transport layer to be tuned for specific network environments. It includes a NAT keep-alive system that uses periodic heartbeat packets to maintain active communication paths and prevent address translation timeo

ENet reliable UDP networking library

GCDWebServer is a lightweight HTTP 1.1 server for iOS, macOS, and tvOS. It serves as an embedded network server for Apple platforms, allowing developers to handle incoming requests through custom synchronous or asynchronous handlers. The project includes a WebDAV server implementation for remote file management, directory browsing, and synchronization using standard network clients. It also provides a web-based file manager that enables users to upload, download, and organize files within an application sandbox via a browser. Additional capabilities include gzip compression, JSON processing,

ESPAsyncWebServer is an asynchronous web server designed for ESP32 and ESP8266 microcontrollers. It enables these devices to host websites and APIs to provide embedded device interfaces for hardware control and data display. The server utilizes non-blocking HTTP handling to process multiple concurrent network connections. This allows the device to manage web requests without pausing other background tasks or sensor readings. The implementation relies on asynchronous socket operations, event-loop request handling, and buffer-based stream parsing. It integrates directly with the network layer

HP-Socket is a networking library for building scalable TCP, UDP, and HTTP servers and clients with event-driven I/O and SSL encryption. It provides a high-performance TCP server framework, an HTTP request handler that parses incoming requests and generates responses, and a UDP communication library for low-latency data transfer, all with optional SSL encryption for secure communication. The library is built on a completion-port-based I/O architecture that uses Windows I/O Completion Ports for scalable asynchronous socket operations. It features a connection-pooled agent architecture for mana

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,