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 &amp; or &#38;). 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.

HTTP/2 (h2c)

HTTP/2 without TLS, by prior knowledge: HTTP/2's own cost, apart from TLS's. No browser speaks it.

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.

Definitions: race.json.

The race

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.

By Little’s law latency ≈ N ÷ throughput: these are a saturated server’s latencies, and they hide three things.

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

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.