Introducing Babylon Lite - Announcements - Babylon.js

= 40rem)" rel="stylesheet" data-target="desktop" />

= 40rem)" rel="stylesheet" data-target="chat_desktop" /><br>= 40rem)" rel="stylesheet" data-target="discourse-ai_desktop" /><br>= 40rem)" rel="stylesheet" data-target="discourse-reactions_desktop" /><br>= 40rem)" rel="stylesheet" data-target="poll_desktop" />

Introducing Babylon Lite

Announcements

Deltakosh

June 17, 2026, 5:04pm

Babylon Lite is the engine we always dreamed of building. Now made possible by today’s technology and more than a decade of learning.

For years we imagined what Babylon could look like if we started from a blank page, with no legacy to carry, building directly on top of modern GPU APIs and a modern toolchain - and distilling everything 13 years of building Babylon.js has taught us. Babylon Lite is that engine: a WebGPU-exclusive, tree-shakable, data-oriented renderer engineered for the smallest bundle size and maximum performance - while producing output that is pixel-for-pixel identical to Babylon.js .

Babylon Lite vs Babylon.js - at a glance2560×710 55.8 KB

Across our parity gallery, building the same scene in Babylon Lite ships about 19× less gzipped JavaScript , renders frames about 3.6× faster , starts up about 2.5× faster , and uses about 5× less memory than Babylon.js - all while drawing the identical image. (Figures are medians across the suite; the per-scene charts further down show the raw numbers.)

Babylon.js and Babylon Lite, together

We want to be crystal clear about one thing: this is not a replacement, and Babylon.js is not going anywhere. The two engines will continue forward side by side, and we are fully committed to both.

They simply optimize for different things, so you can pick the right tool for the job:

If you want…<br>Choose

The smallest possible footprint and maximum performance , WebGPU-native, ship-only-what-you-use<br>Babylon Lite

A fast, flexible, unopinionated engine with the broadest feature set, WebGL + WebGPU, and rock-solid backward compatibility<br>Babylon.js

Babylon.js was built around broad usability: simple APIs, a polished developer experience, a massive feature set, and long-term compatibility across countless use cases. That remains its strength.

Babylon Lite has a different center of gravity. It is built around minimal size and maximum performance first. It is intentionally narrower and more opinionated, and backward compatibility is not a first-class goal - that is the trade that buys the size and speed.

What is Babylon Lite?

Babylon Lite is a ground-up rethink of a 3D engine for the modern web:

WebGPU exclusive. Zero WebGL fallback, no legacy wrappers, no abstraction layers for older APIs. It is built entirely around WebGPU paradigms - render pipelines, compute shaders, bind groups, command buffers.

No classes: pure data + functions. Cameras, lights, meshes and materials are plain state objects. Behavior lives in standalone tree-shakable functions (getViewMatrix(camera), addToScene(scene, entity), …). Nothing carries hidden references, which means trivial serialization, zero circular dependencies, and maximum dead-code elimination.

Obsessively tree-shakable. Every optional feature is an isolated module that is dynamically imported only when a scene actually uses it. Unused features cost zero bytes. A simple scene ships a handful of KB; a complex PBR + IBL scene only pays for what it touches.

Modern toolchain. Built on Vite, with WGSL minification in production bundles and strict, modern TypeScript throughout.

Visually compatible - pixel-perfect with Babylon.js

Babylon.js has been lovingly crafted over the past 13 years to produce some of the most beautiful visual rendering available on the web. It’s literally in our mission statement: build one of the most powerful, beautiful, simple, and open web rendering engines in the world. With Babylon Lite, we’re proud to continue to carry this torch.

This is the part we are most proud of. Given the same scene setup, Babylon Lite and Babylon.js render the same pixels. We don’t copy Babylon.js code - we understand the math and write the minimum code that reproduces the exact same image. Every scene below is validated against a Babylon.js golden reference with an automated pixel-diff in CI.

How we measure it: each scene renders in both engines, and we compute the mean absolute difference (MAD) per color channel (0-255 scale) against an immutable Babylon.js golden screenshot. Every scene must stay under a tight per-scene threshold - the median across our suite is a MAD of 0.05 , i.e. effectively indistinguishable. The diffs run in CI on Chrome’s SwiftShader Vulkan backend, so parity is enforced on every change, not just eyeballed once.

Pixel-perfect parity: Babylon Lite vs Babylon.js reference3168×1320 226 KB

Same model, same lights, same IBL - identical result. The per-frame CPU time on each render tells the rest of the story: the same picture, drawn in a fraction of the time. You...