Open-source alternatives to Reverse Proxy

Tengine is an enhanced Nginx web server distribution designed for high-traffic environments. It functions as a high-performance reverse proxy, dynamic load balancer, and HTTP/3 proxy server, integrating an embedded Lua scripting engine to allow for custom business logic and dynamic request processing. The project distinguishes itself through a focus on modern transport protocols and efficiency, featuring native support for QUIC and HTTP/3 to reduce connection latency. It implements userspace UDP forwarding to bypass the kernel for higher throughput and provides the ability to dynamically upda

Ocelot is a .NET API gateway that functions as an HTTP reverse proxy to route, balance, and secure traffic between clients and backend services. It serves as a centralized manager for incoming requests, providing a single entry point for traffic orchestration. The project differentiates itself through dynamic request orchestration, allowing it to aggregate multiple backend service responses into a single result to minimize client network round trips. It also supports dynamic gateway configuration, enabling updates to system behavior and operational parameters without requiring a service resta

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

This project is a Kubernetes Ingress Controller that functions as a layer 7 traffic router and NGINX reverse proxy. It serves as a secure network gateway, directing external HTTP and HTTPS traffic to backend services within a cluster based on declarative routing rules. The controller acts as a TLS termination gateway to secure traffic and integrates with Prometheus to expose request metrics and latency data for cluster monitoring. It supports canary deployment workflows by implementing weight-based traffic splitting between different versions of a service. The system manages external access

Polka is a minimalist Node.js web framework and HTTP routing engine. It provides a small-footprint server implementation designed for low overhead, mapping URL paths and HTTP methods to specific handler functions. The project utilizes a middleware-based architecture, processing requests through a sequence of functions to handle tasks such as logging, authorization, and data modification. It allows for the organization of these functions into global and path-filtered groups to control execution order. The framework covers core web capabilities including route parameter extraction, request URL

Lura is an API gateway and traffic router that directs network requests to backend services using a configurable pipeline of processing steps. It functions as a backend load balancer and a request middleware engine designed to validate, modify, and transform incoming requests and responses. The system specializes in API response aggregation, allowing it to execute concurrent requests to multiple backend services and merge the results into a single unified output. This includes the ability to perform dynamic response mapping by renaming fields and filtering data to optimize the final client pa

Oak is a cross-runtime HTTP middleware framework and web server designed to operate across Deno, Node.js, Bun, and Cloudflare Workers. It provides a unified system for building APIs and web servers using a sequential chain of middleware functions and a hierarchical routing engine that maps URL paths to handlers via a nested tree structure. The framework includes a runtime-agnostic serverless adapter that translates diverse cloud provider events into a standard request and response interface. It also features a dedicated WebSocket server implementation for bidirectional real-time communication

Kitura is a server-side web framework for building HTTP services and web applications using the Swift programming language. It functions as an HTTP server that handles incoming requests, routes traffic, and serves responses. The framework serves as a Codable REST API framework, enabling the encoding and decoding of native Swift data types for web service communication. It also provides a FastCGI web interface to connect Swift applications to external web servers for improved scalability. The system includes capabilities for secure web communication through SSL/TLS network encryption, server-

Crow is a minimalist C++ micro web framework designed for building fast web servers and REST APIs. It provides a lightweight toolkit for web development in C++, offering core routing and request handling capabilities. The framework includes a built-in JSON parser for converting strings into structured data and an HTML template engine for generating dynamic web pages on the server. It also functions as a WebSocket server library to enable bidirectional, real-time communication between servers and web clients. Additional capabilities include a middleware-based request pipeline for executing sh

OpenWhisk is a serverless cloud platform designed for deploying and executing stateless functions in response to API calls or events. It serves as a complete serverless stack, providing an API gateway for functions, a function-as-a-service runtime manager, and an event-driven workflow engine. The platform distinguishes itself through a polyglot execution model that supports multiple language runtimes and allows for the creation of custom runtimes using Docker containers. It enables complex logic through function orchestration and composition, allowing multiple functions to be chained into seq

Kitura is a server-side web framework for building web applications and APIs using the Swift programming language. It provides a native HTTP server for hosting network traffic and implementing REST APIs. The framework features a pluggable middleware architecture that allows for the insertion of custom logic into the request-response pipeline. It utilizes a Codable data processor to automate the serialization and deserialization of HTTP requests and responses using Swift data models. The system includes a trie-based route matching mechanism for mapping URL paths to handlers and supports the F

v2ray-core is a network proxy framework and custom proxy engine designed for censorship circumvention. It functions as a traffic routing platform that directs network data between inbound and outbound connections to access blocked content and services. The system employs a modular architecture using pluggable protocol handlers and a chain-based connection pipeline to transform and forward network traffic. It provides secure tunneling infrastructure to establish encrypted connections and uses a rule-based routing system to direct data between protocols and destinations. The framework includes

This is a TypeScript web framework and Node.js backend framework used to build web applications and API servers. It serves as a server-side application toolkit providing a structured environment for managing HTTP routing, request parsing, and application configuration. The framework features a dependency injection container to deliver required objects between application components, decoupling internal logic. It includes built-in tools for server-side data security, such as cryptographic drivers for hashing sensitive data and encrypting application data at rest. The project covers broad capa

libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP, WebSocket, and MQTT clients and servers. It provides a non-blocking event loop for managing network sockets, timers, and system signals across multiple threads. The project is distinguished by its integrated support for specialized network roles, including a full HTTP web server with RESTful routing and middleware, an MQTT messaging client for IoT communication, and the ability to implement SOCKS5 and HTTP proxies. It also features a reliable UDP implementation to ensure ordered

