Open-source alternatives to Java WebSocket

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

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

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

Websocat is a specialized set of command-line tools for WebSocket communication, acting as a client, server, and stream processor. It provides a terminal-based interface for connecting to WebSocket servers, hosting secure WebSocket servers, and bridging data between WebSockets and other network transports. The project distinguishes itself by functioning as a bidirectional network relay, allowing the routing of data between WebSocket streams, TCP sockets, UNIX sockets, and standard system input and output. It includes specialized implementations for SOCKS5 and HTTP proxying, as well as a strea

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

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

SocketRocket is an Objective-C WebSocket client library designed to establish bidirectional real-time communication channels between an application and a server. It provides a networking layer for real-time data streaming, utilizing a heartbeat monitor to maintain the stability of active network streams. The library is built to operate across restricted networks by routing traffic through HTTP proxies. It secures data transmission using TLS encryption and SSL certificate pinning to prevent unauthorized interception of network traffic. Its underlying capabilities include low-level TCP socket

netty-socketio is a Java implementation of a Socket.IO server designed for real-time bidirectional communication between clients and servers. It functions as a real-time event engine and WebSocket communication server, utilizing the Netty network framework to manage high-performance socket connections. The project enables distributed socket server scaling by acting as a distributed message broker. It synchronizes client states and broadcasts messages across multiple server nodes through the use of an external data store. The system manages traffic via namespace-based connection routing and r

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

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 Python implementation of the Socket.IO bidirectional event protocol. It serves as a realtime communication framework designed for low-latency, event-driven data exchange between a server and multiple connected clients. The framework functions as a distributed message queue integrator, allowing communication to be synchronized across multiple server instances. It manages user sessions and client connections across distributed environments using a shared message queue for synchronization. The system provides capabilities for bidirectional event exchange, real-time state synch

wscat is a command-line WebSocket client and server tool that provides an interactive terminal interface for connecting to WebSocket endpoints, sending and receiving text messages in real time, and managing WebSocket control frames through typed slash commands. It supports basic HTTP authentication by injecting credentials into the initial WebSocket handshake request, and can route connections through an HTTP proxy using the CONNECT tunneling method. The tool includes a built-in WebSocket server mode that listens on a specified port, accepts incoming client connections, and relays messages be

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

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 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

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

Emitter is a distributed pub-sub platform and message broker that provides real-time data routing between publishers and subscribers across a distributed cluster. It functions as an MQTT message broker for low-power devices and a WebSocket communication server for web-based clients, while acting as a secure channel orchestrator to manage encrypted data streams. The system distinguishes itself through a combination of distributed broker clustering for high availability and a persistence-backed message playback system. This allows the platform to store historical messages and deliver them to su

Uvicorn is an ASGI web application host designed for asynchronous Python web development. It serves applications through a standardized asynchronous server gateway interface to handle non-blocking network traffic and high-concurrency requests. The server manages both HTTP and WebSocket traffic, including the handshaking process required to establish persistent, full-duplex communication channels for real-time data exchange. For development workflows, the project includes a hot-reload mechanism that monitors the filesystem for source code changes and automatically restarts the server process.

Robyn is a high-performance asynchronous web framework and server for Python that utilizes a Rust-powered runtime to execute code. It functions as an asynchronous Python web server designed to handle many concurrent requests efficiently through a multithreaded execution model. The project includes specialized capabilities for AI agent request routing, managing communication between agents and external tools. It also serves as a WebSocket communication server, maintaining persistent bidirectional channels for real-time data exchange. The framework covers a broad range of web infrastructure, i

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

Melody is a WebSocket server framework designed to upgrade HTTP connections into bidirectional streams. It functions as a session manager and binary streaming library that facilitates real-time data exchange between a server and multiple remote clients. The project features a broadcast engine that optimizes multi-client transmissions through wire-representation caching. It includes a dedicated session management system for attaching custom state to persistent network connections and an upgrade handler that validates handshake headers. The framework covers broad capability areas including eve

This is a Java library for establishing real-time bidirectional communication with servers using the Socket.IO protocol. It functions as an event-driven communication client that allows Java applications to exchange named events and binary data with a remote server. The library implements both WebSocket and HTTP long-polling transports, providing a fallback mechanism when WebSocket connections are unavailable. It supports namespace-based multiplexing to divide a single physical network connection into multiple logical channels for separating data streams. The project covers a broad range of

This is a Socket.IO client library for Swift, providing an event-driven networking framework for establishing real-time, bidirectional communication between iOS applications and Socket.IO servers. It functions as a tool for maintaining persistent connections and exchanging named data events and binary payloads. The library implements a WebSocket-based transport with an HTTP long-polling fallback to ensure connectivity. It manages a callback-based architecture to handle server notifications and utilizes encrypted communication channels to secure network traffic. The framework covers the excha

grpc-rust is a native gRPC framework for Rust designed for building high-performance remote procedure call clients and servers. It provides an asynchronous communication stack and a protocol buffers implementation for encoding, decoding, and generating type-safe code from service definitions. The project enables the implementation of unary and bi-directional data streaming over the HTTP/2 protocol. It includes specialized support for gRPC-Web integration, allowing browser-based clients to communicate with services through protocol translation. The infrastructure covers a broad range of distr

Javalin is a lightweight web framework for Java and Kotlin designed for building REST APIs and web applications. It functions as an embedded Jetty web server, allowing applications to run as standalone processes without the need for an external servlet container. The project provides specialized frameworks for diverse communication patterns, including a REST API framework with automatic OpenAPI schema generation, a GraphQL API framework with query and mutation resolvers, and a WebSocket server for bidirectional real-time communication. It also includes a dedicated framework for pushing real-t

This is a minimal WebSocket library for Go designed for bidirectional real-time communication. It serves as a network protocol implementation for managing handshakes, frame masking, and control signals to enable the exchange of text and binary messages over persistent connections. The library distinguishes itself by providing a connectivity layer that wraps browser WebSocket APIs for applications compiled to WebAssembly. It also functions as data compression middleware, utilizing deflate compression to reduce bandwidth usage for transmitted messages. The project covers a broad range of netwo

Elysia is a high-performance TypeScript web framework designed for building type-safe backend services. It provides a modular, plugin-based architecture that allows developers to compose server logic, middleware, and validation schemas into scalable application instances. By leveraging native web standards, the framework ensures portability across diverse JavaScript runtimes, including Node.js, Deno, and various edge computing environments. The framework distinguishes itself through its focus on end-to-end type safety, automatically synchronizing request and response definitions between the s