Open-source alternatives to Beast

websockets is a Python library for building WebSocket servers and clients using coroutines and the asyncio framework. It provides a complete toolkit for creating production-ready WebSocket applications, including a coroutine-based framework for handling connections, messages, and lifecycle events, as well as a client library for opening persistent bidirectional connections to remote endpoints. The library manages the full lifecycle of WebSocket connections, including handshake, message exchange, and graceful closure, with support for path-based routing to organize server logic across multiple

uWebSockets is a C++ networking framework that serves as a high-performance WebSocket server library, HTTP web server, and pub-sub messaging system. It provides the infrastructure necessary to handle standard web requests and maintain low-latency, bidirectional connections between clients and servers. The framework is distinguished by its use of template meta-programming for compile-time optimization and zero-copy buffer management to minimize memory latency. It utilizes a backend-agnostic event loop and static route resolution to process network traffic with minimal runtime overhead. The pr

Handy is a C++11 network server framework and event-driven networking engine designed for building high-performance concurrent TCP and UDP servers. It functions as an asynchronous I/O library and an HTTP server implementation that separates asynchronous network I/O from synchronous business logic to simplify server development. The framework distinguishes itself by utilizing platform-specific event notifications to manage millions of simultaneous network connections and providing an SSL/TLS network wrapper for encrypted asynchronous data transmission. It implements a half-sync/half-async proc

websockets is a Python library that provides both client and server implementations for the WebSocket protocol, enabling real-time, bidirectional communication between applications. At its core, it offers the fundamental primitives for establishing persistent connections, managing their lifecycles, and exchanging text or binary messages asynchronously using coroutines. The library distinguishes itself through comprehensive support for various messaging patterns, including broadcast messaging to all connected clients, targeted messaging to specific clients, and shared application state synchro

Starscream is a Swift WebSocket client library that provides a concrete implementation of the WebSocket protocol for iOS and macOS applications. It functions as an event-driven wrapper for establishing and managing bidirectional connections to send and receive text and binary frames over TCP. The library includes a secure WebSocket client capable of encrypting traffic and validating server identities. It manages the full connection lifecycle, from the initial handshake and header exchange to session termination with custom close codes. The project covers a broad range of networking capabilit

This is a Python WebSocket client library designed to establish full-duplex, persistent network connections for real-time exchange of text and binary data. It functions as an asynchronous network client and a TCP socket wrapper, managing the complete lifecycle of a connection from the initial handshake to graceful closure. The implementation includes a secure WebSocket client that handles SSL/TLS encryption, certificate verification, and secure handshake protocols. It further distinguishes itself by supporting advanced connectivity options, including proxy routing via HTTP or SOCKS proxies an

websocket-sharp is a C# library implementation of the WebSocket protocol used for building bidirectional client and server applications. It enables real-time data exchange between endpoints via persistent connections. The library provides specialized networking capabilities, including SSL encrypted networking for secure transport and certificate validation. It also features HTTP proxy tunneling to route traffic through intermediary servers using basic or digest authentication. The project covers a broad range of capabilities, including the implementation of both WebSocket clients and servers

This project is a Node.js WebSocket library that provides a high-performance client and server implementation for the WebSocket protocol. It functions as a transport layer for real-time bidirectional communication, supporting both UTF-8 strings and binary data transport through the use of TCP socket wrappers. The library enables the creation of WebSocket servers that manage full-duplex connections and broadcast messages to multiple clients, as well as WebSocket clients that establish persistent links to remote servers. It handles the protocol upgrade process via TCP-based handshake negotiatio

Java-WebSocket is a collection of classes for implementing WebSocket clients and servers using pure Java. It provides a framework for hosting servers that manage connections via event-driven subclasses and tools for establishing client connections to remote servers. The library includes a secure communication tool for encrypting traffic using the WSS protocol and a compression library that uses per-message deflate extensions to reduce transmitted data size. It supports the configuration of cipher suites to limit encryption protocols and ensure compatible communication. The project enables bi

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 project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

NanoHTTPD is a lightweight, embeddable HTTP server for Java applications. It allows developers to integrate web server capabilities directly into a Java project to handle incoming requests without requiring a standalone installation. The project provides specialized implementations for an HTTPS web server, a WebSocket server for bidirectional real-time communication, and a static file web server. These capabilities enable secure network traffic through SSL certificates and the delivery of local files with automatic MIME type detection. The server includes systems for request routing and hand

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

