Go, HTMX, and React: What the 2026 Benchmarks Show

Every argument that Go and HTMX beat React ends in the same place: one slide from a conference stage, numbers that got quoted so many times they calcified into received wisdom. The numbers themselves are real — 67% less code, 96% fewer JavaScript dependencies, build times down 88%, documented on HTMX's own site in the Contexte case study. What got quietly dropped in the retelling was the context those numbers lived in: a four-person team, a French political news service, a Django backend, and a publisher's own caveat on the same page: "we would not expect every web application to see these sorts of numbers."

That warning was published in 2022. The meme outlived it by years.

So in 2026, what do the scalability tests actually say? A recent breakdown by Cloud Codes takes a serious run at this question. The honest answer is more interesting, and more structurally useful, than the slide.

The Admission That Outranks Any Chart

Start where Cloud Codes starts: with Carson Gross, the creator of HTMX, writing against his own movement's PR.

In November 2023, Gross published an essay called Does Hypermedia Scale? It reads, for most of its length, as a confident yes. Then it hits a paragraph that the quote-tweet circuit reliably skips. On the question of whether hypermedia applications can scale to teams of a hundred or more, Gross wrote: "This we cannot answer because we have not seen this scenario." And one sentence later: "At this point we are speculating."

That's the author of HTMX, on his own site, saying the enterprise question — the one the whole debate orbits — was still open as of late 2023. He volunteered that before anyone pushed him. It's the kind of intellectual honesty that tends to get punished by the discourse, which is exactly why it deserves more weight than a benchmark chart.

Gross did give a sharper diagnostic than any throughput number, though. In a Hacker News reply, he split software into two shapes: wide applications, which have many screens that are each fairly simple, and deep applications, where a handful of screens demand that every keystroke land instantly. Hypermedia wins the wide ones — a round trip is cheap when a screen changes once. It loses the deep ones because that round trip can be 150 milliseconds on a phone, and no spinner makes that invisible. The crucial observation is that enterprise software is overwhelmingly wide: admin consoles, back offices, configuration screens, reporting dashboards. If you're building the internal tooling layer of a company, the app shape is almost certainly working in HTMX's favor.

What Happened to the Scoreboard

For 13 years, the TechEmpower Framework Benchmarks ran hundreds of server frameworks on identical hardware and published the table the whole industry argued over. It was the closest thing the web development world had to an official record — which meant that when it stopped being maintained, it left a real gap.

According to the TechEmpower/FrameworkBenchmarks releases page on GitHub, the repository was archived in 2026. The goodbye notice thanked the community and stated the repository, its history, and past results would remain as a snapshot. A snapshot is not a scoreboard, and the difference matters when someone is trying to make a current architectural decision.

One developer's postmortem on the project was blunter than the farewell statement. As Cloud Codes recounts it, frameworks had been allowed low-level optimizations until the results were measuring sockets more than real implementations, and the underlying test platform had barely changed in years. Benchmark worship had eaten its own scoreboard.

A replacement is running. HTTP Arena launched around the same time TechEmpower was archived, according to Cloud Codes, and it runs dozens of frameworks on a 64-core machine in the open. Its first round is still labeled alpha, which means the rankings are provisional — Cloud Codes noted that in their breakdown, the Go placement was not where the memes would have you expect, with several JavaScript and TypeScript entries ranking above Go's best submission. But it's worth being careful here: the board is explicitly provisional, Go implementations are underrepresented relative to C and Rust submissions, and absence from an alpha leaderboard is not defeat. Cloud Codes correctly flags this: "That is not a verdict on Go, and pretending otherwise would repeat the exact mistake this video is about."

The Runtime Got Faster Anyway

Whatever the benchmark tables say, Go 1.26 shipped a meaningful runtime improvement. The release, documented in the official Go 1.26 release notes, introduced a new garbage collector called "Green Tea" as the default. According to those release notes — as characterized by Cloud Codes — Green Tea delivers 10 to 40% less garbage collection overhead on programs that lean heavily on the collector, with an additional gain on recent Intel and AMD chips through SIMD vector instructions that allow it to scan small objects faster.

For a server-rendered stack, garbage collection overhead is the relevant bottleneck in a way it often isn't for pure throughput tests. The improvement is real and documented. Whether it closes any specific gap against a React-backed architecture depends entirely on what the application is doing.

Drupal as Enterprise Receipt

The most substantive piece of evidence in this debate isn't a benchmark at all. It's Drupal.

Drupal is 25 years old. It runs government portals, university systems, and newsrooms. It has thousands of contributors. That is precisely the scenario Gross said in 2023 had not been observed — a large, complex, multi-contributor codebase adopting hypermedia at scale. In December 2025, Drupal 11.3 shipped HTMX inside core, not as a plugin. It replaced a homegrown Ajax layer built on jQuery, with the project claiming up to 71% less JavaScript for browser-to-server interaction. The "up to" in that sentence is doing real work — it's a ceiling, not a floor — but the direction is unambiguous.

The same release also let Drupal serve significantly more requests on equivalent database load, which Cloud Codes is careful to note had nothing to do with HTMX — it was a separate architectural improvement. Two wins in one announcement doesn't make them the same win. Both are still wins.

What Drupal provides that no benchmark can is a governance-level signal. When a project with thousands of contributors and a 25-year codebase commits to a dependency at the core level, that's not a conference talk. That's a maintenance decision made by a community that has to live with it. HTMX 4 is already in review for Drupal, updating the underlying request model to the browser Fetch API. The commitment appears durable.

The Question the Metrics Can't Settle

Cloud Codes raises a measurement problem that's worth sitting with. The gap between how npm downloads and CDN hits represent HTMX's market presence is vast — Cloud Codes describes a roughly 740:1 ratio in npm pulls compared to React, collapsing to something closer to 4:1 when looking at CDN traffic direct to browsers. The underlying logic is sound even without the specific figures: npm counts build servers, CI pipelines, and automated tooling; CDN counts browsers actually fetching files. Those are measuring different things. One reflects the JavaScript build-tool industrial complex. The other reflects what's running in production for real users. That gap in any ratio exists because of how the ecosystems are structured, not because one library is winning or losing.

The Contexte case study — the conference talk that started this whole conversation — does include one detail that the meme circuit also tends to drop: when Contexte needed a collaborative editor, they built it in Vue and kept HTMX for everything else. That's not a failure mode. That's architecture. Wide screens get hypermedia. Deep screens get whatever they need. The interesting engineering question is knowing which you're building.

Carson Gross put it plainly: the strongest advocate hypermedia has would not claim it works at the scale the word enterprise actually implies. He said so in writing, unprompted, years before this became the debate it is now. That's either a reason to distrust the approach or a reason to trust the person recommending it. Probably both.

The industry couldn't keep one honest scoreboard alive past 2025. HTTP Arena is trying to fill that gap, but it's still in alpha. Drupal is the best real-world data point anyone has produced — and it's running PHP, not Go. So the Go and HTMX combination remains genuinely promising for the right application shape, meaningfully improved at the runtime level, and still largely unproven at the organizational scale the word enterprise is supposed to describe.

Which leaves the question Cloud Codes ends on, and it's the right one to end on: if the industry couldn't maintain one shared standard for measuring what software does, what exactly has four years of this argument been proving?