A friend asked me last week why he should bother building his next game in HTML5 when Unity exports to WebGL and Godot ships a web target and even Bevy has a wasm pipeline now. Why pick the messier toolchain. Why fight Canvas/WebGL/WebGPU directly when an engine handles it.
Long story. I've been writing browser games on and off since maybe 2014 — first in Phaser 2, later in 3, with a handful of PixiJS detours when I wanted to feel like a real graphics person. I gave him a probably-too-long answer over coffee and then realized I should just put the thing in writing.
The short version: HTML5 games are having a moment that nobody is really talking about, and the reasons are mostly boring ones. Performance got fixed. Distribution got harder. Mobile stores got worse. Browsers got better. The story isn't a single dramatic shift; it's six small ones that compounded.
The Chrome bottleneck dissolved
If you remember writing a Canvas game in 2017, you remember frame drops you couldn't explain. The browser's main thread was doing too much. JavaScript was running garbage collection at the worst possible time. You'd profile the game, find nothing wrong with your code, and just... accept that 45fps was the ceiling.
That ceiling moved. Chrome's V8 team shipped concurrent garbage collection, then Sparkplug, then Maglev, in the span of about four years. Memory allocations that used to stall your render loop now run on a different thread. The same Canvas game I had wheezing in 2018 runs locked at 60 on a 5-year-old laptop now and it's not because I optimized it.
Throw OffscreenCanvas into the mix and you can move all rendering off the main thread entirely. I don't see most browser games actually using OffscreenCanvas in production yet — but the engines are starting to.
WebGPU is actually here
WebGL is just old. It's a wrapper over OpenGL ES 2.0, which is a spec from somewhere around 2007 — back when iPhone 3GS was the cool thing and a unified shader was a research topic. The API surface still looks like that. Most of what GPUs can actually do now, WebGL can't really expose.
WebGPU is the thing that fixes this. I've been hearing it's "almost ready" since 2021 or so. It actually shipped now — Chrome and Edge had it on by default for ages, Firefox flipped the switch last year, and Safari finally caught up in 17.4 (I think? something around there). For the first time the compatibility table isn't depressing.
What that means for HTML5 games: compute shaders in the browser. Indirect draws. Render bundles. Things that took heroic effort to fake in WebGL are one API call now. You can write game logic on the GPU. You can implement actual particle systems without crying.
I haven't shipped anything in WebGPU yet — I'm still in the "rewriting my mental model" phase — but I've been watching the threejs and PlayCanvas teams adopt it and the perf numbers are not subtle.
The mobile store tax is now visible
Apple takes 30%. Google takes 30%. They both have review queues that can stretch into weeks if you're unlucky. They both reject games for reasons that contradict their own published guidelines about a quarter of the time, in my experience.
If you're a solo dev or a small studio, you've probably already done the math. The web doesn't care. Push to a server, point a domain at it, done. No review board. No 30%. No "your screenshots aren't compliant with our 2024 guidelines please resubmit."
The CrazyGames-style portals (and a newer crop like Paizix) operate on revenue share that's roughly 50/50, which sounds worse than 70/30 until you account for: you don't pay for distribution, you don't pay for hosting, you don't pay for marketing, and the audience is already there.
This is, to be clear, not a new argument. What's new is that more developers are believing it.
File sizes that don't ruin your week
I shipped a small Phaser 3 game in 2019. The bundle was something like 4MB-ish after gzip; I remember being annoyed about it. Last month I rebuilt the same project on a whim — same code patterns, same assets — using esbuild and Brotli over HTTP/3 and it landed a hair over 1MB. I didn't change the architecture. I didn't optimize anything on purpose. The tooling just quietly got way better while I wasn't paying attention.
Brotli compression at level 11 is cheap because servers cache the compressed bundle. HTTP/3 means initial connection overhead is one round-trip instead of three. ESM imports mean the browser only fetches what your menu screen actually needs and lazy-loads the rest while the player is in the title sequence.
A modest 2D game in 2026 hits playable interactivity in well under two seconds on a mid-range Android device on 4G. That used to be a "we'll fix it for the launch trailer" problem. It's a default now.
Save state stopped being a nightmare
IndexedDB, finally, is usable. The Origin Private File System (OPFS) gives you actual file-system-like access scoped to your domain. You can stream multi-megabyte savegames to disk without fighting localStorage's 5MB cap.
For most game developers this is a quality-of-life thing rather than a "this enables a new genre" thing — but for save-heavy genres (RPGs, sims, deck-builders), it's the difference between feeling viable on the web and feeling like a compromised port.
The AI generation problem cuts both ways
Here's the part nobody on dev social media wants to talk about clearly. Generative AI made it possible for a single person to ship an HTML5 game in a weekend. Asset generation, music, dialog. There are absolutely a lot of low-effort AI-slop games getting dumped onto portals right now, and they're a real problem for discovery.
But the same toolchain helps small real studios ship more polished games faster. The 2026 wave of indie HTML5 games is not the AI-slop wave. It's small-team games with hand-tuned mechanics that used a generative tool to skip the part where they have to commission art for an unproven prototype. There's a difference. It's a real difference.
The portals are starting to filter on it, too. Some of them now publish editorial policies (I've worked with Paizix's, which discloses the AI-drafted, human-reviewed pipeline they use for game writeups — I think this is the right way to do it, full disclosure). Curation is becoming a value-add again, after a decade of it being an afterthought.
A note on game engines
Quick opinions, since people always ask. Phaser 3 is the engine I keep coming back to for general 2D work; the docs finally stopped feeling like a wiki nobody updated. Pixi if you want a renderer rather than a framework — your code is going to be longer, your perf ceiling will be higher, that's the trade.
Godot 4's web export caught up so much I had to recheck my assumptions. Build sizes used to be a deal-breaker. Now they're fine. If you want an actual editor and you're doing 2D, I'd seriously consider it.
Unity WebGL exists, technically. The build sizes and cold-start load times in 2026 are still not great compared to a hand-tuned Phaser bundle. I would not pick it as a default for a new web-first game. If you're already on Unity for a different platform, sure, web export the thing — just don't be surprised by the metrics.
Bevy with wasm is the Rust-pilled choice. Load times are honestly surprising in a good way. The community is small, the gotchas are real, and you should pick it because you want to write Rust, not because you read a benchmark blog post.
So is HTML5 actually winning?
Obviously not. Mobile gaming is still bigger by — I don't know, ten times? Probably more. It's not even close. The web is a growing slice; it isn't taking over anything.
But the developer-side calculus has shifted. The toolchain pain that used to push solo devs and small teams toward Unity-mobile is mostly gone. The store-tax pain has gotten worse. The browser performance ceiling is higher than most game ideas need.
If I were starting a small studio today and I wasn't sure where to ship first, I'd default to the web. The cost of being wrong is so low that it's almost the obvious answer.
Try shipping something small to a free-to-host portal — itch.io, Paizix, Newgrounds, take your pick — and watch the analytics for a month. You'll learn more about your design than you would in six months of App Store review queues.
P. Kemper writes about browser games and the people who make them. He edits Paizix, an HTML5 game portal, and occasionally ships things in Phaser when he should be sleeping.
Top comments (0)