This project is an API gateway and ingress controller designed to manage traffic, security, and service connectivity within Kubernetes environments. It operates as a controller that monitors cluster state to reconcile gateway configurations with desired infrastructure definitions, ensuring that network policies and routing rules remain consistent across distributed deployments. The system distinguishes itself through a modular request pipeline that allows for the injection of custom logic to handle transformations, security checks, and logging. It supports declarative infrastructure managemen

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

Guzzle is a PHP HTTP client used for sending synchronous and asynchronous requests to web services. It serves as a concurrent HTTP request manager, an HTTP stream handler, and a middleware-based HTTP pipeline. The project is a PSR-7 compliant client, utilizing standardized PHP interfaces for requests, responses, and streams. The library differentiates itself through a customizable functional handler stack that allows for the interception and modification of the request and response lifecycle. It features an adapter-based transport system that enables swapping between network implementations,

Kubo is a peer-to-peer implementation of the InterPlanetary File System (IPFS) designed for decentralized data storage and content delivery. It uses content-addressing, directed acyclic graphs, and distributed hash tables to identify, distribute, and retrieve data across a network without relying on central servers. The project differentiates itself by providing a virtual filesystem via FUSE, which maps decentralized network namespaces to local operating system directories for direct file access. It also includes integrated HTTP gateways that translate peer-to-peer content into standard web t

BPB-Worker-Panel is a control panel designed for deploying and managing VLESS and Trojan proxies hosted on Cloudflare Workers. It functions as a proxy subscription generator and a manager for secure DNS over HTTPS servers and WireGuard configuration provisioning. The project distinguishes itself through network traffic obfuscation capabilities, utilizing packet fragmentation and SNI spoofing to evade detection. It provides specialized administration for Cloudflare Warp and Warp Pro connections, including the ability to optimize endpoints and export WireGuard configurations. The system covers

Drogon is a high-performance C++ HTTP web framework and asynchronous web server designed for building web applications and REST APIs. It utilizes an event-driven, non-blocking architecture to handle concurrent HTTP and WebSocket connections, and it implements a model-view-controller structure to separate business logic from presentation. The framework includes an integrated C++ object-relational mapping system and database client for performing asynchronous operations with relational databases and Redis key-value stores. It supports real-time, full-duplex communication via WebSockets and prov

Go-micro is a distributed systems development toolkit designed for building, connecting, and managing modular microservices. It provides a comprehensive framework for service discovery, remote procedure call abstraction, and event-driven messaging, allowing developers to create decoupled architectures that communicate asynchronously through shared message brokers. The project distinguishes itself by integrating autonomous agent orchestration and language model tool binding directly into the service lifecycle. By exposing internal service endpoints as standardized tools, it enables AI agents t

NodeBB is a real-time, self-hosted community forum platform built on Node.js. It is designed to support scalable discussion environments by utilizing a document-oriented database for content storage and an in-memory engine for high-speed data retrieval and session management. The platform provides a comprehensive administrative interface for managing user groups, forum settings, and system health. What distinguishes the platform is its native support for federated social networking via the ActivityPub protocol, allowing forums to exchange content, synchronize discussions, and interact with de

This project is an educational framework designed to teach the fundamentals of building core distributed systems and web services from scratch in Go. It provides a collection of modular implementations that demonstrate how to construct essential infrastructure components, including web servers, remote procedure call systems, distributed caches, and database abstraction layers. The framework distinguishes itself by focusing on the internal mechanics of these systems rather than providing a high-level abstraction for production use. It covers the implementation of complex architectural patterns

Sanic is a Python ASGI web framework and asynchronous HTTP server. It is designed to build high-performance web applications and servers that handle concurrent requests using non-blocking logic. The framework implements the Asynchronous Server Gateway Interface standard, allowing applications to be deployed across various ASGI-compatible servers. It utilizes an asyncio-based event loop and integrates a Cython-based runtime wrapper around libuv to manage I/O operations. The system manages traffic through route-based request dispatching and a middleware-based request pipeline. These components

Zuul is an API gateway service that manages incoming network traffic to backend services. It serves as a routing layer and edge security proxy that provides centralized control over security and monitoring for microservices. The project implements a dynamic request router that maps incoming paths to backend locations using configurable rules that can be updated at runtime. It also includes a circuit breaker implementation to monitor backend failure rates and stop traffic to failing services to prevent cascading outages. The gateway provides a filter-based request pipeline for processing traf

AWS Powertools for Python is a utility framework designed for building production-ready Python functions on AWS Lambda. It provides a comprehensive suite of tools for observability, event parsing, routing, and idempotency management to streamline the development of serverless applications. The project distinguishes itself through specialized capabilities for event-driven architectures and AI agent orchestration. It enables the implementation of AI agents by exposing functions as tools via OpenAPI schemas and managing conversation states. Additionally, it features an idempotency library that p

Etherpad-lite is a web-based platform designed for real-time collaborative text editing. It enables multiple users to view and modify the same document simultaneously, utilizing an operational transformation engine to synchronize content across all connected client sessions. The platform distinguishes itself through a modular, plugin-based architecture that allows for the integration of third-party extensions to introduce custom functionality. It provides a comprehensive programmatic interface for document management, allowing users to automate the creation, update, and retrieval of text docu