Ten Languages,
One API

Three sizes

Small = plain CRUD, 7 routes. Mid = add auth, roles, row access, middleware, logging, error codes, paging, sorting, state machine, cascade delete. 16 routes. Large = add module split, ETag concurrency, idempotency keys, soft delete, audit log, outbox, quota, bulk write, search, reports, metrics, comments, user admin. 34 routes.

Spec written first. Test written second. Code written last. Nothing count until real server run and pass every test over real HTTP. Mid and large also must pass log check that read server stdout and check every log line.

Token gap shrink when app grow

Bar = cost versus cheapest language that tier. Three bars each: small, mid, large. Expensive language get much cheaper when app get big.

Token cost

Click any header to sort.

Speed, CPU, memory

Big app. 10,000 requests, one at a time. p50 = middle request. Use p50, not p99 — Windows timer tick make p99 lie. Cold start have harness floor removed.

Click any header to sort. Rank on p50 — req/s is noisy for sub-millisecond build. Detail in METHODOLOGY.md.

Token order is reverse of speed order

Click any header to sort.

Shift = token rank minus speed rank. Plus mean faster than token cost suggest.

We fixed our own mistakes first

Where PHP time really go

After OPcache fix we measured layer by layer, same server, fresh store, GET only. Answer surprise us.

Bare PHP 0.874 ms — beat C# and Python. About 94% of gap is Slim container, router, middleware rebuilt from scratch every request. That is shared-nothing model, what PHP require. Not PHP language slow. Not our store slow. Every other language build router one time at startup and keep it for life of process.

We measured both way before we dropped the framework one, so framework cost is a measured number, not a guess:

No framework is 4.5× faster at small, 4.3× at mid, 2.0× at large, 5× less CPU — and cost fewer token too. Plus zero manifest, because no composer file. So the framework cost about 4.2 ms every request and save nothing we measured. Old Slim run kept in perf-variance/removed-slim-run*.json so anyone can check.

These PHP number are median of three run. They hardly needed it: three run gave 1.362, 1.361, 1.376 ms at small — inside 1.1%. PHP is one of the most reproducible build in the whole benchmark. The old framework build swung 13.73, 6.07, 6.10 ms, because its autoloader touch about a hundred file per request. So the wobble was the framework, never the language.

Third PHP fix: our store was O(n)

Even with no framework, PHP looked bad at large tier. We measured why, and it was our fault again.

File I/O was never the problem. JSON was. Large tier grow an audit log and outbox, and our store re-serialize the whole dataset every request. So PHP pay O(total state) per request for what every other language do as O(1) append to a list in RAM. Our design, not PHP.

Fix: audit and outbox move to append-only JSON Lines file, counters in store.json so /stats and /metrics stay O(1), and a watermark so flush stay O(1) and delivered is derived not rewritten.

Flat. Large tier p50 drop 25.2 → 8.6 ms. Cost of the fix: +1,216 token, because O(1) persistence is more code than O(n). That move PHP from 4th to 5th on large-tier token. Honest trade, and the number here include it.

Big findings

Know this before you quote number

• Framework included. Each language use what a real team would pick — which for PHP mean no framework, and for C, C++, Zig mean raw socket. So this measure ecosystem too, not pure syntax. FastAPI hide work C must write by hand.
• Three things left out on purpose. No password hash, no signed token, no timestamp in body. Keep work identical across ten languages. All three cheap in Python, expensive in C — so leaving them out make C number kinder, not harsher.
• Count read cost, not write cost. This count tokens to read working code. Not count retries a compiler would catch. That is where strong types pay back.
• Tokenizer is proxy. tiktoken, not Claude tokenizer. Ratio hold across two encoders. Absolute number will move.
• p99 lie on Windows. Tail land on 15.6 ms timer tick. p50 and p90 solid.
• req/s carry 2× uncertainty for fast build. Measured by running same code three times. Rank on p50. Throughput order among the five fast language is not established here.
• One machine, one run, one request at a time. No concurrency test — PHP built-in server and three others single-thread by design, so concurrency test would rank thread model, not language.
• Three sizes = three dots. Trend clear, curve shape not proven.
• C hit own ceiling. C use fixed arrays. At 10,000 request on big app, audit table full at 2,048 and 748 request answer 409. Real limit, and it make C latency there look slightly better than true.