EdgeRush

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

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