Engine

In one line#

A full game engine in the browser: build a scene, give it behaviour, press play, and export it to the web or to a native desktop and mobile binary.

It is the largest studio in aukimi by a wide margin. This page maps it the way the interface does, by the drawer each panel lives in, rather than listing features alphabetically.

The layout#

The four panel buttons#

They do not all behave the same way, and the difference is worth knowing before you go looking for something:

Systems and Tools share one slot on purpose; they are placed side by side so it is visible that they do.

Systems#

The engine's own subsystems: the things a scene has, rather than the things you make with.

Rendering#

The FX Master switch on the toolbar turns the whole post pipeline on and off in one click: the fastest way to see what it is costing you. Individually: bloom, depth of field, SSR, SSAO, GTAO, SSGI, temporal AA, FXAA, motion blur, volumetric fog, contact shadows, colour grading, film grain, chromatic aberration, vignette and tonemapping, plus Nanite-style geometry and Hi-Z occlusion.

Look Presets are whole configurations of the above. Render Style changes the register, stylised rather than photographic. Shader Lab is where you write your own. Mesh LOD and Post Process Volumes are the two that pay for themselves on a large scene: level-of-detail per mesh, and post-processing that only applies inside a volume.

The renderer is Babylon.js. It starts on WebGL and swaps itself to WebGPU when the browser has it, falling back on its own if that fails.

Gameplay systems#

Physics covers both the 3D solver (Havok) and the 2D one. AI & Navigation is the navmesh and the agents on it. Gameplay Zones are trigger volumes with behaviour attached. Multiplayer room connects the scene to a Colyseus server (see below).

World systems#

Level Streaming loads and unloads parts of a level as the player moves. Baking precomputes lighting; Light Probes capture indirect light and reflections at points in space. Decals project detail onto surfaces without adding geometry.

Tools#

The things you make with.

World generators#

Terrain, water, sky and four content generators, trees, plants, rocks and kitbash pieces. They have a chapter of their own below.

Gameplay authoring#

Inventory, Data tables (Tools → Data) and Dialogue Trees are the three editors that let a game have content without that content living in code in detail below.

Animation#

Timeline for entity animation, Cinematic Sequencer for shots, and Camera Tools for the framing. See Animation and camera.

The world editors#

Seven panels under Tools → World. They are the fast way to fill a scene, and the reason a level does not have to start with a modelling session.

Terrain#

A scene can hold several terrains; each is a row in the Terrains list and is created at one of three resolutions, 128² (fast), 256² (balanced) or 512² (detailed).

The panel has ten modes, and they share one thing: the mask painted in Masks restricts every one of them.

Sculpt. Raise 1, Lower 2, Smooth 3, Flatten 4, Pinch 5, Inflate 6, Noise 7, Sharpen 8, Stamp 9, Terrace 0, Erode E, Fill F, Clone C (Alt-click sets the source), Blur B, Ramp R, plus the two water tools River draws a course, Lake fills at a point.

The brush itself has dynamics: pressure curve, lazy mouse, falloff, symmetry, pattern, and jitter on both size and strength. Stamp carries six shapes crater, mountain peak, plateau, river valley, dome, noise hill. Erosion comes in two forms: the E brush is local, while Adjustments runs hydraulic, thermal and wind erosion over the whole terrain.

Paint. Eight layers, because two RGBA splatmaps hold four channels each. The material library is sorted by category, grass, dirt, forest, rocks, roads and surfaces, cliffs, sand, snow, volcanic, wetland, fantasy, and your own, and each layer carries UV scale, displacement, a detail map, and surface relief (bump strength and parallax depth). Break texture tiling (cell bombing) is the setting that stops a repeated ground texture from reading as a grid.

Generate builds from noise, then Generate Textures assigns materials by height and slope, with north/south shade variation and sand or pebble shorelines where there is water. Real World imports public NASA/USGS elevation tiles: pick a landmark or type coordinates, choose the zoom, and the panel reports the elevation range it brought back.

Sketch is the other way in. Draw ridge and valley strokes on a 2D map, pick up to three real source landscapes, and the terrain is synthesised to match the sketch, optionally blended into what is already there, auto-textured and eroded in the same pass.

Masks are painted with a brush and then edited as a whole: clear, invert, blur, grow, shrink. The smart masks derive one from the terrain itself, by height, by slope, by layer or by cavity.

Paths. Click to drop control points and a smooth curve runs through them; drag the amber points to move them, the cyan handles to bend the curve. Bake Path flattens the ground under it, paints the texture and raises the embankments.

