There is a particular genre of README that I have come to love: the one that opens with a superlative and ends with a benchmark table. Effinitive's is a connoisseur's example.

"A high-performance C# web framework designed to outperform FastEndpoints and compete with GenHTTP."
"Fastest C# web framework tested."
"1.23-1.27x faster than GenHTTP."
"~16x faster than FastEndpoints and ASP.NET Core Minimal API."
"Sub-50μs response times for both GET and POST."

These are testable claims. So we tested them. Cause of death: localhost.

The venue is HttpArena: an AMD Threadripper PRO 3995WX, 64 cores / 128 threads, every framework in an identical Dockerized harness, an 18-point validation suite with anti-cheat probes — random query sums, two different random POST bodies, empty-range DB queries, TCP fragmentation with 30ms pauses. The motto is "Don't just say you're fast, prove it." Both contenders are C# on .NET 10. Both are early-stage: GenHTTP is emerging, Effinitive is explicitly experimental (v2.2.0, ~10 stars). This is not a story about a bad developer. We are not here to autopsy the framework — we autopsy four superlatives, and a README that wrote checks the arena cashed in public.

Head-to-head, best variant per profile: GenHTTP wins 14, Effinitive wins 1. Fourteen of fifteen. Let's go down the README line by line.

Claim 1: "1.23-1.27x faster than GenHTTP"

The README's own table puts Effinitive at 44.37μs GET / 44.89μs POST and GenHTTP at 54.58 / 57.04μs — "1.23-1.27x slower."

On the baseline plaintext profile, the arena measured GenHTTP at 2,075,459 rps and Effinitive at 1,435,736 rps. That is GenHTTP 1.45x faster.

The claim isn't just wrong by a little. The inequality sign is pointing the wrong way. Effinitive claimed to be 1.23x faster; it is 1.45x slower. The single headline comparison in the README is literally inverted. The patient was holding the X-ray backwards.

Claim 2: "~16x faster than FastEndpoints and ASP.NET Core Minimal API"

This one is also inverted, and we have a fuller paper trail. ASP.NET Core Minimal API — the thing Effinitive says it beats by 16x — beats Effinitive on every profile they share:

The README promised 16x in one direction. The arena delivered up to 2.51x in the other. The framework Effinitive was built to dunk on is the one doing the dunking.

Claim 3: "Sub-50μs response times"

This one is true. And it is the most revealing line in the whole document, because it explains everything else.

44 microseconds is a real measurement of one request on a warm, single-stream loop — the demo. The arena does not measure the demo. It measures throughput under 512 to 16,384 concurrent connections across 64 cores, with adversarial validation in the loop. Microsecond latency on a warm localhost loop tells you precisely nothing about behavior at 16,384 connections, and the numbers below are what "nothing" looks like.

Effinitive optimized the demo. The arena measures the war.

Claim 4: "Fastest C# web framework tested"

Here is the rest of the scoreboard. Ratios are GenHTTP rps / Effinitive rps.

The WebSocket pipeline profile is a 32x blowout — 28.6M rps versus 874K. That's not a tuning gap; that's two different sports. The HTTP/2 static profile is a 399x blowout. "Fastest C# web framework tested" is a strong claim to make in a sentence the same hardware answers with a three-order-of-magnitude loss.

The 399x: static-h2 is a single-core stall

This number deserves its own autopsy, because it is the most spectacular. To be precise and fair: every response was a 2xx. Nothing crashed. There were no errors. It simply... stalled.

• At 256 connections: 101 rps on 87.5% CPU. On a 64-core box, that is less than one core doing anything. Roughly 512 total requests served in the entire window.
• At 1024 connections: 404 rps on 286.7% CPU. About 2048 requests, total.

The heart was beating. It was beating on a single core, in a room with 63 empty ones. GenHTTP's HTTP/2 static — which is GenHTTP politely borrowing Kestrel — does 161,502 rps. The framework is not broken in the crash sense. It is broken in the worse sense: it stays up, returns 200s, and serves almost nothing.

Claim 5: "4.5-5.5 KB memory per request (minimal allocations)"

The architecture section promises "zero-allocation routing using Span<T>/Memory<T>" and "minimal allocations." The arena weighed it:

• baseline at 4096 conns: 1.6 GiB
• static at 4096 conns: 1.7 GiB
• baseline-h2 at 256 conns: 2.5 GiB
• baseline-h2 at 1024 conns: 12.9 GiB
• echo-ws-pipeline at 4096 conns: 1.4 GiB

The HTTP/2 path at 1024 connections ate 12.9 GiB — the signature of per-stream buffering with no backpressure, blood pooling because nothing told it to stop. Span<T> in the router does not save you when something upstream looks to be buffering whole streams into the heap. The deceased did allocate minimally — in the demo. 12.9 GiB is the measurement under load.

The one honest win — and what it cost

Effinitive does win exactly one profile: baseline-h2, 1.13x (2,021,859 vs GenHTTP-via-Kestrel's 1,792,309). Credit where due, with two asterisks: GenHTTP's h2 is borrowed Kestrel, and that win is the 12.9 GiB run. It won one round by spending memory like it was trying to lose it. It is the kind of win where you check the scoreboard, then check the hospital bill.

Tail latency tells the same story elsewhere: json at 4096 conns posts a p99 of 265.80 ms; echo-ws-pipeline at 4096 conns, p99 159.10 ms.

Credit where it is genuinely due

This is the part the README should have led with, because it is real. Effinitive's HTTP/1.1 plaintext path scales. Baseline hits ~1.4M rps fanned across all cores at ~5790% CPU. That is a legitimately competent from-scratch socket server doing the thing from-scratch socket servers are supposed to do. It is not a toy.

The trouble is that everything harder than plaintext HTTP/1.1 is exactly where a young custom server is weakest, and Effinitive is no exception: static at scale (1.7 GiB, no zero-copy in sight), HTTP/2 (single-core stall on static, 12.9 GiB on baseline), WebSockets at high concurrency (GenHTTP 5.6x to 32.8x ahead), and the tails.

If the README had said "a young experimental framework with a genuinely solid HTTP/1.1 core," every word would have survived the arena. The honest claim was sitting right there.

The receipts, in one table

The verdict

Effinitive is a young, experimental framework with one genuinely solid path and a README that describes a different framework — one that exists only in a warm localhost loop. The sin here isn't that the code is early. Early is fine. Early is honest. The sin is the superlatives: "fastest," "16x," "1.23x faster than GenHTTP," all of them measuring 44 microseconds of demo and reporting it as throughput under siege. A microbenchmark of one warm request is a fact about one warm request. It is not a fact about your framework.

If Effinitive ships a fixed HTTP/2 path and a static handler that doesn't slurp whole files into the heap, I genuinely want to see the rematch.

One published round is a snapshot, and snapshots can be wrong — so don't take mine for it either. Re-run it, fork the harness, submit your own numbers. Verify all of this at http-arena.com. Don't just say you're fast. Prove it — on hardware you don't own, with a harness you didn't write, against probes designed to catch you cheating.