The Rise of HTML5 Game Engines (Phaser, PixiJS, Babylon)

The browser game world had two distinct eras: before HTML5 and after. Before HTML5 meant Flash — Adobe’s plugin running on practically every desktop, hosting an enormous library of casual games. After HTML5 meant a chaotic transition through 2010–2017 where mobile devices (especially iOS) refused to run Flash, and the web platform had to grow its own game development tooling. The rise of HTML5 game engines is the story of how that tooling appeared, who built it, and why the genre survived the platform shift.

The Flash era and its end

Flash dominated browser games from the late 1990s through the 2000s. Macromedia (later Adobe) Flash was a vector animation runtime that handled audio, ActionScript code, and reasonable game logic. Newgrounds, Kongregate, Armor Games, and dozens of other portals built businesses on Flash games. The format was simple to distribute and ran on every desktop browser.

The crack appeared in April 2010, when Steve Jobs published “Thoughts on Flash” — an open letter explaining why Apple wouldn’t support Flash on iOS. iPhone and iPad would never run Flash content. The reasons given were technical (performance, battery, security) and strategic (control over the App Store). Whatever the real motivation, the effect was decisive: by 2012, mobile was a significant share of internet traffic, and that share couldn’t see Flash games.

Adobe formally ended Flash support on December 31, 2020, but by that point Flash had been functionally dead for years. The HTML5 transition was nearly complete by 2017. The game-portal businesses that survived were the ones that bet early on HTML5.

Why HTML5 took time

HTML5 — the loose name for the canvas element, WebGL, the Audio API, and a few related additions — gave browsers the primitives needed to build games without plugins. Canvas (initially proposed by Apple in 2004 and standardized in HTML5) was the 2D drawing surface. WebGL (released 2011) gave browsers access to GPU rendering. Together they made everything Flash could do possible in JavaScript.

But the primitives weren’t enough. Flash had been an entire framework — ActionScript classes for sprites, MovieClips, sound channels, input handlers. HTML5 had Canvas and WebGL and a long list of “build it yourself” decisions. Game developers needed engines on top. Between 2010 and 2013, several teams independently built the engines that would define the era.

Three.js: the WebGL pioneer (2010)

Ricardo Cabello, known online as Mr.doob, released Three.js in April 2010. The library wraps WebGL with a higher-level API for scenes, cameras, materials, and meshes. By the time WebGL was officially stable in browsers (2011), Three.js was the obvious choice for anyone wanting to render 3D content in a browser.

Three.js’s importance isn’t gaming-specific — it’s used for data visualization, web art, product configurators, and a thousand other applications. But for games specifically, Three.js became the foundation for many 3D browser experiences. It’s not a complete game engine — there’s no built-in physics, scene management, or asset pipeline — but it’s the rendering layer underneath countless projects.

Mr.doob has been a remarkably consistent maintainer. The project has been actively developed for 15+ years and remains the dominant 3D WebGL library by margin.

PixiJS: 2D rendering done fast (2013)

Mat Groves and his team at Goodboy Digital, a London-based studio, released PixiJS in 2013. The pitch was clear: a 2D rendering library that used WebGL when available and fell back to Canvas when not, optimized for high performance on both. PixiJS handled sprites, text, filters, and texture management — but not gameplay logic, physics, or scene management. It was a rendering layer, deliberately.

The deliberate scope made PixiJS the foundation many other libraries built on top of. Some HTML5 games use PixiJS directly. Many use frameworks (including Phaser, which uses PixiJS internally in some versions) that rely on PixiJS for rendering. PixiJS’s performance — particularly its batched rendering and texture atlas support — made it the default 2D layer for anyone serious about frame rates.

Goodboy Digital eventually sold PixiJS to the open-source community in 2018 after years of solo maintenance by Groves. The project continues as a community-managed open-source effort.

Phaser: the all-in-one 2D framework (2013)

Richard Davey at Photon Storm released Phaser in 2013. Where PixiJS was a rendering layer, Phaser was a complete framework — physics, input, audio, scene management, animation, tweens, particles, the works. Davey’s pitch was that game developers shouldn’t have to assemble half a dozen libraries; Phaser would provide one batteries-included framework for 2D HTML5 games.

That pitch landed. Phaser became the most-used 2D HTML5 game framework by a wide margin. Browser game studios, educational coding projects, and individual hobbyists all converged on Phaser. The Phaser 3 release (2018) was a significant overhaul, and Phaser 4 (2024+) shipped with TypeScript-first design.

Phaser’s combination of low entry barrier and serious capability is hard to overstate. A developer can ship a polished 2D platformer in a weekend with Phaser; the same project in raw Canvas and JavaScript would take months. For broader context, our piece on browser game engine history covers more of the lineage.