Vegetation has two halves. The brush places and removes instances by hand; the scatter rules place them by condition, layer weights, seed, min/max scale, and the height and slope band each asset accepts. Grass and flowers fade out past a configurable draw distance, and Export to Scene turns the instances into scene objects.

Biomes is the one-click version of all of the above: pick a biome, tick the categories you want (soil, trees, plants and grass, flowers, algae near water, rocks), set a density, and Apply Biome paints the ground and scatters everything, reporting how many instances of each it placed. Tree age variety mixes saplings through ancients rather than stamping the same tree everywhere, and ground blend (RVT) fuses each rock base into the terrain colour beneath it.

SDF is a different renderer, not a different tool: the terrain is raymarched from a distance field, shape by octaves, lacunarity and persistence, texturing by grass/rock/snow with a snow line and a slope threshold, and its own soft shadows, ambient occlusion and fog.

Large terrains have an LOD system with skirt geometry (which is what closes the gaps between levels), smooth level transitions, frustum culling and a stats overlay. Heightmaps import and export as 16-bit PNG, 8-bit PNG or RAW 16-bit; splatmaps as one RGBA PNG or one file per layer; and the whole terrain, or just its settings, as a preset.

Sky Studio#

The atmosphere. Four sky types, solid, gradient, HDRI, and a physical atmosphere with Rayleigh and Mie scattering, Mie absorption, ozone, ground albedo, turbidity, planet radius and atmosphere thickness.

Everything hangs off time of day, which can cycle on its own: the sun by elevation, azimuth and intensity, with its own shadow intensity; the moon by phase; stars with twinkle; and an aurora. Volumetric clouds have thickness, erosion, noise scale and curl distortion, and light through absorption, scatter, ambient and a powder term; cirrus and the Belt of Venus are separate. Aerial perspective is the haze that thickens with distance and fades far geometry into the horizon, it is the setting that makes a landscape read as large.

Ten presets to start from: clear day, dawn, sunset, dusk, night, overcast, stormy, desert, arctic and space.

Water#

Two tabs: Ocean (FFT) for open sea, Shore & lakes for everything else.

⚠️ Water is created in the Terrain editor: the river and lake tools, or Show Water, and tuned here. Opening this panel on a scene with no water gives you settings with nothing to apply them to.

Shore water carries colour, opacity, wave strength and speed, choppiness, foam width and Fresnel, with screen-space reflections and refraction blur. Under it is the WGSL shader itself: two normal scales with their own scroll directions and speed, foam threshold and softness, refraction strength and index of refraction, and the light inside the water, absorption, turbidity, scattering and translucency.

Tree Generator#

Two modes, Tree and Trunk. A tree is deciduous or evergreen, has an age from sapling to ancient, and can be living, dead, a snag or a fallen log. Everything is seeded, so Randomize seed is the fastest way to get a different tree with the same character.

The shape is per branch level: children, length, radius, taper, gnarliness, twist, sections, segments, angle and start height, plus natural variation, phototropism and gravitropism: the two that make a tree lean toward light and droop under its own weight, and a global force with its own strength. The base has root flare (lobes and height) and buttress.

Leaves are billboards, single or double sided, with count, size, angle, variance, clump, curl, droop, sheen and rounded normals. Bark comes in six styles ridged, aspen, pine, birch, smooth, palm, with relief, moss, a damp base, sun bleach, canopy ambient occlusion and an autumn turn. Four seasons switch the whole look at once.

Forest scatters many at once: count, spread radius, scale variance, and an age mix (single, natural, young, old, even). Add age progression places all five life stages in a row, which is the quickest way to judge them side by side. A tree leaves as a scene entity or as GLB, and any setting can be saved as a preset.

Plant Generator#

Five kinds, flower, cluster, herb, fern, grass, sharing a stem (count, height, thickness, curve, colour) and leaves (count, size, width, angle). Ferns add leaflet pairs, leaflet sweep and frond arch; grass adds blade count and arch.

A flower is optional on any of them: petals, petal rows, length, width, curl, tip sharpness, bloom, centre size, and three colours, petal, petal tip and centre with translucency and roughness for how light passes through the leaf. Add one to the scene, scatter many, or export GLB.

Rock Generator#

Three kinds, rock, stone, cliff, in three styles: realistic, toon, or low poly with an outline.

