# Isogenic Game Engine: a browser 2D engine that survived a twelve year rewrite

> ige is a 2D and isometric scenegraph engine written entirely in TypeScript for the browser, with realtime multiplayer streaming built in, a Box2D physics component and a particle system. Version 3 moved it to native ES modules and dropped the custom class system it had been carrying since 2011.

**Irrelon/ige** — The Isogenic Game Engine

- Repository: https://github.com/Irrelon/ige
- Stars: 585 · Forks: 141
- Language: JavaScript
- License: not declared
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/irrelon-ige

## The engine is a scenegraph, and it renders on a canvas 2D context

The Isogenic Game Engine is described as an HTML5 2D and isometric scenegraph-based game engine written entirely in TypeScript and JavaScript. The main features list is long and specific. There is full un-obfuscated source code, an advanced networking system with a built-in server, a particle system, tile maps, a Box2D physics component for integration with 2D and isometric games, multiple viewport support, tweening support, cell-based animation support, and native and font-sheet text support. One line in that list tells you where the project is in its roadmap: WebGPU support is incoming, and currently all of the above renders using the canvas 2D context. So the rendering model is the traditional one, and the next generation of the API is planned rather than shipped. The isometric support is the piece that distinguishes it from most 2D engines, since the scenegraph and the layout logic are written to handle a tilted grid as a first case rather than as a transformation on top of a flat one.

## Realtime streaming is the claim the author makes most strongly

The version 3.0.0 notes are where the project's own argument for itself is made. The original engine was written over twelve years ago, and the README says it is still by far the most feature-rich browser-based game engine available today, and states that there is still no other engine supporting realtime multiplayer streaming out of the box written purely in JavaScript in a 2D and isometric rendering engine. The streaming model got a specific change in 3.0.2. Transform data sent to clients by the server is no longer directly assigned by writing to a field such as the translate x value, and is instead passed to the transform method related to the data, for example a call that sets the translation, and the same applies to rotation and scaling. The reason given is that code overriding those base class methods will then be called correctly when a streamed entity is transformed, because previously there was no way to detect that a transform had changed through streaming data.

## Modules are declared before init, and the engine waits for a signal

Version 3.0.2 changed how the engine loads, and the shape of the new API is the thing to copy. The optional modules you can declare with uses() are currently network, audio, box2d, tweening and ui. The engine expects you to specify the previously auto-included modules before calling init.

```typescript
ige.uses("network");
ige.uses("ui");

// Now tell the engine we are OK to proceed, having declared what we want to use
ige.init();

// Now wait for the engine
ige.isReady().then(() => {
	// Proceed with the rest of your code
});
```

So the sequence is: declare each module you want with a uses() call, call init once, then wait on isReady before doing anything else. The reason for the change is that these modules were previously included automatically, and making them opt-in means the engine does not carry what you are not using. The trade is that a missing uses() call is now a silent missing feature rather than a bundle that is slightly larger than it needed to be.

## Installation is an npm package and an import, with no build step of its own

From version 3.0.1 the engine is installed into a project and used as a module via npm.

```bash
npm i @irrelon/ige
```

```typescript
import { ige } from "@irrelon/ige";
```

This is a real change in kind, and the 3.0.0 notes explain why. The built-in compiler is no longer required, since import now exists natively in browsers, so it is no longer a requirement to compile with the engine's own compiler to get a runnable project, and you should code with ES module import and export rather than CommonJS, although CommonJS is still currently supported. The node.js server-side executable system that ran the engine on your server for multiplayer support has been removed as well, because the isomorphic JavaScript output now runs natively in Node.js. The ClientConfig and ServerConfig files are gone, since the engine simply uses ES module imports and exports in the files that need them. The background reason is stated plainly: the engine was written in 2011, when ES classes, ES modules, TypeScript and webpack did not exist, so classes were custom-created to get an inheritance-style codebase, and a rewrite was needed to use the native functionality instead.

## Building the engine, with path rewriting as a separate step

Cloning and building is only needed if you intend to change the core engine, since the published package is enough to use it. After cloning you run the install.

```bash
npm i
```

Node.js must be installed, and the engine has been tested against Node.js 16.13.1 and higher. The build compiles the TypeScript to JavaScript files.

```bash
npm run build
```

The build also runs a path fixing tool that automatically resolves TypeScript paths such as an aliased engine path into their relative equivalents in the emitted JavaScript. The output lands in a dist folder, and the docs folder is updated during the build to produce JSDoc compatible documentation. The package manifest shows the shape of it, with separate esm and cjs TypeScript configurations and separate compile and fix-paths scripts for each, plus a generate-exports script that rewrites the index files and a test script that runs jest against test files. The repository also carries a docs folder, an old_documentation folder, a server directory, a src directory and a dist directory, with separate TypeScript configurations for tests and for type definitions.

## The UI entity gotcha, and the state of the examples

The README ends with practical warnings, and the first one is about the UI classes. IgeUiElement instances stop pointer event propagation by default, which means that if you mount one IgeUiElement inside another, only the parent gets pointer events such as pointerDown and pointerUp. IgeUiEntity instances have the same general capabilities but are considered graphical rather than interactive, so they do not hook or interfere with pointer events by default. That distinction is easy to get wrong and produces a UI where nested buttons do not fire. The second note is about the examples, where many have been converted to TypeScript and ES modules but the work is ongoing, and you can tell which ones are ready because they have an index.ts rather than only an index.js file. The README warns that examples might be in a broken state for a while, because the focus has been on the core functionality and bringing the engine up to modern standards rather than on updating example code. Documentation lives on the isogenicengine.com site, and there is a lot in the examples folder with a readme explaining how to run them.

## Conclusion

ige fits a browser game developer who wants a 2D or isometric engine with multiplayer already wired in, and who is comfortable with an engine whose feature set is broad but whose ecosystem is small and unmaintained in places. It does not fit a project that needs WebGPU today, since the README lists that as incoming with everything still on the canvas 2D context, or a team that needs a large community around the engine. Verify first which optional modules you actually need, since the networking, audio, box2d, tweening and ui modules are declared explicitly rather than bundled, and read the UI entity gotchas, because the pointer event propagation rules differ between the two UI classes.

## FAQ

### How do I install and import the Isogenic Game Engine?

From version 3.0.1 you install it as an npm package with npm i @irrelon/ige and import it with import { ige } from "@irrelon/ige". No engine-specific compiler is required any more, because native ES module import is used rather than the custom build the engine relied on before.

### Which modules do I have to declare before using the engine?

The optional modules you can declare with uses() are network, audio, box2d, tweening and ui. You call uses() for each one you want before calling init(), then call init() and wait on isReady before proceeding.

### Does the engine support WebGPU?

Not yet. The README lists WebGPU support as incoming, and says that currently everything above renders using the canvas 2D context. The features that work today include the scenegraph, isometric rendering, tile maps, Box2D physics, particles, tweening and the built-in networking server.

### What is the difference between IgeUiElement and IgeUiEntity?

IgeUiElement instances stop pointer event propagation by default, so a nested element passes events to its parent. IgeUiEntity instances are considered graphical rather than interactive and do not hook or interfere with pointer events by default.

## Sources

- [Irrelon/ige on GitHub](https://github.com/Irrelon/ige)
- [Issues](https://github.com/Irrelon/ige/issues)
- [README](https://github.com/Irrelon/ige/blob/stable/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/irrelon-ige