Workloads
Each workload is one part of a server’s job. Every server must answer the same bytes, checked against a reference before it races. How a race runs and what it reports follow the workloads.
Plaintext GET /plaintext
GET /plaintext answers 13 bytes over kept-alive connections: the cost of HTTP itself.
Every server answers Hello, World! as text/plain. There is nothing to compute, so what is measured is the server's own work a request: reading and parsing it, routing it, writing the headers and the body, and the system calls in between. It is the fastest any server goes; each workload below adds one cost to it.
HTTP/1.1HTTP/2 (h2c)HTTP/2+TLS
Echo 4 KiB POST /echo
POST /echo with a 4 KiB body, answered with the same bytes: reading bodies and writing larger responses.
The body is 4,096 bytes of application/octet-stream, sent back as it came (a server must take up to 64 KiB). Against Plaintext it adds reading a body off the socket and writing a response larger than a packet. On the dedicated class the fastest servers fill the droplet's network link and tie there; each round records the traffic, and the race page says when the network was the limit.
HTTP/1.1HTTP/2+TLS
Templates GET /catalog
GET /catalog renders an 8.7 KB page from a template per request: a record's fields, lists in lists, 96 rows with nine formatted values each, conditions, empty lists and raw HTML: the work of a server-rendered page.
Each server renders the same page with its language's usual template engine, anew for every request, from data made once at start: no cached response. Rows i = 0 to 95 with id i + 1, name NAMES[i % 8], price 500 + (i * 7919) % 20000 hundredths written as 12.05 kr, a discount of (i * 37) % 40 percent (on sale when above 0, the price after it rounded down and the old one struck through), stock (i * 13) % 50 - 10 written as out, 3 left or 16 and as the row's class out, low or ok, hot (a second class) when i % 7 is 0, tags none, veg, or veg and gf by i % 3, added on day (i * 53) % 365 of 2026 written as MM-DD, and 50 + (i * 997) % 5000 grams written as 350 g or 1.25 kg; six groups, group k named Group k + 1 with NAMES k, k + 1 and k + 2 (mod 8); three offers with a percentage each; the prices' total; NAMES are Roux, Skyr & ber, Crème, <b>Stew</b>, Hákarl, Kjöt "s", O'Brien and Pylsa, each escaped where it is printed; a row is a list item, its values separated by commas. Its bytes are kept small, since it measures template rendering rather than the network. The page is checked against workloads/templates.html byte for byte before the race (an entity may be spelled & or &). Until 2026-11-04 this workload was a 12-row menu under a kilobyte, which no engine found hard; its history before that date is the menu's.
HTTP/1.1HTTP/2+TLS
SSE (Datastar) GET /sse
GET /sse with Datastar's signals in the query, answered with a stream of ten Datastar events, a chunk each: the work of a Datastar action.
The signals arrive as JSON in the datastar query parameter, {"count":41}. The answer is a text/event-stream for a count of 42: the new signal, an element patched with it, and eight list items appended, each event a chunk of its own, made and sent in turn with the server's own SSE support, then the end of the stream. Without good signals a server answers 400. This is what a Datastar page's button costs the server: read the signals, stream the patches, finish.
HTTP/1.1HTTP/2+TLS
Connection churn GET /plaintext
GET /plaintext on a new connection every request: accepting, and closing, as fast as possible.
Each request opens a TCP connection, sends Plaintext's request and closes the connection after its answer: the accept, the first read, the answer and the teardown, every time. Every other workload keeps its connections alive, which hides this cost; here it is all there is. It is what a server pays for each new client.
HTTP/1.1HTTP/1.1+TLS
RealWorld (Conduit) /api/articles
An article listing, an article, a comment and a favorite, all at once, on SQLite: an application's reads and writes.
A slice of RealWorld's Conduit API, the backend of a blogging site: a page of twenty articles, one article with its body, a comment posted and an article favorited, the two writes signed in with a token. Each server keeps the data in SQLite, seeded the same for everyone (100 users, 1,000 articles, with their tags, favorites and comments) and opened in WAL mode with synchronous=NORMAL; its answers are checked against the seed's model before the race.
Open loop only: list 50%, article 30%, comment 15%, favorite 5%; 250 to 32,000 requests a second, the same for every server, each climbing until it falls behind or a request fails.
HTTP/1.1HTTP/2+TLS
Variants
Each test is raced in each of its variants: the same requests and the same answers, carried another way. The race page’s tabs are HTTP/1.1 and HTTP/2 + TLS; h2c sits below either.
HTTP/1.1
Plain HTTP/1.1, as a server behind a proxy sees it.
- 256 connections Plaintext, Echo 4 KiB, Templates, SSE (Datastar), RealWorld (Conduit)
- 64 one-shot connections Connection churn
HTTP/2 (h2c)
HTTP/2 without TLS, by prior knowledge: HTTP/2's own cost, apart from TLS's. No browser speaks it.
- 32 connections × 8 streams Plaintext
HTTP/2 + TLS
The realistic deployment: HTTPS as browsers reach a server with no proxy in front. TLS 1.3, AES-128-GCM, X25519, an ECDSA P-256 certificate, no session resumption; HTTP/2 by ALPN (churn: HTTP/1.1). basic-webserver serves no TLS.
- 32 connections × 8 streams Plaintext
- 128 connections × 2 streams Echo 4 KiB, Templates, SSE (Datastar), RealWorld (Conduit)
- HTTP/1.1+TLS64 one-shot connections Connection churn
Definitions: race.json.
The race
- Machines. Each server class gets a fresh server droplet and a loader droplet at least as big, running oha, both in the class’s region, over its private network. The classes race at the same time; every droplet is deleted afterwards.
- Checks. Before racing,
/plaintextmust answer exactlyHello, World!,/echothe body it was sent,/menuthe reference page,/ssethe reference stream with one chunk per event (and 400 without signals), and an unknown path 404; over TLS, TLS 1.3 with HTTP/2 by ALPN; without TLS,/plaintextover h2c too. RealWorld’s answers are checked against the seed’s model before its climb. Each mode, with TLS and without, is checked on its own: a server that fails one is a DNF there and still races the other. - Builds. Each server is built and configured the way its users ship it. Every dependency is pinned but fourneau and roux, which race their master; each race records their commits and the toolchains’ versions.
- Noise. Every round records CPU steal, and each machine its CPU model, so a night’s hardware shows in its data.
Closed loop
oha holds N connections (each workload’s above), each sending its next request when the last answer lands, so every server runs flat out at its own pace. Each closed-loop workload (all but RealWorld) gets, in each of 3 rounds of a seeded random order, a warmup of 5 s, discarded, then a measured run of 20 s.
- Throughput is the best round’s, as a benchmark takes the fastest of its repeats: a server can do no more than it did, and a round that fell short met noise (a neighbour, the network, a frequency change).
- Each latency percentile is the rounds’ median: a tail is the server’s own rare stalls, so the least would report the round that missed them and the most the round a neighbour hit.
By Little’s law latency ≈ N ÷ throughput: these are a saturated server’s latencies, and they hide three things.
- Coordinated omission. A stall stalls the generator too; the requests users would have sent meanwhile never exist, so the tail is understated, most for servers that pause.
- Latency at a given rate. Each server runs at its own maximum, so no two latencies are at the same load.
- The knee. The loop sits at capacity throughout and never shows the climb to it.
Open loop
RealWorld races open loop only: oha offers fixed rates, the same for every server (its card gives them), each step about √2 the last, and each server climbs until it falls behind or a request fails: an error, or an answer not 2xx, such as the 503 of a server shedding load, which counts as a failure however soon it came. Latency is counted from when each request was due (wrk2’s correction; oha -q --latency-correction). Steps, not a ramp, so each latency belongs to one rate.
A step with the loader 85% busy or more is drawn hollow; one where a request failed, as a cross. Each chart's table says how far each server held and what ended its climb, refusals and errors apart.
Caveats
- The loader’s CPU is recorded every round, so a round it bound shows.
- Echo on the dedicated class can fill the network link first: the fast servers tie there (each round records the traffic).
- Only 2xx answers count: an error or another status is no work done.
This is a nightly on hardware anyone can rent (DigitalOcean picks the CPU; each class names it), not a best case on tuned bare metal. The same race runs on your own machine: dragrace race local.