Shape is noise over a sphere: scale, strength, octaves, persistence, warp and a ridged option, plus strata with its own frequency and facet cuts with depth and sharpness for angular stone. Radius, detail, flatten, shape variance and a flat bottom decide the silhouette, and four erosion presets, fresh, weathered, natural, eroded, move all of it at once.

The surface has colour variation, mineral veins, lichen and moss, a detail texture with tiling and strength, triplanar blending and parallax relief. It uses a bundled Stone material by default; send a material from Matter to the Engine to override it.

Kitbash, the same library as Sculpt#

Kitbash is shared with Sculpt: this panel and Sculpt's Edit Forge read one library. A piece built there is placed here, and a piece painted here can be saved back to it.

What the scene stores is the part and its dimensions, not its vertices which is why a kitbashed building costs almost nothing in the file and can be updated later from its source.

Arm a piece from the catalogue and each left click places it. Three snapping modes decide where it lands: on terrain (pieces follow the ground height beneath them), on water (the build plane sits at the water level), and snap to sockets, aim a connection point on a placed piece and the new one turns to meet it. A chain grows from its free end, occupied sockets drop out of the candidates, and each click is its own undo step. Ctrl/Cmd stays reserved for selection and Alt for rotation. Collections keep their source and version, so an instance can be updated when the original changes.

The other editors#

The world editors fill a scene; these ones give it an interface, a map, its content tables and the instruments to check what it costs.

The HUD editor#

Tools → Editors → UI. Six tabs, Templates, Elements, Layers, Preview, Style and Script: over a preview that switches between three device sizes: desktop 960×540, tablet 768×432, mobile 375×667.

Elements come in three groups (Display, Data, Input) and nest: panel and flex hold children, so the Layers tab is a real tree rather than a flat list. History is fifty steps deep.

⚠️ The Style tab is CSS-like, and the difference matters. The HUD is drawn on the canvas by Babylon's GUI, and real CSS does not reach it. The rules you write here map onto GUI properties; the selectors are #name for one element, .type for a kind (.text, .panel) and * for everything.

The Script tab is the other way to build one: the ui.* API, createText, createPanel, createProgress, createButton, with two ways to run it. Build Layout executes it design-time and leaves you real elements to nudge by hand; Run Live runs it in the game.

Two connections outward: HUD artwork opens in Inkwell or Vectra and is linked back rather than copied, and a Vectra document can be imported as HUD elements. The minimap element is its own thing, with range, grid, and markers for player, enemies, allies, items and objectives.

The tilemap editor#

Eleven tools, brush, eraser, fill, rectangle, select, eyedropper, stamp, autotile, prop, zone and path, on four map projections: orthogonal, isometric, staggered isometric and hexagonal.

Autotiling ships four templates, and the number in each name is the number of tiles it expects: Blob 47 (full corner and edge), Wang 16 (edge-based), Simple 4 (NSEW), and RPG Maker A2 (48 tiles, compatible with maps authored there).

Two layers sit above the tiles themselves. Zones paint gameplay meaning buildable, water, forest, road, farm, residential, commercial, blocked, and props place objects by category: trees, rocks, buildings, vegetation, water, paths. Maps live in the browser's own database, so an unsaved one survives a reload.

Inventory, data tables and dialogue#

The three editors that let a game have content without that content living in code.

Inventory edits a catalogue and applies it to the scene. An item carries actions, and an action is a trigger: use, equip, unequip, plus one of eight types: message, heal, damage, grant, remove, event, toast, scene. The panel itself has three layouts (grid, list, compact), three appearance presets (graphite, midnight, warm), and four visual slots, background, slot, equipment, tooltip, that open in another module for a proper redraw.

Data tables are typed: a column is text, number, bool or ref. CSV goes in and comes out. Every edit runs through pure functions, which is what keeps the table the export writes identical to the table the build reads.

Dialogue trees are nodes with a speaker and a line. A node either continues to one next, or branches into choices, each with its own text and its own destination, the branch toggle is the only structural decision in the editor.

Animation and camera#

Cinematic Sequencer builds sequences with a duration and a loop flag, one track per entity, and keyframes captured at the playhead, Add Key takes the entity's current value rather than asking you to type it. The graph editor underneath shows time against progress, with round handles for easing: the slope is the speed. Shots have their own durations, and a Cinemascope framing (1.422:1) is available for the letterbox.

Camera Tools covers FOV, position, target, mode and speed, plus bookmarks for the viewpoints you keep coming back to, and camera layers.

Audio#

