Features

Organise your game into scenes, objects and components. Write behaviour in TypeScript scripts, with editable fields and callbacks for each stage of a frame.

• Typed script fields that can be saved, loaded and edited in the inspector
• A fixed timestep for simulation, with separate callbacks for each rendered frame
• Signals for events, coroutines for sequences and tweens for smooth transitions
• Pause, resume and slow down the game with the shared game clock
• Error codes and logging to help track down problems

Explore:Getting started

Create 3D scenes with cameras, lights and materials. ignifx uses Babylon Lite to render through WebGPU.

• Perspective and orthographic cameras
• Physically based and unlit materials, with support for glTF and GLB models
• Directional, point, spot and hemispheric lights; shadows from directional and spot lights
• Environment lighting, skyboxes, fog and tone mapping
• Bloom, anti-aliasing and adjustable render resolution
• Object picking, screenshots and rendering statistics

Explore:Physically based renderingShadowsBloomTone mappingPicking

Write WGSL in a .wgsl file whose comment pragmas declare its uniforms and textures. Use it as a full material, as hooks on the PBR material, or as a full-screen pass.

• Shader materials from a .wgsl file, with time and main-light uniforms supplied by the engine
• Surface shaders that keep lights, shadows and image-based lighting
• Custom post-processing passes ordered with the built-in effects
• Instanced rendering of one mesh with GPU culling and an LOD partner
• Shader validation at build time and hot reload in the dev server

Explore:Custom shaderSurface shadersVertex animationCustom post-processInstancing

Play fire, smoke, sparks and weather from a .particles.json definition. The GPU evaluates every particle from its spawn record, so the CPU only writes what changed.

• Nine presets and a declarative module set: emission, shape, forces, colour and size over lifetime
• Exact pause, time scale and seeded determinism
• A shared particle budget and quality scale for settings screens
• The same definitions in 2D through sprite layers

Explore:PresetsExplosionWeather2D particles

Load a 16-bit heightmap or generate one from seeded noise. Chunked level of detail, a layered splat material and height queries come with it.

• Heightmap or procedural terrains with chunked LOD and frustum culling
• Up to eight texture layers blended by control maps or by height and slope rules
• Height, normal and raycast queries that need no physics
• A heightfield collider from one call, and sculpting at runtime
• Foliage scatter on instanced meshes with wind

Explore:Heightmap terrainProcedural terrainFoliageWalk on terrain

Load models, textures, sound and scenes by path. Create reusable objects as prefabs, then customise each instance. The Vite plugin checks asset files and reloads them as you work.

• Textures, models, environments, fonts, audio, JSON and text
• Preload asset groups, cancel requests and release assets when they are no longer needed
• Scenes and prefabs stored as versioned JSON
• Prefab overrides preserved when saving and loading
• Asset and script hot reload during development

Explore:Model loading

Define actions such as jump or move, then bind them to the devices your players use. Change the controls without rewriting gameplay code.

• Keyboard, mouse, gamepad and touch support
• Control schemes and combined inputs, such as movement on two axes
• Adjustable dead zones, sensitivity and axis direction
• Interactive rebinding with saved player preferences
• Pointer lock for mouse-look and virtual controls for touch
• Simulated input for automated tests

Explore:Input actionsRebinding

Use Havok to make objects fall, collide and respond to forces. Character controllers handle movement along floors and slopes. Physics runs at a fixed timestep and can be tested without a GPU.

• Dynamic, kinematic and static rigid bodies
• Box, sphere, capsule, cylinder, mesh and heightfield colliders
• Adjustable friction and bounce
• A character controller with slope limits and body pushing
• Collision and trigger events
• Raycasts, shape casts and overlap checks, filtered by layer

Explore:Physics playgroundCharacter controller

Build 2D worlds from sprites and tilemaps. Import art from familiar tools, animate characters and keep pixel art crisp as the camera moves.

• Pixel-perfect cameras with zoom and character following
• Sprite animation and texture atlases
• Atlas imports from TexturePacker, Aseprite and regular grids
• Tilemap imports from Tiled and LDtk
• Sorting layers, Y-sorting and parallax backgrounds
• Object picking in 2D scenes

Explore:Sprite animationTilemap

Build platformers and top-down games with Rapier 2D. The component model follows the same approach as 3D physics.

• Rigid bodies and box, circle, capsule, polygon, edge and tilemap colliders
• A character controller for slopes, steps and one-way platforms
• Collision events, triggers and layer-based filtering
• Physics tests that run in Node without a GPU

Explore:2D physicsPlatformer controller

Start with ready-made character controls, cameras, animation and pathfinding. Adapt them to the way your game should feel.

• First- and third-person controls for walking, sprinting, crouching and jumping
• A smooth orbit camera that adjusts when walls get in the way
• Animation state machines and blend trees for transitions such as idle, walk and run
• Navigation meshes and agents for characters that find their way around a level
• Helpers for moving platforms, projectiles, billboards and levels of detail

Explore:Third-personFirst-person templateAnimator

Mix music, effects and interface sounds with separate volume controls. Place sounds in the world so players can hear where they come from.

• Audio groups with their own volume and pause settings
• One-shot effects, looping sounds, positional audio and music playback
• Sounds queued until the player interacts, as browsers require
• Interface sounds that can keep playing while gameplay is paused
• Audio timing tests without speakers or a browser

Explore:Audio mixer

Build your game interface with HTML over the game canvas. Menus work with keyboard, gamepad and pointer input, while typing in a text field keeps those keystrokes out of gameplay.

• Menus and a menu stack for moving between screens
• Dialogs, notifications and loading screens
• On-screen text and labels that follow objects in the world
• Virtual joysticks and buttons for touch screens
• Layout scaling and safe-area support
• Translations with plural forms

Explore:UI overlay

Package your game for Windows, macOS and Linux with Electron. Start from a desktop template with the build tools already configured.

• An Electron window configured for WebGPU
• Sandboxed rendering and a typed interface to desktop features
• File-based saves and settings through the same storage API
• Window controls for your game
• Add --desktop when creating any of the four templates

Explore:Desktop setup

Inspect your game while it runs. Press backtick to open the overlay and see objects, component values and performance data.

• A scene tree and editable component inspector
• Frame statistics and a timeline
• Views for assets, input and audio
• Physics debugging and a console

Explore:Devtools overlay

Create a project with the CLI, then use Vite for local development and builds. The plugin handles asset setup and checks your game data.

• Four project templates, each with an optional desktop setup
• An automatically generated asset manifest
• Validation for scene, prefab, material and other engine JSON files
• WebAssembly support and hot reload
• Helpers to create scripts and check WebGPU availability

Use the same API to save progress and settings in the browser, on desktop and in tests. Check platform capabilities when your game needs to adapt.

• Browser storage through IndexedDB and file storage in Electron
• Memory or file storage for Node tests and tools
• Information about the operating system, input devices and WebGPU adapter
• Access to locale and reduced-motion preferences

Explore:Save and load

Run gameplay tests in Node without opening a browser or using a GPU. Advance the game a frame at a time to check the result.

• Create a test app with headless: true and advance it with app.step()
• Test physics, navigation, input and audio timing
• Control the clock and capture logs and errors
• Use the repository’s browser and visual tests as examples