HTTP Framework Benchmark Arena

An open benchmarking platform that measures HTTP, gRPC, and WebSocket framework performance under realistic workloads using io_uring-based load generation. Add your framework, get results automatically.

See which frameworks handle the most requests per second, ranked by throughput.

Set up and run the full benchmark suite on your own machine with Docker and gcannon.

Add a Framework

Add your framework with a Dockerfile and open a PR. Three steps to join the arena.

28 Test Profiles Across H/1.1, H/2, H/3, gRPC and WebSocket

Every framework is tested under diverse, realistic workloads — from raw throughput to JSON processing, gRPC unary calls, and WebSocket echo.

H/1.1 Isolated

Mixed GET/POST with keep-alive connections, query parsing, and chunked encoding.

GET/POST /baseline11

Short-lived Connection

Connections closed after 10 requests — measures TCP handshake overhead.

GET/POST /baseline11 (10 req/conn)

JSON Processing

Load dataset, compute derived fields, serialize ~10 KB JSON response.

GET /json/{count}

JSON Compressed

Same JSON workload with Accept-Encoding: gzip, br — measures serialization + compression.

GET /json/{count}?m=N

Same JSON workload over HTTP/1.1 + TLS on port 8081 — measures encryption overhead on top of serialization.

GET /json/{count}?m=N (HTTPS :8081)

Ingest a 20 MB binary payload and return its byte count.

Async Database (Postgres)

Async Postgres query over 100K rows — tests event loop scheduling, connection pooling, and async driver efficiency.

GET /async-db?limit=N

Round-robin across 20 static files — CSS, JS, HTML, fonts, images.

Pipelined (16x)

16 requests sent back-to-back per connection. Tests pipeline batching.

CRUD (REST API)

Realistic REST API with paginated list, cached reads, create, and update against Postgres.

GET/POST/PUT /crud/items

Fortunes (Templates) *

DB query + HTML template rendering with auto-escape. Reference-only — measures template-engine throughput.

H/1.1 Workload

Lighter workload (baseline, JSON, async-db) constrained to 4 CPUs and 16 GB memory — measures efficiency under limited resources.

GET/POST mixed endpoints (4 CPU, 16 GB)

Same API workload (baseline, JSON, async-db) with 16 CPUs and 32 GB memory — tests performance scaling.

GET/POST API endpoints (16 CPU, 32 GB)

H/2

Multiplexed HTTP/2 streams over TLS with 100 concurrent streams per connection.

GET /baseline2 (h2)

Round-robin across 20 static files — CSS, JS, HTML, fonts, images.

GET /static/* (h2)

Cleartext HTTP/2 prior-knowledge on port 8082. No TLS — models reverse-proxy-to-origin and service mesh internals. Anti-cheat rejects dual-serving HTTP/1.1.

GET /baseline2 (h2c :8082)

Same JSON serialization workload as the H/1 json profile, served over cleartext h2 on port 8082.

GET /json/:count (h2c :8082)

Gateway

Two-service proxy + server stack over HTTP/2 + TLS. Mixed workload: static, JSON, baseline, async-db.

proxy:8443 → server (h2)

Same two-service stack as Gateway H2 but with HTTP/3 + QUIC at the edge.

proxy:8443 → server (h3/quic)

Production Stack H2

Four-service CRUD API: edge + Redis + JWT auth sidecar + server. 10K-item cache-aside, concurrent reads + writes.

edge:8443 → authsvc → server → redis/postgres

H/3

HTTP/3 over QUIC — measures framework performance with UDP-based transport.

GET /baseline2 (h3)

Multi-URI static file serving over QUIC with parallel streams.

GET /static/* (h3)

gRPC

Unary gRPC call over cleartext HTTP/2 — raw Protocol Buffers throughput without TLS overhead.

BenchmarkService/GetSum (h2c)

Same unary gRPC call over encrypted HTTP/2 with TLS 1.3.

BenchmarkService/GetSum (TLS)

Server-streaming gRPC over cleartext HTTP/2 — sustained message throughput over a single long-lived call.

BenchmarkService/StreamSums (h2c)

Same server-streaming gRPC call over encrypted HTTP/2 with TLS 1.3.

BenchmarkService/StreamSums (TLS)

WebSocket

WebSocket echo throughput — upgrade, send pipelined text messages, receive echoes. Measures frame processing performance.

Same WebSocket echo with 16 messages in flight per connection — measures frame batching and read-buffer draining under burst load.

WS /ws (echo, p=16)