The Audio Manager holds audio events, tracks and a mixer with channels and categories. Per-source effects are a low-pass, a high-pass and a reverb send; a random mode picks between several clips so a repeated sound stops reading as a loop. Scrubbing plays audio while you drag the playhead.

The profiler#

A frame breakdown, not a frame counter: camera render, mesh evaluation, particles, sprites and shader compilation, each marked real or estimated so a number that came from a measurement is never mistaken for one that came from a model. Counters alongside it: meshes and active meshes, lights, cameras, physics bodies.

Recording is explicit, and it ends on an Issues list rather than a graph to interpret: low FPS, high draw calls, high triangles, high memory, against the target frame rate you set.

Building a scene#

Entities#

A new scene arrives with a Main Camera, a Directional Light, a Skybox and a Ground Plane.

What you can add: Empty, Cube, Sphere, Cylinder, Plane, Light, Camera, Script, Mesh, plus two families that arrive pre-wired:

• Characters: Third-Person, First-Person (FPS), Top-Down, Platformer, Basic.
• Props: Pickup (heal) and Hazard (damage).

The scene graph searches, filters by type, and adds, duplicates or deletes; entities nest, and reparenting is a drag. Placement has snapping and a scatter brush for populating ground quickly.

The inspector#

Transform (position, rotation, scale), an Enabled switch, and the entity's components: added, configured and removed here, with Add Script at the bottom. Select several entities and the inspector switches to batch editing, so one field change lands on all of them.

The console#

Not just a log. It filters by level (all, logs, info, warning, error), links a message back to the entity that produced it, and carries an expression prompt: type an expression, Enter runs it against the live scene, arrow keys walk the history.

Giving it behaviour#

Three routes, and they coexist.

Scripts#

JavaScript with lifecycle hooks, and a reference of its own:

function start() {}                     // once, when the entity starts
function update(dt) {}                  // every frame
function fixedUpdate(dt) {}             // fixed timestep, for physics
function onCollisionEnter(other) {}     // first frame of contact
function onCollisionStay(other) {}      // every frame while touching
function onCollisionExit(other) {}      // contact just ended
function onTriggerEnter(other) {}       // entered a trigger volume
function onTriggerExit(other) {}
function onMessage(msg, data, senderId) {}   // entity-to-entity messaging
function onAnimationEvent(name, data) {}
function onDestroy() {}

Collisions and triggers fire in both 2D and 3D, and each side receives its own contact normal: other.contact.normal points from the other entity toward this one. That is what lets a script tell "I landed on it" from "it landed on me" : a platformer stomp reads other.contact.normal.y > 0.5.

The script editor#

F2, or Add Script on an entity. A Monaco editor with tabs, several scripts open at once, each kept in the browser's own database rather than in the project file, so an unsaved buffer survives a reload.

Five dialects, one program. The language switch offers JavaScript, BASIC, Python, C# and Rust. What it does is not what it looks like: JavaScript is the source of truth, and the other four are views transpiled from the stored JS. Switching from Python to Rust does not translate Python, it goes back to the JS the Python was generated from and translates that. Multi-hop translation is what corrupts a program, and the editor refuses to do it.

Thirteen templates in five categories, each labelled by difficulty:

The character-controller presets and the game-starter props (pickup, hazard) appear in the same list, which is the practical way to drop a working controller onto an imported character.

Running and debugging. F5 runs, F9 sets a breakpoint. The debugger pauses at a line, steps a single frame, and reports live values through watch expressions. Script Lab runs a program with no entity attached at all, a scratchpad for the API rather than a component on an object.

Alongside the code: an API reference, a symbol list for the open file, and a snippet library with favourites and recents. Ctrl+S saves, Ctrl+F finds, Ctrl+H replaces, and the editor ships eight themes.

Blueprints and behaviours#

A visual graph, a library of ready-made behaviours, and a state machine layered over the behaviour stack.

The graph carries 267 nodes in twenty-two groups, Math, Scene, Entity, Animation, Flow Control, String, Events, Physics, UI, Array, Vector, Transform, Debug, Input, Utility, Game, Boolean, Camera, Tween, Variables, Audio and the 2D and 3D families. Three properties separate them, and they are what the graph is made of: 17 event nodes start execution, 117 pure nodes compute a value with no side effect and no execution pin, and 9 latent nodes finish later those are the ones that make a delay or a tween expressible without a state machine of your own.

