Open-source alternatives to Http2 Spec

gost is a multi-protocol proxy tunnel and secure tunneling server designed to route network traffic through encrypted connections. It functions as a traffic obfuscation gateway and a transparent proxy server capable of intercepting TCP and UDP traffic at the IP level. The project also includes a virtual network interface manager for creating TUN and TAP devices to intercept operating system packets. The system distinguishes itself through a chain-based request routing model, allowing traffic to pass through an ordered sequence of proxy nodes. It provides extensive transport-layer encapsulatio

FreeRDP is a full software implementation of the Remote Desktop Protocol, providing both client and server capabilities for remote session management. It functions as an RDP client library and a standalone remote desktop client, enabling remote connectivity and interoperability across different operating systems. The project includes a dedicated network device redirector and an RDP gateway client to handle authentication and proxy routing. It allows developers to integrate remote desktop functionality into third-party software applications via its client library. The software covers a wide r

cmux is a TCP connection multiplexer and layer four protocol dispatcher. It routes incoming network traffic to different backend handlers by analyzing the initial bytes of the payload, allowing multiple network protocols to share a single IP address and port. The project identifies traffic using protocol signatures, byte-prefix matching, and header-value evaluation. It supports the detection of specific protocols including TLS, HTTP/1, and HTTP/2, and enables bidirectional handshaking where data can be sent back to a client during the matching phase. The routing system includes a first-match

This is a Go client library and protocol implementation for interacting with message brokers using the AMQP 0.9.1 standard. It serves as an asynchronous messaging toolkit and message queue client for implementing producer and consumer patterns. The library provides a programmatic interface for managing the full message lifecycle, including publishing, consumption, and delivery acknowledgments. It supports reliable delivery mechanisms such as publishing confirmations and atomic transactions. The project covers the administration of routing topologies through the declaration and binding of que

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

Rathole is a reverse proxy tunneling tool designed to expose local services behind firewalls and network address translation to the public internet. It functions as a secure tunneling infrastructure that enables remote access to private network resources without requiring manual router port forwarding configurations. The system utilizes a client-server architecture where a public-facing gateway coordinates with a private-network agent. It distinguishes itself by multiplexing multiple logical service connections through a single persistent TCP stream, which reduces the overhead of maintaining

Echo is a high-performance, lightweight web framework for Go designed for building scalable RESTful APIs and web services. It provides a centralized environment for mapping network requests to handler functions, utilizing a fast radix-tree routing engine to ensure efficient request dispatching. The framework is built around a modular, middleware-centric pipeline that allows developers to execute reusable logic for cross-cutting concerns like authentication, logging, and security across the entire application. What distinguishes Echo is its focus on developer productivity through structured da

rust-libp2p is a modular peer-to-peer networking library written in Rust, implementing the libp2p specification. It provides a composable stack of transport, security, and discovery protocols that can be mixed and matched to build decentralized applications, with a central swarm manager coordinating all active connections, protocol negotiation, and peer lifecycle. The library distinguishes itself through a pluggable transport abstraction that supports TCP, QUIC, WebSocket, WebRTC, and WebTransport, enabling cross-platform operation across browsers, mobile devices, and servers. It secures ever

Hyper is a low-level networking library designed for building high-performance HTTP clients and servers. It provides a foundational toolkit for creating network services that leverage asynchronous execution and memory-safe data handling, supporting both HTTP/1 and HTTP/2 protocols. The library distinguishes itself through a protocol-agnostic architecture that separates transport logic from HTTP semantics. It utilizes a service-trait abstraction to decouple network logic from the underlying transport, enabling developers to inject custom middleware for request interception and response transfo

Chisel is a network tunneling tool that facilitates secure communication by encapsulating TCP and UDP traffic within HTTP requests. It functions as a connection multiplexer, consolidating multiple logical network streams into a single persistent connection to improve throughput and reduce overhead. By leveraging standard web protocols, the system enables firewall traversal and provides a mechanism for remote port forwarding and proxying. The project distinguishes itself through its focus on resilient connectivity and granular access control. It maintains persistent network sessions across uns

Stockfish is a high-performance chess engine designed to evaluate board positions and calculate optimal moves. It functions as a command-line tool that utilizes neural network-based search algorithms to assess complex game states and determine strategic advantages. The engine is fully compliant with the Universal Chess Interface, allowing it to exchange commands and move data with external graphical user interfaces and professional analysis software. The engine distinguishes itself through advanced computational strategies that maximize hardware efficiency and search depth. It employs multi-t

Rueidis is a high-performance Redis client library for Go that provides a type-safe and asynchronous interface for interacting with Redis servers. It includes a full implementation of the Redis serialization protocol and a dedicated connection manager to handle pooling, multiplexing, and automatic pipelining. The library is distinguished by its support for RDMA connectivity to reduce latency and CPU overhead. It features a distributed lock manager that implements majority-based locking and optimistic concurrency control, as well as client-side caching with invalidation signals to minimize net

This project is a reverse engineering implementation and library designed to parse and decrypt the binary data streams used by the WhatsApp web client. It provides a WebSocket client library and tools to communicate with messaging servers by implementing reverse engineered protocol patterns. The system enables the development of custom clients and automation tools through the emulation of browser sessions and the management of persistent binary streams. It handles account authentication via QR code generation and pairing strings to link devices and maintain encrypted sessions. The project co