Babylon.js: 3D from Microsoft (2013)

David Catuhe started Babylon.js as a side project at Microsoft, and it was open-sourced in 2013. The framework is a complete WebGL 3D engine — meshes, materials, lighting, physics, animation, input. Unlike Three.js (which is rendering-focused) or Phaser (which is 2D), Babylon.js targets full 3D game development in the browser.

Babylon’s appeal is the all-in-one approach. Three.js requires you to bring your own physics, your own asset pipeline, your own input handling. Babylon ships with all of it. The framework is also TypeScript-native, with strong tooling and a powerful editor. Microsoft’s continued investment — Babylon is developed by a dedicated Microsoft team — gives it institutional backing few open-source engines have.

Babylon.js is the heaviest of the HTML5 engines and the most complete for 3D work. It’s used in everything from web-based product demos to full WebGL games to enterprise simulations.

The smaller players

The “big four” — Three.js, PixiJS, Phaser, Babylon.js — are joined by a long list of smaller but meaningful HTML5 engines. Construct (a no-code engine), GDevelop (also no-code), Cocos2d-JS (originally a port from the iOS Cocos engine), MelonJS, Kiwi.js, ImpactJS — most launched between 2010 and 2014 and tried to fill various niches. Some are still active. Most have been overshadowed by Phaser for general 2D work.

Among the no-code options, Construct 3 has the strongest position. It’s used by educators and indie developers who don’t want to write JavaScript. The output is HTML5, and the games it produces run on the same browser foundation as Phaser games. The trade-off is the usual no-code trade-off: faster to start, less flexibility at the edges.

What HTML5 still lacks

Web games have one persistent limitation: distribution. Native game stores (App Store, Google Play, Steam) have established distribution channels with discoverability and payment processing. The web has the open web — which is everything and therefore nothing. A great HTML5 game can sit on a developer’s site getting no traffic, while a worse mobile game gets featured on the App Store and reaches millions.

The platform itself has nearly caught up to native. WebAssembly (Wasm) released in 2017 lets games run near-native performance in the browser. WebGPU (in active rollout 2023–2026) extends GPU access beyond what WebGL allowed. The runtime is no longer the bottleneck. Distribution and economics still are.

The current state

As of 2026, the HTML5 game engine landscape is essentially stable. Phaser dominates 2D for traditional game development. Babylon.js dominates 3D for completionist projects. Three.js underpins most 3D web experiences. PixiJS continues as the high-performance 2D rendering layer. The transition from Flash is long since complete; the question now is how the genre evolves alongside Wasm, WebGPU, and the broader web platform. For more on what HTML5 games actually are, see our piece on HTML5 game basics.

Frequently asked questions

When did HTML5 game engines start replacing Flash?

The transition accelerated after Apple’s 2010 decision not to support Flash on iOS. The major engines (Three.js, PixiJS, Phaser, Babylon.js) launched between 2010 and 2013, and HTML5 was the dominant format by 2017. Flash formally ended on December 31, 2020.

What’s the difference between Phaser and PixiJS?

PixiJS is a 2D rendering library — it draws sprites and handles graphics. Phaser is a full game framework that includes physics, input, scenes, and audio in addition to rendering. Phaser uses PixiJS-style rendering internally in some versions.

Who created Three.js?

Ricardo Cabello, known online as Mr.doob, created Three.js and released it in April 2010. He has been the project’s primary maintainer for over 15 years.

Is Babylon.js made by Microsoft?

Babylon.js was started by David Catuhe at Microsoft and is maintained by a Microsoft team. It’s open-source under the Apache 2.0 license but has institutional Microsoft backing.

Which engine should I learn first for browser games?

Phaser is the standard recommendation for 2D browser games — it has the most documentation, the largest community, and the most complete feature set. For 3D, Three.js or Babylon.js depending on whether you want a rendering library or a full engine.

The takeaway

The HTML5 game engine era was built between 2010 and 2013 by a small number of dedicated developers — Mr.doob, Mat Groves, Richard Davey, David Catuhe, and the teams around them — and matured through the 2010s into the foundation of modern browser gaming. Without them, the post-Flash web would have been a worse place for games. For more on the games themselves, our browser game engines history covers the lineage in more detail, or take a break with the Chrome Dino game — itself written in vanilla JavaScript without any framework.

Related: How Chess Engines Work (Minimax, Alpha-Beta, NNUE) · Flash vs HTML5 Games: Which Era Was Actually Better? · Phaser vs Unity vs Godot for Browser Game Development