This project is a library for establishing bidirectional, real-time communication channels between clients and servers using the WebSocket protocol. It provides a foundational toolkit for managing persistent network connections and processing data frames in accordance with the RFC 6455 standard. The library distinguishes itself through its focus on low-level control and network efficiency. It utilizes an asynchronous, event-driven architecture to manage multiple concurrent connections without requiring dedicated threads for each session. Developers can fine-tune data transmission through manu

PartyKit is a serverless WebSocket backend platform for building real-time multiplayer applications. It provides a globally distributed edge computing runtime that runs stateful server code close to users, with automatic scaling and hibernation for idle rooms. The platform handles WebSocket connections, HTTP requests, and durable storage without requiring infrastructure management, and includes a client and server SDK with hooks, storage, and Yjs integration for building collaborative features. The platform distinguishes itself through per-room isolation using Durable Objects, where each uniq

This project is an educational platform and tutorial series designed to teach the Go programming language through the practice of test-driven development. It provides a structured path for developers to master language fundamentals, concurrency, and standard library usage by building functional applications in small, verifiable increments. The core methodology centers on the test-driven development cycle, where failing tests are written before implementation to define requirements and ensure code correctness. This approach is applied across a wide range of practical scenarios, including the c

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

HAProxy is a high-performance TCP and HTTP proxy that distributes traffic across multiple backend servers to ensure availability and fault tolerance for critical services. It operates in either TCP or HTTP mode, with an event-driven, single-threaded reactor that handles tens of thousands of connections without context switching, and supports kernel-level data transfer to minimize memory usage and latency. What distinguishes HAProxy is its configuration-file-first design, where all load-balancing rules and runtime behavior are defined in a declarative text file parsed at startup. It embeds a L

Ratchet is a PHP library for building asynchronous WebSocket servers that handle persistent, bidirectional communication between clients and the server. It provides a complete server-side WebSocket implementation, including protocol handshake negotiation, message framing over TCP, and an event-loop-based concurrency model that manages thousands of simultaneous connections without blocking. The library implements a connection registry pattern for tracking all active WebSocket sessions, enabling the server to broadcast or unicast messages to any connected client on demand. It relies on non-bloc

WebSocket-Node is a server-side implementation of the WebSocket protocol for Node.js environments. It serves as a framework for establishing persistent, bidirectional communication channels and low-latency data exchange between clients and servers. The project provides a secure socket implementation using transport layer security and includes an integrated client for establishing outbound encrypted connections. It utilizes a formal protocol-state machine and an event-driven connection framework to manage high-concurrency network streams. The framework covers server-side infrastructure includ

The php-standard-library is a comprehensive toolkit for functional programming and asynchronous networking in PHP, featuring typed data structures, structured concurrency, and composable validation mechanisms. It provides explicit result types and pure collection transformers that separate lists from dictionaries, eliminating traditional array key confusion and error-throwing patterns. The library supports concurrent execution through lightweight user-space fibers, message-passing channels, and non-blocking event loops, driving asynchronous TCP, TLS, UDP, and Unix socket servers without relyi

This is a self-hosted WebSocket server for Laravel applications designed to provide real-time communication and replace third-party managed messaging services. It provides a server-side PHP implementation of the WebSocket standard, enabling full-duplex communication between clients and servers. The project implements a Pusher-compatible protocol to integrate with existing frontend client libraries. It includes a dedicated debug dashboard for monitoring active connections, tracking network traffic, and analyzing real-time server performance. The system supports Laravel event broadcasting and

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

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

Luvit is an event-driven runtime for Lua that integrates libuv to provide non-blocking I/O and asynchronous system operations. It functions as an asynchronous network framework and execution environment that leverages Just-In-Time compilation for high-performance script processing. The platform enables the distribution of network traffic across multiple CPU cores through a TCP cluster manager that shares socket handles among child processes. It provides specialized capabilities for building HTTP servers by decoding incoming request streams and encoding responses via a stream processor. The r

PHP-Websockets is a network programming library that provides a persistent server implementation for handling bidirectional real-time communication. It functions as a framework for managing asynchronous data exchange between web clients and server-side application logic, enabling the development of responsive systems that react to incoming messages. The library facilitates the hosting of WebSocket servers by managing persistent connections and pushing live updates to users. It handles the technical requirements of the protocol, including the validation of upgrade requests through handshake ne

Pingora is a Rust-based framework for building high-performance network services, including HTTP reverse proxies, layer seven load balancers, and TLS termination proxies. It serves as an asynchronous network library designed to intercept and route HTTP, gRPC, and WebSocket traffic between clients and upstream backend servers. The project enables zero-downtime service updates by handing over listening sockets between processes during binary or configuration upgrades. It utilizes a programmable multi-phase pipeline to modify request and response bodies and headers, and it provides a pluggable T