A Kubernetes-native API gateway.
Built around a focused proxy core, with the ambition to bring Ingress and Gateway API together in one data plane. Open source, with low added latency and useful built-in features as first principles.
Status: the data plane runs, and the control plane runs it in a cluster; the operator is next. The proxy serves traffic from a YAML file, the development harness, or from a control plane that translates a cluster's Ingresses and Gateway API objects and streams the config to it. Rate limiting runs, each pod on its own or through EdgeRush's rate-limiting service. Not for production. A hobby project with no timelines.
What we are working towards
These are project goals. The proxy, rate limiting and the control plane work today; the operator is next.
One data plane for Ingress and Gateway API
Side by side, from ordinary Kubernetes objects. Ingress stays a first-class API.
Operator-driven
ControlPlane and DataPlane resources become Deployments
and Services; one control plane can drive many data planes, each its own failure
domain.
Rate limiting, per pod or cluster-wide
Limits enforced by each pod on its own, or across the cluster by EdgeRush's own rate-limiting service, which keeps its counts in memory: no external store to run. Limits keep working when the control plane is down.
Performance, measured
Thread-per-core on Tokio, our own HTTP/1 server and client, compiled filter chains, and a benchmark harness for comparing proxies on the same machine. Our latest published run covers NGINX and HAProxy, with methodology and limitations alongside the results.
Why build another gateway?
EdgeRush starts from a frustration with a fragmented API gateway market: the combination a team needs can be spread across products, paid tiers and custom plugins. We want a coherent, open-source gateway that makes common ingress needs straightforward to operate.
Useful features in the open
Our ambition is to make core gateway capabilities available together under Apache-2.0, without putting essential features behind a paywall. Ingress and Gateway API should coexist so teams can adopt at their own pace.
A focused request path
Bloated plugin architectures can add dispatch, allocation and integration costs to every request. We aim to cover common needs with built-in features and compiled configuration, keeping unnecessary work out of the request path. Performance remains something to measure with features enabled.
What works today
- Protocols: HTTP/1.1, HTTP/2 and HTTP/3 (QUIC) from clients; gRPC; WebSocket
- TLS on BoringSSL: certificates chosen by SNI, mTLS both ways
- Routing: Gateway API's matches and precedence; redirects, rewrites and mirrors
- Upstreams: load balancing, health checks, timeouts and retries
- L4: TCP and TLS passthrough, PROXY protocol
- Operations: Prometheus metrics, JSON access logs, a drain on SIGTERM
- Rate limiting: token-bucket limits on routes, enforced per pod or
by EdgeRush's rate-limiting service; dry runs; 429 with
Retry-After - Kubernetes:
edgerush controllertranslates Ingresses and Gateway API objects (Gateways, ListenerSets, HTTP, gRPC, TLS and TCP routes, BackendTLSPolicies) as the cluster changes and streams the config to data planes over mutual TLS; their status and an admission webhook; the data plane follows EndpointSlices itself, prefers endpoints in its own zone, and never sends to the gateway's own pods - Config tools:
edgerush explainshows where a request would go and why;edgerush testchecks routing expectations for CI;edgerush validatetranslates Kubernetes manifests offline
Still to come: the operator, and with it Gateway API's conformance runs; ingress-nginx's annotations; authentication; CORS.
Rate limiting, one mode per data plane
Limits are named on route rules and keyed by the client's address. A request under several limits is decided under all of them at once, and a dry run counts without refusing. How limits are enforced is a choice made once for each data plane.
Off, by default
Limits are compiled and checked but none is enforced, and nothing runs on the request path. Turning limiting on or off needs no edit to the routes.
Local: each pod on what it sees
No service to run. A pod's workers share each key's bucket, a single atomic word updated by compare-and-swap, so a decision takes no lock. A client spread over several pods can get up to that many times its limit.
Synchronous: one owner decides
Each key has an owner in EdgeRush's rate-limiting service, three pods or more, which decides every request; each worker keeps its own stream to each pod. The pods copy their keys to one another, so a pod's keys carry on when it leaves.
Asynchronous: each pod from its copy
Each pod decides every request from its own copy of each key, waiting on no one, and shares what it admitted through the rate-limiting service every cycle. A burst on a key it has not heard of yet may overshoot a little.
Stated behaviour when the service is unreachable
A request waits for its owner at most a configured time, and a breaker cuts off an owner that keeps failing. What happens meanwhile is stated, never assumed: allow, deny, or the data plane's own buckets until the owner answers.
Explore the implementation: the limiters and the rate-limiting service.
Inside the proxy
The proxy architecture is mostly settled. This overview describes the implemented data plane, currently driven by YAML for development and testing. The Kubernetes controller and rate limiting are outside this overview.
Connections stay with a worker
The runtime uses a thread per core, each running a single-threaded Tokio runtime. Once assigned, a connection stays with its worker, alongside that worker's upstream pools. This keeps connection state local instead of moving requests between runtime threads.
Several protocols, one request core
HTTP/1.1, HTTP/2 and HTTP/3 adapters feed a shared request core. EdgeRush has its own HTTP/1 server and client, uses h2 for HTTP/2 and quiche for HTTP/3. Backends speak HTTP/1.1 or HTTP/2; the client's protocol does not dictate the backend's protocol.
Compile before serving
Configuration becomes per-listener routers, rule actions and resolved upstream references. Routing and built-in filters are separate from network I/O. The request core normalises the host and path before matching, so routing and forwarding use the same interpretation unless a configured rewrite changes it.
Publish configuration as a snapshot
A reload publishes the compiled configuration atomically. A request reads one snapshot to make its routing decision and retains the rule it needs. Listening sockets and upstream connections live outside those snapshots, so replacing routing configuration does not require restarting the proxy.
Stream through pooled upstreams
Request and response bodies stream between client and backend. Worker-local pools reuse upstream connections; load balancing and health checks choose endpoints. Timeouts and retry budgets bound attempts. WebSockets become tunnels after their handshake; TCP and SNI-routed TLS passthrough have a separate L4 path.
Make behaviour inspectable
Prometheus metrics, JSON access logs and graceful draining support operation.
The offline explain and test commands use the request
core to show routing decisions and check configuration expectations without
starting a proxy.
Explore the implementation: proxy and protocol adapters, configuration compiler, router and offline inspection tools.
Measured, with context
EdgeRush, NGINX and HAProxy, compared on like for like hardware with the same workload. See the 4 October 2026 results and methodology.
Get involved
- edgerush — the code, and a README that shows how to try it
- Contributing — contributions of any size are welcome, AI-assisted ones included
- Security — report problems privately
- hello@edgerush.dev — anything else