Four tools: select V, pan H, comment C, reroute R, over a canvas that zooms from 0.1× to 3× with a minimap. Variables come in six types, boolean, integer, float, string, vector3 and object. Every node's description is on its tooltip, which is the only place a library that size can explain itself.

The state machine#

Its own panel, and deliberately not the Animator's: the Animator's conditions are a flat enum with hand-written UI per case, while these ones are structured and talk about the world.

Seven conditions, and each one is a question about the scene: sees (a tagged target in range, optionally within an angle and in line of sight), lost (no target for N seconds), distance against a threshold, health, message received, timer (time spent in the current state), and flag (a value on the shared blackboard). Two combinators, and and or, are both listed even though or already existed implicitly, two transitions to the same state are an or, but "it sees me AND I still have health" had no form at all.

⚠️ Health is compared as a fraction of the maximum, never as an absolute. A threshold of "below 30 HP" does not survive a re-balancing pass; "below 0.3" does.

On entering or leaving a state, four effects: send a message, set a blackboard key, play an animation clip, or fire a named effect. None of them moves anything, movement stays with the behaviours, and the machine decides which behaviour is active.

A transition can start from *, meaning any state. The validator returns the list of problems rather than throwing on the first one, so a half-written machine still draws and you see everything wrong at once. Node positions are part of the data: a graph whose layout lives outside the scene comes back reshuffled for the next person who opens it.

BASIC#

The TXT viewport mode is a classic-BASIC environment with bundled demo programs, and the language has a reference of its own. It is a real language here, not a toy: multi-file modules (#INCLUDE), typed numerics (signed and unsigned 8/16/32/64-bit, float32 and float64), nested records, object methods with SELF, references (REF/BYREF), structured TRY/CATCH/FINALLY, conditional compilation, coroutines, typed handles, and WebGPU compute with storage buffers and raw WGSL.

OPTION EXPLICIT is opt-in; classic implicit variables remain the default so imported programs still run.

Playing and shipping#

Play#

Play, Pause, Stop. On stop, a banner reports what the session changed, so a play-mode edit is never silently kept or silently lost. Sessions can be recorded and replayed into a bug report, and scenario bookmarks let a playtest start from the middle of a level.

Build#

Build takes a game type (detected from the scene, or set by hand: sidescroller/platformer, first/third person, text-based) and a target.

• Web: WebGPU with a WebGL fallback, optional WebXR (VR/AR), minification, an FPS counter, and an embed assets option that produces a single file.
• Desktop and mobile: native builds. The scene is exported as data (scene.glb + scene.json) and compiled through a generated Bevy (Rust) project; scripts run unchanged there on an embedded QuickJS runtime.

Compression is configurable per axis, algorithm, textures, meshes, with a quality preset tying them together. Builds are kept in a history with their sizes (original against compressed) and can be downloaded again later.

A native build only contains what the exporter knows how to export. glTF does not capture custom shaders, thin instances, the procedural sky or post-processing, so a runtime system that has not been ported to the Bevy side will be missing from a desktop or mobile build while looking perfect on the web. Check a native build before relying on it.

Multiplayer#

The Multiplayer room panel connects a scene to a Colyseus game server. A free shared test server is available with no account and no configuration; a project can also be given a server of its own. The room is keyed by a share code you can keep to yourself or hand out.

Files it reads and writes#

Sending work to other studios#

Accepts meshes from Sculpt, Retopo and Pigment, whole scenes from Render, pixel art, animations, PBR material sets from Matter, 2D rigs, video projects, images, vector art, and Vectra objects.

Produces 2D rigs.

A Vectra screen mock-up arrives as structure, not as a picture. It becomes a HUD hierarchy the Engine can lay out and script: the difference between a design you can wire up and a screenshot of one.

Shortcuts#

Cmd/Ctrl + K reaches the Engine's own commands from the palette, alongside the global ones. The Engine also has a dedicated, searchable keyboard-shortcut panel in its own settings; it has far more than would fit on the shortcuts page.

Limits and common snags#

• A blank viewport is usually the browser, not the scene. The Engine needs WebGL 2; check that hardware acceleration is on.
• Systems and Tools share one drawer. If a panel "disappeared", it is probably in the other one.
• The console is the first place to look, not the last: it links errors to the entity that raised them.
• A component added in play mode may not survive stop. Read the banner that appears when you stop.
• Physics differs between 2D and 3D in its solver even though the script callbacks are the same. A resting contact in 2D is detected with a 2 mm skin, because the solver brings penetration to exactly zero before detection runs.