Rathole is a high-performance reverse proxy and NAT traversal tool written in Rust. It functions as a secure tunneling server and client architecture designed to expose local services to the internet by forwarding traffic from a public IP to a private device behind a firewall. The system establishes encrypted tunnels between a public server and a private host to ensure private communication. It utilizes token-based authentication to validate identities between the server and client for each individual service. The project provides TCP and UDP port forwarding and manages private tunnels to fa

wstunnel is a tool that tunnels arbitrary TCP traffic through WebSocket connections, enabling communication across restrictive firewalls and proxies. It operates as both a client and server, encapsulating TCP data within WebSocket binary frames and multiplexing multiple connections over a single WebSocket link. The tool supports mutual TLS authentication, requiring clients to present signed certificates for verification before establishing a tunnel, and provides shared secret access control and tunnel forwarding restrictions for additional security. The project distinguishes itself by offerin

libp2p is a modular peer-to-peer networking stack designed for building decentralized applications. It provides the core infrastructure necessary for nodes to discover and connect with other participants across a network without relying on central servers. The project distinguishes itself through a flexible transport layer that abstracts multiple protocols, including TCP, QUIC, WebSockets, and WebTransport, into a single interface. It features specialized tools for NAT and firewall traversal, such as hole punching and relay nodes, to establish direct connections between peers and web browsers

General purpose redis client

open62541 is an open-source implementation of the OPC Unified Architecture standard, providing a complete stack for industrial automation and data exchange. It functions as both an OPC UA server and client, enabling the creation of an object-oriented address space to model physical industrial assets and their relationships. The project is designed for versatility across diverse hardware, offering a C99 library that can be deployed to both cloud servers and resource-constrained embedded environments. It distinguishes itself through a pluggable network layer and interface-based security backend

brpc is a high-performance C++ RPC framework and network programming library designed for building distributed systems. It functions as a multi-protocol RPC server capable of hosting and detecting multiple communication protocols, including gRPC, Thrift, HTTP, Redis, and Memcached, on a single TCP port. The project distinguishes itself through high-throughput data transport and memory efficiency, utilizing RDMA-based transport to bypass the kernel TCP stack and zero-copy memory management to eliminate data duplication. It also implements the Raft algorithm for consensus-based state replicatio

pgdog is a PostgreSQL sharding proxy, distributed SQL router, and connection pooler. It is designed to enable horizontal data distribution by splitting tables and indices across multiple independent servers to scale storage and processing capacity. The project distinguishes itself through online resharding capabilities, using logical replication to move data between shards without application downtime. It supports multiple routing strategies, including hash, list, and range-based query routing, and manages distributed atomic transactions using a two-phase commit process to ensure consistency

Granian is a Rust-based HTTP server written specifically to serve Python web applications. It supports the three major Python gateway interfaces—ASGI for asynchronous apps, WSGI for synchronous apps, and RSGI for async requests—while also handling HTTP/1.1, HTTP/2, and WebSocket connections through automatic protocol negotiation. Architecturally, Granian uses a multiprocess worker model that isolates requests across CPU cores and provides configurable threadpool-limited concurrency to control backpressure per worker. It includes built-in Prometheus metrics exposition for connection counts and

ssh2 is a JavaScript implementation of the SSH2 protocol for Node.js, providing the core components necessary to create secure clients and servers. It enables the establishment of authenticated sessions for remote server automation and secure communication. The project distinguishes itself by providing a complete suite of tools for identity management, including utilities for generating and parsing cryptographic key pairs and integrating with external authentication agents. It also functions as a tunneling proxy capable of routing TCP, HTTP, X11, and SOCKSv5 network traffic through encrypted

Primus is a real-time communication abstraction layer and middleware framework. It provides a standardized interface for messaging that allows developers to switch between different transport engines without rewriting application logic, while also serving as a wrapper for managing socket lifecycles. The project distinguishes itself by functioning as a real-time client library generator, producing compatible client-side code based on server configurations. It further organizes data flow through virtual stream multiplexing and the ability to group connections into named communication rooms for

MsQuic is a cross-platform, C-based implementation of the QUIC protocol. It provides a network library for establishing encrypted and authenticated transport links over UDP, integrating TLS to ensure all data flows between endpoints are encrypted. The implementation utilizes a language-agnostic binding layer to support high-level languages including C#, Rust, and C++. It features connection-ID based migration to maintain active sessions when IP addresses or ports change, and employs multi-stream multiplexing to manage independent data flows within a single connection. The library covers netw

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

Atmosphere is a Java-based framework for building and coordinating AI agents. It provides a real-time transport layer for streaming data via WebSockets, SSE, gRPC, and WebTransport, alongside a multi-agent orchestration framework for managing agent fleets through sequential, parallel, and graph-based execution workflows. The project features a durable workflow engine that persists agent state as snapshots, allowing long-running tasks to survive system restarts and incorporate human-in-the-loop approvals. It also implements Model Context Protocol servers to expose tools, resources, and prompt

SSH.NET is a .NET library that implements the SSH-2 protocol for encrypted remote connections and secure file transfers. It provides a complete SSH-2 protocol stack implementation with a channel multiplexing engine that manages multiple concurrent channels over a single connection, supporting simultaneous shell sessions, remote command execution, SFTP transfers, and port forwarding tunnels. The library includes a pluggable authentication pipeline supporting password, public key, certificate, keyboard-interactive, and multi-factor authentication combinations. The library distinguishes itself t