Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

1.4 MB
Raw Blame

Changelog

All notable changes to Estella are documented in this file.

The format is based on Keep a Changelog, and this project adheres to Semantic Versioning. See VERSIONING.md for what "the public API" means for an engine like Estella (the SDK API, the editor project/asset formats, and the WASM ABI) and what we treat as a breaking change.

Version numbers here track the Estella release — the engine + editor + SDK shipped together, matching the Git tags and GitHub Releases. The SDK is not published separately; it ships inside the editor.

[Unreleased]

Added

  • A terrain's surface can be baked into a runtime virtual texture. Turn on Virtual Texture on a Terrain with layers and each node of ground, from Virtual Texture From (level 1 by default) out, is drawn from a page of its colour, roughness, normal and occlusion baked once on the GPU, as Unreal's Runtime Virtual Texture does, instead of reading every layer at every pixel. Steep ground, and a node whose page is still being baked, is drawn from the layers. On the Terrain & Water example the ground's shading went from 2.1 to 0.8 ms at 1080p. Renderer.bakeMaterial draws a material through another shader into part of a render target.
  • Terrain layers cost less, and a Planet draws its layers as a Terrain does. A point of ground is drawn from the four layers with the most weight there, and a layer not painted there costs nothing: on the Terrain & Water example's lakeside view the ground's shading went from 3.0 to 2.6 ms at 1080p with the picture unchanged. The Planet shader now uses the same layer code as Terrain Layers, so a layer's mask (and its occlusion) darkens the sky's light on a planet too, and the Planet material gains u_heightBlend, u_blendNoise and u_antiTile, 0 by default, which draws a planet as before.
  • Resources carry a revision that changes with their content. A mesh takes a new revision each time it is realized (Mesh::revision), a material whenever its state, a param, a texture or its shader's layout changes (MaterialStore::revisionOf), a texture whenever the device is given new pixels or sampling for it (GfxDevice::textureRevision), and the frame's probe and reflection volumes whenever the set of them, or a probe grid's coefficients, differ from the last frame's (ProbeStore::revision, ReflectionStore::revision). Every kind draws from one counter (core/Revision.hpp, which a probe grid's revision already used), so a revision is never shared, even by a resource that reuses a released one's slot. A texture the GPU itself writes (a render target) does not change revision with what is drawn into it. Nothing reads these yet: with the components' change stamps they are what a renderer that keeps its per-entity work between frames checks before using it.
  • An engine component is stamped whoever writes it. Every write to an engine component now leaves the change stamp the engine's own readers ask for (Registry::changedSince), wherever it is made. A script's write (set, insert, update, a Mut query, markChanged, a compiled system's rows) is stamped in the engine, batched in the World and handed over in one call before the frame's transforms are composed (registry_markComponentsChanged); the physics sync stamps the bodies that moved and no longer rewrites a body that did not; the transform system stamps a transform whose world matrix changed, so a child moved by its parent reads as changed; tweens and the editor's field setters stamp what they set. Changed() queries in scripts mean what they meant: physics motion still stays out of them, as it always has, while the engine's stamps include it. With the change audit on, 28 examples (physics, rigs, tweens, UI, particles, tilemaps, streaming worlds) ran 120 frames each with no write left unstamped; with the physics stamps taken out, the physics examples reported every moving body, 5,000 a frame in one of them.
  • Components carry the tick of their last write. Each component pool keeps, beside every component, the tick at which it was last written, added or replaced, and the latest such tick of the pool. Registry::patch<T>() is mutable access that stamps the write, markChanged<T>() stamps a write made through a reference held from before, and adding or replacing a component stamps it; get<T>() stamps nothing. A reader asks beginChangeRead() for the tick it looks at, and next time changedSince<T>(entity, tick) and anyChangedSince<T>(tick) say what was written after that look, including what was written later in the same frame. Stamps travel with their components through a removal and a re-sort, and are kept within half the counter's range so none reads as new after the tick wraps. Registry::setChangeAudit (World.setChangeAudit from script) keeps a copy of every component each frame and reports each type written without a stamp, which is what a consumer of changes would never see; render-submit-cost.mjs --audit runs it on an example. Nothing reads the stamps yet: this is the ground for a renderer that walks only what changed, and the audit lists what still writes without saying so (an animated rig's bones, the platformer's and the 3D physics example's moving bodies).
  • A playable opens on a start screen. A single-file playable showed an empty page until its first frame: the engine inflated and compiled, the scene loaded, and with quality.prewarmShaders its shaders warmed, twenty-five seconds for one lake scene in a headless browser. It now carries the web export's start screen (the game's title, a bar, what the boot is doing), in markup that is on screen before any script runs, and announces the same esengine:bootprogress and esengine:firstframe events. initPlayableRuntime takes onBeforeRun, called once everything is loaded and warmed, and prewarmShaders.onProgress. A stretch of a boot nothing measures (shaders compiling, then a ground or a field still being made) runs a light along the bar and says which it is, where the bar used to sit still on "Ready"; a web export's start screen does the same.
  • A terrain layer and a field of plants each say how much of the sky reaches them. A .esterrainlayer's occlusion (0 to 1) scales the occlusion its mask holds, and the Foliage material's u_rootOcclusion is the sky's light at a plant's root, rising to all of it at the tip. Both dim only the environment's light, as a material's ambient occlusion does; the sun and other lights are as they were. Left out (1), nothing changes. The terrain layer editor has the field.
  • An ambient light's diffuse has its own scale and tint. diffuseScale and diffuseTint on an Ambient light multiply the light its environment gives surfaces, and leave the reflections and the sky drawn behind them as they were: a sky whose irradiance is too dark or too blue for a look is lifted without brightening every reflection. At 1 and white (the defaults) nothing changes.
  • Things that break. A model can end with a fracture step, { op: "fracture", pieces: 12, at, focus }, which cuts it beforehand into pieces that fit together with no gap, each a closed solid whose cut faces are tagged apart from its skin, smaller round at where it will be struck. It is still drawn whole; the editor also writes a mesh for each piece and a prefab of them, each with a dynamic body and a convex hull, and the reply hands over a Breakable to put beside the MeshRenderer. Raising Breakable.broken hides the whole (its renderer, body and colliders are switched off, not removed), puts the pieces where it stood and throws them out from origin at burst world units a second; lifetime takes them away later, and lowering the flag makes it whole again. Its pieces are loaded while it stands whole, so they appear on the frame it breaks. In the editor a clay pot written by model_write and placed on a floor broke into the 12 pieces asked for, then the 5 asked for after an edit, each of which moved, spread apart and came to rest on the floor, and was whole again when the flag was lowered. Nothing breaks it of itself yet: a script, a graph or a collision handler raises the flag. Physics3D.setLinearVelocity(entity, velocity) is what throws the pieces and is there for anything else that sends a body off. Prefabs.prepare(path) loads a prefab and everything its entities use and holds it, so a later instantiate does not wait on files.
  • A thing breaks when it is hit hard enough. Breakable.breakImpulse breaks it on a contact at least that hard, the speed at which the two came together times the mass they met with, and the pieces leave from where it was hit. It needs a collider of its own, which the editor's reply to a fractured model now hands over as hull (a ConvexCollider3D of its shape); with a dynamic body as well it can be knocked over and break where it lands. Every Physics3DEvents.contactEnters entry now carries speed (how fast the first body was closing on the second along the normal, read before the solver answered), mass (the kilograms they met with, 1 / (1/a + 1/b), a body that does not move counting as none) and impulse, their product, from both the Jolt and PhysX worlds. A sphere of 0.5 m dropped 1.5 m onto a pad reported 5.56 m/s from Jolt and 5.40 from PhysX against the 5.42 the fall gives, and met it with 523.60 kg, its own mass, from both. In the editor a 2 kg stone dropped six metres onto a pot broke it from its rim and took its collider away, and a 50 g pebble dropped from as high onto another left it whole. Native builds carry the new buffers but were only compiled on Windows, not run.
  • A 3D body has a mass of its own. RigidBody3D.mass sets a moving body's mass in kilograms, its inertia scaled with it; 0, the default, keeps the mass its shape gives at the density of water, so scenes made before it weigh what they did. It reaches a body already in play when it changes. Both worlds were given 2 kg and answered 2, and refused a mass that is not a positive number.
  • A script can push a 3D body about. Physics3D answered where things were and could set a velocity, and nothing more: there was no force, no impulse, no torque, and a script could not ask how fast a body was going, while the 2D world had all of it. It now has applyImpulse(entity, impulse, at?) and applyForce(entity, force, at?), at a world point or the centre of mass, applyTorque, applyAngularImpulse, getLinearVelocity, setAngularVelocity and getAngularVelocity, getMass, setAwake and isAwake, and setGravity and getGravity, all in world units, from both the Jolt and PhysX worlds. In each, 4 N s at the centre of a 2 kg sphere gave it 2.000 m/s and no spin; 1 N s half a metre off its centre gave it 2.500 rad/s, which r x J over its inertia says; a force lasted one step; and with gravity set to 2 m/s squared a body fell at 1.000 m/s after half a second.
  • A blast. Physics3D.explode(centre, radius, impulse, { upward }) strikes every moving body within reach away from the centre, less the further it is and none at the edge, and strikes every Breakable it reaches as hard, standing or not, so a grenade breaks the pots round it. In the editor a blast beside a pot broke it and threw the 50 g pebble at its foot away and up.
  • A thing that breaks says so. Broke is sent once a Breakable's pieces stand in its place, with where it was struck in the world and how hard, for the sound, the dust and the score; a thing whose pieces could not be loaded did not break and sends nothing.
  • Box and capsule sweeps, and what a 3D body weighs. Physics3D.boxCast(origin, halfExtents, direction, layers, rotation) and capsuleCast(origin, radius, halfHeight, direction, layers, rotation) sweep a turned box or an upright capsule as sphereCast sweeps a ball, and getMassData(entity) answers a body's mass, its centre of mass in the world and how hard it is to turn about each of its own axes. Swept ten metres down onto a slab, a half-metre box landed at 0.400 of the way, turned an eighth of a turn on its edge at 0.379, a capsule standing at 0.375 and lying at 0.425, as the geometry gives, in both the Jolt and PhysX worlds; a 2 x 1 x 0.5 m block answered 1000 kg and moments of 104.17, 354.17 and 416.67 kg m squared, a block's own, in both.
  • A joint changed while it runs. A 3D hinge's or slider's range and motor limit, and a distance joint's lengths and spring, reach a joint already in the world when gameplay changes them; before, only the motor's speed did, and a door locked from a script by narrowing its range swung on. A door turning at 2 rad/s stopped at 0.30 rad when its range was set to plus or minus 0.3 and went on when it was taken away, and a ball on a three-metre rope rose to one metre when the rope was shortened, in both worlds. A range always holds the pose the joint was made in: one that does not reach 0 is widened to 0, in both worlds alike.
  • A shot through cover. Physics3D.raycastAll(origin, direction, layers, maxHits) names every body on a line, nearest first, each with where the line goes in and comes out and how thick it was there, so a shot can spend its strength on a plaster wall and go on into what is behind it. Along a line through a 0.2 m wall, a 1 m box and a bone-sized sensor, both the Jolt and PhysX worlds named all three with their entry and exit to four places and measured the wall at 0.2000 m; a line that ends inside a body comes out of it at its end.
  • A joint that gives way. Every 3D joint takes a breakForce (N) and breakTorque (N m): held with more than either over a step, it is taken out of the world, its enabled lowered, and the break told in Physics3DEvents.jointBreaks, so a chandelier comes down when its mount is pulled harder than it holds. A 2 kg weight hanging on a rope pulls on it with 19.62 N in both worlds; in the editor a rope rated at 15 N gave way and its weight fell to the floor while one rated at 30 N held.
  • A character that runs into something says so. Physics3DEvents.characterHits tells what a 3D character ran into that it was not already touching, once a meeting, with how fast it closed, the mass they met with and the impulse, as a contact between bodies does; a Breakable a character runs into is struck with it, so a dive through a window breaks it and a lean on it does not. A character dropped 2.1 m onto a floor told it once, at 6.38 m/s against the 6.42 the fall gives and with its own 70 kg, and walking into a 30 kg crate at 3 m/s met it with 21 kg, in both worlds.
  • Telling the parts of a character apart. Hitboxes puts a box on each bone of a skinned character, the size its ragdoll would give it, that follows the animation: a kinematic sensor that nothing walks into or is pushed by and that a ray meets, so a shot names the bone it struck and hitPartOf says whose. While the ragdoll is limp its own bodies stand in. In the editor a character from the character-rig example given Hitboxes had a sensor box on each of its bones, a ray at one of them met that character's bone by name, and three quarters of a second of animation later a ray where the bone had gone still met it.
  • A sound or a piece of music can ship as its recipe. A package shipped every sample of every clip, compressed. An .essound or an .esmusic (the source the sound and music tools write, which until now only the editor read) named where a clip goes is carried as it is and made on the device when it loads, by the same synthesis the editor bakes it with: AudioSource.clip, Audio.playSFX and Audio.playBGM take the path of the source. It is made on a worker thread, a piece of music on one and sound effects on another so a step is never made behind a theme, and kept in the content cache, so a later run reads it back. Importing esengine/sound installs the maker, and an export adds it when a shipped asset is one. A game of four effects and a minute of music packaged 1.7 MB lighter; on a desktop its effects were ready 2.5 s after the page opened and its minute of music after 4 s, the first time only (the music is made at about twenty times the speed it plays). A sound with variants is made as its first, and a backend that plays from an address and not from bytes cannot play one yet.
  • A picture made in the editor is named by its recipe. image_write answered the .png it had drawn, and the material it wrote named its maps as .png files, so a game built from what the tool answered shipped pixels although the engine could draw them from a few hundred bytes. It answers the .esimage as ref and as the texture of meshRenderer now, the material it writes names its maps as recipes, and the drawn file is pngRef. The game the editor plays draws recipes as the edit view does.
  • Viewport keys for moving things quickly. Grid snapping starts on; a tap of Space cycles Move, Rotate and Scale while holding Space still pans; Ctrl/Cmd+backtick switches World and Local; End drops the selection onto the floor beneath it.

Fixed

  • Icons stay drawn and clickable with "selected entities only". The setting hid the icons of lights, cameras, markers and the like that were not selected, so they could not be clicked; it now limits only the wireframes and handles, as its description says.
  • A large image reaches the editor's viewport on a busy machine. The editor served project files without their length, and on a machine whose processor was busy (software rendering) a 10 MB image took 30 s to load and a 4097 heightmap missed its load deadline, leaving the terrain as noise; the same images now load in 8 s and 21 s there, and on a real GPU in well under a second as before.
  • A post-process shader can read more than seven textures. A fullscreen shader's eighth texture parameter found no texture unit and was not bound; units 4 and 5 now take the eighth and ninth. On WebGPU the first validation errors of a run are logged, where before only a refused command buffer reached the console.
  • A Spine skeleton is selected by the character it draws. A skeleton could be picked only on the small icon at its origin, so clicking the character selected nothing. The editor hands the pick box the skeleton's own bounds through the new extentOf option of entityWorldBox and pickEntitiesByRay, and the selection outline follows the same box.
  • Nudging a selection moves each selected root once, so a selected child no longer travels twice. With a parent and its child both selected, an arrow key moved the child by the nudge and again with its parent; each selected root now moves once and what is under it follows.
  • A click selects a shape by its drawn size, and a bare Canvas no longer takes the click. A ShapeRenderer could be selected only on the small icon at its origin, and any scene with a Canvas answered every click in the design screen with the Canvas, so the sprites beneath could not be clicked at all. A shape is picked by its size and its own sorting layer, and a UI node that draws nothing is picked only where nothing else is.
  • An unset texture array reads its default on WebGL. A textureArray param a material left unset was given the plain white texture, which an array sampler cannot read, so on WebGL it read black (WebGPU already drew white). An unset array param now binds layers of its declared default: white, black or a flat normal.
  • Clearing an asset field from automation clears it. set_field on an asset slot stored whatever it was given as text: 0 became the path "0" and null the path "null". The scene kept it, the editor drew nothing there, and an export failed to find an asset called 0. Nothing, however it is said (null, 0, false, the empty string, or "null" and "0" from a transport that sends values as text), now stores what the inspector's clear button stores: 0 in a handle-valued slot and the empty string in a Spine skeleton or atlas, which are string fields. Both ask one function for it (emptyAssetValue). Any other number is refused, since it names nothing a caller could have meant. model_write's text also says what its report holds, to read triangles every time, and that material.texture may name a recipe.
  • A model's picture can be a recipe. A model source's material.texture took a .png, .jpg or .webp and refused an .esimage, the recipe image_write answers as the picture's ref: a tree's branches named the pixels while the foliage material beside them named the layers, and a game shipped whichever was referenced. A recipe is now accepted there. Whether a path names a recipe is asked in one place, sdk/src/asset/textureRecipePath.ts, which reads nothing of the runtime: the registry that draws recipes, the packager deciding what ships and the model source's check each spelled the extension themselves.
  • A model's report is its steps as written, and names a step that undoes a decimate. report.steps of a baked model listed every plain step its repeats came to, by an index among those: a spruce of thirteen rows of branches reported a hundred and thirty-eight steps, most the same line, and none under the index model_edit takes. It is now one entry for each step as written, by that index, a repeat counted once with how many steps it made, and each entry says the triangles the mesh had after it. And a step that splits faces to carry its own detail (a stain by a pattern, a displace, a sculpt) after a decimate took the decimate's triangles back in silence: a rock thinned to 1100 came out at 214,534, under the 300,000 the report calls heavy, and a field of them would have been gigabytes. The report now warns of each such step, with what it was given, what it left and which decimate it undid, and says how to keep the detail (before the decimate, carried by normalBake) or bound it (detail). The test also notes what the advice costs: a pattern stained before a decimate leaves colour seams the decimate will not cross, so it is normalBake's color: true that carries it.
  • A playable's start-screen bar moves through the whole boot. The bar's stages were weighed for a web page, most of whose start is fetching the engine. A playable has the engine inlined, so its bar stood at 82% within a second and crawled to 95% over the twenty-five that followed. A playable now weighs its own stages (the scene's is four fifths of the bar), and that stage is followed in three stretches: assets being read and made (eased by the clock, since nothing counts them), shaders compiled against the most seen compiling, and the world prepared against the most its makers said was left. For that, a hold given to holdShaderWarmup may answer a number (pages, cells) where it answered yes, and warmShaders passes the sum to onProgress; Terrain and Foliage count theirs. One lake scene's bar went from 18% to 95% over its 22 seconds, with one stretch of four seconds standing still. attachSplash takes the weights.
  • An effect chain keeps its uniform buffers from frame to frame. A camera's post-process chain is said again every frame, and each of its passes made a uniform buffer for its parameters and deleted it when the chain was cleared: seventeen buffers created and seventeen deleted every frame for a lake scene with a volume's usual effects, counted in the GL calls of an exported page. The buffers of a cleared chain are now taken over by the passes of the next chain that need one the same size, and one that nothing has taken in eight clears is deleted. The same scene creates none in a steady frame.
  • A still shadow map is not collected again. A frame whose shadow map held what it would draw no longer drew it, but still walked every caster to find that out. Before the walk, each plugin that casts now gives one number for what its walk would read, and the frame adds the shadow views, the camera and the device's state: when that matches the number of the frame that drew the map, the walk is skipped and the map stands. The mesh plugin's number moves when a caster's Transform is written (found by a pass over the Transform stamps, so a camera or a sprite moving does not count), when a MeshRenderer, MeshSkin, MeshMorph, MeshInstances, LODGroup, Billboard, Impostor or MeshLightmap is written, added or removed, when an entity is enabled or disabled, and when a material, a mesh or a mesh program is changed or built (MaterialStore::revision, ResourceManager::meshesRevision, new). A scene with a level-of-detail group always walks: what a group casts follows the levels the camera settled on in its last frames. With the change audit on the walk is always made, and a matching number with a different result is logged and counted (render.shadow.inputsStale); render.shadow.collectSkipped says a frame skipped it. On Bistro at 640x360 the shadow declaration went from 12.7% of the sampled frame to 0.3%, the collect from 0.5 to 0.3 ms and the renderer's CPU time from 1.0 to 0.8 ms. With the audit on, 20 examples found no frame whose inputs matched while its walk differed; Bistro, Dusk Fort, Lighting 3D and Neon Ascension skip it, and where a frame cannot, render.shadow.collectWhy and render.mesh.castChanged say why (a caster that moves, a skin's joints, a level-of-detail group). With the scan of the casters' Transforms taken out, device-quality and cyber-rooftop reported every audited frame.
  • A mesh's draw keeps what no view changes. Every view of every frame derived each mesh's world box, model matrix, normal matrix, material lookups and program facts again, and looked up its motion pose three times in a hash map. What does not depend on the view is now kept per entity and used until something it came from changes: the entity's Transform or MeshRenderer is written (its change stamp), its mesh is realized again (the mesh's revision), its material changes or any material is added or removed (MaterialStore::revision, new), a Billboard, MeshInstances, LODGroup, Impostor, MeshSkin or MeshMorph is added to or taken from it, or the render origin moves. A mesh with one of those components, a parallax, or a view that overrides the look (wireframe, clay, weights) is derived every walk as before. The motion pass now passes over a static mesh that did not move before culling it. With the change audit on, every kept draw is compared with a fresh derivation and a difference is logged (render.mesh.proxy.stale); render.mesh.proxy.kept and .built count the draws kept and derived again. On Bistro (1,143 meshes) the mesh collect's share of the sampled frame went from 23% to 16%, and the motion pass's walk to nothing measurable. With the audit on, 26 examples (Bistro, physics, streaming worlds, terrain, a rig) found no kept draw that differed; with the check of the Transform's stamp taken out, physics-3d reported 365. A renderer that walks another registry (a scene loaded again) keeps nothing from the last one (Registry::identity, new).
  • A run of mesh draws is one call on WebGL2. Consecutive mesh draws that differ only in which range of a shared buffer they draw and which objects they place (the same program, material, textures and state) were each a call of their own, with two blocks bound for each: where its objects' records start, and the light probes its objects stand in. Where the browser offers WEBGL_multi_draw, such a run is now one call: a block staged once for the run says, for each draw, where its records and its instances' probes begin, and the vertex stage finds its own by gl_DrawID. A run of draws that carry probe light shares one probe block, so it holds at most as many objects as that block does. WebGPU, and a browser without the extension, draw as before. On Bistro at 640x360 the instanced draw calls a frame went from 538 to 71 plus 73 multi-draw calls, uniform-range binds from 1,022 to 276, and the WebGL calls from about 3,100 to about 1,920; the renderer's CPU time went from 1.2 to 1.1 ms. render.multiDraw.calls counts the runs drawn.
  • Meshes of one vertex shape share their buffers. Every mesh was given a vertex buffer, an index buffer and a vertex layout of its own, and a layout is part of a pipeline's key: a scene of five hundred meshes switched vertex arrays five hundred times a frame, and pipelines with them, though most of its meshes had the same few shapes of vertex. Meshes loaded from an asset now take ranges of shared pages, one page set per vertex shape (pages start at 1 MB and double, so a small game pays for little), and a run of them is drawn without switching vertex array, buffers or pipeline. Indices are rebased onto the page when a mesh is placed, since WebGL2 has no base vertex; a mesh with morph targets (whose deltas are found by vertex number) and a mesh built in the running game keep buffers of their own. After a lost device a page is rebuilt from its meshes' sources, each into a page of the new device. On Bistro at 640x360 the vertex-array binds a frame went from 540 to 55 and the WebGL calls from 3,627 to 3,102, and the renderer's CPU time from 1.6-1.8 ms to 1.2 ms in three runs each (the frame, which something else bounds at this size, stayed at 6.0 ms). ResourceManager::meshPageCount and meshPageBytes say what the pages hold.
  • A shadow map is drawn again only when what it holds changed. Every shadow-casting mesh was drawn into the shadow atlas every frame for every light, though in most frames nothing in a map had moved: Bistro drew 891 casters a frame for a sun and a scene that were both still. The atlas is now kept from frame to frame, and the frame compares what its squares would draw (where each looks from, the casters, their transforms, bones and shapes, the materials of cut-out casters) with what was last drawn into them, and skips the pass when they are the same. A caster that moves, a light that turns, a camera that walks the sun's cascades on to the next texel, a lost device or geometry rewritten in place draw it again. A material that moves its vertices (wind, a ground's height) is assumed to move them every frame, so a map it casts into is always drawn. On Bistro at 640x360 the WebGL calls a frame went from 7,139 to 3,627 and the renderer's CPU time from 3.3 to 2.3 ms. render.shadow.reused says whether a frame drew the atlas.
  • Walking a frame's meshes costs less, and the profiler says what it costs. Every mesh, in every view, asked its material's layout several questions by name (does it read the picture behind it, is its alpha coverage, does it cut out a shadow), each a string search; they are answered once when the layout is registered, and the last material and layout asked for are kept. A child of a model (most of an imported scene's meshes) was decomposed afresh by every view of every frame though its matrix had not changed; it is decomposed again only when it moves. And the mesh walk read the clock at every phase of every mesh while profiled, which was four in ten samples of a profiled frame and most of the time it reported; it is timed whole (the split by phase is the build option ES_PROFILE_COLLECT_PHASES). On the Bistro scene at 640x360, the best of seven interleaved runs went from 9.97 to 6.83 ms a frame, and a grid of 4096 meshes on one material from 4.08 to 3.09 ms. render-submit-cost.mjs --wall times frames with the profiler off.
  • Sprite and particle shaders compile in the background too. With quality.asyncShaderCompile, mesh and material shaders were compiled without holding a frame, and the batch shader's variants (sprites, text, lit sprites) and the particle shader were not: each was linked in place when first needed, measured at 350 to 490 ms of one frame mid-play under ANGLE. They are deferred the same way now, their texture units set when the link lands. Without the setting nothing changes.
  • A shader warm-up waits for the scene still being made. warmShaders (what quality.prewarmShaders runs behind the loading screen) stopped at the first three frames in which nothing was compiling. A ground still painting its pages or a field still growing its cells draws seconds later, with shaders nothing had asked for yet, so whether a scene opened complete depended on which arrived first: of the runs of one lake scene, about half opened at 13 s and went on compiling for eight more, the rest at 25 s and complete. Terrain and Foliage now hold the warm-up while they are preparing, and every run opens complete; holdShaderWarmup(app, busy) is how a game's own generated content does the same. The wait is still bounded by prewarmTimeoutMs.
  • A ground's layer pictures are read together. A Terrain with layers is not drawn until every layer's albedo, normal and mask have been read, and they were read one after another. A picture that is an .esimage recipe is drawn when it is read, so a ground of four layers with recipes for all three stayed out of sight for as long as twelve drawings took in a row. They are now all asked for at once, and recipes are drawn on as many workers as the device has. How much sooner a ground appears was not timed.
  • A playable waits for its shaders when the project asks it to. quality.prewarmShaders (with asyncShaderCompile) was acted on by the web host alone: a single-file playable opened at once on a scene with most of it missing and filled in over the next seconds. A playable has no splash to draw behind, so its canvas is kept out of sight while the first scene's frames are drawn and its shaders compile, and shown when nothing is compiling any more or after prewarmTimeoutMs. initPlayableRuntime takes it as prewarmShaders.
  • A wide blurred text shadow is one soft shape. Text.shadowBlur was drawn as one ring of eight copies of the label at the blur's own radius, whatever that radius was. At two or three pixels that is a soft edge; at eighteen it is the label nine times over, fourteen pixels apart, and a title set large stood in blocks of dark squares round every stroke. Past three pixels a shadow is now as many rings of copies as keep each within a stroke's thickness of its neighbours (a share of the font size), sixty-four copies at the most, so it reads as one soft shape. A blur of three pixels or less is drawn as it was.
  • A mesh scattered with no material keeps its own colours. A Foliage field with no material is painted, since nothing reads the wind's weights then, and it painted every plant the stock green of grass from root to tip, whatever the mesh's own vertex colours said: a grey rock scattered along a shore came out a smooth green one, and a dark spruce a pale one. A mesh that has colours of its own is now painted in them, each plant a little lighter or darker by its shade; a mesh with no colour channel, or white throughout, is painted as before.
  • A playable samples its textures as their import settings say. A single-file playable was handed no manifest, which is the only way a texture's .meta reaches a package, so its wrap mode, its filter, whether it is colour and its 9-slice border were all lost and every texture took the defaults. A ground or a wall whose picture repeats then drew one copy of it and smeared its last row of pixels over everything past the first tile: cliffs came out one flat colour with level stripes along the waterline, while the same scene was right in the editor and in a web export. The settings of the textures a playable inlines now ride in the page and reach the runtime the way they reach every other package.
  • Drawing a frame costs the CPU a third of what it did. Issuing a frame's draws went through four costs the engine did not need. Every draw staged a light-probe block of its own, up to 16 KB of zeroes filled, copied and uploaded, though no probe lit it; a run no probe lights now reads the zero block. Every draw bound every texture unit its slots named, where the program it drew with read none of some (a shadow caster, most of all); a draw now binds only the units its program samples, read from the program once. The face to cull was set at every change of pipeline though it nearly never changed. And every vertex array bound asked the browser which index buffer it held, through a WebGL emulation (FULL_ES3) nothing in the engine used. Pipelines and other device objects are also found by index rather than searched for. On the Bistro scene at 640x360, where the CPU and not the GPU sets the pace, the renderer's CPU time a frame went from 11 to 14 ms down to 3.3 ms, the frame from 13.4 to 6.7 ms, and the WebGL calls a frame from 17,926 to 7,139; 52 pixel gates on WebGL2 and 23 on WebGPU draw what they did. node tools/render-submit-cost.mjs measures it: a synthetic grid in three spreads of material, or an example such as --scene bistro, with --glcalls and --profile.
  • A cloud's shadow dims the sun, not the sky. Sky Atmosphere's Cloud Shadows and a custom sky's groundShadow multiplied every surface in the frame by the shadow, after it was lit: ambient light, reflections, other lights and emission were dimmed with the sun, and an unlit or emissive object went dark under a cloud. Measured against a reference island lit the same way, its ground came out 25 to 35 levels darker than the reference, and lit by the sky alone it was black. Now the sky draws a cloud shadow map before the scene, into one tile of the sun's shadow atlas (16 km round the camera, u_cloudShadowExtentKm), and the first directional light is dimmed by it where each surface is shaded, as Unreal's atmosphere sun reads its clouds' shadow map; nothing else is. The cloud shadow criteria now light their floor by a sun and add a floor nothing lights, which must keep its colour under the clouds; they and 56 shadow and sun criteria pass on WebGL2 and WebGPU. With the atlas full (High quality's four cascades fill it) the sun gives up its farthest cascade to the map. The map holds the light left at the camera's own height, exact below the cloud layer and an estimate inside it.
  • A package that ships texture recipes draws them. An export carried its .esimage files and drew its ground and its walls with no texture, saying only in the console that nothing there draws recipes. The call that installs the drawer had ended up in a part of the built SDK that was not marked as having an effect, and the bundler dropped it; and a playable ad, whose entry is the whole SDK, never imported the drawer at all. Both are put right, and a check now bundles a game that imports it and looks for it.
  • A cleared asset field no longer stops a game. An empty string in an asset field of an engine component (a material cleared to nothing) was taken for a path to load, came back from the load still a string, was written back as one and asked for again, without end: a field of plants put it on every cell it grew, and the packaged game stopped answering half a minute in. An empty string is no asset now, and a path nothing resolves keeps its placeholder.
  • A Jolt hinge or slider whose motor is switched on in play keeps its limit. Made with its motor off, a joint in the Jolt world took the solver's own motor settings when the motor was turned on later, which push without bound, so a door with a maxMotorTorque of 10 opened as if it had none, where the PhysX world held it to 10. Both now hold every motor to its limit from the start: switched on with a limit of nothing, a door turns nothing in either.

[0.104.1] - 2026-11-13

Added

  • Music plays as its layers. A piece could be exported as stems, one clip for each instrument, and nothing could play them as one piece: clips started one after another are a few milliseconds apart and stay so. audio.playLayers({ drums, bass, lead }, { mix, levels, fadeIn, loopStart }) begins every stem on the same sample and loops them together, and what it returns brings a layer up or down while it plays, music.setLayer('lead', 1, 2). It is the background music, replaced by playBGM and ended by stopBGM. In a browser's audio engine the seven stems of a piece begun this way sum to the whole piece within a ten-thousandth, through the place it goes round and on its third time round; begun a hundredth of a second apart they do not resemble it. Layers that drift are worse than none, so where clips cannot be kept in step (a mini-game, a clip played from its compressed file) the mix plays in their place and music.layered says so.

Fixed

  • A meadow at rest no longer costs the frame 9 ms. What is made round the camera in chunks (a Foliage field's cells, a generated world's squares) was worked out afresh every frame: every cell within reach given a key and a distance, then asked whether it was made. Six fields of 8 m cells reaching 260 m cost 9.1 ms a frame that way with the camera standing still and nothing left to make. The walk is now kept while no source has left its cell or moved a sixteenth of one, and a layer whose every chunk is made is not asked again until a source moves, its generation changes or a part of it is invalidated: 0.13 ms for the same six fields. A camera in flight still walks as it crosses cells.
  • Baking a water region no longer holds the frame. A WaterZone is baked over several frames, a step at a time inside the frame's spare milliseconds, but a step was 16 or 32 rows whatever the rows' length and then whole sweeps of the grid: at a resolution of 2048 each step took 70 ms and the last ones 190 to 400, so the editor and a game ran at 10 frames a second for as long as the bake took, with frames of two seconds in it. A step is a count of cells now (the flood, the two distance sweeps and the blurs step too): the longest measured is 20 ms, and the same bake takes 7,600 steps where it took 300. The baked field is the same. It still runs on the main thread.
  • A ground with no layer files is painted again. In 0.104.0 a Terrain drawn by the stock shader (four layer colours or textures and a splatmap, no .esterrainlayer files) was one colour from edge to edge on every platform, and logged shader Terrain: texture param "u_paintPages" finds no free texture unit. The baked occlusion map made the paint that shader's eighth texture, one past the seven units a material has; the eighth takes an engine unit the shader does not read, and the shader was counted as reading four of them because it keeps three colours in variables named s0 to s3, which is how WGSL names a sampler unit. A name a source declares for itself (let s2, a var in a function, a parameter) is not a unit now. A criterion, terrain-paint, draws a ground painted in two colours on both backends: nothing in the pull-request tier drew a terrain before.
  • A loop is seamless in a packaged game. A .wav is re-encoded to MP3 when a game is exported, and a decoder gives an MP3 back with 1105 samples of silence before its sound and several hundred after it: measured in a browser, a one-second loop that was seamless as a .wav had 21 ms of silence every time round once packaged, and every sound, looping or not, began a fortieth of a second late. No tag in the file tells a player to take the silence off, and none does. The exporter now records, for each clip it re-encodes, how long it really is and what leads it, and the runtime plays the clip from past the lead to its real end and loops it between the two: exact to the sample where the clip is decoded (the web's decoded clips and the native host), and started past the lead where it is played from its file (a streamed clip on the web, a mini-game). A decoder that takes the silence off itself is seen by the length of what it returns and is not asked to twice. A project played from the editor reads its own .wav files and was never affected.
  • A large ground no longer throws every frame once its pages run out. With every page slot in use (a detail that wants more than the 900 there are, or a long flight), TerrainSystem threw Cannot read properties of undefined (reading 'slot') each frame: the ground stopped following the eye, and the log filled. The ground chose what to draw, made new pages, then placed its nodes, and a page was marked as in use only when placed; a page made in between took the slot of the least recently drawn one, which was a page just chosen. What is drawn is now marked before anything is made, and when every slot is drawn that frame the new page waits.

[0.104.0] - 2026-11-12

Added

  • A recipe is read wherever an image is, with its text, its figures and its surface maps. A texture recipe (an .esimage shipped in place of its pixels) was a texture only, and one with text or a figure layer was refused on the device. Now what reads an image as numbers reads a recipe too (a ground's layers and splatmap, a field's density and scale maps). A source's normal map and its roughness-and-metal map are each a texture by a recipe of two lines, { "mapOf": "assets/wall.esimage", "map": "normal" }, with import settings of its own. Text is set by the device's 2D canvas (on the worker where it has one), in a font file of the project where the layer names one; a host with no canvas refuses it and says to bake. A figure is posed on the device by the same bones the pipeline poses, which moved from the pipeline into the SDK (pipeline/src/modeling reads them from there). A recipe may lay in a PNG or another recipe; what it names ships with it (the cook follows a recipe's references now) and is part of what its kept pixels are kept under. An exported game with four such recipes drew all four on workers on the first visit and none on the second. esengine/image is 220 KB of a web package before compression (81 KB gzipped), up from 172. A ground reading a recipe is checked by a test and not yet in a game; nothing was timed on a phone.
  • A texture recipe is drawn on a worker, once. A recipe was drawn on the main thread when its texture loaded, every run. It is drawn on a worker thread now, and its pixels are kept in the content cache under a name made of the recipe and the raster's revision, so the next run reads them. An exported game with a 2048 pixel plate, opened twice in one browser: the first visit drew for 4.1 s on a worker with no main-thread task over 550 ms, the second drew nothing (0 jobs, 307 ms longest task). A browser had no content cache; it has one now, in IndexedDB, which also means files a web game downloads through hot update are kept between visits. Where there are no workers the recipe is drawn on the main thread. Carrying the raster for the worker as well takes esengine/image from 86 KB to 172 KB of a web package before compression (62 KB gzipped). Kept pixels are uncompressed and are removed only by cleanDiskCache. Not timed on a phone.
  • A texture can ship as its recipe. A package shipped every pixel of every picture. An .esimage (the layered source the image tools write, which until now was only ever baked to a .png beside it) can be named where a texture goes, and the package then carries the source: the texture is drawn on the device when it is first loaded. In a headless game a 512 pixel plate drawn from its 691 byte recipe matched its 351 KB PNG at every one of 921,600 pixels. The raster moved from the pipeline into the SDK as esengine/image (about 86 KB of a web package before compression), which an export adds when a recipe ships and no other package carries; the pipeline and the editor draw with the same code. It is drawn on the main thread at load and is not kept between runs, and a picture with a figure layer or text is still baked.
  • A scale map. Foliage.densityMap says how many of a field's plants stand where, and every one that stood was its full size: grass that thinned toward a beach ended in tufts as tall as the meadow's. Foliage.scaleMap is an image over the same area whose red is how large the plants stand: full size at white, smaller toward black, none at black. It is read as numbers, as the density map is, and on the workers with it. With both, a sward thins and shortens as it runs out and has a soft edge.
  • The grade has a gain and an offset, and the vignette a radius and a roundness. Color Grade could add to the blacks (Lift) and never take from them, and its contrast in a linear project is a power curve about 0.18, which leaves black where it was. A look graded elsewhere with a contrast that is a line through 0.5 sinks its blacks: without that, a meadow that measures 0.77 saturation there measured 0.50 here, with a film of blue over every dark green. Gain (u_gain) multiplies every tone and Offset (u_offset, which may be under zero) is added after it, as a grade's slope and offset are; (c - 0.5) * k + 0.5 is a gain of k and an offset of 0.5 - 0.5 * k. The Vignette was full at the middle of every edge whatever its numbers: Radius (u_radius) is where it is full, and Roundness (u_roundness) takes it from the frame's own ellipse to a circle whose 1 is the corner, the usual lens vignette. Every default is the picture as it was.
  • A blade's lean, its turn to the eye, and what a leaf lets through and mirrors are yours to set. Four numbers of a field of grass were the engine's own. Foliage.bladeLean is how far a blade's tip is thrown over (it was 0.12 of its height, written into the builder). On the Foliage material, u_specular is how much a plant mirrors the sun and the sky (it was 0.5, written into the shader), u_translucencyColor the colour of the light that comes through a leaf, which was the leaf's own and is yellower in a real one, and u_bladeFaceEye turns the flat of each blade toward the eye so that a blade seen edge on is not a line. Every default is what it was.
  • A flower turns to face the eye. A flat flower faces the sky, so a field of them is seen edge on from a few metres up and has no colour a field away; tipping each far plant's head at random (farTilt) showed half of them from behind. Foliage.faceEyeNear and Foliage.faceEye turn the head of every mesh plant toward the eye, by the first close to and by the second from half the draw distance away, as a clump of flowers shows its colour from the side. It is done the way a pivot painted into a uv is elsewhere: the copies carry in a second uv where each vertex of a head sits from its plant's axis, and a material's vertex hook now reads a mesh's second uv as es_vertexUv1 (zero on a mesh with none), beside es_vertexColor. At 0 and 0, the default, no channel is added and nothing turns.
  • A far field of flowers shows its colour. A mesh plant kept in a far version grows across the ground to stand for those left out. A flat flower grown that way is a disc facing the sky: from an eye a few metres up it is seen edge on, and a meadow that is all flowers at your feet was plain green a field away. Foliage.farTilt tips the top of each far plant over by so many degrees (the last tenth of its height: the flower, not its stem), each plant its own way round, so half the field shows its face. 0, the default, leaves a far plant as it was.
  • A layer with a grain is read without repeat and without hexagons. Near the eye a terrain layer is read in hexagonal cells, each shifted and turned at random, so no tile shows. A layer with a direction to it (sand in ripples, rock in beds) turned cell by cell has its normal map lit cell by cell, and the ground showed a mosaic of light and dark hexagons a metre wide. u_antiTileTurn on the Terrain and Terrain Layers materials is how far round a cell may be turned: 1, the default, is any way as before; 0 shifts the cell and does not turn it, which is the setting for a layer with a grain.
  • Music with an introduction, and a source that fades. Background music looped from its first sample to its last, so a piece could not open with something heard once; and an AudioSource in a scene started and stopped at full volume, the fades being playBGM's alone. A looping voice now takes loopStart, seconds into the clip that it comes back to at its end: playBGM(url, { loopStart }) and AudioSource.loopStart play the file from its top once and round from there after. It is exact to the sample where the clip is decoded, on the web and on the native host; where a clip is played from its compressed file (a long clip streamed on the web, a mini-game) the player is sent back when it ends, which can be heard as a breath. AudioSource.fadeIn and fadeOut are seconds: raising playing brings it up from nothing, lowering it lets it down before the voice is stopped, and raising it again on the way out turns it round where it is. A piece made with music_write marks its first parts as an introduction with intro, and the reply gives the loopStart to play it with.
  • An AI can make background music. A sound effect is layers; a piece of music is notes, and writing it as layers would be writing every note as a wave. A piece is now an .esmusic: instruments, each the layers of a sound written at the A of 440 Hz and struck at the pitch of every note; patterns of a few bars, each track a line of steps (1 - - . 5, - 3', [1 3 5], x for a drum) written as degrees of the key, so a line cannot leave it; chords that a bass or a pad follows, written once and moving with them; and the order the patterns come in, with instruments left out of a part so a piece builds. It makes a .wav that runs into itself, what rings past its end added to its start, and with stems a file for each instrument that add up to the whole, for music that grows with the game. A loop that joins without a click can still be heard to join, where a full last bar runs into a thin first one: the reply says what the last bar and the first hold and warns when they differ. A piece with loop: false has an end: it rings out past its last bar, and fadeIn and fadeOut bring it up and down; a loop has no fade written into it, since the game fades one with playBGM and stopBGM. There are scales of five notes, pentatonic, pentatonicMinor and the Chinese modes gong, shang, jue, zhi and yu, whose degrees count to five so that a line cannot touch the two notes they leave out; and an instrument may have a scale of its own, which is how such a tune is made: five notes in the flute over chords that have all seven. Right notes at one loudness, each begun from nothing, are a machine reading a score, so a line can be played: dynamics on a pattern give each bar the loudness it begins on and move evenly between them, a crescendo and a diminuendo; legato on an instrument brings a note that runs straight on from the last in under it, from past the attack of its recording, as a bow that does not leave the string; and pedal holds every note of a piano to the end of its bar. A piece is mixed: an instrument's lowcut and highcut take off what it has no need of, and master holds the loud moments down with compress and tilts the whole with low and high, done to the sum and to each stem alike so they still add up. And rubato lets each pattern begin held back, move on and ease off, every instrument together. Whoever writes it cannot hear it, so music_write, music_edit and music_read answer with a picture of the notes, every one a bar in its instrument's colour, and with what can be said of them unheard: two lines crowding one octave, notes outside the key, how loud each instrument is beside the whole. Instruments of layers are made sounds, which suit electronic, retro and ambient music. A piano or strings that pass for real ones are recordings: an instrument may instead have samples, a recording in the project for each of a few notes, and every note of the piece is played from the recording nearest it, faster to be higher and slower to be lower; what dies of itself ends with its recording, and what is held goes round the steady middle of it with loop. A recording made in stereo comes out of a SoundFont as one file with both its sides, and each zone's level and filter come with it as the sample's gain and cutoff, so a piano's hundred and eighty zones stay its seventeen recordings. Each recording is listened to: one whose pitch is not the note it is called, or a whole library an octave out because it counts its octaves from another C, is a warning that names the note to set, since nothing in the notes would show an instrument out of tune. A sample marked dynamic: "soft" or "loud" plays the steps marked ? or !, since a piano struck hard is brighter and not only louder; several samples of one note take turns, so a note repeated is not one recording repeated; and tune takes out how sharp a recording is. A SoundFont (.sf2) put in a project is a bank of such instruments: soundfont_read lists what is in it and takes one out as .wav files and the samples that play them, each with its note, range, tuning and loop, after which the SoundFont is not needed. The engine ships no recordings of its own: they are the project's.
  • An AI can make a sound effect. The engine played recordings and nothing here made one: a game built by an agent had pictures and models of its own and no sounds. A sound is now layers, as a picture is: sound_write takes a source of tones (sine, triangle, saw, square), noise (white, pink, brown) and modes, the tones a struck thing rings with, each placed in time and shaped by a level, a decay, filters whose corner can move, a second tone bending it, drive, pan and repeats, with an echo and a room over the whole, and writes an .essound and the .wav a scene plays. Whoever writes one cannot hear it, so the reply is a picture: the wave on top and pitch against time under it, a thump a blot low on the left, a hiss a haze across the top, a falling tone a falling line, with the level and the share of the energy that is low, middle and high. sound_edit changes a number and makes it again; loop runs the end into the start for an engine or a wind. A gunshot, footsteps, breaking glass, a pickup, an explosion, an engine loop and a laser are 150 to 500 bytes of source each and are made in under a tenth of a second. The same source is the same file on every machine. The first sounds made this way were listened to and did not pass: one noise through one filter with one decay is heard at once as a machine. So a layer can now be what a real sound is made of: noise cut to a band and brought back to full level, several of which die at different rates behind an impulse; a tail that lets part of a decay linger; scatter, which strikes a layer hundreds of times at random in time, pitch, loudness and side, for glass, gravel and rain; repeat with faster, for a thing bouncing to rest; a peak filter for the note a body adds; and reverb as a place, room or open, made by laying the sound over what that place answers to a click, with distinct first echoes and a wash whose top dies before its bottom. A layer can also be a recording in the project (source: "sample"), played at a speed and shaped as any other layer is, for the one sound that will not come out of waves and noise. The tool text gives the method and the numbers for a shot, glass, a step and an explosion; the step is a shoe on a floor, measured against a recording: a blow on something that rings briefly, heel then ball of the foot, a scrape, nothing under 110 Hz, and a room round it. A group is several layers struck together as one event, so four footsteps are one step with repeat (787 bytes of source where it was 24 layers), each striking with its own grit. variants makes up to eight files that are the same sound and not the same samples, their pitch, loudness, decay and timing off by vary, with a sound event beside them that plays one after another without repeating: a game that plays one file for every shot is heard as a machine however good the file. And reference names a recording to be like, which is drawn above the made sound in every reply, the same way and to one scale of time, and measured the same way; sound_read reads a recording on its own.
  • An AI can draw a surface: a picture that repeats, with what the light does on it. image_write drew one picture, and a picture laid beside itself shows its edges; nor is a wall only its colour. tile: true on an image source makes it repeat: a shape, a line or a brush stroke that leaves one edge comes in at the opposite one, a shadow and a blur go round with it, and a noise fill meets itself. material: { relief, height, roughness, metal } makes it a surface: each of height, roughness and metal is layers drawn as a grey picture of their own (light is high, rough, metal), or the colour's own lightness stands in for the relief, and a normal map, a map of roughness and metal and an .esmaterial are written beside the picture. The reply shows the picture laid beside itself two by two, where a join would run through the middle, and the same under a low light, and gives the fields to put on a mesh. A brick wall, a plank floor and a riveted plate, 256 pixels each, drew in under a third of a second apiece and tiled three across in the engine with no join. A filter still stops at the edges, and a noise turned or stretched by transform does not come round.
  • A model is written once for all its like parts, and a leaf can be a picture. A model's source was a flat list of steps with plain numbers: a plant of ten fronds wrote out a frond ten times, and every leaf was a thin solid in one colour. Three things change that. params names numbers and points, and a value written "=length * 0.4" is a sum over them, with points that add and scale, angles in degrees, and makers for what shapes keep asking for: polar for a point round the upright axis, arc for a line that bends from one lean to another, part for a share of a line. { op: "repeat", over: [rows], steps: [...] } runs its steps once for each row, the row's fields being names inside it, and let names a value for the steps after it; what is saved and edited is the source as written, so one edit to a name changes every part. The strip step carries a band with no thickness along a path, shaped by widths, folded by cup, with a picture laid along it from root to tip. material.texture names that picture, and with alpha: "cutout" its alpha is the outline: a leaf with veins and a torn edge, drawn once. loft takes an up for the way its section stands. The palm that was 386 steps is six steps written in two models of 2.9 and 2.4 KB, and 9,150 triangles where it was 26,814. Drawn in the engine it cost a little more GPU than the solid one all the same (about 1.1 ms against 0.8 for the frame at 1024 by 1024 on an RTX 3060): cut-out leaves draw both sides and test every pixel.
  • An AI can lay leaflets along a stem in one step. scatter along a path pointed every copy the way the path runs, turned at random, so the leaflets of a frond, the barbs of a feather or the legs of a centipede had to be written out one step each: a palm was 386 steps and a 749 KB model file. rows (1 or 2) stands the copies off the path instead, in a row or in pairs, sweep degrees from the way it runs and lift out of the plane, each as one number or as a start and an end. A copy's +z faces up, so a flat blade keeps its face to the sky whichever way it points. sizes shapes them along the path, widest in the middle if you say so. The same palm is 40 steps and 38 KB, and bakes to the same triangle count. A scatter without rows is as it was.
  • A game calls its own native code by name. A packaged Android or iOS game can link an ad SDK, a store or a sign-in library, and had no way to reach it: the native host answered the engine's own calls and nothing else. NativeChannel.call(method, args) now runs a handler the app registered (com.estella.host.NativeChannel.register in Java, EstellaNativeChannel in Objective-C) and resolves with what it answered; has says whether a name is answered and on hears what the native side raises on its own. Values cross as JSON. Ads rides on it: once the app's code answers ads.show, Ads.available is true on a device and showRewarded works as it does in a mini-game. The engine links no ad SDK; which one is the project's choice. An exported Android Studio project keeps your Java under app/src/game, which a re-export leaves alone. Elsewhere has is false and nothing is called, so a game that asks first runs unchanged on the web.
  • Text has letter spacing. Text.letterSpacing is extra space after every glyph, in the same px as fontSize; a negative value draws the glyphs closer. The layout always took a spacing, and measureText did, but the component had no field for it and nothing handed one over, so a label could not be spaced. Wrapping, alignment, Ellipsis and Shrink measure with it, Shrink scales it with the type, and it is in the Details panel beside Line Height. The default, 0, is the text as it was.
  • A cliff's beds can wander. A terrain layer seen from the side is read by height, so the beds of a cliff texture lie level, and ran dead straight along a whole wall like lines on ruled paper. The Terrain Layers material's u_strataWarp is how far they wander up and down, by slow noise u_strataSpan wide. At 0, the default, they are straight as before.
  • The tonemap has the fitted ACES curve too. The tonemap effect ran one curve, the engine's (Narkowicz's fit). A picture made for the other ACES fit in wide use (Hill's RRT and ODT, what three.js calls ACES Filmic) came out with shadows about a third brighter at the same mid tones, and with the hue kept in bright colours that curve sends to white. Fitted ACES (u_curve 1) runs that fit; off, which is the default, nothing changes.
  • An anchor on a waterfall. A Waterfall lands wherever the ground or the water under it is, and nothing said where that was, so the mist at its foot had to be placed by hand and stayed behind when the fall moved. A child of the fall's with a WaterfallAnchor is kept on the middle of its path: at the foot (at 1), at the lip (0) or a share of the time down, lift above it. A ParticleEmitter on that child is the mist.
  • A waterfall. A river's surface lies over the ground and stopped at the edge of a cliff with nothing after it. A Waterfall on an entity at the lip, facing the way the water leaves, throws sheets of water level at speed and lets gravity take them: each ends where it meets the ground, or water that is not the water it left, or maxDrop under the lip, and is made again when what is under it changes. It is the entity's own MeshRenderer; with no material it takes the stock Waterfall shader, glass at the lip that tears into strands and then veils, its pattern riding down with the water at the water's own speed.
  • A sky of your own shades the ground under its clouds. Sky Atmosphere's clouds cast their shadow on the scene; a sky written with defineSkyEffect could not, so a stylised sky lit a world with no cloud shadow on it. With groundShadow: true the sky's source holds a second function, skyShadow(world, sun), what is left of the light at a world position, and every surface the sky pass finds is multiplied by it.
  • A texture says whether it is a picture or numbers. Import settings have a Use: Colour, or Data for an image read a number a texel (a heightmap, a mask of measured values, a lookup table). A build treats Data as what it is: never compressed, never decoded as sRGB or filled, kept at its depth, and at its own size unless Max Size (which now offers Source size) says otherwise, in which case it is resampled at 16 bits and not through 8. Nobody has to know to set it: a PNG of 16 bits a sample is imported as Data from the editor and the CLI alike, a texture put in a Terrain's heightmap or splatmap is marked Data there and then (a splatmap cooked as a picture had its weights overwritten wherever the fourth was 0, and the ground fell back to grass everywhere), and Project Health lists textures a component reads as numbers that are still set up as pictures, with the fix on the row.
  • An ocean reaches the horizon. The sea's surface is rings of mesh round the camera, and it ended where they did: from a hill, or with a small cells and rings, a straight edge with nothing past it. A flat apron now carries it on to 80 km, at the cost of one row of quads.
  • A sea is eight waves spread about the wind. Water's waves were four peaked sines, the longest far taller than the rest, and from any height the sea read as regular curved bands. The set is now eight: the first heads with the wind, each after it is 0.78 of the length before, nearly as steep, and off the wind by a golden-ratio step within 65 degrees, each at the speed its length gives deep water. Their heights add up to what the four's did, so waveHeight raises a crest as high as before and nothing built on the old bound moves. Waters.sample, Floating and the drawn surface still share one formula: the shader's waves are now written out from the table in water/waves.ts (WAVE_SET) when its source is assembled, where the same numbers were kept by hand in five places. A quality level's waterWaves is 3 / 5 / 8 (was 2 / 3 / 4), longest first. A scene tuned against the old four will look different: the same height spread over more, smaller waves.
  • A Foliage field has its own material instance, grass that widens as it thins, and a palette. Three things a meadow of several kinds of flower needed. A field wrote what it alone says (where it thins, its colour map) onto the material it was given, so two fields on one material, or on two material files with the same contents, drew with whichever wrote last: each field now draws with an instance of its own, and edits to the material still reach it. Grass thinned between its far versions and stayed as narrow, so the ground showed through until the next version took over: a blade now widens in the shader by as much as its neighbours are left out, up to farGrow, and the field covers the same ground from the near blades to the draw distance. And Foliage.palette is a strip of colours each plant takes the colour of its top from, by a number of its own: as wide a share of the strip, as many of the plants.
  • Foliage thins plant by plant with distance, and is grown only where it is drawn. A cell of Foliage had one far version (every third blade of grass, or a tree's cards), every cell held its full near mesh however far off it stood, and a field ended in a line at its draw distance. A cell now has up to three far versions (farLevels), each keeping farKeep of the plants of the one before, grown by up to farGrow to cover the same ground, and taking over farStep times further out. Every plant has a number of its own: the shader thins by it with distance, and a far version holds exactly the plants still drawn where it takes over, so nothing jumps at the switch and the field fades to none at drawDistance. With a material, each version is a layer of cells of its own, grown only as far out as it is drawn: a meadow drawn to 300 m is whole within the first tens of metres and a fraction of itself beyond, where before it would not fit in memory. farCards says whether a mesh's far version is crossed cards (a tree, as before) or the plant itself, fewer and larger (a flower). The Foliage shader also gains u_tipFrom: how far up a plant the tip's colour begins, for a stem under a flower's head. The defaults keep one far version at a third, so a field's look changes only at its far edge, which now fades.
  • A meadow: a density map and a colour map for Foliage. Foliage scattered its plants evenly over its area, and every plant of a field was the one colour its material gave. densityMap is an image over the area whose red says how many of them stand where (none at black, all of count at white), so flowers grow in drifts and grass thins toward a path; a place keeps or loses its plant by a lot of its own, the same on every thread and in every cell. colorMap is a picture that colours the plants by where they stand, mixed in by its alpha from colorMapFrom up the plant, with colorMapStrength: one flower mesh and one material are pink here and yellow there. The density map is numbers (its Use is Data, set when the field is); the colour map is read each frame and grows nothing again.
  • A baked occlusion over the ground. A terrain's large folds (a gully, a hollow, the foot of a cliff) get less of the sky than open ground, and they are too large for a screen-space occlusion pass to see across. Terrain.occlusionMap is an image over the whole area whose red says how much of the sky reaches the ground, with occlusionStrength; it dims the light that comes from all round and leaves the sun's own to the shadows, on both terrain shaders (u_occlusionMap, u_occlusionStrength on a material of your own). It is numbers: its Use is Data, set when the field is. In full sun it is quiet, as it should be; it tells in shade and under an overcast sky.
  • A colour map over the ground. Layers paint a terrain by kind of ground, and a meadow painted with one grass layer is one green from end to end. Terrain.colorMap is a picture laid over a whole area and mixed into the ground's colour by its alpha (the flowers of a meadow, the regions of a map, scorched ground), on the plain Terrain shader and on Terrain Layers alike; colorMapStrength says how much, and is read each frame. It is one more texture on the ground's material (the seventh on Terrain Layers, whose eight layers are three arrays). A material of your own on those shaders has it as u_colorMap, u_colorMapStrength and u_colorMapArea.
  • Water is a body and a surface. The water's own colour was lit by the ripples' normal, as a painted surface is, so every ripple had a dark far side and a sea was blotched with dark patches no real water has. It is two layers now, as Unreal's single-layer water is: the body is lit as light from under the surface, and the surface is a coat over it that mirrors by the ripples (a coat may now state its reflectance, coat.z in a shader's SurfaceExt; 0 stays a varnish's 0.04). u_bodyShading says how much the ripples still shade the colour (0.25; 1 is the old look), u_reflectance what the surface mirrors seen straight on.
  • The wind's ripples are a map of many waves. The small ripples on water were six straight wave trains summed in the shader. Low across the water the short ones faded and the two longest crossed in a regular board of dark spots. They are now three layers of a tiling normal map the engine makes from 96 waves at every heading, read with mips at sizes that share no multiple (so no one size's repeat shows) and scrolled downwind, as Unreal's water reads its normal maps, with gusts across them: slow patches where the wind ruffles the water and slicks where it does not. No lattice, nothing finer than a pixel, three texture reads where there were six waves. Every number of it is a material param: u_rippleTile, u_rippleFineSize, u_rippleWideSize, the three weights, u_rippleTurn, u_rippleGusts, u_gustCalm, u_gustRuffle, u_gustSize. u_rippleStrength, u_rippleLength, the wind's direction and speed mean what they did. The map is default(ripples), a built-in a shader of your own can name; water's u_detailMap defaults to it, so a material that sets its own detail map gets its ripples from that map.
  • A shader param's range is where its slider runs. range(min,max) on a #pragma param set the slider in the material inspector and also clamped the number typed beside it, so a value the shader's author had not thought of could not be entered. The range is now the slider's reach only, as a UI range is in Unreal: the box takes any number, and the thumb rests at the end of the track.
  • One setting says what a unit is, for materials too. A shader param declares unit(length) or unit(perLength) and its default and range follow the project's Units per Metre, as a component's lengths and a post-process effect's already did; the inspector shows the project's numbers. The water was the reason: its shader, WaterBody, WaterZone and the sky's World Units per km held their defaults in metres while the engine's reference is centimetres, so stock water in a default project was a hundredth of its size and a scene in metres copied from one in centimetres drew clear water. They are now written once, at the reference, and are the same water in either. A scene that relied on the old defaults in a centimetre project (a WaterBody or WaterZone field left unset, a Water material with unset lengths, clouds with World Units per km unset) draws them a hundred times larger than before, which is what they were meant to be; state the values, or set Units per Metre to 1 if the scene is in metres.
  • A tilemap layer can be lit. A lit 2D scene's floor is usually a tilemap, and a tilemap could not be lit: TilemapLayer had no say in it and its tiles drew as they were painted, whatever the lamps did. TilemapLayer.lit lights a layer's tiles by the scene's 2D lights the way Sprite.lit lights a sprite (flat normal, the layer's tint as its colour). A layer built in code with no component stays unlit, and a light's range of sprite layers does not apply to tiles.
  • 2D lighting works out only the lights that reach a pixel. A lit sprite worked every light of the frame out for every one of its pixels, the lamps across the level included, and through the whole of the 3D lighting model. It now has a short function of its own that gives the same sums, each lit quad says which lights can reach it, and a pixel skips the lights its part of the screen is out of reach of (under an orthographic camera facing the plane; any other works them all out as before). 448 lit tiles four deep under sixteen local lamps at 1080p: 2.03 ms to 0.58 on WebGL2. A scene whose every light covers the whole screen pays a few per cent more than it did.

Fixed

  • A game no longer keeps a copy of the built-in ripple map. The map of wind ripples water reads (256 pixels square) was made when the engine started and the device kept its bytes to put back after a loss: 262,144 bytes in every game, water or none, which is what took the device-roundtrip criteria for text and for DragonBones over their 64 KiB ceiling (315,852 read). The map is content the engine can build again from code, so it is now owed after a loss and built again; what the device keeps is back to 53,708 bytes. A new criterion, device-roundtrip-ripples, loses the device twice under a shader that reads default(ripples) and compares the frame, on both backends. With it, what had been red on master since 12 November: NativeChannel is no longer tagged @public (nothing in a golden project calls it yet), encodeWav takes read-only channels, and four checks say what the engine now does.
  • A picture made in the editor ships as a recipe. The editor's image tools type an .esimage as a picture's source, and an export sent an asset of that type out as a plain file: a scene that named one got a texture nothing could load, and a map's own picture was left out of the package. A picture's source is now that one type everywhere (a file with no .meta is adopted as it too), ships as a texture, has a texture's import settings, and the cook follows what it names. In the editor a texture field takes a picture's source, the viewport draws it as a game does, the image tools write a picture's normal and surface maps as recipes beside it (wall_normal.esimage, set as data) and answer their refs, and text is set by the same drawer a game uses. Checked in the hidden editor (written, placed on sprites, drawn) and in an export of metas of that type opened twice.
  • A splatmap is read between its pixels. A Terrain asked its splatmap for the nearest pixel. Near the eye a page samples the ground finer than the paint is (a splatmap of 3 m a pixel under pages of under a metre), so every pixel of the splatmap was drawn as a flat square, and a wide fade from grass into sand was a staircase of squares that smeared into streaks at a low angle. The splatmaps are now read between their four nearest pixels, on the workers as here; a ground painted in whole pixels (a brush's own) reads as it did at the pixels themselves.
  • Grass on a hill is not thinned under your feet. Plants thin with distance, and the distance was measured from their cell, which stood at the Foliage entity's own height while the plants stood on the ground. On a meadow 16 m up, with the eye 3 m over it, the grass underfoot was thinned as grass 19 m away: a third of the blades, each grown several times as wide, bare ground between them; on a mountain every blade was at its thinnest at any distance. A cell now stands on the ground under its centre and its plants about that height, so the distance is the one to where they are.
  • A view of many materials no longer loses the WebGPU device. The WebGPU backend kept 256 bind groups and emptied the whole cache when it filled, on the assumption that a steady scene never fills it. A view that binds more (three imported towns at once: hundreds of materials, each in several passes) made every group again every frame, and on Windows the device was lost with CreateDescriptorHeap failed with E_OUTOFMEMORY after 700 frames with three towns in view and 1190 with two; one town was under the limit and ran. The cache holds 4096, is found by hash instead of a walk of every entry, and when full lets go only of the groups neither this frame nor the last bound.
  • A waterfall's foot is torn to veils, and light goes through it. A Waterfall's sheets are blended one over another, so three of them added up to a white board in the lower half of the fall. The stock shader now tears more of the foot away (u_veil 0.75, by the foot itself, u_tearBy 1): beside the fall it was made from, the foot is 10 levels of 255 over and the middle 14, where the foot was 55 over. And a sheet was lit as an opaque wall facing one way; u_translucency (1 by default) lets the light through, as the Model shader's does. u_veil 0.47, u_tearBy 0.85 and u_translucency 0 are the sheet as it was.
  • A waterfall falls in strands, not in speckle. The stock Waterfall shader's pattern was sixteen times too fine each way: sixty cells across half a sheet and fifteen to a second of the fall, so a sheet read as a solid white board peppered with dark flecks. About four strands now lie across half a sheet (u_strands 3.75) and one lasts about a second of the fall (u_run 0.97, now the count itself and no longer a share of 28), and a little more of the foot is torn away (u_veil 0.47). u_strands 60, u_run 15.4 and u_veil 0.42 are the old sheet.
  • A far plant grows across the ground, not taller. A mesh plant kept in one of Foliage's far versions was grown the same every way to cover the ground of those left out. Cover is a matter of width: a flower that stood for ten stood ten times as high as well, and a meadow seen from a hill was a field of dark poles. A kept plant now grows across the ground only and is as tall as it was. farGrowUp (0) is the share of the growth its height takes: 1 is the growth every way that it was before.
  • A detail the pages cannot hold no longer cracks the ground. A terrain's heights are kept in an atlas of 900 pages, a page a node. A detail high enough to want more nodes than that (about 4 on 1.5 m cells: 1153 from inside a fjord) had part of its ground drawn by coarser pages standing in for the ones that had no room, which do not meet their finer neighbours' edges: slivers of sky showed through steep ground, and the pages were fought over frame after frame, so the ground never finished loading. The ground is now drawn at the share of its detail's range that fits the pages there are, and a warning says so once.
  • The sea past the rings lies at the sea's level. The apron that carries an ocean from its mesh to the horizon took its inner edge's height from whatever water lay under it. With a river on high ground under that edge (a river along a cliff top, seen from across the island), a strip of sea eighty kilometres long rose to the river's height and stood on the horizon as a block with straight sides, moving as the camera did. The apron is now laid at the ocean's level.
  • A colour map and an occlusion map lie the way the heightmap does. Terrain.colorMap, Terrain.occlusionMap and Foliage.colorMap were sampled with their rows turned over: a picture painted to match the heightmap, the splatmap or a density map came out mirrored north to south under them, flowers coloured for the far side of an island and gullies shaded where the ridges were. An image over an area now has its first row along the least z whoever reads it. A map that was drawn turned over to make up for this needs turning back.
  • The ground's lengths follow the project's units. A Terrain's size, height, cell, draw distance and collision distance were plain numbers, and so were its shaders' layer tiles, relief and wet line and a layer file's default tile: a new terrain in a default project was ten metres of ground on 2 cm cells with collision built 64 cm round a body. They are lengths now (worldUnitFields, unit(length)), written at 100 units a metre: a kilometre of ground on 2 m cells, collision 64 m round a body, a layer 24 m across, in a centimetre project and a metre one. What a scene, a material or a layer file states is untouched; a scene that left collisionDistance or drawDistance to the default gets the new one, so state the old (64, 4000) to keep it. Ground with layers is also no longer sent the four layer colours of the plain shader, which warned four times a load.
  • Water mirrors only what is there. Over open sea with no ground behind it the water's reflection went black: the ray through the picture took a sky pixel for something it had met, and the sky is painted after that picture is taken. From above, the sea darkened along the edge of the terrain under it, a line across the water. And a ripple steep enough to send the ray down met the sea bed in the picture, undimmed by its water: white flecks all over a shallow sea. The copy of the scene's distances now marks where the picture holds nothing, a ray sent down goes on up as off the next wave. (A first version also widened the highlight by how far the normal turns across a pixel; that made a distant sea rough and took most of its glancing reflection of the sky away, and is not in this release: the ripple map's mips keep far water from flashing.) The ray's step and the thickness of what it meets are shares of the distance to the water, where they were a number of units (a centimetre in one project, a metre in another).
  • A mesh shader's eighth texture finds a unit. A material's textures past the seventh take an engine unit the shader never reads. A shader that named u_textures at all was counted as reading all eight batch units, though a mesh shader reads only its base texture, u_textures[0]: so anything built on Model had seven textures and no more. Ground Blend has eight, lost the last (the wet-ground map), and did not compile on WebGPU (unresolved value 'u_wetMask'); voxel ground had dropped its wet map to stay under. A literal index now counts as that one unit, so a Lit mesh shader has eight, Ground Blend draws on WebGPU, and voxel ground is wet where the weather says, as other ground is.
  • A Foliage field of any size is cut into cells no wider than its cell size. An area was cut into at most 200 cells a side. Past that each cell was left wider than cellSize, and its plants were still scattered over cellSize of it: a field over a six-kilometre terrain grew in clumps 12 m across with 19 m of bare ground between. The cap dated from when every cell was made at once; cells are grown round the eye now, so it is gone, and a field of any size is covered.
  • Water is as deep as it is, not as far as the eye's line through it. The water a pixel's light had crossed was measured along the eye's straight line to the bed. Seen low across the sea that line is ten or twenty times the depth, so shallows turned deep and blue a short way out and a lagoon was only turquoise from above. Light bends down as it enters water and is never more than 49 degrees off straight down in it: the path is now the depth over that slope, at most half as long again as the depth. The bed is also dimmed by the water its light came down through (u_bedShade, 1; 0 is the old look, lit as if dry), and how soon the water's own colour turns from shallow to deep is u_deepening (0.5 of the density, what was fixed before). A scene's shallows will read clearer from low angles and a little darker from above.
  • A 16-bit heightmap keeps its depth and size in a build. A texture is capped at its Max Size (2048 unless set) when a build cooks it, and the cap decodes a PNG to 8 bits a channel on the way. A Terrain heightmap of 4096 samples and 16 bits therefore shipped as 2048 samples of 256 steps: the exported ground was terraced and coarser than the same ground in the editor, which reads the file itself, and nothing said so. See Use, above; a PNG of 16 bits that is still marked Colour ships byte for byte and the build says so.

[0.103.0] - 2026-11-12

Added

  • Dynamic global illumination that does not leak. A new dynamicGI effect on a PostProcessVolume lights a scene with the light its surfaces throw back, live, on WebGPU: a moved lamp, an opened door or a changed sun is in the next frames, with nothing baked. It traces a distance field of the scene instead of the screen or a voxel grid, so a sealed room stays dark (the voxel GI lit its walls from the sun outside) and what is off screen still lights what is on it. A model takes part when its import setting dynamicGI is on (the import then bakes a distance field and six cards beside the mesh); the built-in cube needs nothing. It reads material emission, the sun and up to eight point and spot lights with the frame's own falloff, and with u_cellSize set the field is three levels that follow the camera, for a world larger than one window. Held to Blender Cycles on six lab rooms (0.54 to 1.3 of its indirect light, zero in the sealed room) and to a cost gate that counts the rays and reads a frame asks for. It costs 3.3 ms at 1080p on a desktop GPU and 7.3 ms on a Snapdragon 8 Elite at 2530 x 1200. Not measured on a mid-range phone; a scene of many instances has not been tried; WebGL2 does not run it.
  • A quality level decides what the dynamic GI spends. The low level leaves dynamicGI out, as it does the voxel GI, and builds no distance field for it. The medium level, which is what a phone gets when a project names none, runs it the cheaper way (dynamicGIReduced in a level's profile): one pixel in four asks the probes, a probe traces a quarter of its rays a frame, the cards are relit over eight frames and there are two thirds of the probe rows - 4.5 ms where the full way is 7.3 on a Snapdragon 8 Elite. It gives up a pixel or two of light across the edge two surfaces share and shows more grain while the camera moves. Project Settings has the switch per level (Rendering, Cheaper dynamic GI). The effect's u_halfRes and u_probeDensity set the same by hand.
  • A native app streams long audio clips. On Android, iOS and the desktop host a long clip stays compressed in memory and each voice decodes as it plays, by the same rule the web uses: a 175 second mp3 keeps 2.3 MB where it kept 64, and starts at once instead of after a 215 ms decode on the frame (measured on Windows). A decoded clip no longer falls out of the cache while a play is waiting on it, which is what left a phone silent where the editor had music.

Changed

  • The 3D Starter looks finished out of the box. Its sun casts mesh shadows (they were off, so every object floated), its camera carries a PostProcessVolume with a sky that lights the scene, height fog, GTAO, auto exposure, bloom, grade, vignette and FXAA, and its ground reaches the horizon. The editor's MCP teaches the same: audit_look says what a flat 3D scene lacks (shadow maps off, no sky light, fog, exposure or grade, gamma colour) with the fix for each, and apply_look adds it in one undo step, in a day, overcast or dusk mood.
  • AgX is its own effect group, esengine/fx-agx. It brings Blender's tables (about 80 KB of source), so it no longer rides in esengine/fx-basic: a package whose volumes name bloom, vignette or colorGrade and not agx is about 92 KB smaller (measured on a WeChat export of the 3D Starter with a bloom volume against one with an agx volume), and the export still takes the group by itself for a volume that names agx. An AgX effect added from a script needs import 'esengine/fx-agx' (or the module set to Include in Project Settings), like the other groups; the editor and any entry that is not lean carry it as before.
  • A web package carries only the SDK its game reaches. An export bundles the SDK with the host and the game's scripts in one pass, so a module nothing imports is not shipped.
  • The animator graph and grip poses ship in esengine/skeletal-animation. They are installed only where the content uses them; a project that has neither no longer carries them.

Fixed

  • A material that loaded with part of it missing no longer fails in silence. A texture that would not load, or a property of a shape nothing reads (a tiling written [12, 12] instead of { "x": 12, "y": 12 }), left the material loaded and drawing with the default look where that part was, and said so only in one log line. The loader now reports what it left out; get_diagnostics lists it as asset-degraded against every entity that uses the material, naming the property and what to write instead, and Project Health shows it as a warning. The field that holds the material in Details is marked amber with the problem as its tip, and write_project_file and create_asset answer a material that has something in it that will not take effect with problems, at the moment it is written.
  • A terrain brush stroke no longer makes the ground vanish for a moment. An edited page of the ground used to be thrown away at once and rebuilt over the next frames, so the touched area had no ground to draw until it was done; it now goes on being drawn as it was, and changes in place.
  • Voxel Ground compiles on WebGPU again. The Model shader's new wet-ground map left the voxel ground one texture past what a shader has units for, so its last texture was dropped and the whole shader was refused (unresolved value 'u_wetMask'). Voxel ground takes no wet map.
  • Several editors open at once can be told apart by an agent, and each grants on its own. An editor advertises itself in a file of its own (its process id, its project, its port, its permission) instead of the one file the last editor to start overwrote. An agent attached to more than one gets list_editors and select_editor (or --instance / ESTELLA_MCP_INSTANCE), and until it chooses it is refused with the list rather than sent to whichever window won. It then drives the editor it chose and no other. The Read only / Can edit permission belongs to the editor window it is switched in and every editor starts read-only; it is no longer a saved setting that a second editor inherited. The Connect AI Tools dialog shows which editor it is.
  • Fog, water, sky, rain, depth of field and light shafts work under an orthographic camera. Distance Fog, Height Fog (and its volumetric pass), Underwater, Sky Atmosphere with its clouds, Rain and Depth of Field measured how far a surface is from the camera starting at depth 0, which for an orthographic eye is a plane as far behind the camera as the far plane is ahead (the projection runs from -far to far so 2D content behind the camera still draws). Distance Fog read every surface as past its end and fogged a scene to full colour at any near and far, Height Fog added a camera-length of extra air, Underwater took the camera for being above the water and drew nothing, the cloud layer, placed by that height, stood kilometres off, so a floor above the clouds was still in their shadow, Rain drew its streak layers in front of surfaces a few units from the eye, and Depth of Field blurred what stood exactly at its focus distance. Light Shafts projected the sun to a place on screen, which an orthographic camera does not have (the sun is at infinity), so the shafts were gone; they now run along the sun's direction on screen, as strong as a 60 degree perspective camera would have them for the angle the view makes with the sun. The rest now start from the plane the camera stands in. Perspective cameras are unchanged. Found by the closed-form render checks in tools/oracle, which draw spheres, floors and patches whose answer is a formula.
  • AgX is Blender's AgX. The effect read a 32^3 table by trilinear interpolation where Blender's configuration names tetrahedral, so a neutral input came out tinted (middle grey 6 codes short in red, where Blender gives 118 / 118 / 118) and a saturated blue lost 12 of its red; and its contrast look (u_contrast 1.2, Blender's Medium High Contrast) took its contrast in a different log space from Blender's, 14 codes off on saturated colours. It now carries Blender's own tables, the 57^3 view transform and the 37^3 luminance compensation the looks start with, reads them tetrahedrally, and takes the look's contrast where Blender does (in the inset Rec.2020 log, through that compensation); every grey and saturated colour checked is within 1 code of Blender 5.2's output, on both backends. The tables are packed (predicted from their neighbours and deflated, unpacked once when the effect is built), and together are 81 KB of source against the 131 KB the old 32^3 table was. Checked against Blender by the render checks in tools/oracle, which keep Blender's output as data.
  • A prefab whose root was put under a Canvas opens again. Reparenting a prefab's root under a Canvas authored in Prefab Mode saved a file the editor then refused to open; it is saved with that Canvas as its root.
  • A wall under a roof is no longer sunlit along its top. A shadow lookup stepped toward the light by as much as eleven texels of the shadow map on a surface the light grazes; where a texel is a few units (the low and medium levels, a large scene) that is further than a ceiling is thick, and the top of every wall under it came out lit. The step toward the light now stops at what a slope of 1.2 asks (under four texels) and the rest of the clearance is taken along the surface's normal, at every level and on both backends. A floor under a sun 40 degrees up or more is asked exactly as before, so a shadow on it has not moved; on a steeper surface a shadow's edge sits a fraction of a texel nearer its caster. The wide filter of a soft shadow still forgives by slope, so a very soft shadow under a very thin roof can still let some through.
  • Dynamic resolution lowers the scale when a frame is late. A GPU timer that read half a millisecond counted as headroom, so a late frame kept its scale; on WebGPU the timer now covers the whole frame and not the last pass alone.
  • The device's language reaches a native game. Android, iOS and the desktop host report the system locale, and zh-Hans-CN reads as the zh-CN a browser gives; it was always en.
  • A game started over and over in one page no longer runs out of WebAssembly memory. The module host has an end, the App that made it disposes it on quit, and the KTX2 transcode workers stop with it.
  • A chunk of decoration or grass is drawn out to the distance its rule names. A chunk with little in it (one group of rocks) was culled 60 m away under a rule that said 1200.
  • Importing a feature module installs it under a bundler that treats chunks as pure. esengine/ai, tilemap, logic, worldgen, rig2d, dragonbones, gameplay and replication registered themselves as a side effect of the import, which such a bundler dropped; the game then ran without them.
  • A camera whose viewport does not start at the window's corner draws through the post-process chain. Its picture was placed as if it did.

Performance

  • A generated world is there in a second instead of thirty. Terrain pages and a foliage field's cells are made on the workers and only landed in the frame, the frame's budget is shared among everything that streams, and what stands by the player gets more of it. The first seconds of a generated world run at 5 to 12 ms a frame instead of 20.

[0.102.0] - 2026-11-11

Added

  • Multi-touch can be turned off. Input.setMultiTouch(false) handles one finger at a time: the first to go down until it lifts, with any finger pressed meanwhile ignored by the UI and the game alike, so it cannot press a button or move a joystick under the first. Turning it off with several fingers down keeps the first and cancels the rest. isMultiTouchEnabled() reads it. It is on by default; Project Settings → Game → Runtime → Multi-touch sets what a game starts with, and a call to setMultiTouch wins over it. It works the same on the web, mini-games and native apps (#117).

  • A Spine skeleton can be part of a UI. A SpineAnimation under a Canvas paints by its place in the Canvas tree, between the controls around it, and takes the UI tree's opacity, hidden state and masks. Under a screen-space Canvas it is drawn with the UI in the screen overlay instead of by the cameras, where before it showed up in the world at the Canvas' pixel coordinates and never in the UI (#116). A non-zero layer still holds it over or under the whole UI, and a skeleton outside any Canvas is unchanged. DragonBones armatures under a screen Canvas are drawn in the overlay too.

  • A grip is edited where it is held. Select an object with a GripProfile and its Details section edits the grip while a character in the scene holds it in the edit viewport, without Play: pick the character (it is given a GripHolder), create and pick the two palm anchors, see each palm drawn where it goes, switch the leading hand, and change every finger joint by joint in degrees, starting from a grip pose. Anchors are placed once and mirrored in the object's own plane for the other hand (GripProfile.hand, mirror); fingers said joint by joint (GripFinger.bend, fan, kept in mainFingers/supportFingers) are measured on the hand's own axes, so they mirror and fit any rig. The preview is the viewport's Preview FX and gives the bones back when it is turned off.

  • Fingers close onto what they hold. A GripSurface on a held object, or on anything under it, is a cylinder, capsule, sphere or box sized like a collider; with the GripProfile's new wrap (on by default) each finger closes from open toward its pose and stops where a bone meets one, the joints after it closing on, and the thumb stops on it the same way. No physics and no mesh: a distance to a shape, the same every time. In the editor, the grip section lists and creates surfaces and says which fingers touch, the viewport draws them, every finger joint of the previewing character has a handle to drag its bend (one undo step), and a timeline can be put under the grip in the edit viewport, scrubbed or played, the hold going over it as in Play.

  • A material reads its maps through Tiling, Offset and Rotation. The Model shader's u_uvTiling, u_uvOffset and u_uvRotation move where every map is read (colour, normal, occlusion, metal-roughness, emission), as Unity's Tiling and Offset do; Ground Blend takes them too. A glTF's KHR_texture_transform is imported into them, turned into the engine's V-up uv, where before it was dropped with a warning and a tiled texture set was stretched once over each mesh: a three.js port of a container port lost 224 of them. Maps of one material that disagree are all read through the first map's, and the import says so. A cut-out's shadow and depth prepass read through the same transform, so a tiled fence casts the shadow of the fence drawn.

  • The sky lights the scene. Sky Atmosphere's Light the Scene makes the sky the scene's environment: every Ambient light that names no environment of its own lights with it, its diffuse light from the dome and the clouds and its reflection on metal and wet ground, scaled by the light's colour and intensity as an imported one is. The sky is worked out again as it changes (the sun moving, a weather coming in, clouds drifting), at most once a second; with clouds that takes about 20 ms on a desktop. The sun's disc is left out, since the directional light the sky follows is its direct light. Below the horizon it is the ground, lit by the sky's sun and dome and giving back Ground Albedo of it (0.2 by default, between asphalt and grass; Unreal's atmosphere uses 0.4), so a wall in shadow takes the sunlit ground's bounce as well as the sky's: under a high clear sun that doubles its fill, under a low hazy one it adds little. Off by default, so a scene already lit by hand looks as it did.

  • The sky's lower half is the sunlit ground. When Sky Atmosphere lights the scene, the panorama below the horizon is the ground lit by the sky's own sun and by the dome above, giving back Ground Albedo of it (0.2) and fading into the horizon colour; it was the horizon's haze at a quarter, a ground that took no sun. A wall in shadow takes the sunlit ground's bounce. Lighting only: the sky drawn below the horizon is unchanged.

  • Rooms stay dark under a sky that changes (sky occlusion). With Sky occlusion on in the Lighting settings (BakedLighting.skyOcclusion), a probe bake keeps how much of the sky each probe sees instead of the sky itself: the probes hold the lights and their bounces, and the sky the frame has now (a live Sky Atmosphere, a weather, an environment) is added through what each probe sees of it, to the diffuse light and to the sky's reflection. A ball inside a roofed room measured 119 where the baked sky gave it 150, and a ball outside kept its light. A .esprobes baked this way carries skyVisibility; one without it lights as before. Probes are read per object, as Unity's light probes are: one large mesh spanning indoors and out takes one value.

  • A planar reflection softens with roughness and keeps a hot spot's hue. The reflection is filtered over nine taps, a pixel and a half at the least and wider as the surface gets rougher (it was five taps of a few texels, so a damp road mirrored as sharply as a puddle and its silhouettes stepped), and what it shows is brought under a soft ceiling of 1.5 by its brightest channel, with a knee from 0.75, so a reflected sun or a sky's glow stays orange instead of clipping toward white. planar-reflection-hot checks a (6, 0.6, 0) cube reads 255,203,0 directly and 255,108,0 in the mirror, on both backends.

  • Wet ground: a map says where it is damp and where water stands. The Model material takes a wet map over the world's X and Z (u_wetMask, with u_wetOrigin and u_wetSize) and a master u_wetness: red is standing water, green dampness; damp ground darkens (u_wetDarken) and grows smoother (u_wetRoughness), a puddle goes flat and near-mirror, and a Planar Reflection on the same mesh then shows the scene in the pools alone. Wetness 0 (the default) costs one comparison. wet-ground checks a puddle, a damp patch and dry ground under one sun on both backends.

  • Color Grade has split toning, an S-curve and lift. Shadow Tint and Highlight Tint multiply the dark and the bright tones (blended by luma between Tone Low and Tone High), S-Curve blends in a smoothstep about the picture's range and Lift adds a tinted black level, all on the picture as the display shows it (put the grade after Tonemap). Defaults are white, white, 0 and black, so no existing grade changes. A reference game's neutral-grey shed turned out to be a scene as orange as ours, graded teal in the shadows and lifted toward teal in the blacks; color-grade-split checks the three tones on both backends.

  • A captured probe volume drives reflections too. What a shiny surface inside a capturing LightProbeVolume reflects is the capture, box-projected, rather than the outdoor sky: the SDK prefilters each capture into a column of one reflection atlas beside the sky and the frame uses it wherever no baked ReflectionProbe is. A mesh now picks its reflection box by its world bounds (its centre, else the smallest box it overlaps), as probes do, so an imported level's walls whose origin sits outside the room still reflect it. A capture face now counts as done only once it is drawn. probe-capture-reflection checks a chrome ball shows the green wall on its right and the magenta one on its left, on both backends.

  • A probe volume can be filled at run time. LightProbeVolume.capture draws the scene from the box's centre all round (one small face a frame, no post-processing), reads it back and lights everything inside with it in place of a bake — the walls as the lamps light them now and the sky through the openings, which a bake cannot see on meshes without lightmap UVs. captureInterval recaptures (each pass a bounce). Unreal's real-time Sky Light / Reflection Capture; probe-capture checks a white ball between a red wall, a blue wall and a green ceiling takes each colour on the side that faces it, on both backends.

  • Lamps can fall off as real ones do. A Point or Spot light's Inverse Square falls it off as 1/distance² in metres (the project's units per metre), with intensity the light one metre away and radius only where it is let go, eased out by glTF's and three.js's window — Unreal's Use Inverse Squared Falloff. A lamp pools under itself instead of washing a room evenly; point-inverse-square checks 0.5, 0.177 and 0.045 under, 1 m and 2 m from a lamp. glTF punctual lights import this way (candela over π, range scaled with the model).

  • A sky of your own lights the scene. defineSkyEffect({ type, label, glsl, wgsl, ... }) turns one function, the sky's radiance along a direction, into an effect a PostProcessVolume carries: drawn behind the scene and, with Light the Scene on, read back from the GPU as a small panorama about once a second and made the scene's environment, diffuse light and reflections, as Sky Atmosphere's is. A stylised sky lights the world with the light it shows, as an Unreal sky material does under a real-time Sky Light; the custom-sky gate checks that a ball under a blue-above, red-below sky is blue on top and red underneath on both backends. Effect textures can tile (wrap: 'repeat').

  • Direct Lighting Only and Indirect Lighting Only view modes. Beside Clay in the viewport's Show menu (and Renderer.setViewShading(view, 'directLighting' | 'indirectLighting')), as Unreal's lighting components: clay lit by the lights alone, or by everything that is not a light (ambient, sky, reflections, probes, bakes). The two add up to Clay, so a dark shadow says at once whether its fill is missing or merely weak.

  • A post-process pass can read an earlier pass of its own effect. A texture param named u_pass_<name> is bound to the output of the sub-pass called <name>, which the chain keeps alive until it has been read, so an effect can be a pyramid (down, then up, adding each level back) and not only a line of passes.

  • A probe volume lights each pixel, not each object. A lit mesh inside a LightProbeVolume reads the baked grid where each of its pixels stands, so one large mesh that spans a dark room and the open yard outside it (a merged building, an imported level) is dark inside and lit outside, as in Unity's Adaptive Probe Volumes; before, it took the one value at its origin and was lit the same end to end. The grids ride one half-float atlas the frame builds when a bake changes. A mesh with lightmap UVs that has no bake still reads its volume per object, as before.

  • Instances in the open scene take a changed prefab at once. A prefab saved, applied, re-baked or rewritten on disk re-derives every instance of it in the open scene, keeping overrides and entity ids.

  • A 2D rig's bones keep an id, take a new parent and rebind onto another skeleton. A bone carries an id, so removing or reordering a bone no longer moves what a scene added to it onto another; setRigBoneParent hangs a bone off another where it stands, rebindRigToSkeleton binds a rig to another rig's bones by name, and the editor rewrites a clip's paths to follow.

  • Defaults follow the project's units. Every default that is a length, a speed or an acceleration — a character's capsule, a first-person walk and jump, a view model's near plane, a nav volume's cells, a perceiver's range, a particle's size and speed — is written at 100 units a metre and scaled by the project's units per metre (Project Settings → Physics → 3D). A centimetre project gets exactly the defaults it had; a metre project (an imported glTF scene) now gets metres instead of values 100 times too big. A value a scene states is never scaled. A component declares its own with worldUnitFields. Post-process effects follow too: a length a volume leaves unset (rain and snow shelter range and puddle size, SSR distance and thickness, GTAO / SSAO / SSGI radius, contact-shadow length, depth-of-field focus, voxel GI cell, height-fog start and range) takes its default in the project's units, and fog density and height falloff — rates per length — by the inverse; the inspector offers ranges in those units and writes an added effect's defaults in them. A metre project's rain used to shelter within 3 km.

  • Particle.emitAt(emitter, count, position, { normal, velocity }) spawns a burst where something happened, now — an impact's sparks, a muzzle's flash — from the emitter's own settings, its shape turned onto the normal, without moving the emitter or replaying it (Unity's ParticleSystem.Emit). CPU-simulated emitters.

  • A first-person player has its own jump feel. FirstPersonController.gravityScale (the player's gravity as a share of the world's), coyoteTime (a jump just after walking off an edge still takes off) and jumpBuffer (a jump pressed just before landing takes off as it lands).

  • A UI node can stand over a point in the 3D world. UIWorldAnchor puts its UINode at the screen position of an entity (plus an offset) or a world point every frame: an objective marker, a name over a head, a health bar. clampToEdges keeps an off-screen or behind-the-camera marker on the screen's edge in its true direction; onScreen, behind and distance read back. It is placed from the camera's pose at the end of Update, so a marker does not trail a first-person view that turned this frame.

  • Perceivers hear. Perceiver.hearingRange and a Noise event (where, how loud, who made it): a perceiver hears a noise within hearingRange * loudness, through walls, as Unreal's hearing sense does, and Perception keeps heard, where the last noise came from and sinceHeard.

  • A ray can meet characters. Physics3D.raycast(origin, direction, layers, { characters: true }) stops on a CharacterController3D's capsule where it is now, on Jolt and on PhysX alike; a plain ray still passes them, which line of sight and a camera's boom rely on. Before, nothing could shoot a character that walks.

  • A 3D collider with no RigidBody3D is a static body, as in Unity. An imported level now collides with a MeshCollider3D on each mesh and nothing else; before, a collider without a body built nothing and a character fell through the floor. A collider under an entity with a RigidBody3D is still left to that body, and the collider wireframe marks the same shapes the world builds. Removing an entity's RigidBody3D while its collider stays now leaves a static body rather than none.

  • The 3D physics world is set in Project Settings, not in code. Physics → 3D Physics sets what a scene unit is to the solver (Units per metre: 100, a centimetre, as before; 1 for a metre scene such as imported glTF), gravity in m/s², collision steps, velocity and position iterations, the bounce threshold, sleep and the body budget. Iterations and the bounce threshold left at 0 keep each solver's own (Jolt's, or Unity's for PhysX). The 3D world also takes the project's fixed step and collision-layer matrix, which only 2D did. A metre scene used to get gravity 100 times too strong, since everything was read as centimetres. Settings left at their defaults write nothing, so an existing project and its builds are unchanged. In project.esproject they are features.physics.world3d.

Changed

  • Bloom glows round and soft, and costs less. It is built on a pyramid (a half-size prefilter that tames single blazing pixels, five steps down to 1/64 and five back up, each adding its own size back), as Unreal's and Call of Duty's are, in place of five full-size Kawase passes that threw a diamond-shaped band: a dark edge against a bright sky no longer carries a hard glowing rim. Threshold, Intensity and Radius mean what they did; Radius now widens the whole glow. Scenes with strong bloom will look softer and wider. Measured at 1080p on WebGPU: 0.26 ms against the old 0.45 ms.

Fixed

  • A bake falls light off as the frame does. The lightmap and probe bake (TypeScript and the C++ kernel alike) took every point and spot light as (1 - d/r)²; the frame lights them linearly by default, with Inner Radius and Falloff, so a baked room disagreed with its own lamps. Both now use the frame's falloff, inverse-square included. Bakes made before read as out of date.
  • A mesh is lit by the probe volume it draws in, not the one its origin is in. An imported level's meshes keep the origin the file gave them, often the world's centre, so a shed's walls were in no volume and took the open sky's light indoors. The volume is now chosen by the mesh's world box (its centre, else the smallest volume it overlaps), and per pixel each pixel reads the grid where it stands.
  • Rain does not fall through a glass roof. The rain's map of what stands overhead took only what casts a shadow, so a see-through roof set to cast none — glass, as it usually is — left the floor under it wet. A see-through surface keeps rain off whether or not light passes it; what is opaque and casts no shadow (a held gun) still stays out. Gate: ssr-shelter-glass.
  • The prefab bar and the Details header fit a narrow panel. The prefab bar is two rows, icons only below 300px, and the header's facts and Add Component no longer overlap.
  • A character controller or a 3D collider added with its defaults is a real size. Their defaults were metres (a 0.3 radius, a 0.5 box) under a world that reads centimetres unless told otherwise: a 3 mm character, a 5 mm crate. They are a 1.6 m person and a 1 m box now, in whatever units the project uses. Every example and template stated its sizes, so none changes.
  • A model's import no longer calls it tiny in a metre project. The note read every model as if a world unit were a design pixel; it now measures the model in metres by the project's units per metre and suggests that as the Scale.
  • Navigation bakes an imported level. The bake took only bodies with a static RigidBody3D, so a level of mesh colliders (static by themselves) baked to no ground; and it placed every collider at its LOCAL pose and unscaled, so one under a parent landed elsewhere. It now takes what the solver builds, where the solver builds it.
  • Perception senses from where things are in the world. It read each entity's own position, so a perceiver on a head bone or a target on a player's eye camera sensed from near the origin; sight measured feet to feet was also cut by every kerb.
  • A first-person view model no longer hides the world in a linear or tone-mapped project. A camera that keeps the colour under it (clears depth only, as the held-gun camera of FirstPersonViewModel does) still draws through a capture of its own when the frame is linear or has an output transform; that capture started black and was copied over the camera beneath, so the world went black around the gun. It is now laid over by coverage. Gate: overlay-camera-linear.
  • Post-process volumes skip a camera that draws over another one. Such a camera was given the scene's global stack too, which ran fog, sky and the look over the whole finished picture again with its own cleared depth — the world under a held gun went to fog. Local volumes now also weigh a camera by where it is in the world, not by its position under its parent.
  • The editor's MCP server starts its editor again after the editor goes away. When a call found the editor unreachable before the editor's exit was seen, every later call in the session failed at once with "the editor host is not running" and no editor was started.
  • A scene whose only 3D physics is a compound collider or a ragdoll gets a physics world. The scene loader did not count CompoundCollider3D or Ragdoll as 3D physics, so a scene with nothing else ran with neither moving.
  • Geometry with no lightmap UV set still stands in a bake's light. It was left out of the bake altogether, so it cast no shadow on the baked surfaces and the probes saw straight through it. It now shadows them and hides the sky from the probes, while receiving no baked light itself (the import still says to generate lightmap UVs for that).
  • An opaque surface no longer lets the sky through where its map's alpha is below 1. An unblended draw wrote its base colour's alpha into the frame, and Sky Atmosphere reads a pixel's alpha as how much of it geometry covers, so wherever a texture used its alpha for something else (glTF's OPAQUE ignores it) the clouds showed through the wall. An opaque Model surface now writes 1, except a cut-out's coverage and the subsurface mark.
  • The sky no longer shows through everything when water or glass and a blended surface are both in view. The frame keeps the opaque scene aside and puts it back around the blended draws; it was put back through the copy made for refraction, which marks its alpha 0.5, so every pixel came back half covered and the sky showed through half of the picture.
  • Ground under a roof stays dry in the reflections too. Screen Space Reflections' Wetness and Puddles read the rain's map of what stands over each place, as the rain itself does, so a floor indoors or under an awning is no longer a wet mirror. The map is drawn only for an effect that states a reach (Rain, Snow Cover); reflections borrow it, with its reach and bias, and cost no second picture of the scene on their own.
  • A colour written among a post-process volume's uniforms is read as a colour. It was blended as a number into NaN and the effect drew garbage (a Height Fog turned the whole scene teal); it is now used as the colour it is, with a warning that it belongs in colors, and any other value that is not a number is left out.
  • A prefab reverted just after the editor noticed its scene file change is no longer lost. The editor's reload of a clean scene from disk reads the file and expands it before it replaces the model, and an edit made in that window (a revert, an instance dropped in) was thrown away with the old model. The reload now gives way to an edit made while the file is read; a reload the user confirmed after edits is unchanged.

[0.101.1] - 2026-11-10

Fixed

  • An Android package built for the emulator carries its Spine runtimes on x86_64 too. v0.101.0 put each Spine runtime's library into the first architecture only, so on an x86_64 emulator or device a Spine skeleton did not load. Phones (arm64) were not affected.

[0.101.0] - 2026-11-10

Added

  • Holding an object in both hands. A GripProfile on an object says where each palm sits on it, by anchor entities, and how its fingers are held; a GripHolder on a character takes hold of it, bends the supporting arm (and with the object placed by the game, the leading one) to the anchors and blends the fingers over the clip by slerp(clip, grip, weight). It runs in one fixed order that cannot loop, eases every joint when what is held changes, puts the palm on the anchor for any arm length within reach, and gives the same bones for the same inputs. captureFingerPose keeps a hand's fingers as JSON.
  • A tiled terrain exports and imports its heightmap, over every tile or only the loaded ones. The terrain sculpt panel exports the heights as one image the size of the whole area, and imports one (16-bit grey, or the red and green the export writes) over the tiles, as do the Terrain: Export Heightmap and Terrain: Import Selected Heightmap commands. Loaded tiles reads no tile that is not in memory: an export takes the rest from the overview, and an import writes only the tiles in memory and the overview; All tiles reads and writes every one. An import is refused while the terrain has changes not saved.
  • Tiled terrain can be sculpted and painted, and a save writes only what changed. A brush on tiled ground runs on the samples copied out of the tiles under it and writes them back to every tile that holds them, so a seam stays one height and the result is the same as on one heightfield, sample for sample. Only tiles in memory are edited: a dab over one not read yet is skipped and the tile is read. A changed tile is kept in memory past the budget until it is saved, the overview follows each stroke so distant ground shows it, and undo covers the tiles and the overview. Save Ground writes the changed tiles and the overview only: six dabs on a 4097 by 4097 terrain wrote 2 of its 64 tiles.
  • A terrain can be kept as tiles that are read where they are looked at. A Terrain's tiles names a .esterrain: the ground cut into tiles of 513 samples a side and a low-detail overview. Distant ground is drawn from the overview, which is always in memory; full-detail tiles are read near where the view or a moving body is, and the least recently used are let go past 256 MiB. Measured in the editor on a 4096-unit area: an 8193 by 8193 field held as one image is 256 MiB, as tiles it opened holding 36 MiB and 45 MiB close to the ground. Split into Tiles in the terrain sculpt panel converts a terrain. The tile images are referenced only by the .esterrain, so they are no longer preloaded and uploaded as textures the way a heightmap is. The editor now also waits for ground still being built before it counts itself idle.
  • A streamed world opens in the editor without its cells. Only its WorldPersistent entities are in the view when a scene with StreamedWorld opens, and the textures and meshes of the rest are not loaded. The World panel loads and unloads cells one at a time or all at once, the viewport marks the loaded ones, and the next session opens with the same cells loaded. The document still holds every entity: an unloaded cell is saved as it is, and Play and export see the whole world. The get_world_cells and set_world_cells_loaded tools do the same for an agent.
  • Hands that hold things. A GripPose holds a rig's hands in a named pose: pistol, handle, cup, fist and others, or one a game registers. A pose says how far each finger bends and nothing about bones, so it fits any rig with fingers; a change of pose eases over, a trigger moves the index finger alone, and it goes over what a clip does with the fingers by its weight.
  • Clouds that keep time with the game. Where a Sky Atmosphere's clouds are is now what the wind has done so far, so a wind that changes carries them on instead of moving the whole sky; a Weather's wind reaches them, their shapes change as they go, and a paused game has a still sky. They can have a second layer with its own height, grain and wind, and skyClockState() keeps their place in a save. Self-shadowing reaches through a deep cloud, edges wear into billows, and the lit edge near the sun is narrower.
  • Ground that is a volume. The optional esengine/voxel module adds VoxelTerrain, beside the height-field Terrain: it holds caves and overhangs, and can be carved, filled and painted with a sphere, a box or a capsule while the game runs. Only the chunks an edit reached are made again, with their collision, and a save holds only what was changed, chunk by chunk. A sleeping body is now woken when the collision under it changes, on a Terrain as well, where before it stayed in the air.
  • What stands on the ground can blend into it. The builtin:ground-blend material fades a rock or a foundation into whatever is behind it, on both backends, with nothing baked, and can bring a second layer up from the ground or paint one with vertex colours. RoadDecal lays a mesh along a Spline over a terrain with soft edges. The snowCover post effect and a Snow weather lay snow on whatever faces the sky, terrain and meshes alike.
  • GPU particles can hit things, tell each other, and drag trails. collisionMode: Depth collides with what the camera sees, Sdf with ParticleCollider spheres, boxes and capsules that need no physics (and run on the CPU too). A GPU emitter's births, deaths and collisions go to a buffer: a gpuSimulation child spawns from it in its own kernel, with no trip to the CPU, and collisionEvents read back to the game a frame or two late. trailEnabled now works on the GPU.
  • Plants can be touched, felled and harvested. A FoliageContact on a character parts Foliage grass around it, on both backends. A kind in PlacedFoliage or WorldRules.plants with an interaction leans away with any material, becomes an entity with a physics capsule while something is near, and can be damaged, felled and harvested through PlantInteractionRes, with stumps, regrowth and saveState / loadState; what became of a plant outlasts its chunk.
  • A side-on character comes ready to run and jump. PlatformerController2D beside a CharacterController2D reads the keyboard or a game's input, and has coyote time, a jump buffer, jump cut, air jumps and a drop through one-way platforms. CharacterController2D gains stepHeight, followPlatform (it rides what it stands on, sideways too), dynamicBodies (block, push or ignore them), constantSlopeSpeed and dropThrough, and reports floorEntity and floorVelocity. The 2D platformer template and example use it.
  • A 2D character can be rigged in the editor, with no other program. Right-click an image to create an .esrig, then cut it into parts, drag out bones, cover the parts with a mesh, bind by distance and paint weights with add, remove and smooth brushes, and push vertices into named deforms, all on one canvas that can try poses without changing the rig. Saving writes an .esmesh and an .esprefab beside it, so a built game carries no authoring data. Bones are ordinary entities, so clips, the Animator's blends, layers and masks all reach them, and a deform is a MeshMorph weight clips can key.
  • 2D bones can reach for things and follow each other. IK2D on the last bone of a limb bends it to a target after the animation has played, exactly for two bones and iteratively for more, with a weight clips can key. BoneConstraint2D limits a joint's rotation, which a chain through it keeps to, or copies another entity's rotation or position, or looks at it. Both follow a character mirrored by a negative scale. esengine/rig2d also makes all of this from code.
  • A tile layer can be dug, blown up and rebuilt while the game runs. createDestructibleTilemap in esengine/tilemap gives a layer tiles with hardness that wear down over several blows, circular explosions with falloff that walls can shelter from, and placing and filling, with one list of what changed for drops and effects. The neighbouring autotiles re-resolve, createNavGrid or syncNavGrid keeps a navigation grid in step one cell at a time, and toJSON and load save only the cells that differ from the map it started as, refusing a damaged save whole. On a streamed world, publishChunk lays a player's changes over what the generator made, so a chunk let go and made again comes back as it was left.
  • Solid tile ground can have colliders only where it is exposed. TilemapRuntime.setCollisionOutline generates plain boxes for tiles with an open side, so solid ground costs no bodies and a tunnel below a surface leaves the surface's colliders alone. A destructible layer turns it on; collisionOutline: false keeps merged ground.
  • A native app plays every Spine version. Android, iOS and desktop apps now read skeletons exported from Spine 2.1, 3.8, 4.1, 4.2 and 4.3, each with the runtime of its own version, as a browser build does, so a project can mix them. The official runtime templates carry all five. An Android package includes only the runtimes its skeletons need, at 0.2 to 1 MB each per ABI; iOS and desktop link all of them, about 1 MB more. Packaging with a template from an older release, which carries one version, lists every skeleton it cannot play. Before this, a project whose skeletons were not 4.2 needed an engine source checkout to build its own template.
  • Which Spine runtimes a package carries can be set per runtime. Project Settings → Spine has a row per runtime with Auto, Include and Exclude, and each row says what the build will do. Auto carries a runtime when a packaged skeleton was exported from it. Include is for skeletons only code loads, such as a path built at run time or content fetched later. Exclude leaves a runtime out, and an export whose skeletons need it fails and names them. The same decision applies to web, playable, mini-game and Android packages, and each export result lists every runtime with why it was carried or left out. The old single Spine version setting, which never changed a package, is gone.
  • An agent can open any Settings page. The editor's open_settings tool opens the Settings window on a section, or on the section holding a given row, so a screenshot can show it.

Changed

  • run_editor_command refuses an id that does not exist. It used to answer "ok" for any id. A disabled command now answers { ran: false, reason: "disabled" }.

  • A 2D character stands still on a walkable slope, and a steeper one is a wall. It used to drift down any slope and could walk up one past floorMaxAngle. stopOnSlope and blockSteepSlopes turn each back off.

  • Editing a tile no longer replaces the colliders around it. A tile edit used to destroy and remake every collider in its chunk, which ended a body's contact with the floor it stood on and woke what was asleep there. Now only the colliders whose shape changed are replaced.

  • A row of tiles being edited uploads a piece of itself. One changed tile re-uploaded its whole row of chunks, over a megabyte when the row is full. A row that changes is now held in pieces of four chunks, so an edit uploads about an eighth of that, for up to seven more draws in that row until it has rested. A static map is drawn as before.

Fixed

  • Physics no longer stops on Android and the desktop host. The native host had no way to ask whether an entity was still alive, so PhysicsStepSystem threw n.valid is not a function every frame and nothing moved (#114). The Registry's entity operations are now generated from one table for the web and native hosts, and a native host that lacks one fails at startup and names it.

  • The profiler no longer calls a long render stall vsync. Time in the render submit that nothing measured was all filed as "present · vsync", with a hint that it was idle: an 820 ms frame spent growing text outlines read as waiting, and its banner blamed two domains of 0.1 ms. A wait now counts up to 50 ms, the slowest a display presents; the rest shows as "untimed work", marked as a hotspot. Text drawing has its own render.text row, and when timed work explains under half an over-budget frame the banner says so instead of naming a domain. A long task under a pinned frame is put down to the scope that timed it rather than to "GC / uninstrumented JS". ScopeCost gains parent: a scope measured inside another is listed under it.

  • While editing, foliage and generated worlds follow the viewport. A WorldStreamingSource in the scene used to hold foliage, generated worlds and voxels around itself in the edit view while terrain detail followed the viewport, and a 2D view counted as no viewpoint at all. Sculpting and painting a terrain also no longer copies the whole ground at each stroke: it keeps 32 by 32 tiles as they are first touched, so a diagonal stroke's undo holds what it reached and not the square around it.

  • Zooming in on outlined text no longer freezes the editor. Growing a bitmap glyph into its outline cost the fourth power of its size on screen, and a label did it again for every glyph at each step of the zoom: past 1500% a single frame took more than 15 seconds, and showing a hidden label at full zoom hung the editor. The outline now costs what the glyph's size does and looks the same, a frame stays under about 70 ms through the whole zoom, and Auto text at 128 screen pixels or more draws from a distance field wide enough to hold its outline. Bitmap is still honored where it is set, at the new cost.

  • Labels no longer come back as black boxes after a change between Plays. Stopping left each label's geometry in the engine, by entity number. Adding, removing or dragging anything before pressing Play again moved those numbers, so the old labels drew on other entities from an atlas already released.

  • Particles and plain sprites in a Canvas paint by their place in its tree. An emitter listed after a panel went under it, and one listed before a plain Sprite went over it. Both now follow the hierarchy like the controls round them, and the layer they were authored with is no longer overwritten. A Sprite with no UINode under a Canvas may change place as a result; a non-zero layer keeps the old order.

  • A trigger no longer stops a 2D character. The mover took a sensor for a wall and for a floor.

  • A 2D character honours one-way platforms. It was stopped from below by the mover as if they were solid.

  • A 2D character under a parent moves in the world. Its local position was handed to the mover as a world position.

  • A skinned mesh is not culled for where its entity stands. A skinned mesh is placed by its joints, and was culled by its entity's box in the bind pose, so a body an animation carried away from its root vanished when that box left the view, in 2D and 3D alike. It is now culled around its joints.

  • A texture stays on a scene that rescans as it is placed. Two project rescans in a row started two loads of one texture, and the second to finish could release the one the scene was drawing with. The entity then drew white and stayed white, since the load counted as started and nothing asked again. An asset now loads one at a time and loads again afterwards when it was asked for meanwhile.

  • A tile's custom properties in an .estileset reach the game. getTileProperty answered nothing on a layer painted from an .estileset; only Tiled maps carried them. Replacing a tileset blanks the properties of the old one.

[0.100.0] - 2026-11-08

Added

  • Static geometry can be baked into material-preserving proxies. The pipeline can merge and simplify a static cluster by material and draw state, bounded by a world-space error limit. Moving, deformed and transparent surfaces are refused, and important painted or emissive geometry can be preserved.

  • The cyber-rooftop example has an editable, anchored HUD. Status icons, keycaps and inventory artwork share their layout with the runtime, while text and borders remain editable independently of the bitmap atlas.

  • An imported scene keeps its materials, animation, particles and colliders. A glTF scene brings the materials, animation, particle emitters and physics shapes it describes rather than geometry alone, and a Godot project can export a scene in that form with the bridge script in pipeline/bridges/godot. The two components only an imported scene writes, NodeVisibility and ParticleModelUnits, live in esengine/imported-scene, which an export adds only when the shipped content uses them.

  • A 3D body can be several shapes, and a scaled model collides at its scale. CompoundCollider3D makes one body out of child shapes, on Jolt and PhysX alike, and a mesh collider follows its model's scale.

  • A generated building stands on its ground, and generated roads keep foliage off them. World generation fits an upright building's base to a grid of ground samples over its whole rotated footprint, and refuses a site that is water, too steep, or rises and falls more than a given relief, reporting how deep the foundation has to reach. Foliage takes the zones a WorldGen world reserves for roads and buildings (and any extra tags) as places it does not grow, with an optional clearance. The world rules editor and the editor's agents can set both.

  • An exported game's scripts are minified, and a WeChat main package is about 0.9MB smaller. The game and engine JavaScript of a web, mini-game or playable export is now minified unless the project turns off packaging.minifyScripts (Project Settings → Packaging → Minify scripts); a development build keeps readable scripts as before. The ui-controls example's WeChat main package went from 4.18MB, over the 4MB cap, to 3.27MB.

  • On a phone, a lit 3D scene costs about half as much. The quality level gains lighting. At low and medium, which a phone takes when the project names no level, every lit mesh and material is compiled as #pragma lighting direct asks: the same lighting model with the sixteen lights of the light block and hard shadows, without the lights past them, soft shadows or hair shadows. On a Snapdragon 8 Elite a full-screen lit floor drawn fifteen times over went from 57 to 24 ms a frame under the default soft-shadowed sun, and from 33 to 25 ms under a hard-shadowed one. high, and a project with quality off, keep everything. Project Settings → Rendering → Quality → 3D lighting changes it per level. Sprites keep their 2D lighting at every level.

Changed

  • Animation tracks reuse named-child lookups. Repeated tracks in 2D and 3D hierarchies avoid searching the same children each frame, while renaming, reparenting and deleting children still update the result.
  • Shadow storage and planar reflections avoid unused work. The shadow atlas allocates storage for occupied tiles, and a planar reflection can reuse the depth prepass.

Fixed

  • Returning from Prefab Mode keeps the current scene intact. A delayed file-watcher read or discard prompt for an earlier document no longer reloads the scene now being edited, invalidates freshly reverted prefab instances, or overwrites a newer save's baseline.

  • Simplifying a mesh preserves painted features. Vertex colours participate in simplification so a small painted feature is not treated like an otherwise identical, unpainted surface.

  • A streamed world finishes retiring before it is replaced. Teardown drains pending cell work and releases its scene resources before another world takes over, for both 2D and 3D content.

  • Batched and instanced meshes keep their visibility and shadows. Batches preserve each part's shadow participation, and placement bounds include rotation, scale, shear, usable LODs and declared vertex displacement when culling and fitting shadow maps.

  • Rendering follows the game's clock. Shader time and rendering follow scaled game time, including pause and manual stepping, instead of advancing independently of the simulation.

  • A paused scene can prepare its presentation without advancing gameplay. Camera, text and UI layout preparation can finish while simulation systems remain paused, including compiled systems.

  • WebGPU keeps incompatible binding layouts separate. The bind-group cache uses the full layout, preventing resources from being reused with a shader layout they do not match.

  • Planar reflections keep the scene's tiled lights. Reflective surfaces retain the lights assigned to their view instead of losing them when the reflection pass changes view state.

  • Imported skin weights include every glTF attribute set. Influences on the same joint are combined, the strongest four are retained and normalized, and invalid or empty weights are reported.

  • An imported specular-glossiness material, and a normal map's strength, come through. A glTF material authored in the specular-glossiness workflow is drawn with the same lighting as a metallic-roughness one instead of losing its look, and a normal map keeps the strength its material gives it, zero and negative included.

  • Generated plants and placements let go of what they held. A foliage cell's meshes and materials are released once the last cell using them retires, and world generation releases a scene's zones when the scene goes and keeps an authored placement the same object across regenerations, with shared 2D placements no longer losing each other's change subscriptions.

  • The profiler's frame time is the frame's own. Work counters and manually stepped frames are kept out of frame timing, and Play's frame rate leaves out windows that were stepped or reset.

  • A render target reads the right way up on WebGPU, Android and iOS. A camera drawing into a RenderTexture, or anything painted into one, came out upside down wherever the engine draws with WebGPU (the web on WebGPU, Android, iOS): such a device keeps a target's rows top first, where a texture expects them bottom first, and nothing put them back. A target now hands out a copy with its rows in the order every backend samples, made at the end of each frame drawn into it. The 2D fog of war and the 2D rain's shelter, which had turned their masks back by hand in their WebGPU shaders, read them as they are. Pixel checks on both backends now hold the orientation of a target and of the fog.

  • Building terrain no longer stalls a frame. A page of ground made from the built-in noise was sampled and painted whole in the frame that asked for it; it is now made a slice at a time within the frame's budget, and starts over when the ground or its paint changes meanwhile.

  • A moved or scattered model part keeps its texture mapping. An explicit UV mapping on a face is now resolved before the face's vertices move, so transforming or scattering a modeled part no longer slides its texture across it.

  • An iOS game opens on iOS 27. Built with Xcode 27, every game closed 0.3 s after launch on an iOS 27 device: the host opened its window the way UIKit no longer allows, without a window scene. The host now adopts the scene lifecycle (one window scene; the game pauses and resumes with it). Its log also reaches the device console as text, where it read <private>. The simulator in CI runs an older iOS and could not see it; it was found on an iPhone.

  • A Spine atlas of any size loads. The atlas text went to the Spine module through its 64 KB stack, so an atlas past about 60 KB wrote over the module's memory: a crash or a corrupted skeleton, whatever the skeleton's format. Its length was also counted in UTF-16 units rather than bytes, so an atlas with non-ASCII page or region names was cut short. The atlas now goes through the heap as UTF-8 with its byte length, as the skeleton data and DragonBones' atlas already did; a 150 KB atlas named in Chinese loads on Spine 3.8 and 4.2.

  • A material parameter named like an engine uniform is refused on every platform. A #pragma param u_ambient in a Lit shader compiled on WebGPU and failed only on WebGL, a WeChat mini-game among them, with redefinition of an interface block member name. The names a parameter may not take are no longer a hand-kept list of three: they are read from what the engine actually declares for the shader's domain, so every member of the light block is refused at load, a name only the light block uses stays free in an Unlit shader, and the error says which block owns it.

  • World text under a perspective camera no longer eats the memory. A Text left on renderMode: Auto in world space, seen through a perspective camera, was rasterized as if the camera were orthographic: a 32 px label asked for glyphs tens of thousands of pixels high. On a phone the native heap swung between 2.4 and 4.2 GB and the game drew about one frame in two seconds. Auto now draws world text under a perspective camera as SDF, since no single bitmap size lands 1:1 at every depth; the same eight floating labels hold the heap at about 45 MB and 60 fps. A bitmap glyph is also never rasterized larger than half an atlas page (512 px), which also covers an orthographic camera zoomed far in and a forced Bitmap; past that it is drawn from 512 px and the log says so once.

  • Sound comes back when a device's audio dies on its own. On the Android and iOS hosts, a game whose audio device did not start again on returning from the background, or whose output stream was dropped while it was away, stayed silent until it was restarted. The host now checks every frame that the device is still taking sound while the game wants it; after half a second of nothing it restarts the device, and from the third try rebuilds it, retrying at growing intervals of up to 5 seconds. Sounds that were playing carry on where they were, and the log says each time it acts.

  • A render target works on a native device. On the Android and iOS hosts RenderTexture.create handed back 0 for its handle and its texture, so a camera's renderTarget and anything painted into a texture drew nothing, and nothing was logged. The SDK asked only the web's engine module for a target; it now asks whichever engine core is running, and a device names the target's texture for a Sprite as the web does. A target that cannot be made is now reported once in the log.

  • A point light's shadow is whole or absent. When the shadow atlas could not fit all six cube faces of a point light, it was given the faces that fit and drew light through the rest; it now gets all six or none, and the editor's Light Status says why. A new denial is also logged once as a warning.

  • An asset swapped onto a runtime entity is released when the entity goes. A texture or material that a hot update put on an entity spawned at runtime, outside any scene, stayed loaded until the app shut down; it now ends with the entity's despawn.

  • The editor stops reporting texture work that has finished. When a texture's background compression finished while the viewport was still asking about it, the editor could count it as unfinished work for good, so a capture or an agent waiting for the editor to be idle waited until it timed out.

  • A #pragma lighting direct surface takes a sun's shadow. Under a directional light with a size (any sourceAngle above 0, the default 0.53 included) such a shader drew no shadow at all; it now draws the hard shadow the directive promises.

[0.99.1] - 2026-11-07

Fixed

  • A WeChat mini-game no longer takes WeChat down with it on iOS. On an iPhone on iOS 27 with WeChat 8.0.80, any package closed WeChat at its first frame, whatever the game drew. The mini-game engine is now built without the compiler's automatic vectorization; the SIMD the math is written in stays.
  • Animated characters move in a WeChat mini-game. A package whose characters play clips through an Animator, with no TimelinePlayer in its scenes, left out the loader for those clips: every character stood in its bind pose and the log said No loader registered for type: timeline.
  • The engine-subpackage loading notice shows a real percentage, and comes down when it should. With the engine in a subpackage, a host that reported a progress of -20608 had it shown as it came; a progress report after the subpackage loaded put the notice back over the game; and a game that failed to start left the notice up for good with nothing in the log. The notice now shows a percentage only when it is one, stops at load, and is taken down with the reason logged when the start fails.

[0.99.0] - 2026-11-07

Added

  • An Ambient light can be two colours, sky and ground. A hemisphere of light without baking a panorama: the ground colour fills what faces down, and a scene with none set looks as it did.

  • A material can hold more than seven textures, and Water gains a foam texture. Past seven, a material takes the texture units below 8 its shader never reads. Water's u_foamMap reads as coverage: thin foam keeps only the texture's densest marks and thick foam fills it.

  • Every row of Project Settings can be read and written by id over MCP. A partial write keeps what it did not name.

  • Glyphs can be put on the atlas before they are shown. The first page of a novel is hundreds of new characters, all landing in one frame. preloadGlyphs(app, label, text, { budgetMs }) makes them ahead of time, a slice a frame, drawn as that Text will draw them, and returns progress, done and release(). On a Snapdragon 8 Elite a book's 2992 characters at 28 px took 145 ms over 25 frames with the worst frame at 9.5 ms, after which the first page's frame went from 49 to 11 ms and no page made a new glyph. Preloaded glyphs hold their atlas pages (4 MB each, a few hundred characters at that size) until release().

  • Voxel GI lights what the camera does not see, and bounces light more than once. The cache now reads the sun's shadow map back into the world, so a surface the sun lights behind or beside the camera still sends light into the view. Each surface also gives off again the bounce light it received, so a corner or a floor in shade gets light that took two or more bounces to reach it. A ray now brings what it meets at full strength however far it went (it used to fade with distance, 40% at 4 m with 12 cm voxels). Each voxel is weighed by how much of it a surface covers, so a bright patch no longer lights like the whole voxel around it. Together these keep the result close to a path tracer's whatever the voxel size. In a sunlit test room the whole frame carries 0.95 of Cycles' light at the default size and 0.74 at 12 cm voxels; before, it was 0.54 at the default and darker the finer the grid. With the lit patch behind the camera, the walls went from no bounce light to 25–57%. A closed room the sun only lights from outside stays dark. Two inspector controls tune it: Off-screen Sun Albedo (the colour the shadow map cannot give, assumed) and Multi-bounce. A fine grid no longer drops every voxel: a count truncated by the cache's ageing had kept them below the two samples a ray asks for. The WebGL2 fallback does the same in its own passes: each voxel asks the sun's map whether a sunlit surface stands in it, and traces two rays through last frame's grid for the light it is given. In the test room it carries 1.00 of Cycles' light at the default size (it was 0.56) and 0.80 at 12 cm; with the lit patch behind the camera 0.20 (it was 0). Its voxel pass costs about 1.3 ms more at 720p on a desktop.

  • An AI can draw 2D pictures. image_write turns layers into a .png beside an .esimage: shapes and SVG paths, gradients, strokes, shadows and glows, clipping and cutting, or pixel art as rows of characters. It answers with the picture on a mid ground and a light check and at 96, 64, 48 and 32 pixels, to look at and correct; image_edit changes one layer, a row or a block of pixels without restating the rest, and moves layers or wraps them in a group. Strokes can keep sharp corners, and the reply measures where each layer ended up. A layer or group can be blurred, for depth of field, and a fill can be noise for cloud, texture and film grain, the same picture from the same seed. A paint layer is a canvas of brush strokes with pressure, softness, tapering, bristles and smudging, added to round by round, for what shapes cannot do; one sweep instruction lays a mass of hair gathered into locks, one field covers a region in strokes along a flow, with named brushes from ink and pencil to oil and watercolor, and one along repeats strokes along a line. A layer can work across everything under it, to fuse separate parts into one painting, and image_read shows lightness alone and reads colours. Text in any script, windows in rows on a face, buildings in true perspective, reflections on wet ground and bloom over what is bright are one instruction each, and words and strokes can be laid on a building's face in its own coordinates. An image editor's finish is there to turn by hand: adjustment layers from levels and curves to gradient maps, twenty filters from lens blur to fog and light rays, the full set of blend modes, feathered masks and bevels. An edit draws only the layers from the change up. A figure layer is a posed skeleton in plain blocks from any angle to draw over, and an image layer brings in the team's own art: both stay out of the .png, and the figure reports where each joint landed and lets broad light follow the form. image_read enlarges a part, and image_set shows several together with the stroke widths and size of each. Drawn on the CPU, so a source makes the same picture on any machine.

  • An AI can give a body standard bones, pose it, and model a limb by its sections. rig: { humanoid: true } gives a model bones that fit, and pose holds a body in a pose by angles, or with reach by where a hand should be. What a body wears takes its weights from the skin under it, so an arm stays in its sleeve. organic gains limb, cross-sections along a path, and fine, regions split finer on one skin. displace gains folds, running the way cloth hangs. scene_views no longer takes on a shot's lens blur and grade.

  • An AI can read shapes and colours off a picture as numbers. reference_trace grows a part of a reference from places inside it and answers its outline as points, ready for an outline, or its strongest edges as lines, ready for a sculpt press. reference_probe answers the colour at the same places in the reference and the game. reference_compare with overlay: "parts" draws only the outline of the entities named on the reference. Each shows what it found on the picture, and judges nothing.

  • An AI can take a frame apart to see why it looks wrong. reference_compare draws a region close through the camera, from the same place and at full size, where it used to cut one out of a smaller picture and hide what a surface was doing. camera_layers shows one frame as the shape under a plain light, the shape under the scene's lights, the paint, the triangles and the scene before its effects. light_sheet shows it with each light alone. Each puts everything back.

  • A fixed shadow map stays on what casts, and ambient occlusion leaves hair alone. A sun's shadowExtent was centred on every mesh, so a far backdrop with castShadows: false took the map away from the character in front of it and her shadows disappeared; it is centred on what casts now, and the docs, which said the camera, say so. gtao took a strand in front of a surface for a wall and turned what was behind it black: a horizon now falls back when what lies beyond is lower, and a pixel-wide strand no longer has a normal guessed from depth. On a test head the black went from 1.17% of lit pixels to 0.07%, and shade round a solid block stays.

  • An AI can read a shape off a picture and model it. reference_view takes a ruler, a numbered grid of where the picture falls in the world through a camera, so a nose or a fold can be read off as coordinates. An organic part can be an outline, a closed drawing stood up as a smooth dome with no flat on it, so a traced profile is the silhouette. sculpt works a surface stroke by stroke: press along a line for a fold or a seam, inflate, move, smooth, and with from a stroke or a stain line is given in the two axes of a view and lands on what that view sees.

  • reference_compare with a region shows the same part of both pictures. Through a camera it drew the game at the shape of the part, so the cut took another place from another picture. field_sweep did the same.

  • An AI can model a character's hair by where it goes, and draw on a surface. hair takes guides, lines the cards follow over the head rather than through it, with gather closing them into a ponytail. stain draws along a line: an eyelid, a lip, a seam. scatter puts hundreds of copies of a shape across a surface, along a path or through a box. material.emissive makes a model give off light, past 1 for what glows and blooms. apply_scene_ops now says which field a component does not have, where it used to drop it without a word.

  • An AI can put the game beside the pictures it is imitating. The look tool group takes pictures or a video's frames, and reference_compare sets a frame of the game beside one with the reference's outline drawn over it and the exact colours of both. field_sweep shows a field at several values on one sheet, so what a number does is seen before it is chosen. motion_sheet lays the running game out over time, under a video's frames. scene_views shows the scene as the engine draws it from every side, in clay, paint and wireframe.

  • An AI building a model can dress it in clothes that swing. rig.drape turns a skirt or a cape into a ring of chains that swing as the game runs, blended so it moves as one sheet, rig.colliders keeps it out of the legs, and a pleats pattern presses folds into it.

  • An AI building a model can make hair. A hair step grows cards from a scalp, falling around the head, and writes the strand textures and a Hair material. hairSway gives them bones that swing as the game runs, and a character's attach carries the hair at its head joint, through saving and export.

  • An AI building a model can make things see-through. material.alpha is cutout for leaves and lace or blend for glass and gauze, and a stain can set alpha by a pattern or a shape, which a bake keeps on a thin mesh.

  • An AI building a model can shade its creases. normalBake with occlusion: true works out how much sky each place on the dense surface sees and writes that as an occlusion map, so cracks, folds and the contact between parts read as depth under ambient light.

  • An AI building a model can say what it is made of. material sets roughness and metal for a whole model, paint and stain for parts of it, and normalBake with surface: true keeps the differences as a map: wet moss on dry stone, bare steel where paint wore off.

  • An AI building a model can colour it finely, and keep that on a thin mesh. A stain step lays a colour over a surface by a pattern, in what is sunken or on what stands out, by which way it faces or around a spot: moss on top, dirt in the cracks, a pupil. normalBake with color: true writes that as a base colour map, in linear and gamma projects alike.

  • An AI building a model can carve fine detail into it. A displace step pushes bumps, wrinkles, cracks, scales, pores, ribs, weave or scratches out of a surface along its normal. A pattern needs no UV and has no seams, can be limited to some faces or to around a point, stacks with others, and splits the surface as far as it needs. Followed by decimate and normalBake, half a million triangles of detail draw on 1,500.

  • An AI building a model can make it light and keep its detail. A decimate step thins a model to a share or a number of triangles, keeping paint and tags on the side they were on, and rigs and shapes are found on what it leaves. With from it thins the form as it stood before the fine detail, so edges and features keep their triangles. normalBake writes the surface as it stood before that as a normal map on the thinned one, rigged or not: a 77,000-triangle rock at 800 triangles lights close to the original, and the map bakes in about a second.

  • A mesh can have 256 joints, up from 64. A rig with fingers, a face and hair no longer imports as a statue. A draw sends only the joints it has, so a small rig costs what it did.

  • A mesh can blend 64 morph targets at once, up from 8. A face rig holds dozens open at a time. A draw pays only for the targets that are live.

  • A foot stands on the ground under it. A foot-plant constraint on an Animator looks down from each foot through physics and bends the leg to land on whatever is there, slopes and steps included, keeping any lift the clip gives it, laying the foot along the slope and lowering the hips so the leg can reach.

  • AI agents can build 3D models in the editor from steps. The modeling tool group writes a .esmodel, the steps that build a model (boxes, cylinders and floor plans, then extrude, inset, bevel, slice, array, mirror, paint), and bakes the .esmesh a scene draws beside it. Changing one number rebuilds it and whatever draws it follows, Undo takes both files back, and model_views shows every side with its silhouette, so an agent can check a shape without a scene. Blockouts, buildings and hard-surface props; and with the organic step, creatures, plants and rocks, as one skin over parts that melt into each other, carve, mirror and roughen. lathe and loft make curved solids from a few points: vases, pipes, handles, hulls. A rig of joints gets its weights found over the surface and animations of a few keys play as ordinary clips, so a creature can walk, with feet told where to land and a controller choosing which clip plays when. rig.adjust corrects a weight, shapes make expressions a clip can move, and controller.ik reaches and looks at goals as the game runs. subdivide and a rounded bevel smooth what polygons leave hard. A boolean step cuts real holes through solids, and a uv step or uvAtlas lays out how a texture lands.

  • A model of many parts that moves: CompositeBatch. Put it on the root of a ship, a vehicle or a moving platform assembled from many meshes, and while the game runs its parts are drawn in a few draws parented to the root: a mesh repeated four times or more (a deck plank, a rail post) as one instanced set that copies no vertices, every other part merged by draw state into chunks of the root's own space. Moving, turning or scaling the root moves the whole model and merges nothing again. Adding, removing, re-meshing or re-placing a part re-merges only its chunk within half a second (CompositeBatchingRes.refresh(root) looks at once), and a part that keeps moving inside the model is let go to draw itself. The root reports what it drew, and so does get_stats. On a model of 2,004 parts, the meshes handed to the renderer went from 2,003 to 5 and the CPU frame from 3.3 ms to 1.2–1.4 ms; a model of about a hundred parts costs the same either way. A part under a composite is never also statically batched.

Changed

  • A lightmap or a baked normal map gets nearly twice as many texels on its model. Charts are laid out by their outlines and at the largest size that fits, so they fill about half of their atlas where they filled about a third. A model's lightmap UVs change the next time it is imported, so bake its scene again.

  • Phones and tablets take Medium when a project names no level. Full-screen water on a Snapdragon 8 Elite is 8.6 ms a frame there against 25.8 as authored, mostly by leaving four samples behind. Naming a level still wins, Off included, and the setting gains Default for naming none. Mini games keep their own defaults. Such a project on a handheld also draws without multisampling, with Medium's particle limit of 5000, three shadow cascades and streamed textures: name a level to keep what it had.

  • The temporal smoothing of a quality level leaves orthographic cameras alone. Medium and any level set to temporal put it on every camera, which softened a 2D game's sprites and text and gave it a full-screen chain. A taa an author lists on an orthographic camera still runs.

  • The blank template starts in the linear pipeline. A lit mesh in gamma clips and washes out, and blank is where a project with no other plan starts. Only the template changes: a project that says nothing stays gamma.

Fixed

  • Color Grade contrast no longer blacks out a dark scene in a linear project. It turned on 0.5, which is well above mid-grey in linear light, so raising it took everything dark to pure black: at 1.4, a night scene. It now turns on mid-grey, as a curve that keeps what is dark. Linear projects that set a contrast above 1 will look a little brighter in their shadows.

  • A WeChat mini-game opens in WeChat DevTools. A package stopped there at "BigInt64Array is not defined" while a phone ran it, as the engine and its side modules needed a global DevTools' game realm does not have. They no longer do.

  • A prefab made over MCP is in list_assets at once. A full scan of the assets and a file change's update ran side by side, and the one finishing last rebuilt the list from an index without the new prefab, which came back only with the next file event. They run one after another now.

  • An agent is told when a child it adds inside a prefab instance will not last. A scene stores an instance as its root and its changes, so such a child lost its parent on saving, and an exported game dropped it, with no word. apply_scene_ops now warns, and says what to do instead.

  • A material's normal and metal-rough maps are read as data in the editor's Play. A map named beside its .esmaterial missed its import settings there, as Play spells it by URL, so it was decoded as colour: mid-range roughness read far too smooth, and normal maps bent. Filter and wrap settings were lost the same way.

  • A rotation given to an agent as a quaternion is that rotation. set_field and apply_scene_ops read { w, x, y, z } as degrees and dropped w, so a character meant to turn 90 degrees turned under one, with no error. A joint posed this way looked as if the skin did not follow it.

  • An agent's get_stats waits out a long frame. It gave a running game two seconds to answer, so on a machine that takes that long to draw a frame it said the game had stopped.

  • A saved scene reaches a device preview on Linux. The project watch followed each file's inode, so a file replaced by rename stopped reporting. It watches each folder there now, which also ends the crash when a watched folder was deleted during a scan.

  • A linear game looks the same on every Play. From the second Play on, a scene with no post-process effects showed raw linear values, about a third as bright, with nothing in the log. Stopping a game shut down the pipeline that encodes the frame, and nothing brought it back unless the camera had an effect.

  • Water costs a phone half of what it did. A full-screen sea on a Snapdragon 8 Elite went from 45 ms to 21.5 at full quality, with the same picture. Every lit material on a phone gains part of it: the light loop read all sixteen slots for every pixel, and now stops at the lights there are. A surface can also declare #pragma lighting direct to compile out what it never reaches. Water does, so water takes the first sixteen lights only.

  • A quality level can skip every effect there is. The list was cut at thirty-two and there are forty effects now, so the last ones in name order kept running while the row showed them off.

  • A new material no longer shows the inside of a sphere. An opaque mesh tests and writes depth whatever its material says, and a new surface material tests depth.

  • A scene view no longer goes black for good after a heightmap loads. A texture made or rewritten from JS left the device's unit bound differently from what the renderer believed.

  • A blended pane in front of water is drawn over it. With no post-process chain the water follows the camera, sorted nearest and covered what stood in front of it.

  • A restarted scene draws its images again instead of white. A reload released a handle the scene still named.

  • A saved layout of empty groups no longer leaves an editor with no viewport. And a plugin writing its cache is no longer reloaded on Windows.

  • A setting the manifest would refuse is not written. One bad field can no longer leave a project that does not open.

  • A mesh's colour draws as picked. A script-built mesh's colour stays as typed, the graph and terrain pickers show the true colour, and a lit mesh in a gamma project offers to switch to linear.

  • One box of a vector row edits a material or a clip, and Rotation boxes behave. Typing one box of a Rotation row turns that axis, where it stored NaN in all four components, and a Rotation scrub survives the pole.

  • Undo after a save takes back the edit over MCP. A save was an undo step, so Undo put the scene file back instead.

  • A lightmap bake's bounces start at 8 and go to 16 in the panel. As the SDK default now does.

  • A sea seen from above is no longer scored with straight lines. Its waves were straight sines a few directions apart, whose crests add up to long parallel strokes that turn with the wind. Each wave is now read at a place bent by a slow sine, in the shader and in the CPU's formula alike, so what floats still sits on what is drawn, and the ripples spread over 74 degrees either side of the wind rather than 41. It adds nothing measurable to a frame on a phone. The detail map in the Terrain & Water example was mostly one wave and drew its own fine lines over all that: it has waves in every direction now, from tools/render-lab/water_detail.py. A project that copied the old map should take the new one.

  • Quality high no longer costs a phone 40 ms a frame. The render target pool keeps at most 256 MB of targets nobody has borrowed, and it counted what the frame had just given back as nobody's. A frame's own targets past that size were destroyed and allocated again every frame: a 4096 shadow atlas and a 4x MSAA scene target at 2670x1200 come to 320 MB. On a Snapdragon 8 Elite high went from 50 to 10.5 ms with GI off, level with no quality setting at all. Any platform with targets that large paid the same.

  • A linear project on a native build is no longer far too dark. A native host read only half of the packaged config. The colour space, output transform, MSAA, quality, y-sort and depth layers and camera fit never reached it, with no error. A linear game ran as gamma and showed its linear values with no encode: a grey of 0.2 read 51 instead of 124, on Android, Windows and every other native build. Web and native now apply these through one function, and the colour space is read before the first shader compiles. A native build matches the web to about one level in the test room. Linear costs a phone 2.7 ms a frame at 2670x1200 with nothing else on. A project that declares a quality level now gets it on a device.

  • Voxel GI no longer changes with the size of the picture. It took the same one pixel in four for its cache every frame, so a face a few rows tall (the top of a block seen nearly edge on) landed in it at one row or two according to the window's size, and the light around it moved: a wall read 18% apart across sizes, up to 11% for a window one pixel taller. The pixel now changes each frame. Across eight of nine sizes the same wall is within 7%, one size with an odd width and height still reads higher, and the light against Cycles and the frame-to-frame stability are unchanged.

  • Voxel GI costs a third of what it did. Every cell a ray crossed took two integer divisions, a hash, and a read in the 32 MB grid, which is a cache miss, for a cell that is nearly always empty. Wrapping is now a mask, the hash check is gone (the cache re-tags every slot each frame, so it could not fail), and the tags hold a mark saying whether a slot has anything, read before the grid is. On an RTX 3060 at 720p the default settings went from 17.3 to about 5.4 ms a frame, and the picture is the same: held against the old kernels, the difference is no larger than between two runs of one build.

  • Writing an entity list on the web replaces it. A SpringBone.colliders or MeshSkin.joints written to a component that already had one was added to what was there, so a [a, b] written twice read [a, b, a, b], a Mut row grew it on every write-back (72 entries in a few frames) and writing [] cleared nothing. Number lists and native builds were right.

  • A spring bone's colliders work in a native build. Entity lists were left out of the native bindings unless written by hand, and only MeshSkin and Children were. SpringBone.colliders from a scene never reached the engine on a device, with no error: hair and tails passed through what they should have been kept out of, and a script reading the field got undefined. Every entity list now crosses as a generated pair, as other lists do.

  • Mut() on the web no longer turns a component's colours to NaN (#107). Since 0.98.0 a Mut row is written back when the loop moves on and once more when the system returns, and the first write rewrote the row's colour into the engine's shape, so the second sent NaN. A loop over Mut(UIVisual) that wrote nothing made the element vanish. Components read through the wasm heap, and every native build, were not affected. Writing back no longer touches the row. The same write also handed a list field to the engine as a JS array, so Mut on a component with one threw every frame; it now takes the one marshalled write world.set and insert use.

  • A new character costs a phone about a third of what it did. A glyph was drawn and distance-transformed at 4x its stored size, 16 times the pixels, and on a phone most of the time went there. It is now 2x, on the web and on every native host alike: at 12x magnification 2x and 4x look the same on the densest CJK glyph, where 1x loses its counters. The distance transform also leaves out the sites that cannot change a byte of its result, tested byte for byte against the plain transform. On a Snapdragon 8 Elite a new CJK glyph with its distance field went from 5.3 to 1.8 ms, and a Latin one from 3.4 to 0.74 ms. Text can differ from before by a few levels at its edges, up to 6 of 255 in the field.

  • A native Android build shows CJK text from the system font. Android 16's system CJK font (NotoSansCJK-Regular.ttc) has CFF2 outlines, which stb_truetype cannot read, and only Apple had the platform fallback for that, so on such a phone every CJK character from the system font drew nothing. Android now draws such a face with android.graphics: the same file and face its font matcher chose, with synthetic bold and italic where the face lacks them, handed back as coverage so the distance field and the atlas tile stay the shared code's. A project that bundles its own font is not affected.

  • A new glyph on a native build no longer stalls the frame reading a whole system font (#106). Every native host (Android, iOS, macOS, Windows, Linux) read the matched font file whole on every call, which is every glyph rasterized, and the rasterizer then dropped those bytes for a face it had already parsed. A system CJK font is tens of MB: on a Snapdragon 8 Elite phone that read was 9.7 ms a glyph (63 ms for the first). A platform now only answers which file and which face (Platform::matchFont), and the shared rasterizer maps each face's file the first time it sees it, so the OS pages in only the tables and glyphs it touches. The read is gone: looking a face up costs 0.02 ms on the phone. On Windows a new CJK glyph, rasterized and turned into a distance field, costs 0.9 ms.

  • Android frames no longer drop to 30 fps when they come close to the frame budget (#105). The Android host drew each frame from a Choreographer callback and asked for the next one after the frame, whose present had already blocked until the display took it: two clocks, and a frame that ran past one vsync waited for a second. A 15 ms frame on a 60 fps cap ran at 30 fps on a Snapdragon 8 Elite, every interval 33 ms; a shooter in the issue saw 33/50/66 ms. The host now runs its own loop, as the desktop one does: the present paces it, input is served while it waits, and a frame is drawn when one is due even while a fast touch panel keeps the queue full. The same 15 ms frame holds 60 fps (p99 18.5 ms), and a 20 ms one runs at 46 fps instead of halving. A backgrounded app still draws nothing and uses no CPU. The cap App.setTargetFrameRate sets is now held by one pacer every native host shares (the web loop's rule: a cadence, restarted after a stall), so the desktop and iOS hosts, which ignored it, keep it too.

  • A native build reports its GPU frame time. The desktop and Android hosts never asked the GPU for timestamps, so the engine's GPU frame timer and the profiler's GPU track read -1 on every device. They ask for them now where the GPU has them.

  • Voxel GI costs less on mobile GPUs. The gather, which only reads the cache, reads it as a plain array, and the per-frame ageing reads and writes each slot plainly (each invocation owns one) and leaves empty slots alone; both had gone through atomics. On a Snapdragon 8 Elite phone at 2670x1200 a frame with one ray per point went from 134 to 83 ms, and with a 4-voxel range from 32 to 17 ms. Voxel GI is still too heavy for a phone at its defaults (about 0.8 s a frame).

  • Baked lighting shows on built-in meshes. A builtin: cube, sphere or plane baked with bake-scene or the editor drew as if nothing had been baked: the bake unwrapped a lightmap UV set for its own use, but the mesh the game loaded had none, so the atlas was never read. The built-in meshes now carry that UV set, the bake lays out its charts by it, and existing bakes stay valid.

  • Bounce light takes the colour of what it lands on. Voxel GI and Screen Space GI guessed a surface's colour from the lit picture, so a wall the sun did not reach got its bounce as a dim grey: a red wall in a sunlit room received 15% of the red light a path tracer gives it. The scene pass now writes each surface's diffuse colour beside its normal, and both effects reflect the bounce by it. In the same room the red wall gets 50–75% and keeps its hue, and the ceiling went from 14% to 57–90%. A custom shader that writes the surface record keeps working and has its colour guessed as before until it also writes fragAlbedo (location 2).

  • Baked lighting reflects light 8 times by default, not 2. Two bounces left a room of light walls at about half the light a path tracer gives it, and a face only bounced light reaches at a tenth. Eight is within about 10% of Cycles in a measured room and cost a 252k-lumel bake 0.7 s more. The inspector now goes to 16. A scene that states its own bounces keeps them.

[0.98.0] - 2026-11-05

Added

  • PhysX as a second 3D solver. Project Settings → Physics → 3D solver (features.physics.backend3d) picks Jolt, the default, or PhysX 5, set up with Unity's defaults (PGS, patch friction, average combine, 0.01 m contact offset, 2 m/s bounce threshold, 6/1 iterations), so a scene ported from Unity behaves the way it did there. Components, joints, characters, queries and events are the same on both. A web build carries only the solver chosen; the Windows, Linux and Android hosts link both and run the one the project chose, and on Android PhysX is a library of its own that only a PhysX project packs. macOS and iOS hosts run Jolt for a PhysX project and say so once. The PhysX module is 3.6 MB (1.15 MB gzip) against Jolt's 1.3 MB.
  • A web game can run in a browser without WebAssembly. Project Settings → Web → Run without WebAssembly (packaging.platforms.web.engineJs, off by default) packs the engine a second time as JavaScript (about 4 MB), which the page loads only where WebAssembly is missing or with ?engine=js. It runs without WebGPU and with compiled systems interpreted; on a small project it cost about 2 ms more per frame. With the setting off, a browser without WebAssembly gets an error that names it.
  • The Windows and Android hosts run the game's scripts on V8. A game's scripts ran on an interpreter on these hosts, about nine times slower than in a browser; V8 now compiles them with its JIT, with Intl and TextEncoder, and nothing in the project changes. Measured on 5000 scripted entities: 76 to 8 ms a frame on the desktop, 64 to 14 ms on a phone. iOS keeps the interpreter (no JIT is allowed there), as do macOS and Linux for now.
  • An Android package runs its @compiled systems as machine code. The systems the AOT compiler takes are built into the package and installed at boot on the phone, as on the desktop host (14.3 to 4.1 ms per frame on a phone). The Package dialog says when an Android export needs the NDK for them.
  • Mesh textures stream to the size their views need. With texture streaming on, each texture a mesh draws is held at the size its views need, measured per draw from the mesh's UV density, behind the same handle, and a quality level keeps the total within a budget. A web build ships a small copy of each such texture first and fetches the file only once a view needs more. Measured on the examples, the first view needs none of 93% of dusk-fort's texture memory and 46% of bistro's.
  • Impostors. An Impostor stands a picture of its mesh in once the mesh is small on screen, taken from many directions by the engine's own cameras, and draws as one batched card per view.
  • Billboards. Billboard turns a mesh to each view that draws it, flat in the view plane or upright about world up, without writing its Transform.
  • A draw call budget per quality level. The device counts every draw a frame asks of the GPU, every pass included, and the profiler's Render module shows it split by pass against the quality level's budget (a Quality setting).
  • A first-person controller. FirstPersonController looks, walks, jumps and crouches in a CharacterController3D, and FirstPersonViewModel draws a held thing with a second camera so it does not go through walls.
  • Ragdolls. Ragdoll turns a skinned character's bones into jointed bodies and blends back to the animation. The joints are limited by their part of the body, read from bone names (a stiff spine, a loose shoulder, knees and elbows that fold one way), RagdollJoint gives a bone limits of its own or no body at all, and the viewport draws the limbs and limits of a selected ragdoll before it falls.
  • Move along a spline, and a 2D ground along one. PathFollower moves an entity along a Spline at a steady speed (once, loop or ping-pong). TerrainBand2D draws a 2D ground along a spline, with a surface lip that can repeat an image and an optional chain collider. A spline on its own gets drag, insert and delete handles in the viewport.
  • Terrain brushes. The terrain brush raises, lowers, smooths and flattens an area's ground and paints its layers, and only the pages a stroke reached are made again.
  • MouseButton.Left, Middle and Right. The binding function also names the three buttons, so MouseButton.Left reads where 0 did.
  • SceneManager.getLoading and whenLoadsSettle. What is loading now, and a promise for when it has all landed.
  • App.setRunInBackground. Keeps the game loop going while the page is hidden.
  • CameraView.pointerToWorld and pointerRay. They take the pointer as Input reports it, and the camera views are published on the native core as well.
  • uvRectFromPixels. The one conversion from a pixel rectangle of a texture to the y-up UV rectangle a Sprite takes.
  • pointerEvents: Receive under a None ancestor. A node set to Receive takes the pointer back inside a subtree whose ancestor lets it pass through.
  • An asset path written into a component while the game runs is loaded. A path written into Sprite.texture, MeshRenderer.mesh or any declared asset field of an engine component read back as the path while the engine held nothing, and nothing drew; it is now loaded as a scene file's paths are (atlas frames included) and held for as long as the entity, on every core. A package now carries the assets its scripts name, the size report says which, and a file they name that is missing is reported by name.
  • sceneOutOfBandFields. Names what a component's scene codec saves beside its fields (a MeshRenderer's inline geometry), which no inspector or edit reaches.

Changed

  • The new-project gallery is in Chinese in a Chinese editor. The starters and examples show Chinese names, descriptions and tags; a title that is a name (Bistro, Dusk Fort) keeps its own, and an example's suggested folder name stays its folder's.
  • The settings window shows what a project is set up with. Each group folds its own tuning rows at its foot, as Unreal's settings do, instead of one Advanced fold at the foot of the page. The engine modules, the splash screen, achievements and the physics fixed step and sub-steps are no longer folded, so Build opens to its decisions rather than two rows over a fold of 23; solver contact constants, the theme's colours, load timeouts and cache budgets stay folded.
  • An agent call over MCP is one undo step, files included. Everything one call changes — its scene edits and the project files it writes — goes back with one Undo and forward with one Redo, shown in History as AI · tool. A call that only wrote files does not mark the scene unsaved, and the undo / redo tools answer once the files are back on disk. Every tool also carries MCP annotations from what it does (read-only, undoable, destructive), so a client asks before only the calls that leave the project or run unlisted code; a long call sends a progress note every five seconds; arguments are checked inside arrays and objects, with the place named; and each call is noted in a local log (~/.estella/mcp-calls.jsonl, never the arguments, ESTELLA_MCP_CALL_LOG=0 to turn off) that desktop/scripts/mcp-call-stats.mjs summarises by the tools that fail most. write_project_file no longer reports a failure for a script it wrote outside the project's script folders.
  • The MCP connection survives an editor that fails to start, and tells the agent how to work. A call made while the editor cannot start says why, in the editor's own output, and the next call tries again; the connection used to drop with it. Every session gets short server instructions at connect (tool groups, the open scene versus the running game, step instead of waiting, one call per undo step). Saves, exports, project creation and play-mode tools are no longer undo steps, so Undo does not roll a saved file back. A cancelled call does not start, and a composite one stops at its next step. enable_tools takes plugins, for clients that do not refresh their tool list.
  • History shows where an agent run began, and an agent's undo reaches further back. A rule marks each run's start (AI run · client · time), so taking the whole run back is one click on the row above it. Copies of the files agent calls write are kept by space (512 MB) instead of the last 32 calls, and a step whose copies had to go is marked files kept before anyone presses Undo. Screenshots an agent takes are sent at 1568 px on the long side by default — what Claude's vision input looks at — which halves their size with nothing seen lost.
  • Plugin agent tools reach MCP clients. A tool a plugin lends with ctx.agentTools.register is now listed to every connected MCP client beside the editor's own, and a call runs in the editor. Its schema is checked first, and a tool whose effect is not read is offered only while the editor lets agents change the project. The LDtk plugin's estella_ldtk_import is the first.
  • More of the editor answers over MCP. edit_controller and set_gear_binding author UI controllers and gears; capture_viewport can read the running game's own frame back, and device_screenshot a native build's; frame stats carry what texture streaming holds. The everyday tools are listed from the start and the rest in groups enable_tools turns on, every tool still callable by name; the editor starts on the first tool call; step waits for scene loads in flight and names them; click_ui confirms its target with the game's hit test and play_input presses on the first frame it is given. An edit made through a tool is recorded as automation's, and a change on disk reloads the scene without asking when those are the only unsaved steps.
  • orthoSize stays the zoom under a design-resolution fit. With a Canvas in the scene or the project's fit on, the main camera's orthoSize was replaced by half the design height, so changing or tweening it did nothing. The fit now adapts the camera's own size to the screen: orthoSize is the half-height at the design aspect, as in Unity, and the world UI box is the design resolution fitted to the camera, so a zoom never reflows UI. At orthoSize = half the design height everything is where it was; a project that authored another value under a fit now shows that value.
  • The editor looks and handles like Unreal. The transform gizmo takes Unreal's proportions: shafts that brighten toward the tip, all three plane handles near the centre, a dotted disc for uniform scale, and handles 1.2 times the old size by default. Empties, lights and cameras get no selection box; a selected camera in a 3D view draws its whole frustum. The chrome is flatter and denser, with one slate selection colour, solid viewport overlays, segmented controls and a lighter status bar. Graph wires follow Unreal's curve, a backward wire looping out to the right instead of under the nodes. Alt + right drag dollies the eye.
  • The content browser has one toolbar. Path, search and filter share one row; New and Import moved to the empty-space menu; a slider at the bottom switches between list and grid; a narrow dock shows the folder tree as a drawer; and in a dock group 800 px or wider the toolbar rides in the tab strip.
  • Tilemap mode has a way out. A mode pinned from the activity bar held through every click in the viewport. The tile toolbar now starts with Leave Tilemap Mode, and Escape with nothing selected releases a pinned mode.
  • An Android APK is less than half the size. Its native libraries are deflated (unpacked once at install), so an empty project is 20 MB instead of 54. Project Settings → Android → Compress native libraries turns it off, to store them for the system to map in place.
  • A native game runs at the frame rate it asks for. The target frame rate reaches the host, which paces its display-driven loop to it, and Android is asked for 60 fps and clocks frames by the vsync timestamp.
  • Every shader's WGSL twin is derived as it is read. A project shader keeps only GLSL; the cook and a packaged editor derive the WebGPU version where the host ships the converters.
  • Far LOD levels reach their budget. A far level may collapse across borders and seams and shed specks, where it used to stop short of its triangle target.

Removed

  • The editor no longer has an agent of its own. The Agent drawer, its panel, the status-bar and activity-bar entries, the palette's "Hand to Agent" row, the provider settings (keys, models, custom endpoints), the agent marks in the Outliner and viewport, and the History panel's folded agent runs are gone, with the agent_send, agent_status, agent_confirm, agent_transcript and done_when tools. Agents connect over MCP (Window → Connect AI Tools…), where the same tools have always been served. History now lists every step on its own line.

Performance

  • Systems and plugins with nothing to do cost nothing. A single system can sit out the frames it has nothing to do in, seven built-in subsystems do so for scenes that give them nothing, and Plugin.activeWhen names the components a plugin needs, so a plugin no entity uses costs nothing per frame.

Fixed

  • A transparent edge shows no dark fringe. Atlas pages fill their clear texels from the colour beside them, and solid art is no longer taken for premultiplied.
  • A bitmap glyph's outline is the glyph grown, not eight stamped copies of it, and a label's shadow and outline fade with its own colour alpha.
  • A UI press lands on the frame a control appears. Every Interactable carries its UIInteraction from its first frame, and an exported game has one hit test.
  • Nine-slice borders reach the native core, and a short box keeps its corners round.
  • A material's sprites no longer merge across textures.
  • A cooked MP3 starts with its first frame, not the encoder's flush bytes.
  • Long music plays in an exported web game and in Play. Their content security policy allows blob: media, which a streamed clip plays from.
  • Commands inside a query. cmds.spawn(...).id() inside a query reserves the id instead of throwing, a Mut row kept past the loop stays live until the system returns, and world.set reads a vector written before the component grew an axis.
  • A reserved #pragma param says how to read the uniform it shadows.
  • The shipped .d.ts files keep real names between their chunks.
  • A packaged editor type-checks scripts with TypeScript's standard library, so the script check no longer reports "Cannot find name 'Math'".
  • Play keeps running in a hidden or background editor window, and a new Play reads textures as they are on disk.
  • A live texture edit keeps drawing once the texture's cooked form lands, and the editor shows a texture's shipped image, not only its KTX2.
  • Fitting a sprite to its texture never overwrites a size written after the texture.
  • A project manifest is never seen half-written. Text writes publish whole files.
  • An export that does not name an option takes what the Package dialog saved.
  • A viewport dropdown closes on its own button and on a press of the scene.
  • A camera move in the viewport always repaints.

[0.97.0] - 2026-10-31

Added

  • Pack several textures onto one canvas at run time: TextureAtlas.pack. It draws the textures you give it onto one new canvas (the smallest power-of-two size that holds them, up to maxSize, with padding between pictures) and returns where each landed: atlas.sprite(source) gives the texture, uvOffset and uvScale a Sprite takes, atlas.get(source) the pixel rectangle. Sprites cut from one canvas batch into one draw. Pictures are copied without blending so their transparency is kept, and the canvas is drawn again from the sources after a graphics device is lost. Its pixels are checked on WebGL2 only, as RenderTexture's are. The Render Texture example builds four cards and packs them.
  • Rich text reads the tags other engines write. <size=24>…</size>, a colour by name (<color=red>), and <br/> now work beside <color=#RRGGBB>, <font size=…>, <b> and <i>. <u>, <s>, <outline …> and <on click=…> are accepted so text written for another engine shows no raw tags: the words are kept, the underline, outline and click are not drawn. Unknown tags still show as text.
  • Scroll areas can be pulled past an end and spring back. A scroll area whose movement is Elastic now does what the setting always said: a drag past an end is stiffer the further out it goes, letting go returns the content, and a flick that reaches an end bounces off it. It is opt-in per area (ScrollMovement.Elastic; Clamped, the default, behaves as before), and the gesture model (ScrollMotion, with ScrollContainer.dragTo and getOverscroll) is exported for scrolling anything else the same way.
  • More easing curves. Sine, quart, quint, expo and circ (each in, out and in-out), bounce in and in-out, and smoothstep and smootherstep join the quad, cubic, back, elastic and out-bounce curves. They are new EasingType members after the existing ones, so a saved tween keeps its curve, and they ease the same in a C++ tween and a script value tween.
  • World content has a rectangle: ContentRect. A size and the pivot the entity's transform sits on, which the Sprite and Text on the entity follow and which a UIMask on it clips to — no UINode needed, so a clipping region or a scroll viewport can stand in the world. contentRectContains tests a world point against it.
  • RectAnchors: world content that follows its parent. A new engine component pins content placed by its Transform and sized by a ContentRect to the edges or centre of its parent rectangle (stretch, pin to an edge, centre with an offset, margins in units or as a fraction), or, with no parent rectangle, to the screen, which is centred on the world origin. An engine system aligns parents before the children that depend on them, in the editor edit mode as well as in play, on ONCE / ON_RESIZE / ALWAYS. The Cocos Widget is now a view on it, and a converted project carries RectAnchors instead of a compatibility-layer component, so a scene is laid out where the editor shows it. The visible area of the Cocos layer is centred on the origin, as the engine screen is.
  • The script bundle is not rebuilt for nothing. The project-script bundle is stamped with every file it read (size and modification time) and the build tool that made it, and Play builds it again only when one of those changed: a project of thousands of scripts goes from a multi-second build at every Play to a check of a few hundred milliseconds.
  • Large projects open faster. The asset dependency scan no longer asks the path index about every string in every document (names, types and labels cannot be paths), which took the open of a 5000-document project from 17 s to under 5 s, and the Cocos script rewrite makes two passes over a file instead of one per declaration.
  • A model texture the project does not have is left off. A model whose material names a texture file that is not there is imported without it, with a warning, instead of keeping a reference that fails to load on every use. A texture the model names by a path on the artist's machine is looked for by its file name beside the model first.
  • An unlit mesh variant with tangents links. The fragment stage declared the tangent varying wherever a mesh had tangents, though the vertex stage wrote it only when lit, so an unlit variant failed to link.
  • Bursts on a schedule. ParticleEmitter.bursts is a list of { time, count }: each releases its particles once the emitter has been emitting for time seconds, and a looping emitter repeats the list every duration. It runs beside burstCount, which still repeats one burst on an interval.
  • A 3D collider can sit off its entity. BoxCollider3D, SphereCollider3D and CapsuleCollider3D take an optional center, the shape's place from the entity origin in world units. The body stays at the entity, so a dynamic body turns about its origin and the shape swings round it.
  • Text can underline, and a box can grow to its text. Text.underline draws a bar under each line, taken from the font's own underscore. TextOverflow.ResizeHeight keeps every line and sets the entity's ContentRect height to the height they take, so what sits below a paragraph can follow it.
  • An emitter runs on its own clock. ParticleEmitter.simulationSpeed scales how fast that emitter's time runs: 2 plays it twice as fast, 0.5 at half, 0 holds it. Emission, lifetimes and motion all follow it. The default, 1, is the behaviour before.
  • An animator state can play at the speed of a parameter. speedParameter on an AnimatorState names a float parameter; the state's clock advances by dt times its value, so a run clip follows a character's speed and a value of 0 holds the pose. It applies to every kind of motion, since it is the state's own clock that is scaled.
  • Particles can carry an added velocity and be held to a speed limit. ParticleEmitter.addedVelocityMin and addedVelocityMax give each particle a velocity on top of its own, chosen between the two when it is born and untouched by gravity, damping and noise. speedLimit pulls a faster particle back toward the limit, by limitDampen of the excess every 1/60 s so the braking does not depend on the frame rate. Both are run by the CPU simulation.
  • An emitter can start late. ParticleEmitter.startDelay holds back emission for that many seconds after the emitter starts playing; the duration of a non-looping emitter is counted from the end of the delay. Zero, the default, is the behaviour before.
  • Particles can be stretched along their velocity. ParticleEmitter.renderMode is Billboard (as before) or Stretched, which turns each particle's quad so its Y axis runs along the particle's velocity and makes it size * lengthScale + speed * velocityScale long: sparks, rain and streaks. A particle at rest keeps its own rotation. It is drawn by the CPU simulation; an emitter simulated on the GPU still draws as a billboard.
  • Fade a whole group of world content with one value: GroupOpacity. On an entity it fades that entity and everything under it; the opacities multiply down the hierarchy into each descendant's own alpha, as UINode.opacity does for a UI subtree. Sprites, text, shapes, trails and tilemap layers follow it. It is not a composited layer, so children that overlap show through one another while the group is partly faded.
  • A held pointer reports where it goes, and a hold can be given up. pointer_move goes to the entity a pointer is holding for as long as it is held, press_cancel to one whose hold was taken away (UIControlPointers.cancelHold, optionally handing the gesture to another entity, so a scroll area can take a drag from the button under it), and every pointer event now says which pointer it was and where, in the world and on the surface. An entity that is only a ContentRect with an Interactable can be the one pressed.
  • The engine's runtime tuning is a project setting. Project Settings → Game → Runtime sets how a scene switch fades (duration and colour), how far one frame may advance the game and how many fixed steps it may catch up, how long an asset may take to load and how soon a failed one is tried again, how much memory the texture, audio and device-loss caches keep, the text canvas size and the default font family. They were reachable only from code (RuntimeConfig) and no project file could carry them. The project holds features.runtime with only what differs from the engine's own values (RUNTIME_BUILD_DEFAULTS), a build ships the same block, and initRuntime applies it before the first asset loads on the web, desktop, native, mini-game and playable targets and in Play. The edit viewport keeps the engine's values.
  • Rows for the choices that could only be written into the project file. Under Rendering: compile shaders in the background, warm them up behind the loading screen and how long to wait, draw only changing frames and how many frames to keep after a change, each level's anti-aliasing (MSAA or temporal; the MSAA count is hidden where temporal ignores it) and its depth pre-pass. Under Game → Display: the render resolution (screen, design resolution or integer multiple). Under the web build: the servers the page may connect to, each checked by the parser the export uses. check-project-settings now reads the keys of QualityConfig, QualityProfile and RuntimeBuildConfig and fails a key that has no row and no stated reason, which is how these went unnoticed behind the one row the block had.
  • Rain for a 2D scene. The rain2d post-process effect is rain for a scene that reads no depth: streaks, and rings, splashes and puddles on the ground in world units (intensity, wetness, puddles, puddleScale, rippleScale, wind, speed, streakLength, colour). RainShelter on a roof or a tree crown keeps the ground it covers dry, as far as that ground can be seen, so a roof faded to show the room under it has a dry room. A scene has as many shelters as it has roofs: the ones in view are painted into a small mask each frame, whose size is the effect's Shelter Mask Size (maskSize, 64 to 2048) and at most the quality level's shelterMaskSize (256 low, 512 medium, 1024 high, set on the quality page of Project Settings). RainUpright on a sprite that stands on the ground (a character, a trunk, a crate) keeps the rings, puddles and wet darkening off it, while the falling streaks still cross it.
  • Mist, wind in the grass, and roofs that fade over the player. The mist2d effect lays drifting banks of mist over the ground in world units, and what is lit glows through it. The Sway sprite material (sprite-sway) leans grass, reeds and cloth in the wind with the foot fixed and the tip free, scaled by the weather's wind, and a SwayPusher on a character makes the plants lean away from it as it walks through. CoverFade on a roof or a crown eases it down to opacity of its alpha while a CoverFadeTarget (the player) stands on the ground it covers, and back when the target leaves.
  • Footprints and ripples. Footsteps on what walks and StepSurface on the ground worth marking: every stride world units a step falls, left and right in turn, as a ring that spreads and fades on a Water surface or a footprint that fades over printLife on a Print surface (mud, snow). The steps use the engine's own ring and print or textures of your own, are drawn on the sprite layer you name, are never saved, and at most 256 are alive at once.
  • A 2D light can keep to a range of sprite layers. Light.layerMin and layerMax limit the sprite layers a light reaches, so a lamp inside a hut does not light the roof drawn over it; the roof still takes the scene's ambient light. The default is every layer, a directional light takes a range too, and a custom lit sprite shader joins in by calling applyLighting2DLayer instead of applyLighting2D.
  • More 2D lights cast shadows at once. The 2D shadow mask has eight channels (four in a frame where some light has a shape), and lights whose reach and shadows cannot meet share a channel, so a camp of torches spread round a clearing all cast. Every light can cast, the lights shaded through the screen tiles past the lighting loop's sixteen as well (up to 96 more, brightest first). A light left without a channel still lights the scene and drops only its shadow, the dimmest first, and the profiler's render.shadow2d.unplaced counts them.
  • A soft 2D shadow's smoothness is a quality setting. A light with a size draws its penumbra as that many silhouettes added up, and how many is the quality profile's shadowSoftSamples (1 to 32; 8 low, 12 medium, 16 high), with a row on the quality page of Project Settings. Fewer is cheaper and shows the edge as bands.
  • What the player can see, and what they have seen. SightViewer on the player and SightTarget on a sprite fade the sprite out while no viewer has a clear line to it past the ShadowCaster2D walls, for what the light alone does not hide: an unlit enemy, its health bar, a pickup that glows on its own. segmentBlocked, seesPoint and currentSightRings give gameplay the same answer. FogOfWar with a fog2d effect keeps the ground no viewer has seen dark and the ground seen and left dimmed and drained of colour, and exploredToString / exploredFromString let a save keep what the player found.
  • A palette effect. The palette post-process effect holds the whole picture to the colours of a strip image (up to 64), after an ordered dither whose scale can match the art's pixel size.
  • A 2D world streams on x and y. A streamed world, a procedural chunk layer and a cooked world manifest can be cut on the screen plane (plane: 'xy', StreamPlane.Screen, Screen (x, y) in the editor) instead of the ground, so a 2D scene streams as a grid rather than as one row along x, and the editor's streamed-world grid is drawn on the plane the world is cut on. An infinite tile layer can let a chunk go (removeChunk), its mesh with it, so a layer that follows a walker holds only the chunks near it.
  • A generated 2D world. createWorld2D in esengine/worldgen lays a world out on the screen plane by the same rules as a terrain world (biomes, recipes, layers, zones) and publishes it in chunks round the camera; what a placement looks like and how the ground is painted are the game's, said in publish. A chunk is the same whatever order it is made in, and a PlacementDiffs keeps what players changed.
  • Grid placement, and what stands nearest. esengine/gameplay has snapFootprint, snapToGrid, gridCellAt, gridCellCentre and checkPlacement, which says whether a footprint is clear of colliders, solid tiles and the cells the game counts as taken, for a build mode; and nearestMarkers and nearestEntities, the markers or entities nearest a point filtered by type, properties, radius and count, for an interact button.
  • Save power when the battery is low or the device is hot. QualityConfig.power, with rows in Project Settings: while the battery is under lowBattery and not charging, or the platform reports thermal pressure at thermal or worse, the engine lowers the frame cap to fps and holds the quality level at or below ceiling, and puts both back when the device recovers; at critical pressure it halves the cap and holds the level at Low. Off by default, and what a platform does not report never triggers it. Device.power() gives a game the same readings.
  • Bitmap fonts. Text draws a bitmap font (.fnt) from its page texture through the same layout as any font, so wrapping, alignment and overflow work as they do for any text, and the baseline comes from the font's own base. A glyph page is read by a mode (plain, distance field, mask or fill), so a font with its outline baked into the page draws in two passes with the outline in any colour.
  • Text can shrink to fit its box. TextOverflow.Shrink sets the type smaller, a whole pixel at a time, until the text fits both sides of its box.
  • A layer can be painted in hierarchy order. Renderer.setTreeSortLayers(mask) names the layers whose sprites, labels and shapes stack in the order of the hierarchy (a parent before its children, an earlier sibling's subtree before a later one) instead of by shader and depth, so a panel covers the text of the panel under it.
  • A text field can stand in the world. TextInput works on an entity with a ContentRect as well as on a UINode, and TextInputFilter has Decimal and Phone beside Digits.
  • UI pages that exist only while they are wanted: UIPages. A page registered as a prefab is built the first time it is opened (opens at the same moment share one build), its nodes are found by name inside it, and on close it is switched off (keep) or taken out with its assets (destroy). A page goes under a parent as a new root, or under a mount already in the scene so it keeps its place in the draw order.
  • Virtual prefab instances. A prefab instance marked virtual (the Virtual toggle in the prefab bar of Details, or the outliner's context menu; deferred in its metadata) is shown and edited whole in the editor, but a running scene makes only its root and builds the rest when it is opened, so a screen of many pages does not pay for the ones nobody opens; UIPages registers such instances as pages. An instance that adds, removes or re-parents parts is made whole. ?expand-virtual in the page address makes every virtual instance whole at boot, for a harness that expects every node, leaving out one marked as another layout, and deferredEntities and deferredRecord are exported for a game that keeps two layouts this way.
  • The loading screens say how far they are. One bar, a line per step with its count and time, and the time so far; the engine step says which step of the boot it is in, and the asset scan reports how many documents it has read of how many.
  • A material can read a mesh's second uv set. In a mesh variant that carries one (MESH_LIGHTMAP), the vertex stage hands the material the mesh's second uv set as authored, v_texCoord1, beside the lightmap coordinates, for a mask or a dissolve map.
  • Paste textures onto a blank texture: TextureCanvas. TextureCanvas.create(width, height) gives a canvas whose draw(source, x, y, width?, height?) pastes a texture at a pixel position, in the order you call it, and whose texture a Sprite shows. Where TextureAtlas.pack lays textures out for you, this puts each one where you say.

Changed

  • The profiler's tables sort by their column header. Click a column of the cost tree or the systems list to order it by name or by time, and again to reverse it; the choice is remembered. Ranking by time moved a name whenever two systems passed each other, which is every few frames on a live window, so a reader could not follow one; by name the rows stay where they are. The systems list names twelve systems instead of five, so the members change less often too.
  • A selection stays off the running game unless Inspect is on. While the game plays, the selected entity's outline and handles are not drawn over it unless Inspect is on; a new selection shows where it is for a moment.
  • UI gears cost nothing on a frame where nothing they read changed. The gear pass visited every UIGear entity every frame, walking up to its controller, which was 2 to 4 ms for a still screen of 2530 gears. It now skips a frame in which no controller, gear or parent changed, the world's structure is the same and no tween is in flight.
  • A second scan of a large project reads nothing it has already read. The asset scan keeps what each document can refer to, keyed by the file's size and modification time (.esengine/cache/ref-candidates.json), so a document that has not changed is not read and parsed again.

Fixed

  • A 3D contact point is in the units of Transform. The point a Physics3DEvents.contactEnters entry carries was in the physics world's own units, so with the default 100 pixels to the unit it sat a hundredth of the way from the origin, and the contact crosses of the physics debug draw landed there instead of where the bodies met. It is now scaled as a ray hit is.
  • RectAnchors, AnchorFlag and AnchorMode can be imported from esengine. They were exported from the UI module only, so the import the manual shows did not resolve.
  • Lit materials draw on WebGPU again. A lit material on the engine's own vertex stage, and a 2D lit shader, built a WebGPU program with a preprocessor line left in it, so the material drew nothing (and a desktop build of a 3D scene came up black). #if and #elif conditions with defined, !, &&, || and parentheses now resolve in a WGSL twin as they do in GLSL.
  • A scanned preview reaches the game's own server. The page a phone opens from the preview QR code allowed connections only to itself, so a game that logged in to a server on the LAN worked in Play and in a single-file build but not on the phone. The preview now connects as Play does; a shipping web export still connects only to the servers listed in Project Settings → Allowed server origins.
  • The ground has no dark patches on a Mac. With the depth prepass on (quality high and medium), a material written as a fragment shader alone, the terrain among them, drew its colour from a vertex stage that did not declare its position invariant, while its depth came from one that did. Metal is free to compute the two a bit apart, and wherever they differed the colour failed the equal-depth test: sand, sea floor and grass showed dark triangles. Both stages now declare it, on WebGL2 and WebGPU.
  • No "uniform not found" warnings for a texture a program does not read. A material sets each of its textures on every program it is drawn with, and the depth program of a terrain or a lit material reads few of them, so opening a scene filled the log with warnings that read like typos. A texture a program does not use is now skipped quietly.
  • A terrain with texture layers no longer keeps a second copy of them in memory. Its layer arrays were made as content the graphics device keeps a CPU copy of, to restore after a GPU loss: 12 MiB on Terrain & Water, which took the copies past their 16 MiB budget and logged a warning. The terrain now says how to make them again: after a loss it reads and packs its layer files once more and puts them back behind the same textures.
  • No "NaN is an invalid value for height" error when a project opens. The content browser measured its grid before the editor had placed the panel, read the panel's padding as a number it was not, and gave the grid a height of NaN for that first frame.
  • A web game comes back after the GPU goes away. A browser can take the GPU from a page (a driver reset, a laptop waking, too many tabs). Three things stood in the way of the way back, all seen on Terrain & Water: while the engine waited for its textures, the frames it refused still gathered geometry and never emptied it, until an allocation of gigabytes stopped the module; the restored context had none of the WebGL extensions the engine relies on, so an HDR scene came back black; and the terrain's page atlases were never refilled, so the ground came back flat and black. The game now recovers to the picture it had.
  • Rain wets hillsides and plants, not only flat ground. The rain effect darkened only what faced almost straight up, so in a storm a slope began to stay dry-bright at about 18 degrees, and past about 31 was not darkened at all, beside the darkened flat, and every plant stood light on dark ground: from a distance a hillside read as pale wedges and white speckle. Everything under the rain darkens now, a little less where it faces away from the sky; standing water still only gathers on the flat.
  • A subpath of an official package resolves. Importing estella-plugin-…/something from a project script no longer hangs the script build.
  • Background shader compilation, the warm-up and on-demand drawing reach a build whose quality level is Off. A build dropped the whole quality block when the level was Off, though these three choices hold whatever the level: a project that switched asyncShaderCompile, prewarmShaders or renderOnDemand on read them in the editor and shipped a game that ignored them. The block now ships when any of them is on.
  • A terrain and a streamed world run on the Android and iOS templates. The terrain's layer textures were refused on a device (it has no wasm heap to copy them through), and a chunked world's maker threw on every tick because QuickJS has no AbortController. The layers now go over as bytes, as every other texture does, and the world uses a handle of its own where the host has none.
  • A pointer lands on what is drawn on top. Where two pressable things overlap at the same depth and layer, the press went to the one created last; a node taken from a pool and added under a panel is created last and drawn first, so it took presses meant for what covered it. It now goes to the one drawn later by its place in the hierarchy. In the Cocos layer, a Toggle belongs to the container its parent holds, and assigning isChecked switches the others of its group off.
  • The edit viewport frames and lays out the scene as the game does. The design and device frame is drawn round the camera that shows the scene, so a project whose camera is off the origin sees the frame where the camera looks, and the edit world lays UI out in the project's screen fit, so a root pinned to the screen takes the design box instead of the viewport's pixels.
  • A project script bundle that throws while it loads is reported. Play logged nothing and ran as though the project had no scripts; the error is now logged.
  • A playable far over its size cap is built at once and says its size. The search for a smaller page built the whole page, a base64 copy of every asset, for each candidate encoding, so a game of 140 images never finished; the size is now worked out from the parts, the search is skipped when what no encoder can shrink is already over the cap, each stage reports itself, and a page over the network's limit is a warning with its size instead of a failed build. A 57 MB game went from no answer to 4 s.
  • The status strip fits a narrow window. Each readout keeps to one line, and when the strip is short of room it drops the long message and the least useful readouts instead of wrapping.
  • A texture keeps the colour under its clear texels when it is made smaller or read back. A texture that stores numbers in its colour where it is clear (a terrain weight map) came out black after a Max Size resize or a read back through a 2D canvas, which keeps what it holds premultiplied. The resize and the read back now keep the colour.
  • A camera that clears no colour is drawn over the main view. A full-frame camera that only clears depth (a UI camera) competed with the world camera to be the main view and hid its picture; it is now drawn over it.
  • Stopping Play closes the connections the game opened. The play window is kept between plays, and a socket the last play opened stayed connected, so a game that logs in as the same account on the next play was told it had signed in somewhere else.
  • A drop on an Outliner row lands. A drop that arrived before the hover had been drawn was lost; the drop now asks for its own answer when the one it holds is for another row.
  • A play that cannot start says why. Every compile error of the project scripts is printed to the output log, and the status line gives the reason instead of only saying it failed.

[0.96.0] - 2026-10-27

Added

  • A quality level can smooth edges temporally. QualityProfile.antialiasing is 'msaa' (what every level does today) or 'temporal': that level draws at one sample, adds the taa pass to the camera's post-process volume whether or not the scene lists it, leaves fxaa out, and runs taa even where the level skips it. On the terrain-water example at 1080p it is 12.9 ms against 15.4 ms for 4 samples and FXAA, and 12.6 ms against 13.5 ms for the medium level's 2 samples; the pass itself is 0.18 ms. The picture is softer, a cut-out leaf has no coverage dither, and water, which has no motion vector, smears a little when the camera moves fast. The medium level uses it; set antialiasing: 'msaa' in its profile to keep the 2 samples.
  • An Offset side the layout drops is dimmed, with the reason in its tooltip. In the inspector, a UI node whose Offset has both a start side and a size set already has this axis fixed, so the far side does nothing; that field is dimmed, and its tooltip says which two settings decide the axis and that setting one of them to auto brings the side back.
  • Every render-graph pass has its own GPU time in the profiler, and the scene pass can be split by shader. The profiler reads a GPU time for each pass of the frame on WebGL2 and WebGPU, not one number for the frame. With the profiler on and module.esGpuDetail set, each run of draws that use one shader is its own timed segment of the scene pass (WebGL2). docs/TERRAIN_WATER_GPU_COST.md says what each part of the Terrain & Water example costs and why.
  • Optional tools a project switches on, fetched and checked by the engine. A project names a tool in project.esproject (tools.luban.enabled); until it does, the engine does not look for it, mention it or download it. Luban, the industry's configuration tool, turns the Excel tables a game's designers keep into JSON and the TypeScript that reads it, with references between tables checked (a site that produces an item that does not exist fails with the table, the record and the field). It is a .NET program, so the engine also fetches the .NET runtime it runs on. When either is missing, estella tools install luban shows exactly what it would download (name, version, licence, size, and where from) and asks before it does; --yes agrees in advance for CI. Each tool is pinned in external-tools.manifest.json to one vendor file, and a release publishes those files, repackaged as .zip, beside an index naming each one's size and SHA-256 and the vendor file it was made from: the engine takes them from the release mirror first and the release itself second, refuses a file that does not match, and refuses an index built from a different vendor file than it pins, so an engine version always runs the tool versions it was built against. There is no fallback to the vendor's own site. estella luban gen writes the tables (only the files that changed, and it removes what a deleted table used to produce), estella luban check fails when they are out of date, and an export of a project that has Luban on rebuilds them first. Windows, macOS (both architectures) and Linux (both architectures).
  • Protobuf as a second optional tool: .proto files become TypeScript types and a binary codec. tools.protobuf.enabled in project.esproject (folders proto and src/proto unless the project says otherwise) makes the engine fetch the pinned protoc the same way it fetches Luban, asking first, and turn the project's .proto files into TypeScript: an interface and an encode/decode pair per message, written against one small _runtime.ts beside them, so the game carries no protobuf library. proto3 is supported, with scalars, enums, nested messages, repeated, optional, oneof and map; 64-bit integers are numbers and a value past 2^53 throws instead of rounding, and proto2 is refused by name. The output is checked against protoc itself, in both directions, byte for byte. estella proto gen writes only the files that changed, estella proto check fails when they are stale, and an export of a project with Protobuf on regenerates them first. A session can carry it (next entry).
  • A session can speak protobuf, with the JSON wire kept for debugging. ClientSession({ wire: 'pb' }) asks for it in the hello and SessionHost({ wire }) decides: 'json' (the default, nothing changes), 'pb' (a client that asks gets binary frames, and one that asks for JSON still gets text, which is how a session is read in a debugger) or 'pb-only' (a client that asks for JSON is turned away and JSON frames are dropped afterwards). A message from a .proto file is a contract type with proto(Order), or protoAs(Order, { to, from }) to keep the game's own types on either side of it: the generated code brings its binary codec, a checked JSON form for the debugging wire, and a shape that goes into the contract fingerprint, so changing the .proto changes it. On the binary wire every control message is one fixed envelope on binary channel 255, which is now reserved (0-254 stay the game's); the frame limit, the rate limit and retry-safe requests apply to it as before, and a retried request is answered from its stored result on either wire. Types written with s keep working on both wires. esengine/session also exports createRng, so rules shared by a server and its clients draw the same numbers from one import.
  • A text field can accept only digits. TextInput.inputFilter (TextInputFilter.Digits) keeps a field to 0-9 for a count or a price: a letter typed or pasted never reaches value, and the caret stays where the kept characters put it. A script that cleaned the value itself each frame lost to the field: while a field is being edited its own editor is the source of value, so the cleaned value was overwritten with what was typed and the screen kept showing the letters. The filter runs where the editor's text is read in, beside maxLength, so what is on screen and what a script reads are the same. Off by default; a maxLength still applies after it.
  • A web build can say which servers its game connects to. The exported page's Content-Security-Policy let a game talk only to the page it came from, so a game with a server of its own could not reach it: the browser refused the connection and said nothing the game could see. A project now lists the origins in packaging.platforms.web.connect (wss://play.example.com, ws://127.0.0.1:* for any port on a host, or a bare wss: for any secure WebSocket) and each becomes a connect-src source. An entry is checked rather than pasted in: a path, a wildcard host, a space, a semicolon or a quote fails the export and names the entry, so no entry can end the directive and start another. Web only; a mini-game's server addresses are the platform's own list.
  • A session can be told to redial now, and says why its link ended. ClientSession.retryNow() dials at once instead of waiting out the backoff, for a player who pressed "try again"; it does nothing when the session is ready, already dialling, or closed. lastClose is the WebSocket close code of the last link that ended (4003, SessionCloseCode.unavailable, is the server saying it is full or going away) until the next one is ready, and attempts counts dials since the session was last ready, so a screen can tell "reconnecting" from "the server is full" and say which attempt this is.
  • A session layer for online games that do not share a tick. esengine/session is the request and reply side of a game played asynchronously over a shared world. A SessionHost on the server authenticates each connection before it serves anything, limits frame size and message rate, pings the client, and lets a newer connection for the same player replace the older one. A ClientSession on the device dials, redials with backoff and jitter when the link drops, waits for the server before a request goes out, and keeps its event subscriptions across reconnects. Every request carries a key, so one that was lost on the way back and is sent again is answered from memory instead of running twice (a purchase, a departure); serverNow() gives the server's clock, corrected for the link's delay. defineContract writes every request and event once, with s.object, s.int and the other validators: the server checks each request against it, the client checks each reply, and both are typed from it; its fingerprint lets a server turn away a client built against another contract. acceptWebSocket hands a ws socket to a host, and IdempotencyStore is where a server with several processes keeps the answers in one place. NetChannel gained the keyed requests, a heartbeat, a rate limit, a frame size limit and NetRequestError (timeout, closed, rate-limited, retry, remote) for them. Replication is untouched.
  • A random generator that gives the same numbers on every host. createRng(seed) returns a seeded generator (float, int, chance, pick, weighted, shuffle) whose sequence is the same on a server, a browser, a mini-game and a phone, because it uses only 32-bit integer arithmetic. fork(label) makes a named stream that does not move when another stream draws more, and hashSeed turns a number, a string or a list of them into a seed. It is for rules that a server settles and a client previews, which must agree; Math.random cannot be seeded and is not the same anywhere.
  • Sharpen on WebGL2. The sharpen effect was a compute shader, so a device with no compute stage (WebGL2, which is most of the small-game targets) left it out and showed the picture as it was. It now has a fragment pass of the same arithmetic that stands in where there is no compute stage: on WebGPU the two draw the identical picture, pixel for pixel, and a test switch in the render host (noCompute) checks that. Flat areas are untouched and an edge cannot overshoot past what is on either side of it.
  • Blob shadows. A BlobShadow component puts a soft dark disc on the ground under an entity: no shadow map, no light, no extra pass, which is the shadow a phone can afford. It fades and shrinks as the thing leaves the ground (fadeHeight, shrink), follows the ground (groundY, or a height function from setBlobShadowGround for ground that is not flat) and is hidden by what stands in front of it. It is a disc, not the light's shadow: it does not stretch with the sun or land on a wall. The same picture on WebGL2 and WebGPU.
  • Edge Outline, a coloured line at silhouettes and creases. A post effect (edgeOutline) that draws a line of u_lineColor where the scene's surface changes: where the distance from the camera steps (a silhouette) and where the surface's normal turns (the edge of a face, a fold), so a box on a floor is inked along its corners as well as its outline, which depthOutline (depth only, black only) does not do. Distance is measured in the world, so one threshold holds across a perspective view, and a plane at a grazing angle draws no line. Creases need surfaces that write their normal (lit meshes, Model and Toon materials); the same picture on WebGL2 and WebGPU.
  • Filled polygons and joined strokes. setPath(app, entity, points, style) draws a path on a MeshRenderer: an ear-clipped fill of any simple polygon (concave ones, holes), and a stroke with mitered, rounded or bevelled corners and butt, round or square caps that does not overlap itself at a corner, so a translucent line is even; feather fades the outer edge for a quality level without multisampling. It sorts, batches and saves with the scene like any mesh. Graphics still fills only rects and circles; buildPathGeometry, cubicBezier, quadraticBezier and circlePoints are the pieces. The same picture on WebGL2 and WebGPU.
  • Toon and Matcap materials. builtin:toon lights in steps: each lamp's light is cut into flat bands with a shade colour where no lamp reaches, a flat highlight and a rim, and a lamp's shadow is part of its step; the same picture on WebGL2 and WebGPU. builtin:matcap shows a picture of a lit sphere looked up by the way the surface faces the camera, with no lamp asked and one texture read, for phones.
  • Drawing only the frames that can look different. quality.renderOnDemand (off unless a game turns it on): a still screen costs the game's logic and nothing else. A frame is drawn when the player did something (a key, a button, a finger, the pointer moved), the surface changed size, entities were created or destroyed, shaders are still compiling, or the game asked (app.pipeline.demand.request()), and for renderOnDemandTail frames (30) after the last of those; demand.hold() keeps every frame drawn while a tween, a video or an animation the engine cannot see move is playing. On the UI template a still screen made 11,600 draw calls in 3 seconds before and none with this on, and a click drew again at once. What the engine does not see is a script changing a value or an animation playing, which is what request and hold are for.
  • Shaders that compile without stopping the frame. quality.asyncShaderCompile (off unless a game turns it on): a draw whose shader the browser is still compiling is left out until it is ready, and every shader asked for in the meantime compiles at once, where before each was waited for in turn. On a first visit the Terrain & Water example's shaders took 43 seconds of a frozen page on Chrome and D3D11 (the heavy lit ones 3 to 10 seconds each, the worst frame 10 seconds); with this on the page was blocked for about a second in all and the whole scene was drawn at 20 seconds, not 56. The same scene, once everything has compiled, is the same picture. renderer_getPendingShaders() says how many are still compiling, for a loading screen. Off, nothing changes. WebGL2 only (a WebGPU pipeline is not compiled this way). With quality.prewarmShaders (and prewarmTimeoutMs, default 30 s) a packaged game draws its first scene out of sight behind the loading screen until nothing is compiling, and opens complete; warmShaders(app) does the same from code, shadersCompiled(module) waits for the queue, and a scene prepared ahead (readyRenderPrograms) now claims its programs ready only once they have compiled. The lit shaders also link about 23% faster on a first visit: a light that comes from the tiles no longer carries a second copy of the shadow lookup in the program.
  • A depth prepass for the opaque scene. A quality level can draw the opaque meshes twice, depth alone first, so a pixel is shaded for the surface that is in front of it and not for every one drawn there on the way: QualityProfile.depthPrepass (on for high and medium, off for low and with the quality system off), and renderer_setDepthPrepass for a host without one. Cut-out leaves take part, with the coverage their own shader writes. A surface whose material bends its vertices with a hook takes part too, unless it is also a cut-out. On the Terrain & Water example, on an RTX 3060, a frame is 4 to 39 ms shorter, most where trees stand thick.
  • A third mesh for a plant. A part of a world's plants can name lod2Mesh and its kind lod2Distance: past that distance the third mesh stands in for the cheaper one, until the kind stops being drawn as itself. The Terrain & Water example's trees have one (a tenth of the triangles, made by tools/plant-lod2.mjs) from 80 m, which takes 9 to 15 ms off a frame on an RTX 3060 where trees stand between 60 and 170 m. tools/terrain-water-cost.mjs measures what each part of that example costs a frame headless, and docs/TERRAIN_WATER_GPU_COST.md has the numbers.
  • Connect AI tools to the editor from one dialog. Window → Connect AI Tools… (also the status-bar mark and Settings) lists the Claude Code, Cursor, Claude Desktop and VS Code on the machine with a Connect / Disconnect button each. Connecting writes only the estella entry (the rest of the file is kept, an unparseable file is refused); Claude Code is written by its own CLI so a running session does not lose edits, and the others by merging their JSON in their own shape. The entry runs the bundled front on the editor's own executable, so no Node.js install or path lookup is needed. What an agent may do is the editor's to grant live: Read only / Can edit is asked of the editor over /policy and a change reaches every connected tool at once, with no entry rewritten and no restart. The dialog reports the last call that landed and which tool made it, and tools the editor cannot write for get the same entry as text to copy (JSON, TOML, command).
  • A generated world on worker threads. A planet provider can give the engine its generator as workerSource (the text of a self-contained module), and the world's placements and the planet's pages (heights, normals, and the paint by the biomes) are then worked out by a pool of workers (runtime/jobs.ts), byte for byte what the main thread works out, while the main thread only puts each answer in the world as it arrives. Laying out a planet's world no longer costs the frame: 2 to 8 frames a second while it was laid out became 60.
  • A flat world's generation on worker threads too. Laying out a WorldGen over a Terrain (a field or noise ground, with its baked water) is worked out by the same pool of workers, from the ground and the water handed over as data, byte for byte what the main thread works out. Stopping the terrain-water example no longer leaves the editor at 2 frames a second: it is back at 60.
  • A planet's sea and sky. Planet.sea draws a translucent, lit sphere at seaLevel in which the ground that dips below it stands, and skyAtmosphere takes the planet's radius and centre (u_planetRadius, u_planetX/Y/Z, as heightFog does) to work the sky out in the frame of the ground the camera stands on, so the horizon, the sun and the haze follow it round.
  • A generated world on a planet. A WorldGen with surface Planet, on a Planet's entity, lays the world out over the cube's six faces, each as a plane of metres, by the same rules a flat world has: biomes over fields, recipes and layers. A direction is planned by the face it falls on; what is placed is taken to the planet and stands along its up. The fields are the planet's own (height, slope, noise in three dimensions with no seam between faces, paint.<layer>, and the fields a planet provider names with fields), the biomes paint the ground too, and seaLevel and WorldZones work over a planet.
  • A planet pulls and answers. Planet.gravity pulls every dynamic 3D body toward the centre of the nearest planet that pulls (the world's gravity is taken off the body and the planet's put on, as a force each fixed step), and the PlanetRegistryRes resource answers up, altitude, groundHeight, groundPoint and nearest for what stands, aims or falls on a round world.
  • A render origin for large worlds. setRenderOriginStep(step) turns on drawing relative to a point near the camera: the origin is the camera's position rounded to step and moves only when the camera is further than step from it, the renderer takes every mesh, light, probe and shadow bound from it before the GPU sees them, and the camera's view-projection is built for the same origin, so a world tens of kilometres across stops jittering. It is off by default and changes nothing then. It covers meshes, lights, probes, occluders, planar reflections, sprites, text, particles (GPU too), trails, tilemaps, world-space UI, 2D shadows, and the terrain, planet, water, foliage, height fog and cloud shaders, which read the world's own position back from a new u_renderOrigin frame constant. Debug and custom draws stay in the world's coordinates, and the previous frame's view and meshes are taken to the new origin when it steps, so motion vectors and temporal effects carry on.
  • A planet's ground has the layers' textures. Planet.layers names up to four .esterrainlayer files, as on a flat terrain: each layer's albedo and normal map are read on the planes of the world's axes by how much the ground faces them, with a wider read mixed in far off so the repeat is lost. Without layers the ground is still the four colours.
  • A planet's ground collides. Planet takes collision, collisionDistance, collisionLayer and friction as flat terrain does: the finest nodes round every moving 3D body and character are built as collision geometry from the same samples the ground is drawn from, one chunk layer to each face of the cube.
  • Height Fog by height above a planet. heightFog takes u_planetRadius and the planet's centre (u_planetX/Y/Z): with a radius above 0 the fog thins with the height above the ground's sphere and not with world Y, so a round world is hazy at its horizon and clear from orbit.

Changed

  • UI text costs less: labels are laid out when they change and submitted by the engine. A Text label is laid out in the script only when its text, font or box changes and hands the engine its glyph quads once; the engine clips and submits them every frame. 600 static labels cost 2.7 ms a frame and now cost 1.1 ms, with the same draws and triangles. UI text costs a third less again because the engine itself watches the world scale an automatic label picks its bitmap or signed-distance glyph pipeline from.
  • Tilemaps that have not changed cost almost nothing per frame. A layer that stands still draws from strips of tiles the GPU already holds, one chunk row wide, in the order the old merged draw used, so nothing is uploaded or copied per frame: a far view of 47 thousand tiles went from 5.8 ms to 0.5 ms of CPU. A layer that is faded, tinted, rotated or carried keeps the per-frame path until it has stood still for a while.
  • Fewer GL calls when a draw changes buffer. Each combination of vertex layout and buffers has its own vertex array object, so a draw that moves between a tilemap's strips or a mesh's buffers no longer re-points its vertex attributes.
  • A frame of sprites is not sorted again when its draw keys have not changed. The 2D sprite sort is skipped when the keys are the previous frame's, and the order is the same.
  • The temporal anti-aliasing pass samples its history with a Catmull-Rom fit instead of one bilinear fetch. A fetch at a fractional offset blurs a little, and every frame resamples the frame before it, so the blur accumulates: the softness of the pass and the smear of a moving camera. The detail the pass keeps in water goes from 44% to 64% of what 4x multisampling gives, and leaves stop being softer than it. Five taps, 0.18 ms of a 1080p frame.
  • A draw that changes buffer no longer re-points its vertex attributes. The WebGL2 device kept one vertex array object per vertex layout, so every draw from a different buffer (each strip of a tilemap, each mesh sharing a layout) rebound the buffer and set its five attributes again: 15 GL calls a draw that a vertex array object exists to save. It now keeps one per layout and the buffers it reads, and deletes them with the buffer. The 47,000-tile view goes from 651 GL calls a frame to 190 and the 3,300-tile view from 188 to 73, with the same picture; the 3D example is unchanged (about 2,000 calls, a few more vertex array switches).
  • A tilemap that has not changed uploads nothing and copies no vertex. Every frame the layer copied the vertices of each visible chunk into a list, placed them, copied them again into the frame's buffer and uploaded all of it: 47,000 visible tiles were 6 MB a frame and 5.8 ms of CPU. The layer now keeps its geometry on the GPU in strips (a row of up to 32 chunks, in world space) and a frame in which no chunk changed submits them as they are. 47,000 tiles go from 5.8 ms to 0.5 ms; a 3,300-tile view from 0.59 ms to 0.40 ms. The picture is the same: the strips are submitted slot by slot and row by row, the order the merged draw laid tiles out in, which matters where tiles overlap, and the near and far views are pixel-identical to before (the far one within the run-to-run noise of its animated tiles). A strip is made again only when a chunk in it changes, the layer is placed somewhere else, or the device was lost; a layer faded, tinted or carried along is placed anew every frame, and a strip is every chunk of a row, so such a layer (and one with parallax) keeps the old per-frame path until it has stood still for thirty frames. What the strips hold is bounded (96 MB, the ones not drawn lately go first). The cost is more, smaller draws: 8 for the near view and 32 for the far one, and about four times the triangles in the near view, which the GPU clips.
  • A label's glyph pipeline no longer costs a transform read per label per frame. An automatic label draws with hinted bitmaps near 1:1 and with SDF past 2% of it, so script read every label's world scale every frame to see whether the choice had changed, a Transform converted through embind each time: about two thirds of what the script still spent on 600 static labels. The engine now holds the choice it was laid out with and watches the scale itself in renderer_retainedTextStale, by the same rule (pinned by one table on each side). 600 static labels go from 1.6 ms to 1.1 ms of CPU a frame, and the script's own per-frame loop to about 0.05 ms. Evaluated and not taken: driving the check from the change tracker (a script component written in place through world.get is not reported, and that is documented and tested behaviour), and making Text an engine component (an in-place write to one is dropped, which would end that behaviour for user code).
  • UI text is laid out when it changes and submitted by the engine every frame, instead of handed over by script every frame. Every label cost script an embind round trip for each of its domain, hidden state, opacity, matrix, size, order and cull bit, a JSON signature to find out nothing had changed, and a copy of its quads into the engine: 4.3 microseconds a label, which is 2.7 ms a frame for 600 labels that never change. The glyph quads are now handed to the engine once, in renderer_retainedTextBegin/Batch, and the engine reads everything else off the entity itself, clips against the view as the script did, and submits them (renderer_retainedTextSubmit). Script compares the fields a label was laid out from and lays it out again only when one differs; the engine reports the labels whose box was resized or that moved between the world and the screen (renderer_retainedTextStale). 600 static labels go from 2.7 ms to 1.6 ms of CPU a frame, with the same draws and triangles, and a pixel-identical picture once the page has settled. A host without the new entry points keeps the old path. The engine's culling and the script's are checked quad for quad on 120 random cases (test_retained_text).
  • A frame of 2D sprites is not sorted again when its draw keys are the last frame's. The draw list sorted every command each frame, 0.15 ms for 4,000 sprites and growing as n log n, although a 2D key holds the layer, shader, blend and material and no position: sprites that move, or do not, give the same keys frame after frame. The order is a function of the key sequence alone (ties break on emit index), so a frame with the same keys takes the last frame's order and skips the sort. The draw list's finalize in a 4,000-sprite scene goes from 0.30 ms to 0.10 ms. The sort result is the same bit for bit; a frame whose keys differ is sorted as before.
  • Lens flare costs a third of what it did. The flare looked ninety places in the picture for something bright at every pixel of the full-size frame, to light almost none of them: 0.76 ms of a 1080p frame in the terrain-water example. It is now worked out at half size and laid over the full-size picture (0.22 ms and 0.07 ms), 0.47 ms less. The picture is the same except along the hard edges of whatever throws the flare, where it softens by a pixel or two (0.6 of 255 on average in a scene built to make that worst). A new render scene, hdr-lens-flare, is the first to check a flare on both backends.
  • The engine's own examples and fixtures no longer commit a generated WebGPU shader twin. The wgsl full section of a .esshader is a translation of its GLSL joined to the engine's headers, so every edit to an engine header (the render origin in FrameConstants, a lighting function) changed it in dozens of files nobody had touched: 83% of that text is the engine's own lighting code, 2% the author's. It is now derived when the shader is read: by the export (cookAssets), by the fixture server the render checks use, and by the editor when it serves a project of the repo. Deriving all 44 shaders takes 2.3 s. gen-shader-twins --derived checks that each one still translates and that none commits a twin again; a project of your own keeps its twin in the file as before, because the converters are not in a packaged editor. 18 files lose about 11,000 lines; the 248 WebGPU render scenes draw the same.
  • The web module is 144 KB smaller (50 KB gzipped) because it no longer carries a C++ stream library. Log, the shader parser, the font and material parsers, file reads and one JSON status string used ostringstream, istringstream and ifstream, which link libc++'s whole iostream and locale machinery (money, number and time facets, global locale setup at start-up) into every build. They now use std::string, a small line reader and stdio, with output kept the same: all 69 shaders parse and assemble to byte-identical text for both targets, a log line prints as before, and the 262 WebGL2 render scenes still draw what they claim. 2,202,592 to 2,058,299 bytes.
  • Instanced meshes that share a material now draw together, so a scene makes a tenth of the draw calls. An opaque draw sorted by shader, then material, then depth, so two meshes sharing a material alternated by depth and no two neighbours were the same mesh: every instanced draw broke the merge (610 of 612 in the terrain-water example). An instanced mesh draw now puts a hash of its geometry in the top bits of the depth field, so one mesh's draws sit together and merge into one instanced call, in the scene, the depth prepass and the shadow pass alike. The example goes from 612 scene, 610 prepass and 385 shadow draws to 57, 55 and 45, from 10,709 GL calls a frame to 1,977, and from about 6.2 ms to 4.1 ms of CPU a frame. Only the order among opaque draws of one material changes, and they are order-independent (they write depth); the 262 WebGL2 render scenes still draw what they claim.
  • The GL device no longer sets state the context already holds. Enabling or disabling depth test, stencil, culling and blend, the depth, colour and stencil write masks, and the binding of a uniform-buffer slot were each sent to the driver on every draw even when the value had not changed. The device now remembers the last value and skips the call (a buffer that is deleted forgets the slots it held). On the terrain-water example a frame makes 10,709 GL calls instead of 26,223, and the CPU side of the frame is about 0.3 to 0.5 ms lighter on a desktop browser; a phone, where each call costs more, gains more. Pixels are unchanged: the 262 WebGL2 render scenes still draw what they claim.
  • Writing one material uniform sends that one value, and asking whether the GPU can render to float no longer walks its extension list. Material.setUniform re-defined the whole material and pushed every one of its uniforms into wasm (a string across the boundary each) for each value written, and then did the same for every instance that inherits it, so a system that sets twenty values a frame on a material of sixty made twelve hundred crossings. It sends the value that changed, to the instances that inherit it and not to those that override it; a value the engine already holds is not sent at all; a texture still takes the whole flush, since its lease is counted. In the terrain and water example setUniform went from 0.40 to 0.03 ms a frame. The post-process chain asked supportsFloatTargets() several times a frame and each ask read every extension the context has through the browser; it is answered once per context. The frame is 6.2-6.7 ms with the engine's profiler off (it was 6.7-6.9 after the last change, and 8.4 before it); every render scene draws what it did (262 of 262 on WebGL2, 248 of 248 on WebGPU). A value handed to two materials as one object and then edited used to reach each of them whenever it next flushed; now each sees the value as it was when written to it.
  • A mesh draw no longer searches its shader's source or rebuilds a feature list to find a program it already has. MaterialStore::meshProgram, asked once per mesh draw, looked for "ES_GBUFFER" through the whole text of the material's shader every time and built nine strings and a vector before it checked its cache. The mention is found once when the source is stored and the cache is asked first. With the engine's own profiler off, the terrain and water example's frame at a CPU-bound size went from 8.4 to 6.7-6.9 ms (about 19% less), the same programs are chosen, and every render scene draws what it did (262 of 262 on WebGL2, 248 of 248 on WebGPU). Note for anyone reading the frame costs: switching the engine's profiler on (render(), costs(), gpu() on the cooked hook) made that frame 76% dearer, so a per-phase number from it says where time goes, not what it costs; render.collect.mesh.<scene|depth>.walks/.visits/.ms now say which pass walked the meshes and how many times (two per frame in that example: the scene and the sun's shadow).
  • The engine's wasm is 239KB smaller, with no change to what it does. Reordering a component's storage (Sprite.order and the authored entity order reach the draw list through it) sorted inside SparseSet<T>::reorderBy, so each of the hundred-odd component types carried its own copy of std::stable_sort and its merge helpers: 275KB, 15% of the engine's code. The sort never looked at the component, so it is one function now (SparseSetBase::stablePermutation) and the template only moves the components along the permutation it returns. The web engine is 2,437,989 bytes, now 2,199,086 (238,903 less); the same sort and the same order: 300 random cases with ties and unranked entities came out identical to the old one, and the terrain and water example draws the same frame at the same cost. ESTELLA_WASM_NAMES=1 keeps the name section through the optimizer, for a build made to find where the bytes are.
  • A blank mini-game package no longer carries terrain, water and timelines. The mini-game build was shipping 47KB of terrain and 37KB of water code (and its component definitions) in a project that uses neither: the SDK's shared chunks hold every entry's code together, and a bundler cannot drop a top-level defineComponent(...) or new SomePlugin() it cannot tell is pure. The chunks now keep their /* @__PURE__ */ annotations (the minifier that removed them is set to mangle names only; consumers minify again), and terrain, water and timelines mark what only defines something. A blank WeChat package was 3,345,193 bytes and is now 3,234,518 (111KB less, 79.8% of the 4MB main-package cap down to 77.1%); a project that uses terrain, water or a timeline installs them as before. A gate (lean-bundle) fails if a blank package carries them again.
  • A multisampled frame is not written out on a tile-based GPU. The samples of a multisampled target, once resolved and with nothing left to draw on it, the depth of a shadow pass (the map keeps its depth in colour), and the default framebuffer's depth and stencil at the end of a frame are now said not to be needed, which a phone's GPU takes as not writing them to memory. The picture is the same on both backends; it changes nothing measurable on a desktop GPU and is most of a multisampled frame's memory traffic on a phone, which is where it was not measured.
  • A sun's shadow map leaves out the casters that shade nothing the camera sees. A directional light with a fixed reach (shadowExtent) draws one map of its whole reach, so every caster in it was drawn however much of it the camera looked at. A caster's shadow is the segment its bounds sweep along the light's rays down to the lowest thing that can receive it; one whose segment stays outside the camera's view is no longer drawn into the map. The picture is the same (a mean difference under half a level on the Terrain & Water example); its shadow pass is 4.0 to 1.7 ms and 4.7 to 1.4 ms at two of its viewpoints on an RTX 3060, and unchanged where the camera sees the whole island. A cascaded sun (no shadowExtent) already fits its maps to the view and is as it was; a frame with a planar reflection keeps every caster.
  • The sea takes the sun's shadow as one hard edge. The water lit itself with the sun's full soft shadow (a search for blockers and a filter of up to sixty-four taps), which a surface the sun seldom leaves and whose edge the waves hide does not need; a shader can now set g_shadowHard before it lights to read the shadow as the edge a source with no size throws, nine taps, and the water does. The picture is the same to the eye (a mean difference of a quarter of a level on the Terrain & Water example); the water is about 0.5 ms shorter on an RTX 3060.
  • A lit surface no longer works out the light slots nothing shines from. The light block holds sixteen lights and a scene has one or two, but the lighting loop shaded all sixteen: every empty slot paid for its distance, its direction and the whole specular lobe, to add zero. A slot with no intensity returns at once now; the picture is the same to the pixel gates on WebGL2 and WebGPU. A frame of the Terrain & Water example is 4 to 6 ms shorter on an RTX 3060 (the trees' shading alone is more than a third faster).
  • The sky's clouds and the fog's light shafts cost a third of what they did. The cloud layer, the shadow it casts on the ground and the sun's light through the haze are smooth and were worked out for every pixel of the frame; they are worked out at half size now, and each pixel reads them back from the four texels around it, weighted by how near their depth is to its own, so nothing is carried across the edge of a hill or a leaf. The dome, the sun, the moon and the stars, which have an edge, stay full size. The picture is the same to the eye (a mean difference of a third of a level of 255 on the Terrain & Water example); a frame of it is 5 ms shorter on an RTX 3060 (25.6 to 20.1). The sky and the height fog are two passes each in a chain now, sky_clouds and sky_composite, fog_volume and fog_composite.
  • The water surface leaves early where it is not water. A shader that may discard late is not let test depth early, so the water behind a hill ran all of it; the test that decides whether a pixel is water now comes before the waves and the light are worked out. The picture is the same, a frame of the Terrain & Water example about a millisecond shorter or more on an RTX 3060. The WebGL2 shader only.
  • A lit surface takes its shadow in fewer operations. The shadow lookup of a light with a size (the sun's penumbra) worked a sin, a cos and a sqrt for each of its forty-eight taps and a whole matrix for each of the sixteen that look for a blocker; the taps are a table now, turned once a pixel, and the matrix is applied to the light's direction once. Inside a shadow, where every blocker tap hits, it returns at once, and a penumbra a texel or two wide is averaged over 8 or 16 taps, not 32. The picture is the same to the pixel gates on WebGL2 and WebGPU; a frame of the Terrain & Water example is 3 to 10 ms shorter on an RTX 3060.

Fixed

  • A Text spawned in Update is ordered in the frame it appears. The Text render nodes were only made in PreUpdate, so a Text spawned later in the frame reached the order pass with no UIVisual and no order, and was drawn at the base layer, under every panel, for its first frame. A second pass now makes them in PostUpdate, before the order is assigned.
  • Transform stays on top of the inspector. A component can name the sections it ranks first, and a Transform it did not name was pushed below them; Transform now leads whatever order a component gives.
  • A small caster no longer drops out of a wide shadow map. A light's soft shadow first looks for what blocks a point over a disc of 24 texels, with sixteen taps spread over it, none within four texels of the point: a caster narrower than the gaps between them (about a dozen texels) could stand right over the point and be missed, so with a sun whose shadowExtent is large (a texel of 30 units, a bush two of them wide) its shadow was speckled and then gone. The point's own texel and the four a step and a half round it are asked first now. A frame of the Terrain & Water example costs 0.2 to 0.4 ms more where it is lit, and the shadows of its bushes, stones and flowers are there.
  • A material's vertex hook reads its own textures when it casts a shadow. The program a caster is drawn with into a shadow map had its texture samplers left on unit 0, so a hook that reads a texture (the terrain's height pages) read another texture there, and the terrain cast the shadow of heights that were not its own. The samplers are set on the units the material declares them on, as the program it is drawn with in colour has them.

[0.95.0] - 2026-10-25

Added

  • A Planet: ground on a sphere. A Planet component draws ground on a round world: a cube whose six faces are each a quadtree, every point pushed out to the radius, the finest cells under the eye and a handful of coarse nodes from space, so one ground is drawn from the surface and from orbit. It reads a generator the game registers with registerPlanetProvider, which answers for directions from the centre (a sphere has no x and z) with heights and layer weights. It is the first slice of round worlds: the ground is drawn; collision, the layers' textures, the sea, a round sky and gravity toward the centre are not in it yet.

  • A far world is planned sparsely, and a failed asset load is tried again. A layer's farSpacing plans the far versions of its plants that much further apart, so ground cover that keeps a quarter of its plants far off no longer plans all of them first, and the far plants of a planet settle in a quarter of the time. A world whose recipes' assets fail to load while the project is still opening tries again, a few times and a little later each time, instead of staying empty.

  • A quality level sets how far plants keep their detail. A level's profile takes a detailScale (0.25 to 1; Low 0.5, Medium 0.8, High 1): a placed plant changes to its cheaper mesh, stops being drawn and stops casting a shadow at that share of its distances, so the same world draws a fraction of the triangles on a phone. It is a row in Project Settings → Rendering → Quality Levels.

  • Placed plants cast shadows only as far as twice their detailed distance. MeshInstances takes a shadowDistance (metres from the eye past which an instance casts no shadow); a plant kind with a cheaper mesh sets it to twice that mesh's distance, so a tree far off is drawn into the shadow maps no more than its shadow is worth.

  • The editor lets go of a generated world while the game plays. The game runs in a realm of its own that builds its own copy of a generated world; the editor's copy is released for as long as it runs and made again on Stop, so the two are not held together.

  • Plants are instances of one mesh. A generated world's and a PlacedFoliage's plants no longer merge their vertices a cell at a time: a new MeshInstances component places one resident mesh at many places (sixty-four bytes a plant), and the engine culls each plant against the view, takes a cheaper mesh past a distance and draws none past another, as one instanced draw that cells sharing a mesh and a material merge into. The geometry exists once however many plants there are, so a planet's plants take a tenth of the memory and a fraction of the draws, and a cell is grown in microseconds instead of a few milliseconds.

  • A project can keep folders out of its asset database. assetExclude in the project manifest names folders (a source-art repository, docs, a server) the asset scan does not index, does not write a .meta into and the editor does not watch.

  • Small plants need not cast a shadow. A plant part takes castShadows: false, so ground cover too small to be worth a shadow-map draw is left out of the shadow pass.

  • A project plugin that needs trust says so. Opening a project whose editor plugin has not been trusted shows a notice with a way to review it, instead of leaving its missing pieces (a ground that is not drawn) unexplained.

  • A game's generated ground shows in the editor. An editor plugin may now import the engine subpaths the editor is built on (esengine/terrain, esengine/worldgen, esengine/water, esengine/spline, esengine/tilemap, esengine/replication), as the editor's own instances, so a project plugin can register the terrain provider its game registers and the viewport draws the ground the game will. New projects' .gitignore leaves .esengine/plugins/ and .esengine/platforms/ versioned, as the plugin page always said, and ignores the typings and the session.

  • A lookup table is adopted as data. A PNG shaped like a colour lookup table (N slices of N by N: 1024 by 32, 256 by 16, 4096 by 64) is given no compression, no mips, no sRGB decode and clamped edges when it is added to a project, where it used to take the picture defaults and answer wrongly until someone found why.

  • An Outdoor Environment to create. Create → Rendering → Outdoor Environment makes a sun, a sky light, a clock, a weather and a global volume with the sky (clouds that cast shadows), the haze (beams in their gaps) and a plain grade, already pointing at one another. It is the arrangement the Terrain & Water example uses, for the engine's scale of a hundred units to the metre.

  • An Online 3D starter. A template for a networked 3D game: a lit ground, a pawn per player predicted on its owner's screen and replicated to the others, a camera that follows your own, and a server/ that runs the same project headless. The rules both ends agree on are one module, src/shared/rules.ts. tools/check-arena-server.mjs now takes --project, and runs against this template too.

  • Start a project from the command line. estella create <template> <dir> [--name] makes a project from any starter or example, and estella templates lists them. The editor's New project gallery and the command line now share one implementation (pipeline/src/project/scaffold.ts), so both copy the same files and write the same package.json and .gitignore.

  • Clouds drawn from a coverage picture. skyAtmosphere takes a Cloud Mask (u_cloudMask, with u_cloudMaskTile in kilometres of the cloud layer) and a second, higher one (u_cloudMask2): the clouds stand where the mask says and the noise only erodes them. The shadow the clouds cast and the beams of heightFog's cloudShade read the same masks, which the fog takes from the sky. Terrain & Water uses the two the art made.

  • A Display LUT. The displayLut effect reads a look off a 1024x32 lookup table by the picture as the display will show it, in the last pass, after the output transform and the transfer function: the place a look authored against the finished image belongs, and one no effect in the chain can be, since they run on scene values before the curve. It is a variant of the pass that was running, one texture read and no pass of its own, and PostProcessStack.setDisplayLut(texture, amount) is the same thing in code. The last pass now reads its parameters off the reflected layout as a material does, and the copies it makes share them.

  • Light beams that follow the clouds. heightFog has a cloudShade: its volumetric light marches the sun's ray up through the cloud layer of a skyAtmosphere whose clouds cast shadows (the same density the sky draws, fixed to the world and drifting with its wind), so a gap in the clouds is a beam in the air and what they cover is dark, whichever way the camera looks. volumeRange may now be as long as a million units, for beams through clouds kilometres up. The sky's clouds are copied onto the fog each frame, and an effect's uniform may be internal, which an inspector does not list.

  • Sparkle on the water. The Water shader reads two tiled normal maps that scroll over the surface (u_detailMap, u_detailTile0/1, u_detailStrength0/1, u_detailFlow0/1), packed into the one texture a material has room for, so the sun's glints on small slopes come from lit specular response and not a white texture; a material that sets no strength is unchanged.

  • A generated world's plants. A recipe's members can name a plant in the rules' plants (a .esworld file holds them): several parts (a trunk and its crown), a cheaper mesh and a far version, the colourings the art gives it, how far it is sunk and its unit (100 for metres in a world of centimetres). The world is laid out from the rules as the eye moves, the plants grown a cell at a time by the machinery a PlacedFoliage uses: a chunk stands at once and fills in over the frames after it inside the frame's budget, a cheaper mesh stands in at the middle distance, and a tree's crossed cards, laid out as a layer of their own, stand for it far off (a part's soft turns the normals of such a card toward up, so a crown's card is lit as a rounded crown and not a dark slab on the side away from the sun). A plant with no cards of its own may use its cheaper mesh as its far version and set farKeep, the share of its plants that version draws, so ground cover far off costs a share of what it does near; a member with attach: 'align' leans a plant with the ground, so a stone on a slope sits as the slope lies; the far versions are laid out in cells as wide as the shortest distance they are shown over allows, which took the Terrain & Water example's draws from about 1,800 to about 1,100. The terrain's paint is a field each of its layers (paint.grass), a rules file names noise fields of its own, and fields are worked out only where a condition reads them. The Terrain & Water example's woods, shrubs, stones, grass, flowers and reeds are laid out this way from assets/worlds/plants.esworld.

  • Each terrain layer says how it meets the others. A .esterrainlayer may name a heightBlend: 0 blends by the paint alone (grass into sand), 1 by the layers' heights (stones standing through grass), weighted by how much of each layer is there; absent, it is the material's u_heightBlend. The editor's layer panel sets it.

  • Placed plants. PlacedFoliage keeps every plant an artist placed by hand as data in one entity, a table of kinds and six numbers a plant, instead of an entity, a renderer and a draw each. The engine cuts the area into cells and grows only those round the eye, each as one mesh for every part of every kind in it, a few milliseconds a piece of the frame's budget so a cell fills in over the frames after it appears, and lets them go past their distance. A kind keeps the mesh as made (normal map, second uv, vertex colour), has a cheaper mesh for the middle distance and a far version, a tree's crossed cards, drawn out to a far distance: a hierarchical level of detail that makes the whole area stand at once. The Terrain & Water example now grows its woods, shrubs, stones, grass, flowers and reeds this way from the lakewood plant set, and its grass and sand are that set's terrain layers.

  • Water zones. Oceans, lakes and rivers are now drawn as one surface. A WaterBody says what water is where (its form, outline or Spline, shore width, current and how high its waves stand), and a new WaterZone bakes every body over its region into one field: the surface's height, the distance to the shore, the waves' height, the current and the depth over the terrain. One mesh of rings that follows the camera reads it, so a river runs into a lake or the sea at one height with its banks running on into the shore, its current fades into the still water, and no shore foams across its mouth; a lake or a river over the sea is the lake's, not the sea's, and the sea's waves calm and foam where it shallows over the terrain. The zone holds what the bodies share: the material, the waves' length, speed and heading, the mesh's detail and the ripples. A scene without one gets a zone over its lakes and rivers, and the ocean goes on past it. Waters.sample reads the same field, so what floats or looks out from under the water meets the surface that is drawn. In the editor the zone's region is outlined in the viewport.

  • Wind and rain on the water. The weather drives the wind: each preset has a wind and a wave strength (mist calms, a storm raises the waves to over twice their height), the Water Body's waves and the foliage's sway follow it in play, and a Weather that does not drive the wind (WeatherDrive.Wind) leaves them as authored. Rain falls on water that keeps ripples as rings, as hard as the weather rains, and the rain effect no longer lays a wet floor or puddles over the water itself.

  • Surf on the shore. Waves run in toward every shore of a water zone, stand up as the water shoals, break white and run up the ground past the waterline before falling back. WaterZone.surf sets how high a breaker stands against its body's waves and surfLength the length of the surf's waves; a current carries none, and Waters.sample rides the same surf. The zone now measures the distance to the shore across the ground for every body, an ocean over a beach included, where an ocean used to measure its depth.

  • Terrain without cracks, and without end. The ground is now a CDLOD quadtree round the eye: every node is the same small patch drawn as instances of one mesh, its heights and normals read on the GPU from pages of a height atlas, and its vertices slide onto the coarser grid toward the end of their level's range, so levels meet without cracks or skirts and nothing pops as the camera moves. Terrain.extent Infinite makes ground that goes on for ever from seeded noise read anywhere (worn by the noise's own erosion), drawn out to drawDistance; cellSize is the finest cell near the eye. Pages are made a few a frame, coarse and near first, and shown as progress.

  • Terrain from a generator the game names, versioned. Infinite ground is now made by a terrain provider: a function of the world position that samples whole regions (heights, and paint if it has its own), the same on every machine, and that may answer later from a worker or a server. Terrain.provider, world and generatorVersion name it; registerTerrainProvider adds a game's own, and the engine's noise is estella:noise version 1. A terrain whose provider is missing, whose version its provider no longer has, or whose heightmap cannot be read fails with a reason in Terrains.status and answers nothing, instead of growing noise in its place.

  • Terrain collision, the same ground that is drawn. 3D bodies and characters now collide with a Terrain: it is built in tiles round everything that moves on it (collision, collisionDistance, collisionLayer, friction), the tile under a body at once, and kept through a rebuild until the new ground replaces it. What is collided with, what Terrains.heightAt and normalAt answer and the finest level drawn near the eye are now one set of triangles, so a ray, a query and the picture agree wherever the camera is; Terrains.collisionReadyAt says when the ground under a point is ready. Any system that makes static geometry while the game runs can hand it to the 3D world through the new CollisionGeometry resource.

  • Procedural chunks, with one owner and one budget. What a game makes as it runs is now chunks of layers in ProceduralChunks (chunksOf(app)): each layer says how it is cut, how far round the streaming sources it is wanted and how a chunk is made, published and released, and the chunks are made nearest first within the frame's budget (the one Bakes.budgetMs, shared with the bakes and the terrain's pages), released with everything they published past the unload radius, and made again when the layer's generation changes, the old version staying until the new one replaces it; an answer for an older generation is thrown away. status and stateAt say where they stand. Terrain collision and foliage cells are layers: plants now grow round the eye out to drawDistance and are let go past it, and a changed field or ground regrows them without blinking out.

  • Generated worlds. The new esengine/worldgen lays a world out by a game's rules as it is explored: biomes weighed from fields (the terrain's height and slope, the water's depth, seeded moisture, temperature and rock, and a game's own), mixed at their edges and painting the terrain; recipes an artist composes (an anchor and members round it, with footprint apart from canopy) placed in layers, big things first, each keeping clear of what was placed before it; and WorldZones (a home, a road, a building) that keep out what they name and hold a biome, fading at their edge. The same seed lays out the same world in whatever order its chunks are made, every placement has an id that outlives rules added later, interactive ones are entities with a PlacedObject, and what players change (diffs().remove(id)) is kept apart and laid over before anything is shown. plan().explain(x, z) says why anything stands or does not. A new example, Generated World, walks through one.

  • Which water a place is. The sea fills only low ground joined to the open sea past the water zone's edge: a hollow below its level walled off by higher ground stays dry (or holds a lake of its own). A lake or a river is water only where its surface is over its ground, so a hill inside its outline is land, for what is drawn and what Waters.sample answers, whatever order the bodies were added in. WaterBody.bodyId names a body the same in every session; Waters.sample carries it and Waters.bodyAt(x, z) says which body a place belongs to. findBasins gives a game the ground's basins (each filled to the lowest point of its rim, with its outlet), the drainage down to the edge and the sea's reach, for deciding where its lakes and rivers go; drainPath follows the water from a point.

  • An area without a heightmap is a window on its provider's ground. Its noise is read from Terrain.provider where the area stands in the world, over the provider's height range, instead of being made in the area's own space and stretched to fill it: two areas of the same size side by side join, an area is the same ground its provider gives without end, and a game's own provider can make an area. Ground read from a provider is read again when its terrain is moved, so it stays the world's ground.

  • Rays against the terrain, anywhere. Terrains.raycast(origin, direction, maxDistance) meets the ground's triangles exactly (the ones collision and heightAt use) wherever the ray goes, with no physics world and no collision tile there, for a line of sight, a pick or a landing spot.

  • Far versions for generated decoration. A recipe member can name its far version (far: crossed cards, or a tent for a conifer, showing a rectangle of its texture), drawn past its layer's lodDistance, and decoration that leans with the ground (attach: 'align') now leans in its merged mesh too.

  • Terrain modifiers, and zones that level their ground. Terrains.setModifier lays a change over the ground (flattenModifier levels a circle or a turned box, blending back over its edge) that what is drawn, the queries, rays and collision all follow, remaking only the pages and collision tiles it reaches; heightBeneathAt reads the ground as it was made. A WorldZone with flatten levels its plot to the ground's height at its centre.

  • Terrain layers: up to eight kinds of ground, each with its normal and mask maps. A terrain layer (.esterrainlayer, with an editor of its own) names the albedo, normal and mask (occlusion, roughness, height) an artist made for one kind of ground, and how it is laid; a Terrain lists up to eight (layers), weighed by its splatmap and a second one (splatmap2). They are drawn by the new Terrain Layers shader from texture arrays: where layers meet the higher one shows, near the eye they are read without repeat, on slopes they are projected from the sides, and their normals, occlusion and roughness light the ground. Biomes can paint all eight. The four-layer Terrain shader is unchanged for materials that use it.

  • Foam is where waves burst, not along every shore. The zone bakes how steep each shore is: against rock and cliffs the shore foams and the breakers burst white; up a gentle beach the waves wash in a thin line only and run up a short way rather than spreading a white sheet over the sand; and the less room the wind has to raise them (a sheltered lake), the less of either.

  • Surf comes in from open water as lines. Its crests followed every turn of the shore, bending into a river's mouth from far out; they now follow a distance of their own, the open water's edge with a river's water taken for land, smoothed over the surf's length, so they come in straight and turn to the shore only as they near it. Where the surf rises, breaks and runs up is still the real shore's, and a river's current calms it over a spread past the mouth rather than cutting it off at the river's side.

  • A river gives way where it runs into the sea or a lake. Over half its width past their shore it fades into them, its current with it, where it used to stop within a texel and a half and leave its sides running on into the open water: the surf, which no current carries, broke off along those lines. The surf now runs on along the coast and round into the mouth.

  • Water meets the shore along a smooth line. Close up, a river's banks and the surf on a beach ran in steps a texel of the water zone wide: the baked shore distance is now stored finely near the shore (a signed square root of it), and past the shore the surf's film and the shallows' foam are told dry from wet by the picture's depth at each pixel rather than by the baked depth, which only knew whole texels.

  • The distance to the shore is a distance. Near the water's edge the baked shore distance was the water's depth (or, on land, the height above the water), so Waters.shoreAt, a generated world's shoreDistance and the surf's reach mixed heights with distances; the depth is now turned into the distance across the ground by the ground's slope there. Waves still calm as the water shallows.

  • Heightmaps say how they hold their heights. Terrain.heightmapFormat is Grey (the grey or red channel at the file's depth, so a 16-bit grey PNG, what terrain tools export, is read at full precision) or Red + green (sixteen bits across two 8-bit channels); the format is no longer guessed from the pixels. A heightmap that cannot be read as data says it must ship as the PNG it is. Upgrading: a terrain whose heightmap packs sixteen bits into red and green sets heightmapFormat to Red + green.

  • Rivers cut their beds. A river's WaterBody.bedDepth cuts its bed into the terrain, a trough under its surface with banks that blend back into the ground, laid as terrain modifiers along it so what is drawn, the queries and collision follow, and editing the spline remakes only the ground along the river.

  • Whether a place can be walked to. Terrains.findPath(from, to, { maxSlope, step, blocked }) searches the ground for a way a walker held to a slope can take, reading the ground where it goes (modifiers too, nothing baked), and returns it pulled straight with its length, or says whether there is no way, the search ran out, or an end stands on no ground: what a game checks a spawn or a goal against.

  • World rules as a file, with an editor. A WorldGen's rules can name a .esworld file: the biomes, recipes and layers as data, checked as they are read (a missing recipe or layer fails the world with where it went wrong), followed by the cook like a material so the meshes and materials it names ship with the scene, and watched so a saved edit lays the world out again. The editor opens it in a World Rules editor that lists the biomes, recipes and layers, edits each with a form, and says whether the engine would take the rules as they stand.

  • How far a place is from the water. Waters.shoreAt(x, z) gives the distance across the ground to the water's edge (above zero on dry land, below on the water), and generated worlds read it as the shoreDistance field, so a beach or a band of reeds can follow the shore.

  • A vertex hook can hand the fragment a colour. What a material's vertex hook leaves in es_vertexColor is now the colour its fragment receives (times the instance's tint), on both backends.

  • Bakes run over frames, with progress. Work that used to hold a frame until it was done (a terrain worn by rain, a water zone baked, terrain chunks built, plants grown) is now spread over frames within a budget, and listed with its progress in the new Bakes resource (bakesOf(app).active). The editor's status bar shows it as a bar, for the edit world and for the game running in Play, and a game can show it on a loading screen. Plants wait for the ground and the water they stand on instead of being grown twice.

  • Eroded and warped terrain. Terrain.erosion wears the ground with rain (a heightmap's as well as the noise's): gullies down the slopes, sharper ridges, silt in the valleys, and dirt painted where the water ran; the same seed wears the same ground. Terrain.warp bends the noise by noise of its own for winding valleys and bent ridges. erodeHeightfield and erosionJob do the same for a tool.

  • Terrain layers without repeat, and with natural edges. Each layer is read with hex tiling near the eye (every hexagonal cell takes it shifted and turned at random, the three about a point blended by distance and brightness), so no tile is seen; from the middle distance on it also mixes in itself on a tile u_farScale times as wide; and each layer's weight wanders by noise of its own (u_blendNoise), so where grass meets sand the line is ragged instead of the paint's gradient. u_antiTile now sets the hex tiling's strength.

  • A richer Terrain shader. Layers meet by their relief (u_heightBlend), each is read twice and blended by slow noise so no repeat is seen (u_antiTile), every layer gets the broad variation, their brightness is drawn into the light as relief (u_relief), and ground below u_wetLevel + u_wetBand darkens and shines at the waterline.

  • Water mirrors the world. Seen from above the surface now reflects what is on screen (hills, trees, the far shore) along its reflected ray, not only the sky, fading at the picture's edge; the quality level's mirror switch covers it.

  • Soft water edges. Where the water thins out at a shore the ground behind shows through more and more over the last u_edgeSoftness of depth, so the water meets it along a soft line instead of the zone's texel steps, and the shore's foam is broken up rather than drawn as an outline.

  • Plants keep out of the water. A Foliage area grows nothing under water unless waterDepth lets it stand that deep (reeds in the shallows), and is grown again when the water changes. Grass thins out blade by blade toward the distance its cells turn to their far version, so a near cell beside a far one is no longer three times as thick.

  • Hair with Blender's highlight. The Hair shader takes the Principled shader's highlight when u_anisotropy is above zero: GGX stretched along the strand as Blender stretches it, with u_specular as the specular factor. A hair card imported with an anisotropy (KHR_materials_anisotropy, which Blender exports from its Principled anisotropy) is set to it, so the broad sheen across a fringe that Blender draws is drawn in the same place.

  • Hair shadows and diffuse. A hair material draws the sun's shadow of hair as hair. The Hair shader gains u_hairShadow, how much light a layer of strands takes per world unit along it (declared with the new #pragma hairshadow), and while it is above zero the frame adds a cascade fitted to the hair alone as the first in the sun's list: cards a few millimetres apart fell inside one texel of a cascade spread over the view, so the layers could not shadow each other, and the face under a fringe is now shadowed at the hair's resolution too. The light left after a depth of hair falls off with that depth, from the nearest card to this one, as a deep shadow map reads it, with a card's own surface left out so it does not shadow itself. A hair material imported from a glTF is set to a density of 400. The Hair shader has u_strandDiffuse, how much of the diffuse is the strand's own Kajiya-Kay term against a surface's N dot L, and a hair material imported from a glTF sets it to 0. At the old 0.6 a card turned edge-on to the light still took a third of it, so every lock was lit to one tone and the gaps between locks never went dark; with the Principled shader's diffuse they do. With the lamp highlight at a tenth and the tinted second lobe at half what they were, the top of the hair comes out within about six percent of Blender's render of the same frame on both backends, where it was half again as bright.

  • Hair drawn as locks. The Hair shader can draw a card's strands as locks: u_clumpCount sets how many across its width, u_clumpTone how much lighter or darker one is than the next, u_clumpShift how far each lock's highlight is pushed along the strand so it breaks from lock to lock, and u_clumpGap how dark the seam between locks is; 0 leaves the card as authored. A hair material imported from a glTF is set to seven locks, so cards cut from one strand texture no longer read as a combed plate. Against Blender's render of the same frame the top of the hair comes out within about ten percent in every channel, where it was half again as bright.

  • Hair that reads as hair. The Hair shader has a lobe gain, u_lobeGain, for how much of the strand highlight a lamp draws apart from the reflection of the environment, and an imported hair material now sets it with the rest from what the source states: the specular factor as the environment's Fresnel, the roughness factor, a quarter of the lamp highlight, and a third of the shader's own strand shift and second highlight so the cards read as locks of hair and not plates. Against Blender's render of the same frame the hair comes out with a sheen on each lock and dark gaps between them, where it was a flat red plate.

  • Character materials shade like the source. A model imported with Character Materials now shades like the Principled shader it was authored against: a glTF carries no subsurface scattering and no second strand highlight, so the Skin shader's scattering, wrap and fuzz and the Hair shader's second highlight, translucency and root darkening are written as off, and a hair material's specular factor is scaled to the strand highlight's own units. Measured against Blender's render of the same frame, a character's hair comes out about 15 percent brighter than the reference where it was two to three times too bright, and the skin no longer glows in the shadows.

  • AgX view transform. A new post-process effect, agx, applies the AgX view transform Blender renders with, taken from the data Blender ships: scene-linear colour goes in and display-linear comes out, so put it last and leave the project's output transform at none. Its contrast setting is the look (1 is AgX Base, 1.2 is Medium High Contrast), it carries its own table, and against Blender's own render of the same frame the colours of a character come out within about two percent.

  • Hair maps from the model. A hair material's strand-direction map, highlight-shift map and tip softness are now imported from the model: a glTF has no slot for them, so a material names them in its extras (flow_map, shift_map, suggested_tipSoftness) and the importer binds them to the Hair shader instead of leaving the highlight to be worked out from the surface.

  • Spring-bone data in the file. The Spring Bones import setting now reads what a model states before it looks at names: the VRM spring-bone extension (VRMC_springBone, with its stiffness and gravity converted to units the engine uses) and a node's own extras.estella.springBone and springCollider properties, which carry exact sizes from a Blender custom property. Names fill in whatever those leave out, a chain with no collider list is kept out of every collider in the model, and springs that cannot be used are reported in the import warnings.

  • Spring-bone collider handles. A selected spring-bone collider carries six square handles in the viewport: on a sphere any of them sets the radius, on a capsule the four round its middle set the radius and the two on its ends set the height. The ones on the far side of the shape are faded, the value shows beside the pointer while one is dragged, a drag is one undo step, and with Preview FX on the strands follow it live.

  • Spring-bone import. A model's new Spring Bones import setting (By Bone Name) builds hair motion from names the file already carries: a bone called Hair__00 becomes a SpringBone with the bones below it as the strand, and an empty called SBC_Spherer or SBC_Capsule_r_h becomes a collider every chain is kept out of. The region sets a starting stiffness and drag, sizes follow the model's metres and the import scale, and the result is ordinary components to adjust in Details.

  • Spring-bone wind. A spring-bone chain takes a wind: wind is a steady acceleration on the chain, windGust swings its strength from calm to twice as strong, and windFrequency sets how often. Each bone meets a gust a moment after the one above, so a strand ripples rather than swaying as one, and a chain's gusts depend only on its own clock, so the same scene moves the same way twice. The wind is a field on each chain; there is no scene-wide wind source yet.

  • Spring-bone authoring. Spring bones can be authored in the editor: Details groups a chain's fields into Motion, Chain and Collision and counts the bones below it (or warns that there are none), the viewport draws a selected chain (the bones as posed, a ring at each joint, the tips) with the colliders it keeps out of, or a selected collider on its own, behind a Spring bones entry in the Gizmo menu, and View · Preview FX simulates the chain in the edit viewport, drawn solid over its dashed pose. Ending the preview gives the bones back as the scene has them.

  • Spring bones. Spring bones give a skeleton secondary motion: a SpringBone on the root of a chain of bones (hair, a tail, a cord) makes everything below it a spring that lags the animation, falls with gravity, is pulled back to its animated pose, never stretches, and is kept out of SpringBoneCollider spheres and capsules. It runs in C++ in the engine, so it costs the same on every target: 300 chains of six bones step in 0.28 ms. Only the bones' rotations are written, and switching it off gives the animation's own back.

  • Water rows in the quality settings. Project Settings → Rendering has a Level · Water group for the five water quality fields (waves, ripple cells, displacement, mirror, caustics) of the level chosen under Editing level. Each is saved as a difference to that level only, and the group is hidden while quality is off or the project excludes the water module.

  • Built-in shaders ship with their modules. The Water, Terrain, Foliage, Hair, Skin and Eye built-in shaders now ship with their modules instead of the core: a package that installs none of them no longer carries about 80 KB of shader source (a blank web package is 80 KB smaller, a blank WeChat bundle 7% smaller). A material that names one of them is what brings its module into an export, with no component in a scene needed; the three character shaders are a new esengine/character-shaders module.

  • Opaque models no longer vanish beside glass. Opaque draws are told from blended ones by the stage they are sorted in, not by their blend mode, when a frame has both a refracting surface and blended draws; before, a lit material whose blend mode was not None (the Model material) was treated as blended and could vanish from such a frame.

  • Water quality levels and a lite water. Water spends what the quality level allows. Each level's profile has waterWaves (waves summed, 2 / 3 / 4), waterRippleCells (the ripple grid's side, 32 / 64 / 128), waterDisplacement (off is the lite water: flat geometry with the waves in the shading only), waterMirror and waterCaustics. What Waters.sample answers follows what is drawn, and a minigame with no quality policy gets the Low level's water.

  • Move gizmo plane handles closer in. The three plane handles of the move gizmo sit closer to its centre, on the inside corner between each pair of axes, instead of out at a third of the way along them.

  • Water editing in the viewport. Select a lake or a river and its points are handles in the viewport: drag a point to move it on the body's own plane, drag the circle on an edge to insert one, press and release a point to delete it (a lake keeps three, a river two), and drag the handle beside a river's point to set its width there. Each gesture is one undo step. Details shows a water body only the fields its form uses, with a Boundary row for a lake's outline and the point count and the pressed point's width under a Spline. Also: the move gizmo now travels with the entity while an axis is dragged, instead of staying where the grab began.

  • Blended surfaces ordered against water. A blended surface (a pane, a particle, a leaf card) is now ordered against water and glass by the pixel and not by when it was drawn: one under the surface is seen through the water, one in front of it lies on the water instead of being covered, and where there is no water it is blended once. The frame is drawn in layers only when it holds both a refracting surface and a blended draw.

  • Ripples and wakes. A body of water keeps what disturbs it. With ripples above 0 the water steps a window of its surface (that follows the camera) with the wave equation: Waters.disturb(x, y, z, radius, strength) and a Floating body's wake (wake) put in bumps that spread as rings, fade, and bend the shading and the reflection, and leave foam that lingers and thins (rippleSpeed, rippleDamping, foamFade). Waters.sample carries the ripples, and Waters.rippleAt gives them alone.

  • Waterline, caustics, shafts and a mirror under the water. Under water the picture is lit and bounded like water. A camera with its lens half in the water has a waterline across it, soft and sliding as it dips; what it sees is lit by the web of caustics the waves focus the sun into (the Water material's u_causticStrength, u_causticScale and u_causticSpeed, also drawn on what lies under the water seen from above); the water along each ray scatters the sun into shafts (u_shaftStrength); and the surface seen from below, past the critical angle, mirrors the world beneath it.

  • Underwater view. A camera under water sees through it. Whenever the active camera is below a water body's surface an Underwater effect is added to the post-process volumes: the light of each pixel is taken out colour by colour (red first) by the distance it crossed, with the same absorption and density the surface's material draws with, and the water gives back its own colour, dimmer the deeper the camera is. The surface seen from below turns over and, past the critical angle, reflects whole (Snell's window).

  • Floating bodies. Water holds things up. A Floating component on an entity with a RigidBody3D floats it: a buoyant force against gravity (buoyancy is the water's density against the body's, so 2 floats it half under) and a drag against its velocity relative to the water, which brings it to rest in a lake and carries it with a river's current, applied at a few points of the body so waves tip it. It works from the CPU's own water surface, so it needs no renderer, and it needs the 3D physics module, which gains force and mass queries.

  • Rivers and splines. A WaterBody can be a river: put a Spline on its entity and it lays a ribbon along the curve, as wide as the curve says at each point and at its height, with a current (flowSpeed, faster where it narrows) that the shader carries the waves and ripples along and that Waters.sample reports as flow. Splines are a new optional module (esengine/spline): a curve through points with a width each, measured by the distance along it.

  • Lake outlines and shores. A lake can have an outline of its own and knows its shore. boundary cuts it to a polygon on its plane (crisp at the pixel, not at the grid's cells), shoreWidth calms its waves toward the edge and where it is shallow over a Terrain, and the shore foams along the outline. Waters.sample answers with the same calmed waves and says a point in the notch of a concave lake is not inside.

  • Water bodies. Water gets a component and a chapter of its own. A WaterBody builds an ocean (without an edge, following the camera, in rings that coarsen with distance) or a rectangular lake, lifts its geometry with the waves, follows its own up when it is tilted, and answers for its surface from code (Waters.sample) with the same formula the shader draws. Water is an optional module (esengine/water): a 2D game carries none of it.

  • Cyber Rooftop update. Cyber Rooftop gets a rebuilt rooftop model and textures, a wet roof material with a planar reflection under a rain sky, rain, fog and bloom in the scene, a larger set of HUD icons and inventory art, and a wider build footprint.

  • Hair tips. The Hair shader can draw the soft outer band of its cards: u_tipSoftness is how far below the cutoff alpha a second, blended pass draws each strand's tip fading out, sorted with the other blended draws, so tips are not stair-stepped by coverage. A model imported with Character Materials also has its hair triangles put in the order that pass wants, the cards nearest the middle of the hair first. Off by default.

  • Character materials on import. Importing a model can now give its character materials the right shader: turn on Character Materials in the model's import settings and a material whose name says skin, face, head, hair or eye gets the Skin, Hair or Eye shader with its normal and occlusion/roughness maps bound, and hair is cut out by its alpha and feathered by coverage. Off by default.

  • Curvature-shaped skin scattering. The Skin shader can take its wrap past the terminator per colour and shape it by curvature: u_preIntegrate (red travels furthest, every colour further where the surface turns sharply) and u_curvature, so a nose or an ear glows at its edge while a flat cheek stays crisp. Off by default.

  • Skin detail normal layer. The Skin shader has a detail normal layer: u_detailMap is a fine normal map tiled over the surface (u_detailTile) for pores and creases, laid on the sharp normal the shine reads by u_detailStrength (0 leaves it out) and not on the soft diffuse normals.

  • Cutout shadows for hair cards and leaves. A material whose alpha is coverage (u_alphaCutoff above 0, now also on the Hair shader) casts its cut-out shape into shadow maps instead of the rectangle it is drawn on, and Hair cards feather their edges with alpha-to-coverage.

  • Eye lid shadow. The Eye shader shades the eye the lids sit on: u_lidMap is an authored occlusion map, and u_lidShadow darkens, and fades the cornea's reflections, where the surface faces up from u_lidStart, which is the upper lid on an upright head.

  • Eye shader. A new Eye shader (builtin:eye) draws an eye from a mask and a dome normal map: the iris sits behind a refracting cornea so it moves as the eye turns, with a pupil, fibres and a limbal ring, a white lit with wrapped light, and a near-mirror cornea that shows every light as a catchlight.

Changed

  • Terrain is cut by its cell size. Its chunks, chunkCells and lodLevels are gone: the quadtree's levels follow from cellSize and the area (or drawDistance), and detail sets how far the finest cells reach.
  • WaterBody keeps only what a body says. Its material, cellSize, cells, rings, waveLength, waveSpeed, waveDirection and ripple fields have moved to the new WaterZone, which every body shares; shoreWidth now calms the waves toward the shore of an ocean and a river as well as a lake. A body of water is no longer tilted with its entity: it is turned about up only. ShoreField, buildRectMesh, buildBoxMesh and buildRiverMesh are gone from esengine/water.
  • A lite engine for mini-games. A WeChat or Douyin package whose scenes and scripts use no particle emitter, post-process volume or tilemap now ships a lite engine, the same engine without those three subsystems and about 200 KB smaller, so a UI-only game has room under the 4 MB main-package limit. It is chosen from the same evidence as the lean SDK entry plus a scan of the project's scripts; any mention of one of the three carries the full engine. Build it with node build-tools/cli.js build -t wechat-lite (-t all includes it).
  • Post-process effects are optional groups. The post-process effects' shaders are now three optional groups, esengine/fx-basic, esengine/fx-atmosphere and esengine/fx-lighting: a package carries a group when a PostProcessVolume names one of its effects (or a Weather or TimeOfDay component is in the content), and a game with no volumes ships none of them (about 180 KB less in a UI-only mini-game). An effect a script adds by code needs its group imported (esengine/fx-basic and the others) or the module set to Include; the editor and a non-lean entry carry all three.
  • Timelines are an optional module. Timelines are now an optional module, esengine/timeline: a package carries the timeline runtime and its loader when a scene has a TimelinePlayer, the content has an .estimeline, or a script imports the subpath, and a game with none of them ships neither. The API is unchanged and still reachable from esengine.
  • Terrain and Foliage are optional modules. Terrain and Foliage are now optional modules, esengine/terrain and esengine/foliage: a package carries them when a scene has a Terrain or Foliage component or a script imports the subpath, and a game with neither ships none of them (about 33 KB less in a UI-only mini-game). The API is unchanged and still reachable from esengine; the export installs the module for a scene that uses either component.

Fixed

  • The editor's own eye shows the scene's post-processing. The sky, haze, exposure, anti-aliasing and the rest a scene's PostProcessVolume says were bound to the scene's camera entities only, and the editor viewport is not one, so a scene whose sky is skyAtmosphere showed a black sky while authoring and a blue one in the game. The editor's eye now resolves the scene's volumes at its own position and shows them, and lets them go when the game's camera is the one looking.
  • Resizing a viewport no longer piles up render targets. A viewport dragged or docked through many sizes borrowed a full set of targets (the scene, its depth, the post chain) at each size and left each idle for two seconds before freeing it, which grew the GPU process to ten gigabytes in a few seconds and lost the graphics context. Targets nobody borrows are now kept within a budget of 256 MB, the longest idle first.
  • Many placed objects no longer crash the renderer. The texture that holds every object's record in a frame grew by doubling but was created from storage sized to the frame's need, so a frame with many objects read past its end and the engine aborted with memory access out of bounds; stopping then reported one warning for every entity. The texture is created from storage as tall as itself, and an aborted engine is reported once.
  • A cloud's shadow stays where the cloud is. The shadow a sky's clouds cast on the scene added the camera's position to the cloud's, so it slid across the ground as the camera moved while the cloud in the sky stood still; it is taken from the same place the sky draws the cloud from.
  • A leaf or a blade of grass no longer has a pale edge. A cutout texture (one with a Mip Coverage) has the colour of its solid texels carried into its clear ones when it is cooked, as a model's cutouts already did: what an artist leaves under alpha 0, often white, was averaged in at every leaf's edge by the filter and the mips. The source image is not touched.
  • A world's layers over an area are counted over the area. The chunks of a procedural layer are walked over the part of the wanted radius that lies in the layer's extent, not over the whole radius, and a generated world on an area of terrain takes the terrain's bounds as its extent: a layer wanted a thousand chunk-widths out no longer costs seconds a frame.
  • A level-of-detail group with only a cull size is no longer ignored. A LODGroup with no stand-in mesh and a cullSize draws the renderer's own mesh while it is big enough and nothing once it is smaller, where it used to be dropped as if it were not there, so a tuft of grass had no distance to be drawn to.
  • A river runs into a lake cleanly, and water casts no shadow. A river whose spline ran on into a lake drew a bright seam across the lake's bed: the surface was drawn into the sun's shadow map, darkening everything under it but where the river's heights changed its shape. Water no longer stands in the light's way (MeshRenderer.castShadows, new and on by default, says whether a mesh does), a lake now holds the water over a river that runs into it, and the surf's slope fades out on the ridge between two shores instead of flipping on a line.
  • Rain and storms on water. Rain no longer drops dips into the zone's ripples (which twitched and left blotches of foam under a storm): drops ring out on the surface in the Water shader, as fine rings that spread and die, the more the harder it rains, with no foam. The wind's ripples are six short waves around its heading instead of drifting noise, so a lake no longer shows cells of light and dark. A weather raises waves as far as the water is open to the wind (the sea whole, a lake by its width, a river hardly at all), and surf is swell from open water, so a lake's shore laps in a storm instead of breaking like the sea's; what floats rides the same water.
  • Shadows follow what the camera draws. A mesh the camera's level of detail culls (grass past its draw distance) no longer casts a shadow, and one drawn coarse casts coarse; seen from high up, a field of grass no longer laid an unseen square of shadow on the ground. The terrain's vertices slide between levels by the eye the ground was chosen for in every pass, so a shadow's ground is the ground that is seen, under an orthographic camera too.
  • Ridged ground without end has no steps. Infinite noise ground that was both ridged and worn broke into terraces with sheer walls where a ridge's fold turned; the crest is now rounded over a few hundredths, so the ground is continuous.
  • The running game's resolution can be chosen. A picker beside Play shows the target screen and stays usable while the game runs (it used to sit in a menu that was disabled in Play), with Free Aspect, the project's design resolution, the device presets and portrait or landscape; the choice is kept per project. (#100)
  • Terrain skirts and surf films no longer show as streaks. The skirt under a terrain chunk's edge, seen where two levels of detail part, took the relief bump meant for the ground and lit as a bright line; it now draws without it. The surf running up dry ground no longer stretches into a wall between two waters' heights.
  • Ripples and surf on calm water. The ripples a zone keeps fade out toward the edge of their window instead of stopping on a line across a lake, a breaker only whitens when it is steep for its length (a lake laps, the sea breaks), and foam seen from under the water is a faint shadow instead of a white sheet.
  • Water reads its data textures as numbers. The textures the water's field, shore and ripples are read from were decoded as sRGB colour, which bent their values.
  • A mesh on a material records its surface. An opaque mesh whose material has a blend mode of Normal (the default) was drawn blended, so it wrote no surface record, and the effects that read it (screen-space reflections, rain, contact shadows) passed over it, and alpha-to-coverage cut-outs on it had no coverage. It is now drawn opaque. Water and refracting glass write their own record where the device can blend one target and not another (WebGPU, and WebGL2 with OES_draw_buffers_indexed).
  • A terrain's splatmap keeps all four layers. A splatmap whose fourth layer is in its alpha no longer erases the other three where that layer is thin: it is read as the numbers in the file, not as a colour the browser premultiplies by its alpha.
  • Types for every SDK subpath. esengine/terrain, esengine/timeline, esengine/fx-basic, esengine/fx-atmosphere, esengine/fx-lighting and esengine/foliage named type declarations their package never built, and esengine/wechat built them without naming them, so a TypeScript project importing any of them got no types. All seven now ship and resolve, and the release check reads each entry's declarations where package.json says they are.
  • Dusk Fort exports. The Dusk Fort example's scene had no .meta, so an export of the project reached nothing from it: the package carried no assets and booted to "asset not found: assets/scenes/main.esscene". The scene now has its id, and the script that composes it writes one when it is missing.
  • Normal maps along a triangle's edge on WebGPU. On WebGPU with multisampling, every pixel a triangle only partly covers lost its normal map: on Metal the screen-space derivatives that build the frame were moved behind the branch that picks it, where those pixels have no neighbours to difference against. A normal-mapped quad drew a dotted line down its diagonal and round its rim, and the Skin shader's detail layer left those pixels without their highlight.
  • Cut-out colour in its clear texels. An imported cut-out's clear texels take the colour of the solid ones nearest them, so a mip, whether the cook makes it or the GPU does, no longer averages in what the painter left under alpha 0.
  • Cut-out shadows. A cut-out's shadow is the same shape on both backends: the shadow pass read a card's alpha at level 0 on WebGPU and through its mips on WebGL2. Both now read the mips and cut at the cutoff, as the cut-out itself is cut.
  • Imported eyes. An imported eye shades as the Principled shader it was authored against: the Eye shader's tinted white, its warm wrap of light past the terminator (which reddened a painted iris) and its lid darkening are written as off, and both its glossy layers take the source's roughness instead of a near-mirror cornea.
  • Energy in lit materials, and soft sun shadows as wide as the sun. Lit materials keep the light a rough surface reflects and pass on what it does not. The environment's specular came from Karis' analytic fit, 21% low for a metal at roughness 0.5 and up to 80% off at a grazing view; it is now a fit to the integral itself (tools/gen-dfg-fit.py, worst 3%). The light a rough metal loses to bounces between its microfacets is returned (Fdez-Aguera's multiple-scattering term, and the same ratio on a lamp's highlight), where a metal at roughness 0.9 under a white sky came out at half of Blender's brightness. The diffuse under a dielectric's specular is reduced by what the specular reflects, as in the Principled shader. And a lamp's highlight takes Smith's height-correlated masking at alpha = roughness squared in place of the Schlick k = (r + 1)^2 / 8 remap, which left a rough metal's rim a quarter dark. In the render lab six spheres under a white sky now match Blender within 0.5% at every roughness, and flat cards of five albedos within 0.002, on both backends. A sun with a size casts a penumbra as wide as Blender's. The disc a penumbra was averaged over stopped at 8 texels of the map, which held a sun's soft edge to sixteen texels: with a fine cascade that is less than the sun throws, and the render lab measured an edge 60% as wide as Blender's. The disc now reaches 24 texels, its spiral of taps is turned point by point so the wider disc grains rather than bands, and each blocker tap forgives only as far as it stands from the point, so a box standing on a floor stays shadowed to its foot.
  • Mip chains on WebGPU. On the WebGPU backend, a mesh without a material, a sprite and a particle are sampled through their texture's mip chain, as they always were on WebGL2: their WGSL read level 0 alone, so anything drawn smaller than its texture shimmered into stripes and moire there and not on the other backend. A compressed (KTX2) texture also keeps every level of its chain on WebGPU: the upload stopped at the first level whose side is not a multiple of four, which left a 1240x1268 hair atlas with level 0 alone. In the render lab a card of fine strands seen small now reads the same on both backends.
  • Cut-outs are glTF's MASK at every distance. A material with an alpha cutoff keeps a texel where its alpha reaches the cutoff and drops it where it does not, near or far, as glTF defines MASK; under multisampling alpha-to-coverage feathers that edge. Seen small, a cut-out keeps the area it covers because its mips do: the cook rescales each level's alpha so the share of texels past the cutoff is the full image's, now in both directions, so fine strands no longer close into a solid card when averaging lifts them over the cutoff, and sparse ones (a railing) still do not thin away. A soft painted band below the cutoff (eyelashes fading out) stays out at every distance. Khronos's AlphaBlendModeTest cuts each box at its own mark again. The shader helper is cutoutCoverage(alpha, cutoff, edge).
  • Faces speckled with dirt in shadow. The high quality profile's shadow cascades are now 1024 texels on a 4096 atlas (they were 512 on 2048). At 512 a cascade's texel is several millimetres across a close character, so a brow, a hairline or a lash card sitting a fraction of a millimetre above the skin fell inside one texel of it and the shadow speckled the face with dirt; at 1024 the face is clean. Medium and low are unchanged.
  • Ambient occlusion at metre scale. The ambient-occlusion effects, ssao and gtao, accept a radius down to a centimetre (they stopped at one world unit), so a 3D scene measured in metres can use them on hair and faces. A radius of 0.05 separates the cards of a hair mesh without the black speckle a larger one leaves on their edges.
  • Global illumination at metre scale. The global-illumination effects accept lengths down to a centimetre: the voxel size of voxelGI, and the radius and thickness of ssgi, used to stop at four, ten and one world units, so a 3D scene measured in metres could not set them small enough to do anything. Against Blender's render of the same frame, a character lit by one sun gets its soft bounce light in the shadows once they are set to metre-scale values.
  • Lite engine builds compile. The lite WeChat and mini-game engine builds compile again: the pass that puts the opaque scene back after water and glass named the post-process pipeline outside the guard that leaves it out of those builds, so every package without post-processing failed to build.
  • Shadow cascades fit the scene. A directional light's shadow cascades are now spread over the geometry that is in the scene instead of over the whole view. A close shot of a character in a view that reaches fifty metres used to spend its first cascade on three metres and drew blocky, misplaced shadow edges; the cascades now end where the scene's geometry ends (rounded in quarter octaves, so the split does not swim as the camera moves), and the shadow lands where it should.
  • Colour fringes on skin shadows. An imported skin no longer blurs its diffuse light separately per colour channel, which put a red and cyan fringe along the edge of every shadow on it; like the rest of the scattering, it is written as off unless the source says otherwise.
  • Opaque textures under a cutout material. A texture whose alpha is fully opaque, used by a cutout material (a hair material or any alpha-cutoff one), no longer vanishes once it is minified. Coverage-preserving mip levels were scaling its alpha down onto the cutoff, so every level past the first was discarded; a level that already reaches the share it must keep is now left alone.
  • Shadow program for a normal-mapped mesh with tangents. A model with tangents and a normal map no longer stops its shadow program from linking when the sun casts shadows. The depth pass wrote no tangent varying while the fragment stage still read one, so the shader failed on WebGL2 and the logged error named no material; the depth variant now leaves the tangent frame out.
  • Selection outline across a plane. The selection outline of a mesh no longer draws a stray line across a large plane seen from close by: a triangle with a corner behind the camera was judged by a different rule than its neighbour, so their shared diagonal showed as an edge.
  • Normal maps read against the frame they were baked in. Imported meshes now carry a tangent at each vertex (a glTF's own direction, or one made from the UVs), and normal maps on them are read against that frame instead of one derived per pixel, which was wrong at UV seams and on stretched textures. Re-import a model to get them; one imported before keeps its old shading. A mesh whose vertices carry a tangent is drawn with an extra vertex attribute and one more varying; a shader of your own that calls perturbNormal picks the frame up with no change.
  • New Project keeps the wrong template name. The New Project page no longer keeps the previous template's name when you pick another: the suggested name follows the template, and a name you typed stays.

[0.94.0] - 2026-10-22

Added

  • GPU particles. Particle emitters can now simulate on the GPU: turn on gpuSimulation and a compute kernel advances every particle, so an emitter of a hundred thousand or a million particles costs a dispatch instead of a loop. The kernel runs the same emitter: shapes, curl noise, force fields, gravity, damping, a floor plane, colour, size and speed over life and sprite sheets, up to 2,000,000 particles. Sub-emitters, trails and physics collision stay on the CPU, the particles are not sorted, and it needs WebGPU: on WebGL2 and mini-games the same emitter runs on the CPU, capped at 20,000 particles.
  • Contact shadows and screen-space bounce light. Contact Shadows and Screen Space GI effects add small sharp shadows at contacts and one bounce of colour between surfaces, and the weather softens the sun's shadows. contactShadows marches a short ray toward the scene's sun in the depth buffer; ssgi gathers eight rays a pixel over the G-buffer's normals at half size into a float target and averages the neighbours on the same surface before laying the light, times the receiver's colour, over the picture. The Weather component raises the sun's sourceAngle and lowers its shadowStrength as the sky clouds over.
  • Terrain and Foliage. A Terrain component makes ground from a heightmap or noise, paints it with grass, dirt, snow and rock layers and draws it in chunks that coarsen with distance; a Foliage component scatters grass or a mesh over it, swaying in the wind and thinning out with distance.
  • Separate material maps packed on import. Importing an FBX with separate metalness, roughness and occlusion images now packs them into the one map the Model shader samples, instead of dropping them. Occlusion goes in red, roughness in green and metal in blue, each from its image's red channel (a glossiness map is inverted); a channel with no image stays at full so the material's own value speaks. Only PNG and DDS can be read.
  • Skin and hair. Two new shaders for characters: Skin softens diffuse light by colour, warms the terminator and lets light through thin places without blurring the picture, and Hair lights strands along a flow map with two shifted highlights. Normal maps on stretched UVs (a face unwrapped into an atlas) now keep their shape, and mipmapped textures are sampled with anisotropic filtering where the device has it. Both read a normal map and an occlusion/roughness map as data textures (import them with sRGB off); the Skin shader shades each pixel with three lighting passes, so it is for characters in view. Hair is shaded as strands but a hair model is still cards or ribbons.
  • Anisotropic filtering. Mipmapped textures are now sampled with up to 16x anisotropic filtering where the device has it (WebGL2 with the extension, WebGPU always), so a floor, a hair card or a sleeve seen at a slant keeps its detail instead of washing out to grey.
  • Wilds example. Wilds is a new 3D example: a lake under mountains at dusk, made from a generated heightmap with the Terrain, Water and Foliage features and the sky's cloud shadows. Everything in it is made from numbers by examples/wilds/tools/build.mjs, so there is no art to credit.
  • Foliage. A Foliage component scatters grass or a mesh across an area and over a Terrain, swaying in the wind and thinning out with distance. Each cell of the area is one mesh with all its plants in it, built twice (near, and a far version: fewer broader blades, or two crossed cards a mesh), so a field is a few hundred draws. The Foliage shader bends vertices by weights painted in the vertex colour, which a vertex hook of your own can read as es_vertexColor. Plants do not collide and do not bend away from a character.
  • Terrain. A Terrain component makes ground from a heightmap or noise, paints it with grass, dirt, snow and rock layers, and draws it in chunks that coarsen with distance. Add a Terrain component to an entity: its heightmap (or a seed, for noise) sets the shape, and each chunk is built at up to four levels of detail with a skirt that hides the cracks between levels, so the engine's level-of-detail choice needs no knowledge of its neighbours. A Terrain material shader draws four texture layers by world position, with the rock projected from three sides. TerrainsRes.heightAt(x, z) answers how high the ground is. The ground is drawn, not simulated: it has no collider, and no holes or overhangs.
  • Water. A Water material: waves that travel, the scene seen through it bent and tinted by how deep the water is, reflections, and foam at the shore and on the crests. Give a horizontal plane a material on the built-in Water shader. The depth is measured, not guessed: the frame takes a copy of how far each pixel of the opaque scene is from the eye, so water over a shelf goes from the shore's pale teal to deep blue, with red absorbed first. It needs the same engine-copied scene as glass (a post-process chain running) and a float target for the depth; the waves are drawn in the surface's shading, not as displaced geometry, and the surface is taken to lie flat.
  • Cloud shadows. The Sky Atmosphere's clouds can now cast shadows on the scene. Cloud Shadows marches the sun's ray up through the same cloud slab the sky draws, so the ground is darker and patchier under cloud; it also pins the clouds to the world instead of the camera, and World Units per km says how large a kilometre of sky is in the scene. The default is 0, which leaves every existing scene as it was. Ambient light is not shadowed, and the clouds are still only drawn where there is sky.
  • Voxel GI on WebGL2. Voxel GI now runs on WebGL2: the world-space bounce light is built with fragment passes where there is no compute stage. The result matches the WebGPU one in the editor check; the gather is fixed at half size, grazing surfaces are thinner in the cache, a 32 MB half-float atlas is used, and the low quality tier leaves the effect out. Its cost on real GPUs has not been measured.
  • Cyber Rooftop example. Cyber Rooftop adds a rooftop survival-base example with a 2D HUD and a first-person build tool. The world is editable 3D models (a rooftop shelter, planters, containers, pipework, a water plant, city buildings, a train) with rain, steam and puddle reflections; the HUD is built from Canvas, UINode, UIVisual and Text. It is a runnable reconstruction of a reference image, not a pixel match, and its survival systems (inventory, saving) are not implemented.
  • Thin lines against the sky. A wire or railing thinner than a pixel stays one line against the sky instead of breaking into dashes. The Sky Atmosphere effect paints every pixel whose depth is the far plane, and depth is resolved from a single sample of a multisampled target, so a wire covered at some samples and not at that one was painted over wherever the sample missed. With the sky in the chain the scene is now cleared to nothing, its alpha is how much of each pixel geometry covers, and the sky is laid under it by that coverage: on a half-pixel wire across the sky the columns that show it went from 49% to 100%, on WebGL2 and WebGPU. An effect asks for this by declaring u_sceneCoverage; with Keep Background above zero the scene is cleared to the camera's colour as before.
  • Cleaner contact shadows. Contact shadows are soft and keep off surfaces facing away from the sun, so a wall no longer carries a speckle a temporal pass could not average, and the effect stack flags a Temporal Anti-Aliasing that sits before a noisy effect. The march now fades along its length (a hit at the far end is half a shadow), starts at a different offset every frame as well as every pixel so a temporal pass averages the whole march, and skips a surface facing away from the sun. On the Bistro hero the grain on a flat wall fell from 3.95 to 2.82 (the same wall with the effect off: 2.72); the example now runs taa after the fog, where it can average the noise before it.
  • Details panels for the world. Time Of Day shows the day as a curve with a hand for the hour, Weather as preset buttons with a live readout, a volume's effects are grouped and tagged, and a Model material's surface layers are sections with switches. The sun's curve is the real one for the component's latitude and declination; the effect stack lists colour parameters it used to leave out, folds, and marks the effects that need WebGPU; a layer's switch writes its strength parameter as an ordinary undoable edit.
  • Subsurface scattering. A Subsurface Scattering effect blurs the lit colour of the surfaces a material marks as scattering, red furthest, without bleeding across a depth edge. The Model material's u_subsurface marks its pixels (alpha 0.996, which nothing shows and the effect restores to 1); the effect is an x and a y pass whose width is a world length, each colour reaching a different share of it. Only marked neighbours on the same surface are gathered. It blurs the whole lit colour, specular included, and the width is the effect's, shared by every marked material; the low quality level leaves it out.
  • Refraction. Glass and water refract: a material with transmission bends and tints the opaque scene behind it, softened by its roughness. The frame draws the scene in two halves with a copy of the picture taken between them: the materials that read it (a shader that declares u_sceneColor, the Model shader while its transmission is above zero) are drawn second, ray-bent through their thickness. The surface's own highlights are no longer dimmed by blending, as they were when transmission was only coverage. Only the opaque scene is refracted, and it needs a post-process chain to copy from; without one transmission falls back to the earlier coverage.
  • Ground-truth ambient occlusion. Ground-truth ambient occlusion (GTAO) is a post-process effect beside SSAO: a crease darkens by how closed it really is and a flat floor stays white, with no bias to tune. It marches the depth buffer along a few slice planes through each pixel, finds the horizon on both sides and integrates the open arc against the surface's own normal; the blur and composite are SSAO's, the low quality level leaves it out, and the ambient-occlusion switch governs both.
  • A sharper upscale. A scene drawn at a render scale below 1 is stretched back to the screen with a resampler that keeps edges steeper than a bilinear copy. The resampler is Catmull-Rom clamped to the texels around each point, so it draws no halo; a whole-number stretch is still an exact copy. Measured on a sprite edge at the low level's 0.75 scale: the edge's 10-90% width is 1.04 px against 1.15 px bilinear (0.69 px at full size).
  • Motion blur, film grain and lens flare. Motion blur, film grain and lens flare are post-process effects, and a moving mesh's motion now reaches effects on WebGPU too. Motion blur follows the camera by the depth buffer and a moving mesh by its own motion, with the shutter and a cap on the streak as its settings; it needs no temporal anti-aliasing and does not shift the picture. Film grain is mid-tone noise that crawls with the clock; lens flare throws ghosts and a halo from what is brighter than a threshold. The low quality level skips motion blur and lens flare. Also fixed: a 32-bit float texture an effect only reads texel by texel (the motion pass's) is no longer paired with a filtering sampler, which WebGPU refused — temporal anti-aliasing's object motion logged an error every frame there.
  • Shading layers. The Model material has shading layers — clear coat, sheen, anisotropy, translucency, thin film, index of refraction and transmission — and a glTF with the matching extensions arrives using them. Clear coat puts a second, sharper highlight over the base and darkens what is under it; sheen is the soft grazing-angle light of cloth; anisotropy stretches a highlight across brushed grooves; translucency lets light wrap past the terminator and show through from behind; thin film shifts the reflection's hue with the angle; the index of refraction sets how strongly a non-metal reflects; transmission lets a surface show what is behind it, drawn blended with no refraction. Custom Lit shaders reach the same lighting through applyLightingSurface and a SurfaceExt. A layer's textures are not read — its factors are — and the import says so; a material that sets none of them draws as before.
  • Many lights. A frame now carries up to 112 lights: sixteen are read for every pixel and the rest are tiled, so a street of lamps lights what each one reaches. The sun, the lights that cast a shadow and then the brightest go in the lighting loop as before; every other point and spot light without a shadow map is recorded per screen tile (16 x 12) and shaded only by the pixels it reaches, so the cost follows the lights near a pixel and not the lights in the scene. Tiled lights do not cast shadows, and the whole lighting block still fits the 16 KB a uniform block is guaranteed, so it runs on WebGL2 and WebGPU alike.
  • Play on WebGPU. Play runs the game on the graphics backend the project asks for, so a WebGPU project is played on WebGPU and its compute effects and Voxel GI are seen in the editor. Until now Play always ran on WebGL2 whatever the project asked for; it now follows features.rendering.backend the way a shipped build does, and falls back to WebGL2 on a machine with no WebGPU.
  • Voxel GI. Voxel GI adds diffuse bounce light from a world-space voxel cache the camera remembers, on WebGPU. The cache is a voxel grid around the camera that each frame takes in the lit picture (the radiance and facing of the surfaces it sees) and fades what it held; light is gathered by marching cosine-weighted rays through it, so a wall that has left the screen still tints the floor beside it and a moving light lights its surroundings, which Screen Space GI cannot do. It holds only what the camera has seen, at the voxel's size, with one diffuse bounce: it is not a trace of the scene's geometry, and not Lumen. A device with no compute stage goes without it.
  • Compute effects. A post-process effect can be a WGSL compute shader over the picture, run on WebGPU and left out on WebGL2, and Sharpen is the first. An effect registers with compute instead of factory; it is handed the picture so far, a storage texture to write, its parameters, the size and the scene's depth. Sharpen pushes each pixel away from its neighbours and holds it inside their range, so an edge steepens without a halo. A compute effect refines a picture that is already whole, so a device with no compute stage simply goes without it.
  • Sky. The Sky Atmosphere effect scatters the sun's light through an atmosphere and draws volumetric clouds that the sun lights and the wind moves. The dome is single scattering through a planet's atmosphere (Rayleigh and Mie), so a sunset's reds and the afterglow come from the same calculation as noon's blue; the clouds are a slab marched against a noise density, lit through what lies between them and the sun, and a Weather's overcast raises their coverage.
  • Time of day. A TimeOfDay component moves the sun and the moon across the sky, and a Sky Atmosphere effect draws the day, the dusk and the night. The sun is placed from the hour, the latitude and the season; the scene's directional light is aimed at it by day and at the moon by night, scaled and tinted by a day's curve, and the ambient light, baked reflections, fog and exposure follow. Sky Atmosphere draws the dome, the sun, a dusk glow, the moon and stars where there is no surface, and Weather greys it as it clouds over. A directional light that follows a panorama's sun can now be aimed by its own Transform (aimFollowedSun), which is what lets a panorama photographed with the sun in one place be lit by a sun that moves.
  • Weather. A Weather component puts a scene under clear, mist, overcast, rain or storm, turns between them and cycles by itself. A preset is a set of multipliers of what the scene already has — the sun at a fraction of its strength, the fog thicker, the picture greyer — plus absolute levels for rain and wetness, so one preset fits any project. The component drives the directional and ambient lights (in play mode only), the effects the scene's volumes resolve (Height Fog, Rain, Screen Space Reflections, Colour Grade, Auto Exposure), and takes registerWeatherPreset for weathers of a project's own. Volumes whose effects differ only in numbers now write the numbers into the passes they have instead of rebuilding them. Reflection probes follow the weather: the ambient light scales what baked probes show and how much colour they keep. The Ambient Light gains reflectionScale and reflectionSaturation, which the weather drives. Rain stays off what stands under a roof, and the Weather component turns a looping rain track up and down. The frame draws the scene once from straight above, depth only, around the camera whenever a rain effect is in the chain, and the effect keeps wetness, puddles, ripples and streaks off ground that something stands over; soundSource names the AudioSource the weather drives.
  • Quality levels are edited in Settings. Settings → Project → Rendering edits each quality level, including which effects it runs. Editing level picks Low, Medium or High and the groups below — Rendering (render scale, minimum scale, MSAA), Shadows, Reflections and particles, Post-processing — show and change that level, so a level is read the way Unity's Quality page reads: a level, then its settings by subsystem. Post-processing lists every effect the engine has, ticked where the level runs it; an unticked one is skipped at that level wherever a camera's volume asks for it, with all of its passes. Device rules — the model, GPU, memory and core conditions Auto chooses a level by — are a table, shown when the mode is Auto, that says so on a row with no condition instead of dropping it while it is typed. Only what you change is saved to project.esproject, as a difference to that level, so an engine default that improves later still reaches a project that never touched it; a row's "changed" mark and reset follow the default of the level it is showing. The old per-level shadow distance rows are the Shadows group's Distance now. The effects a level leaves out had been matched by the prefix of a pass's name, which found none of Auto Exposure's passes; they are now matched by effect type. A new Quality Levels page in the performance docs describes it.
  • A G-buffer, and reflections that read it. Reflections now know how rough and how metal each surface is, from a G-buffer the frame draws on request. A post-process shader that says #pragma gbuffer makes the scene target carry a second RGBA8 colour attachment, written in the same pass by the scene's own shaders — octahedral normal in r/g, roughness in b, metalness in a (0 where nothing wrote) — and finds it at u_gbuffer. A frame whose chain has no such effect makes none and compiles no variant. The render device grew multiple colour attachments for it on both backends: WebGL2 attaches and resolves a second target and sets the draw buffers per pipeline, and WebGPU declares the second target on every pipeline of the pass (written by the ones that write it, an empty write mask for the rest), clears it to zero and resolves it with the colour. Pipelines say whether they write it (PipelineDesc::gbuffer), a blended draw never does, and the second output is its own shader variant (ES_GBUFFER), so no pass pays for what it did not ask for. The built-in Model shader — what an imported glTF material becomes — writes it from the material's roughness, metalness and normal map. ssr reads it: it takes the surface's own normal (normal-map detail that depth cannot see), weighs and blurs the reflection by roughness, reflects a metal at nearly full strength where a dielectric reflects 4%, skips a surface rougher than maxRoughness before marching the ray, and takes the Rain effect's wetness as a film that smooths the ground. Where nothing wrote a record, it falls back to depth and the dielectric it has always assumed. Verified in the editor on both backends: of two floors that differ only in their material's roughness, the glossy one changes ten times the pixels the rough one does. Quality levels can also leave out expensive effects now: quality levels can now skip expensive post-process effects by name. A level's skipEffects lists the effects it leaves out, each named by its effect type (ssr, taa, depthOfField, lightShafts, autoExposure, …), and an effect leaves with all of its passes however they are named; a project's own list in its quality profile replaces the level's. By default low leaves out reflections, temporal anti-aliasing, depth of field and light shafts, and medium leaves out reflections and depth of field; high leaves out nothing. These defaults come from the work each effect does per pixel, not from a weak device: the editor's new fx-cost check measured every effect on Bistro at 2560×1600 on a fast desktop GPU, and none added more than about 6 ms (reflections ~5, bloom ~4, the example's whole eight-effect chain ~11, the rest within the ±3 ms the run drifts by), so the levels have not been checked against the hardware they are for. Screen-space reflections leave a surface that recorded nothing alone, plain meshes now record a rough dielectric, and a puddle reflects the sky and what lies off screen.
  • Rain, wet ground and puddles. A Rain post-process effect adds falling rain, wet ground, puddles and ripples. rain draws three layers of slanted streaks, each at its own distance so a nearer surface hides them and the sky does not; darkens the ground that faces up by wetness; lays ripples and splashes where drops land on a grid in the world, so they stay on the ground as the camera moves (ripples need intensity above 0: wet ground under no rain is still); and, by puddles and puddleScale, covers part of the flat ground with standing water that is darker and takes denser, clearer ripples. ssr takes the same two numbers and treats those pools as mirrors — flat, far more reflective than dry ground, and sharp — so the pools the rain darkens are the pools that reflect. The clock is u_time * timeScale + phase, so a capture can pin it. The rain is a screen-space layer, not particles that collide with the world, and a puddle is flat ground whatever it lies on. Verified in the editor on both backends: streaks light a dark sky and move between two moments, wet ground reads darker, standing water darker still, and puddles change the reflection. Puddles gather in the low places of the ground and thin on its rises, read from the depth buffer. Three rings of depth taps measure the ground around a pixel, so pools gather against a kerb, in a dip and at the foot of a slope instead of lying on the world-space noise alone.
  • Auto Exposure and Depth of Field. Auto Exposure and Depth of Field post-process effects are available. autoExposure measures the average log luminance of the picture (leaving out pixels darker than 2^-8, so a black backdrop does not open the exposure to its limit), turns it into the exposure that puts it at middle grey, and moves toward that over time from where the last frame left it — brighter faster than darker, per second, within minEV and maxEV, with a bias in stops. To keep the settled value between frames a post-process shader can now declare a u_feedback texture: the engine keeps that pass's last output, at the pass's own size, and binds it there, without shifting the picture the way u_history does. depthOfField blurs by distance from focusDistance, with a sharp slab of focusRange, a blur radius that grows with how far a surface is from focus up to maxBlur, and a gather that counts a neighbour only where its own blur reaches back, so a sharp object does not bleed into a blurred background. Verified in the editor on both backends: a dim scene brightens (mean 6.9 to 16.5) and a bright one darkens (30.7 to 20.4), a drop in light is first dark and then recovered over real time (5.2 then 15.8), and focusing close takes the squared edge energy down to 21% of the sharp frame. Auto Exposure can meter the middle of the picture or a spot, and Depth of Field focuses by itself and blurs a light into the shape of its aperture. Auto Exposure gains metering (average, centre-weighted, spot) and meterSize, and keeps its measurement in float targets so it behaves the same in an 8-bit chain. Depth of Field becomes three passes — focus, circle of confusion, gather — with autoFocus (a point on the screen, a glide at focusSpeed), blades and bladeRotation for the aperture's shape, and highlight for bright points; a post-process shader can ask for a float target with #pragma highprecision.
  • Height Fog and Light Shafts. Height Fog and Light Shafts post-process effects add atmosphere. heightFog is exponential height fog with a closed-form integral — no marching — so a valley fills and a hilltop clears, the horizon turns hazy while the zenith stays clear, and looking toward the sun the haze takes the sun's colour; sky pixels run through the same formula with a very long ray, and skyFog sets how much haze the sky keeps. lightShafts marches each pixel toward the sun's place on screen and counts how much of the way is open sky, leaving rays through whatever stands in front of the sun. The sun's direction is set on the effects (azimuth and elevation), not read from a light. Neither is a shadowed volume: fog is lit evenly. Both run on WebGL2 and WebGPU; with an output transform of None, a floor fully taken by the fog reads exactly the authored colour on both. Height Fog and Light Shafts follow the scene's own sun, and Height Fog can carry the sun's shadows as volumetric light. followSun (on by default) takes the sun from the first directional light that shines; volumetric walks the air in 24 steps against the sun's shadow map, so shadows are dark fog and gaps between them beams. A post-process shader can ask for the light block and shadow atlas with #pragma lights.
  • Screen Space Reflections. A Screen Space Reflections post-process effect mirrors props in floors. Add ssr to a PostProcessVolume: with no G-buffer, the surface normal is rebuilt from the depth buffer, the reflected ray is marched through the world and projected back to the screen at every step, and a step landing just behind the visible surface is a hit, refined by bisection. The reflection is blended over the pixel by a Schlick Fresnel term — faint face-on, strong at a grazing angle — and blurred by how far the ray travelled, which stands in for roughness. intensity, maxDistance, thickness and floorBias are the settings; floorBias at 1 lets only up-facing surfaces reflect, since the chain does not know a material's roughness. What is off screen or in the sky is not reflected; the pixel is left as it was. It reads the same depth buffer as ambient occlusion, runs on WebGL2 and WebGPU alike, and its per-pixel start offset is meant to be averaged away by taa. Verified in the editor on a lit scene with both backends: the props appear in the floor they stand on and nothing else on screen changes.
  • Temporal Anti-Aliasing. A Temporal Anti-Aliasing post-process effect smooths edges across frames. Add taa to a PostProcessVolume and the engine shifts the scene's picture by a different sub-pixel amount each frame (eight positions, repeating), keeps the effect's last output as its history, and blends the two — reaching what multisampling cannot: shader aliasing and thin geometry. Where a pixel was last frame comes from the depth buffer and the previous camera, so a moving camera keeps its history; the history is clipped to the colours around it, so what no longer matches is dropped rather than smeared, and each camera keeps a history of its own. One blend setting says how much of each frame is new. Measured in the editor on a lit scene with multisampling off, in-between edge pixels went from 2% of edge pixels to 43% on WebGL2 and 44% on WebGPU, still frames held still, and a picture taken mid-slide of the camera matched the plain one to within a fraction of a level. Objects that move by themselves are not tracked — they are handled by the clip, so fast movers can look slightly soft. Temporal Anti-Aliasing now follows meshes that move by themselves, from a motion pass that draws only what moved, so a thin fast object keeps its contrast. Moving meshes are drawn a second time into a target of their own that records how far each pixel travelled (an RGBA32F target, only on devices with float render targets), and the effect follows that where it is the surface the scene shows; Object Motion at 0 trusts the camera alone. Skinned meshes are followed by their bones, from the palette they were last drawn with.
  • Smaller meshes on disk. Newly imported meshes are about 9% smaller on disk. A mesh whose indices all fit in 16 bits is now written with 16-bit indices (.esmesh version 4), half the index bytes, and read back as 32-bit so nothing downstream changes: the renderer, the lightmap and decal bakers and static batching see the same indices as before. A mesh that needs 32 bits is written exactly as before, on the version every earlier reader knows, and files written before this change still load. Measured on the Bistro meshes (1143 files, 116 MB), re-encoding saves 10.4 MB; existing .esmesh files are not rewritten until the model is re-imported.
  • Levels of detail generated at import. Imported models can generate cheaper levels of detail automatically. Set Generate LODs to 1–3 levels in a model's import settings (or pass --lods <n> to import-model) and each mesh is collapsed into copies with about 50%, 20% and 7% of its triangles, written as <mesh>_lod<n>.esmesh, with a LODGroup on the entity that swaps them in as it shrinks on screen. The collapse bounds how far the surface may move and will not pull apart a UV seam or a hard edge; vertex colours and the lightmap UV come along unchanged. Skinned and morphing meshes, and meshes under a minimum triangle count, keep one level. Measured on the Bistro exterior (1143 meshes, 2.83M triangles), the 621 meshes large enough to get levels hold 1.35M, 0.44M and 0.10M triangles at levels 1, 2 and 3; the levels are extra files, so they make a large scene cheaper to draw rather than smaller to ship.
  • Steadier highlights on curved and bevelled surfaces. Lit models no longer sparkle on rails, bevels and rounded trim. Where a surface's normal turns faster than a pixel can resolve, the highlight is the sum of many normals the pixel cannot tell apart, and shading it with one made it flicker as the camera moved. The Model shader now widens a highlight by how fast the vertex normal turns across the pixel — a steady, slightly rougher highlight in place of a flickering sharp one — on WebGL2 and WebGPU alike. Measured on a street scene shifted by sub-pixel steps, frame-to-frame shimmer on rails and lamp trim fell by about 5–8%; a surface that is flat or smooth is not touched.
  • A Neutral output transform. The output transform has a Neutral option that keeps hue and saturation. The output transform is the one curve a finished frame goes through on its way to the display; None only encodes and ACES rolls highlights off a filmic shoulder, but ACES also desaturates as it goes, so a brightly lit red drifts toward cream. Neutral (Khronos PBR Neutral) rolls highlights off in the same way and leaves colour alone, so a sunlit red awning stays red. Pick it in Settings → Project → Rendering, or set outputTransform: 'neutral'; it applies to the viewport, Play and every export, on WebGL2 and WebGPU alike.
  • Static batching. Static meshes that share a material can be drawn as one. Add StaticBatch to a mesh that will not move, and the meshes that share its material, texture, colour and layer are merged while the game runs into one mesh per area, so a level built from many different props costs a few draws instead of one per distinct mesh. The renderer already drew copies of the same mesh as one instanced draw; this is for different meshes. The marked entities stay as authored — scripts find them, colliders collide, the editor picks them — and only their drawing moves to the merged mesh. A mesh is left out, and the reason recorded, when it is skinned, morphing, a level-of-detail group, blended, moving (a dynamic body or a character), lit by a bake or a probe volume, or alone in its group. Merging copies each part's vertices, so it spends memory to save draws; StaticBatching reports each merged mesh's size and what drawing its parts cost before. In the editor the outliner's menu marks the selected meshes, a marked mesh's Details say whether it merged and why not, and the profiler lists every merged mesh and the meshes left out.
  • Camera shots and nested sequences on the timeline. Timelines have camera and sequence tracks. A camera track is a row of shots: each bar is the camera that is the view for its span, bars that touch cut, and a bar dragged over the previous one blends across the overlap with its own curve. A sequence track plays another timeline in a window of this one, on its own clock, with a speed, a loop, and a node to bind to so one sequence can play on different characters. A timeline cannot play itself, directly or through another, and nesting stops at four levels. The Sequencer shows both as bars above the object tracks, with the shot or clip in Details, and the viewport's camera preview follows the shot while you scrub. Which shot and which nested frame show is a function of time alone, so scrubbing, jumping and playing backwards agree.

Changed

  • Long audio streams on the Web. Long clips on the Web play from their compressed file instead of being decoded to memory. A clip's import settings have a Load Type: Auto streams clips of 30 seconds or longer and decodes shorter ones, Decompress On Load always decodes, Streaming always streams. A streamed clip takes almost no memory (a three-minute stereo track is about 69 MB decoded), goes through the same bus, volume and fades, and gives up two things the import setting says: a sample-accurate loop point, and a second simultaneous voice of the same clip. The profiler's memory section shows the decoded audio and, when clips stream, how many and the memory they saved (an estimate from their length). The choice rides in the exported game's audio settings, so an exported game and a playable ad stream the same clips Play does.

Fixed

  • Distance Fog's colour was drawn too bright in a linear project. The fog colour is authored as sRGB, like a clear colour or a light colour, but the effect took it as linear light, so a fully fogged surface showed a much lighter colour than the one picked (a 0.4, 0.5, 0.6 fog read as about 0.66, 0.73, 0.80). It is now converted for a linear project, so the colour picked is the colour a fully fogged surface shows. A linear project that tuned its fog colour by eye against the old result will look darker and may want it re-picked.
  • Opening a timeline opens the Sequencer. Double-clicking a timeline used to leave the Sequencer closed unless its tab was already open.

[0.93.0] - 2026-10-19

Added

  • Dynamic planar reflections. A shared 2D/3D render-graph capture provides mirrored cameras, plane clipping, layer filtering and PBR reflection input for flat meshes. Details adds quality overrides, plane preview and capture diagnostics; project tiers, every-frame/fixed-rate/on-demand capture, per-camera ownership and device recovery share one implementation. A runnable example and WebGL2/WebGPU headless pixel checks are included. One visible surface per view; mobile device acceptance remains pending.

  • SUD OpenPaaS development export. An opt-in project platform preset exports a main.js directory for PinK's third-party builder. Its SDK profile bridges sud, package-file WASM loading, XHR, WebSocket and localStorage through the shared 2D/3D mini-game runtime. Headless checks exercise real exported 2D and 3D frames, including a WASM result without module; PinK packaging and Android/iOS acceptance remain pending. Login, ads, payment, WebGPU and EmscriptenGLX are not enabled by this initial integration. The directory includes the initial manifest.json emitted by the official web2sp converter. That converter produces a SUD project directory, not a binary .sp file; final package generation remains separate from directory export. package-openpaas now invokes PinK's official packer directly to generate encrypted, signed .sp files and verify all payload files before replacing the output. Real 2D/3D examples pass export → package → verify → decrypt → payload comparison → headless rendering with independent test keys; authorized Hello PinK and device acceptance remain pending. Uploading is user-managed.

  • Plugin filesystem operations. Editor plugins can read and write binary assets directly, list directories, inspect files, create folders, rename and delete in their own directory or the capability-gated project scope. Moves preserve asset UUID sidecars, deletion uses the OS trash, and project edits join the existing file journal. User-installed plugins outside the project are supported; generated plugin data no longer repeatedly reloads its producer. Addresses #99.

  • One-click LAN device preview. Scan Preview beside Play prepares the current scene for a phone browser, with a QR popover, tokenized local-network address, connected devices and advanced scene/interface settings. Scene and asset saves publish complete preview builds; compatible script changes retain the world through existing hot-swap APIs, with explicit reload reasons otherwise. Closing the project or stopping invalidates the session. The same Web runtime serves 2D and 3D; native/minigame device acceptance remains separate.

  • Budgeted particle scene collisions. Particles query existing 2D or 3D physics along their movement segments, with layer filtering, rotating per-emitter/App query budgets, camera-distance culling and explicit floor/skip fallback. Bounded collision events use the standard EventReader; collision-triggered sub-emitters support local storage and capped inheritance depth. Details adds live counters and transient hit normals. A side-by-side sample demonstrates both physics paths and project-owned contact counters; device and performance acceptance remain pending.

  • Reusable UI trees and color pickers. TreeView adapts arbitrary project records with stable IDs to the existing virtualized ListView. It supports expansion, selection, keyboard navigation, row and empty-state prefabs, and validated drop requests whose mutations remain project-owned. ColorPicker composes HSV/RGB/HEX and alpha editing with standard sliders and text inputs, per-control recent colors, and canonical RGBA change events for 2D UI, sprites and 3D materials. Both have UI Widgets presets and themed Inspectors; preview sample data never overwrites saved project data. Their Details panels use standard property alignment, shared override/reset feedback, concise manual links and folded editor-only previews. Recent-color capacity is disabled without losing its value when history is off; opaque color editing fixes alpha at 1.

  • UI tabs and tooltips. TabView connects ordinary Toggles to content pages, with ordered entity bindings, keyboard navigation and an editor preview that leaves the saved initial page untouched. Tooltip adds delayed hover, keyboard-focus and touch-long-press hints, screen-edge placement and project theme or prefab styling. Both are available in the UI Widgets palette.

  • 3D swing/twist and six-axis joints. SwingTwistJoint3D adds an elliptical swing cone and twist limits; SixDOFJoint3D locks, limits or frees each translation/rotation axis. Both support live velocity motors. The existing Details controls expose degree-based authoring, and selected viewport gizmos show limits. The 3D Physics example includes a shoulder and carriage with reversible motors. Partial property searches keep only matching generic fields. Headless solver checks do not replace target-device acceptance.

Changed

  • Mini-game packages for other vendors are lean. Douyin and the other mini-game vendors ship a lean engine entry. A package for Douyin, Kuaishou, Bilibili, QuickGame, Alipay, Huawei or a vendor of your own now carries only the subsystems its project uses, as a WeChat one already did — one sample project went from 4.23MB to 3.76MB, under the 4MB main-package cap it had just crossed.
  • Planar reflections survive a driver that refuses float targets. Planar reflections fall back to an 8-bit capture on drivers that refuse a float one. Without that a planar reflection on such a driver showed nothing. The planar reflection diagnostics read the editor view. They report the capture the viewport actually drew instead of calling it inactive.
  • The string table speaks XLIFF. The string table exports and imports XLIFF 1.2. It is the format translators and agencies work in: Export asks for the source language, the target languages (each with how many entries it still lacks) and whether to carry only the untranslated ones, and writes one file with a section per language; a plural entry is a unit per form, a {name} placeholder is a tag translation tools leave alone, and importing merges by key, never overwrites with an empty translation, refuses a translation whose placeholders changed, and matches ja-JP to a ja table.
  • The viewport can preview the scene in another language. The viewport toolbar has a Preview language menu, shown when the project has a string table, that shows the scene's text in one language in the viewport and in Play, and says how many keys each language lacks; it is kept per project on this machine and does not change the editor's own language. The preview language menu appears once the string tables are indexed. Play starts in the preview language.

Fixed

  • Faster 3D multi-selection. Selected mesh overlays snapshot WASM transform scalars once per instance and reuse world vertices, projection buffers and complete silhouette edges until their inputs change. Deselecting releases derived geometry. Multi-object Details resolves entities in one scene pass. The optimization preserves all selection outlines and adds no drawing limits.

[0.92.0] - 2026-10-18

Added

  • Material graphs have a Tiling & Offset node. Scale and offset UV coordinates with one node in the material graph editor.
  • Material graph editor polish. Subgraph connections use the type the subgraph returns, a multi-selection drags together, and depth-only mesh programs no longer warn about an unused texture.
  • Material graphs have switches, a live preview and extract-to-subgraph. Build shader variants with Switch nodes, preview graph changes live, and turn a selected group into a reusable subgraph.
  • Material graphs can bend a mesh and its shadow. The output exposes vertex offset with an authored bounds expansion; the deformed mesh casts its deformed shadow.
  • Material graphs can output a standard PBR surface. Normal, metallic, roughness, occlusion, emission and alpha inputs join the standard material output.
  • Material graphs can use other graphs as nodes. Reusable material subgraphs are compiled inline into the parent graph.
  • The Plugins panel shows conflicts and what disabling removes. Inspect ID conflicts, filter plugins by phase, and preview the contributions removed by disabling a plugin.
  • The Agent panel is redrawn. Run outcomes, steps and acceptance results have a clearer layout.
  • The Project Health panel is redrawn. Filter by severity, group findings, and see checks that could not run.
  • The UI debugger is redrawn. Text and focus order use tables; event propagation is shown as a chain.
  • The UI Widgets palette is a searchable, grouped list. Find widgets by name within their groups.
  • The World panel is a table of cells beside the Content Browser. Inspect streaming cells in the same workspace as project assets.
  • The Spine preview, running-game inspection and the Game panel states are redrawn. These views share the editor’s updated controls and status presentation.
  • The lighting, history, scatter, plugins and string table panels are redrawn. Lighting keeps bake controls pinned, history marks the current state, the scatter brush previews itself, plugins have a list and detail view, and string tables number their rows.
  • The script, material and behavior-tree graph editors are redrawn. Graph nodes share one design; script variables have a searchable panel beside the canvas.
  • The sequencer and the sound event editor are redrawn. Key shapes show interpolation, tracks show values, sound variants show waveforms and shares, and attenuation is drawn.
  • The profiler and the frame debugger are redrawn. A module rail, CPU timeline and cost table organize profiling; the frame debugger names passes, columns and break reasons.
  • Editor polish and plugin compatibility. The Scene Report example accepts supported editor versions from 0.33 onward. Controller bindings wrap long names, UI debugger spacing is retained, collision material fields are aligned, and warnings and lighting bake summaries take less space.

Changed

  • Gizmos are redrawn. The transform handles are larger and clearer: arrows have filled heads, rings dim on their far side, the scale handles are solid cubes, and the part under the cursor turns yellow while the others fall back as you drag. A chip beside the cursor reads the offset, angle or factor being applied (X +120.0, Y 42.5°, X ×1.35), a rotate drag fills the swept angle, a move leaves a ghost where it started and, with snapping on, ticks at each increment. The entity under the cursor is outlined faintly before you click it, and a selected entity's outline is a little heavier. A selected mesh shows corner brackets with the length of three edges and its triangle and vertex count in the readout, the Show menu can draw its wireframe and normals, and a skinned mesh or one of its bones shows the skeleton as bones with the chosen joint in yellow. A decal projector shows its box and the line it projects along, a light probe volume the grid of probes a bake would lay, a LOD group the level it is showing and the share of the screen it takes, and the Gizmo menu has a handle-size slider. A selected UI node shows its margin and padding as bands, the pinned insets of an absolutely placed node as dashed lines with their values, and a flex container's direction and the gaps between its children. The six faces of a light probe volume, reflection probe or decal projector are handles: drag one and that half of the box follows the cursor. A selected mesh is outlined along its own silhouette rather than a box, up to 80,000 triangles. The Show menu can draw wireframe on every mesh at once, and choosing a bone paints the surface it moves from blue to red, the rest left grey; convex colliders now draw with the other 3D colliders. A Hunter's attack range is drawn as a red ball, a Perceiver's sight as the cone it actually tests (a ball when its field of view is all round), and a ThirdPersonCamera's boom as a line from the point it looks at to where it ends up, with the probe swept along it as a ball at the end. A UI element drawn as 9-slice shows its picture under its Slice Border field with four guides to drag, as the texture inspector does; while the texture carries a border of its own, which the renderer prefers, it says so instead. A selected Spine or DragonBones entity shows its bones over the artwork as the 3D rigs do, laid where the runtime posed them this frame, with the entity's scale and flips applied; the Spine and DragonBones modules gained a call that lists the bone tree, so a module built before it still draws the skeleton and only the bones are absent. A selected tilemap layer reports its tile count and the size of the area its tiles cover in the viewport readout (172 tiles · 32×17), and on a square grid outlines that area, so an infinite layer's edge can be seen. The profiler is laid out as a module rail (Frame, CPU / GPU, Render, Counters, Memory, Systems, Spine) beside the module chosen: its timeline plots what the CPU was busy with and no longer the wait for the next frame, so a healthy window is no longer one flat block and a hitch is a tall column; clicking a column pins that frame and the strip beneath says in a sentence how far over budget it ran and where; the cost tree is a table of total, own cost and share of the frame, in columns; the toolbar is icon buttons with the live state as a pill. The frame debugger's draw list has column headers, a header per pass with its draw count, a swatch for each draw's type, a break-reason filter that starts with All, and the position of the selected draw in the capture. The sequencer's keyframes take the shape of how the curve leaves them (round smooth, diamond linear, square held, round with an arc eased) in the colour of their track, a group's row sums up the keys beneath it, each channel row shows its value at the playhead beside a swatch that is its curve's colour, the ruler marks seconds as well as frames, the playhead's flag carries the frame, the record button is red and the snap toggle says what it is; the curve view marks its grid and names the selected key's frame, value and interpolation. The sound event editor lists its variants as a table with each clip's waveform and the share of the draw its weight takes, groups its settings (playback, level and pitch, voices, space), draws volume and rate as ranges, plots the attenuation curve with the function the runtime uses, and leads its preview bar with the Trigger action. The Show menu also picks how the viewport shades meshes: as authored, as neutral clay (shape, without anyone's colours) or as flat albedo (base colour, no light); the engine takes it as per-view state, so a camera preview in the same frame keeps the authored look. A fourth shading, wireframe, draws every triangle edge on a dark surface with the hidden ones hidden; the engine's pipelines now carry a primitive topology, WebGL2 and WebGPU alike, and each mesh the editor loads keeps a line list of its distinct edges. Script graphs, material graphs and behavior trees share one node look: a header in the colour of what the node is for, an icon and a plain name with the stored id small beside it, round pins that are solid when wired and hollow when not (control pins are triangles), and wires coloured by the type they carry. A graph with no saved positions is laid out left to right when it opens and opens no smaller than half size, and an Arrange button lays any graph out again. A script graph's inputs, outputs and variables are a searchable list beside the canvas that shows how often each variable is read and written, lights the nodes that use the selected one, and lets you drag a variable onto the canvas to get or set it. The Lighting panel folds into groups with a short state beside each title, shows its warnings as a plain row with an amber edge rather than an amber box, and keeps the bake state, counts and the Bake button pinned at the bottom. The History panel draws a rule at the present, with undone steps below it. The scatter brush draws one real sample of itself to scale. The Plugins panel is a list grouped by origin, with search, beside the details of the plugin picked: its actions, declared capabilities, what it contributes and its health. The string table numbers its rows, marks a missing translation with an amber edge and totals its problems in a status bar. The Spine preview in the asset inspector uses the editor's own dropdowns and icon buttons, shows the time against the animation's length, and names the bounds drawn over it (fixed, unsaved, last scan). While a running game is inspected, the selected entity's outline carries its name, the move handles have arrowheads, and a chip beside the handle reads the position, turn or scale being applied. The Game panel says it is idle, starting or failed with an icon, and a failure shows its reason in a block that can be selected. The World panel is a short panel beside the Content Browser: a toolbar with the cell count and size, the persistent entities as a count that opens their list, and — while the game runs — what is in each residency state, the hit rate and the last demand-to-resident time; below it a table of cells with their entity count and, at runtime, state, prefetch result and demand-to-resident time, and the entities of the picked cell beside it. Picking a cell frames its entities in the viewport. The UI Widgets palette is a searchable list in groups (layout, display, input, popup, touch controls) with the Chinese name and the widget's own name on each row, instead of a grid of tiles. The UI debugger's four views are laid out alike: the Elements tree shows each element's main component and its picked element's size and components sit beside it; Text and Focus order are tables with a state dot per row and select on a click of the row; Events draws each dispatch's bubbling path as a chain from its target. Project Health's three counts filter the list, its findings are grouped by severity under folding headings, and the checks that could not run are listed with their reasons instead of in a tooltip. In the Agent panel each run's header carries a dot for how it came out (running, held, not held, stopped early, never checked), a run's steps hang on a rail with a dot each, the acceptance line is ruled off like the change set instead of boxed, and the key hints under the input show while you are typing. The Plugins panel lists the ids a plugin and another owner both claimed and who got them, filters the list to failed, awaiting-trust, incompatible or shadowed plugins, no longer offers a built-in plugin a trust withdrawal that cannot hold, and says what a plugin contributes before disabling it. A material graph can now use another graph as one node: a .esmatsub material subgraph has inputs (a name, a type and a default each) and one result, a graph that uses it fills the inputs by wire or by typing a number on the node, and the compiler inlines it, so one subgraph used twice makes two independent copies and saving a subgraph recompiles the shaders of the graphs that use it. New ones come from the Content Browser's New menu; the subgraph's own header says how many graphs use it. A material graph's output node takes the standard material's surface: normal, metallic, roughness, occlusion and emission ports (and an alpha port that also works on an unlit graph), with a typed number for any left unwired. Connecting any of them compiles the graph to the same lit mesh shading the built-in Model material uses — metal read from blue and roughness from green, occlusion on the ambient light only, emission added after lighting — and a graph with none of them compiles exactly as before. New nodes: Normal Map, which reads its texture as data and unpacks it the way the standard material does, and Channel, which takes one of R, G, B or A as a number; a texture node can be set to read its map as data. The output node also has a vertex offset port: a number moves each vertex along its normal, a vec2 or vec3 moves it by that displacement, so a graph can sway foliage or ripple water; the mesh's shadow bends the same way, and a Vertex bounds field on the node says how far the offset can reach so culling keeps a bent mesh that is still on screen. The offset runs on lit 3D meshes only, and its graph cannot sample textures or read the screen. A Switch node makes a variant: it takes two values and a switch name, and the material turns the switch on or off to choose which one its shader is compiled with, so the side not chosen costs nothing at run time. The graph editor draws the graph as it is now, on a ball, cube or quad in its corner, a moment after each edit and before saving, with a checkbox per switch to look at each variant. Select nodes with shift- or ctrl-click and Extract to subgraph moves them into a new .esmatsub beside the graph: every wire from outside becomes an input, the one node something outside reads becomes the result, and the graph keeps one node in their place; a node of a subgraph draws its wire in the type the subgraph returns, and a selection of several nodes moves together when one is dragged. A Tiling & Offset node scales a UV and shifts it, for a texture that repeats or slides.

  • A material's preview is a real shape. Selecting a material shows it on a sphere, cube or plane (lit materials open on the sphere, sprite shaders on the plane), over a dark, checker or light background, with a sample image for shaders that sample a texture; the choice is remembered per kind. The header carries the ball as its icon and the name with a faint extension, the shader is a plain section with a link to make it unique, and the Content Browser's material thumbnails use the same preview. The engine's offscreen preview target now has a depth buffer, so a mesh drawn there is no longer drawn inside out.

  • The 2D animation editors are redrawn. In the sprite animation editor the view's tools float over its corner, playback and the timeline are one panel, frame events are flags on an event track (click one to rename, move or remove it), the frame source folds into a strip that opens on an empty clip, and frame rate, loop and Save no longer appear a second time in the inspector. The animator controller shows states as cards with their clip and speed, wires between a pair of states run side by side with a pill for the condition (dashed when it waits for the exit time), and its inspector puts the selected state or transition first, with the controller's layers, typed parameters and a folded constraints section below.

  • The tile editor matches its design. The layer and tileset menus sit on the raised surface, a picked tile has a 2px frame and shows its id on hover, the brush column shows the tile id, the replace dialog's button says Replace, and the tileset inspector shows one-way and trigger as switches, the layer opacity is a slim slider, and a collision layer's friction and bounce fields are flat with their own heading.

  • Collision layers are easier to paint. A new collision layer takes its cell size, origin and position from the tilemap it sits over instead of a fixed 32px; solid, slope, one-way and trigger cells read differently in the viewport; the cell grid is drawn over the art while tiles are painted; the brushes are grouped, named on one line and picked with the digits 1–9; and the layer menu and the empty palette offer a new collision layer. Tilemap and collision layers have their own icons and type names in the Outliner and Details instead of reading as sprites.

  • Tilemap editing is redrawn around the viewport. Painting tools and the active layer sit in the viewport toolbar once you enter the tile context; the atlas, terrains, stamps and current brush (flip, rotate, random) live in a wide Tile Palette tabbed beside the Content Browser; the layer menu keeps visibility, lock, order and opacity, with Replace tiles as a dialog that shows how many cells it will change. The tileset editor puts the atlas on the left and the collision, terrain, animation and property settings in an inspector on the right. Painting tiles no longer shows the old tilemap badge in the viewport, and the tool name joins the cell readout.

  • A redrawn viewport toolbar, and flying the eye. World/Local, Center/Pivot/Individual and 2D/3D are side-by-side choices with an icon each and the current one raised; grid snap is a switch beside its increment; the screen size and device menus moved to the right beside Show and Gizmo; and the bar drops words before it ever cuts a control off. In a 3D view, holding the right mouse button and pressing W A S D Q E flies the eye (Shift is faster) without switching tools.

  • Floating panels and pop-out windows are designed. Right-clicking a tab offers Close, Close Others, Float, Move to new window, Maximize and Reset Layout; each docked group has a ⋯ menu beside its collapse chevron; a floating panel is a rounded, outlined card with Dock and Close buttons; drop zones and splitter hover use the accent; and a popped-out window drops the system title bar so its tab strip is the title bar, with a Dock to main window button and the panel's name as its title.

  • Tabs with icons, and a calmer Content Browser. Every dock tab carries its panel's icon; the Content Browser toolbar puts New and Import first and the search, filter, sort and view switch last, a filter shows as removable chips, and asset items lose their type pills and colour lines for a small corner icon, a two-line name and a ring when selected.

  • The viewport's minimap is gone. The scene overview in the bottom-right corner and its View menu entry are removed; the camera preview, which shows when a camera is selected, is the only overlay left there.

  • A project can no longer open with no panels. A saved layout made only of empty groups is ignored on restore and is never saved, so the editor falls back to the default layout instead of showing blank docks.

  • Running-game polish. The viewport tab shows a green or amber play mark while the game runs or is paused, the status bar's log line shows only warnings and errors, and a vector field (Position, Rotation, Scale) no longer wraps to two rows when the inspector has a scrollbar.

  • Run after a failed start. When a Play session fails to start, the run button goes back to the ordinary Run instead of staying red like Stop, so retrying is obvious; the failure is still shown in the status bar and a notice.

  • The main window names the scene. The viewport tab carries the scene's name and an unsaved mark, the outliner opens with a scene row (name, unsaved mark, entity count, a menu to save or locate it), an entity's header has an enable box, and the status bar shows whether the scene is saved and the newest log line.

  • Strings go to and from Excel. The string table editor exports every language as one .xlsx or .csv sheet (a column per language) and imports one back, merging by key: it lists the new keys, changed translations, skipped columns and conflicts before anything is written, never clears a translation with an empty cell, and leaves plural entries alone. Before exporting it reports missing keys, untranslated strings, mismatched {placeholders} and plural forms a language needs.

  • A tidier launcher. Recent projects are a table with name, path, last opened and build, sortable, with a row menu to show the project in its folder, copy its path or remove it; templates are icon tiles and an empty list says what to do.

  • Toasts show their kind. Information, success, warning and error toasts carry an icon in their own colour, and warnings in the Agent, Project Health and Plugins panels are tinted blocks rather than side-striped cards.

  • A string table editor. Opening an .eslocale shows every language side by side, one row per key, with untranslated cells marked, a filter, and add and remove for keys; edits save to each language's file at once.

  • The utility panels share one look. Filter chips and buttons are quiet instead of outlined, the Lighting and Project Health panels use ruled sections without side stripes, and the Scatter brush panel is a proper form.

  • Textures can turn mip maps off, and the preview zooms. A texture's import settings have a Mip Maps switch (on by default; turn it off for pixel art and UI drawn at their own size), honoured in the editor, the cook and the shipped build. The preview scrolls to zoom and drags to pan, and shows the image, its 9-slice or its sprite sheet one at a time.

  • Outliner selection is quieter. A selected row is a soft tint instead of a solid block, and rows selected together join into one rounded block.

  • The input map editor captures keys. Press "Capture" and the next key, mouse button or gamepad press becomes a binding; click a key cap to rebind it, and a key that another action also uses is flagged on the row.

  • The interface font is a setting. Choose Rounded (the default, which prefers HarmonyOS Sans SC or MiSans for Chinese text when installed), Sans, Serif, or the name of any font installed on the computer, under Settings › Editor › General › Appearance.

  • An asset's header names its kind and size. The line under the name reads, for example, "Texture · 18 KB" in your language rather than the internal type name, and a segmented switch is used only when its words fit side by side, otherwise the choice stays a dropdown.

  • Asset inspectors are redrawn. The preview is a rounded card, the facts about a file are ruled key-value rows, the open and copy-path actions are tinted buttons, the header carries the asset kind's icon in its colour, and a texture's border values read as chips. A property's label column is wider, and a segmented switch whose options are long now clips them instead of overflowing.

  • Details and segmented switches get the finer finish. The prefab bar and the stale-override warning are flat tinted banners, a component's heads-up and action button match them, Add Component is a tinted button in the header, component glyphs carry a hue by kind, value wells use the smaller mono size, and a selected segment of any switch is a raised neutral instead of an accent fill.

  • Details is redrawn in a flatter style. Components are separated by a hairline rather than a dark band, the axis letters of a vector are coloured text rather than filled blocks, property rows keep a fixed label column, and a choice of two or three options is a segmented switch rather than a dropdown.

  • Details fields fit better. A gradient, curve, property map, effect list or set of weights takes the row's full width with its label above it; a four-value field (a rectangle, the four sides) is laid out two by two; and a curve key's interpolation is a themed dropdown instead of the system's.

  • The editor has a new set of design tokens and a tidier main window. Surfaces step further apart, text is one size larger, corners are rounder and the title bar, tabs and property rows are taller. The viewport's readout now carries the selection's position and rotation, so the status bar loses its cursor and selection items and keeps the session's state, the frame's cost and the engine.

[0.91.0] - 2026-10-16

Added

  • Audio demo exercises authored sound events. Three weighted no-repeat footsteps, two sequential button variants and rate-limited collision bursts reuse the existing percussion clips. Source buttons expose seeded selection parameters and shared playback/rejection counts; normal exports retain all definitions and candidate dependencies, with an eight-voice project budget.

  • The Lighting panel names the scene's environment and binds it. An Environment section shows the Ambient light the frame takes its sky and image-based light from, binds its .esenv with the usual asset picker, adds an environment light when the scene has none, and says why a sky is missing: no Ambient light, none naming an environment, an asset the project no longer holds, a light that is hidden, switched off or at intensity 0, a sky not drawn, or a later light that loses to an earlier one. Lights are never deleted or overwritten to settle it. It draws the environment as a panorama with a matte and a mirror sphere, turned the way the frame and the bake turn it.

  • Saved environment looks. environmentPresets in the project file keeps an environment asset, whether it is drawn as the sky, its rotation and its intensity under a name. Applying one lists the fields it changes first, writes them as one undo step, and refuses a look whose asset has gone, naming the path. Saved from the panel or edited in Settings, Rendering.

  • The Lighting panel explains the selected object's light. Baked atlas, probe volume (named), the frame's lamps, or only the environment; and why a part is missing: never baked, a moving object outside every probe volume, no probe volume in the scene, or not a surface a bake reads.

  • An environment can be made from six images. A .escube names one PNG or JPEG per face, each turned or mirrored on its own, read as a viewer inside the box sees it. The inspector assigns the images, marks the face an import cannot read, and draws the resulting panorama to check seams and turns by. New Cube Environment creates one; a missing, non-square or mismatched face is named and a black face is never filled in.

  • OpenEXR panoramas import as environments. Scanline lat-long files in NONE, RLE, ZIPS, ZIP or PXR24, half or float. PIZ, B44, DWA, HTJ2K, tiled, deep, multi-part and cube-map files are refused by name with what to save instead.

  • A low-dynamic-range panorama picture can be the source. One lat-long PNG or JPEG in a .escube, with its colour space chosen, imported with a note that an 8-bit picture holds no light brighter than white.

  • An environment import reports what it clipped, and the sky has a width setting. Every import measures its sizes, bytes and the share of the source brighter than the 8 the sky and reflections store, and warns when some is. Sky Width joins Reflection Size in the import settings, Reflection Size gains 512 px, and sizes past what an import allows are limited with a warning.

  • The viewport can light the scene with a studio preview, and expose it. A neutral sky, a key and a fill replace the scene's lights in the editor view only, with a preview exposure in stops; none of it is a scene entity, is saved, or reaches a packaged build, and one click returns to the game's own lighting.

Changed

  • One rule picks the environment light. The frame, the bake in the editor and the command-line bake each chose their own; the two bakes took the first light naming an environment whether or not it was enabled, hidden or lit. They now take what the frame takes, so a scene whose first environment light is switched off bakes against the next one.
  • UASTC textures ship under zstd. Cooked and cached UASTC textures are supercompressed: 59% fewer bytes over a sample of 24 ORCA Bistro textures, 47% over 256-pixel crops of them, with identical decoded pixels. Existing cook caches are encoded again once.
  • An Android package carries the phone ABI only. An empty APK was 75.9 MB, half of it the emulator's x86_64 libraries no phone can run. Packages now carry arm64-v8a; tick Include the emulator (x86_64) in the Android settings, or pass --emulator-abi, for a build to install in an emulator. The same choice applies to the App Bundle. The template's libc++_shared.so is stripped like the other two libraries (9.2 MB to 1.3 MB per ABI) from the next published template; an empty arm64 package measured 38.3 MB with the current one.
  • The settings window is ten pages, not sixteen. An Editor / Project switch separates the editor's own preferences, kept on this machine, from the project's, kept in the project and shared with whoever opens it; each side is four pages, and the old sections are headings inside them. A row is one line with its explanation behind a ?, a changed setting is marked, a page can be reset in one click, and the 49 settings that are rarely changed (the physics solver, the UI theme's colours, the engine module switches, device-quality tuning) are folded under Advanced. Search covers both sides and names where each hit lives. A plugin's section still gets a page of its own.
  • The editor's chrome is tidier. The menu bar and toolbar are one title row, with the menus on the left, Play in the centre and Compile on the right. The panel buttons down the rail are one Panels flyout that ticks what is on screen, and the Sequencer opens from it instead of holding a permanent tab. The viewport's five display toggles are one Show menu, the Content Browser's row of type chips is a Type menu, and the status bar reads the frame's cost as one group.
  • Every document editor and every Details view has one header. The Flipbook, Tileset, Animator, state machine, behaviour tree, script graph, material graph, sound event and Sequencer editors show the file's name, a stat and Save on a first row, with their tools on a second; the Details panel's entity, asset, folder and live-game views share one header, and Save looks the same wherever a thing saves.
  • The Outliner and the launcher lose their duplicate controls. The Outliner's folder and entity buttons are one Add menu, the live-world banner is a pill on the source row, the column header row appears only when extra columns are on, and the columns are chosen from the sort menu. The launcher's New project button is on the Recent page beside the search, rather than in the top bar, the rail and the page.
  • Content Browser tiles and the Details header are redrawn. A tile is a card with the type code and colour on its thumbnail, status chips for the startup scene, export exclusion and delivery mode at the top right, a check mark when selected, a checkerboard under images and their pixel size beneath; delivery badges show on the folder tree. The Details header carries the kind's icon, an editable name, one quiet line of facts, and the Add Component button.
  • Docked panels are rounded cards. Panels sit apart on the window colour with rounded tabs, and the viewport's line of tool hints, which showed all the time, is now off until you turn it on in the View menu.
  • The Outliner and Details match their new design. The Outliner opens with labelled Lock and Visibility columns, always visible, and the Type column is off until you turn it on from the sort menu; a component's help and menu buttons stay in view, and a modified property is marked with a dot.

Fixed

  • The Neon Ascension example exports and boots. Its scene and materials had no .meta files, so a packaged build could not find the scene.
  • Animated sprites play in the viewport whether or not they are selected.

[0.90.0] - 2026-10-15

Added

  • Sound events have a dedicated authoring panel. Create from audio selections or the Content Browser, drag in variants, reorder and edit weights/ranges with shared undo, save, reload and workspace handling. Continuous preview uses the runtime event manager and existing mixer/voice pool, showing the sampled clip and parameters alongside the shared waveform. A bounded peak cache avoids repeated waveform decoding and invalidates on disk/project changes.

  • Sound event sources share code and graph triggers. SoundEventSource references the same validated event assets as SoundEvents; script graphs, FSM hooks and BT actions expose trigger/stop verbs. Same-frame triggers retain their order, cold definitions retain at most 256 intents per source, and source lifetime checks cancel stale definitions and clips after edits, removal, disable, Stop All or teardown. Scene preload, inspector pickers, UUID projection and export dependencies use the shared asset metadata.

  • Sound event playback owns pending and paused voices. The per-App SoundEvents resource loads owned emitters, shares event concurrency and cooldown before clip IO, and routes selected clips through the existing Audio priority pool. Natural completion, Stop All, owner despawn, registry disconnect and App cleanup release receipts and cancel late starts. Requests expose selected parameters, lifecycle and rejection reasons; spatial events reuse source attenuation/panning. Pending admissions avoid rescanning the loading queue, and unchanged gains skip backend writes.

  • Sound event definitions share deterministic selection. Beta .esaudioevent assets validate weighted clip slots, sequential and no-repeat selection, volume/rate ranges and event playback settings. The shared selector uses independent seeded streams for clip and parameter choices, combines duplicate audio identities, and reports empty or disabled pools. Definitions load through Assets without decoding every candidate; export dependency scanning retains all candidates and UUID references survive file moves.

Fixed

  • Editor Play can connect to game servers. The Play realm permits HTTP(S) requests and WS(S) sockets through the same SDK Web platform adapter used by exported games. This fixes createSocket failing against the local server in the multiplayer-arena example (#97), while preserving script restrictions and editor isolation. A headless Chromium regression checks cross-origin requests, text and binary socket round trips, and normal connection shutdown.

  • Asset documents retain edits made during a save. A completed JSON write only marks the document clean if its asset and path still match the written snapshot. Pending file opens are also invalidated when the project changes.

  • Mixer bus edits retain the project's voice budget. Adding, changing or removing a bus preserves the other audio settings, including an explicit unlimited voice count, instead of silently restoring the runtime default limit.

  • Unchanged 2D joints retain their solver state. Paused collision edits, full mutation-history refreshes and identical joint writes preserve existing constraints instead of destroying and recreating them. Missing solver joints recover on reconciliation, changes to the live Canvas scale rebuild joint dimensions, and older cores observe joint writes after a previous physics run in the same tick. All six joint types retain their enabled and partner-lifetime behavior.

Known issues

  • The Neon Ascension example failed Android and iOS template boot checks in 0.89.0 and iOS template checks in 0.89.1 because the exported package could not load its entry scene. This release does not resolve or claim device acceptance for that example on those platforms.

[0.89.2] - 2026-10-16

Fixed

  • Physics reconciliation follows component mutation cursors. Body, collider and activity edits reconcile affected World-owned entities, including native hierarchy changes and edits between fixed steps in one frame. Paused and disconnected consumers release their readers; component stamps survive without retained history and skip unchanged body definitions on resume. Full refreshes compare shared collision-definition snapshots to retain unchanged shapes and contacts; native reset epochs distinguish registry resets from history overflow so overflow recovery preserves solver velocity. Static poses and one-way platform updates follow affected entities, while older cores retain the full-reconcile path.

Known issues

  • The Neon Ascension example failed Android and iOS template boot checks in 0.89.0 and iOS template checks in 0.89.1 because the exported package could not load its entry scene. This release does not resolve or claim device acceptance for that example on those platforms.

[0.89.1] - 2026-10-16

Fixed

  • Tile edits preserve unaffected collision chunks and contacts. Runtime collision reuses native chunk revisions and replaces only changed chunk bodies, retaining other body identities and resting contacts. Frame and fixed-step edits derive before physics, while tile animation advances once per rendered frame. The editor and runtime share owned chunk readback that survives WASM memory growth and releases temporary buffers; older or failed readback falls back to content comparison. Layout, cell dimensions, material and lifetime changes still rebuild the affected geometry.

  • Moving static collision uses a shared batch pose channel. The engine exports composed 2D poses for selected active entities and physics applies them in one call, skipping unchanged solver poses. Web modules copy populated rows between their heaps; native hosts use their shared arena. Batch rows share a generated C++ stride, lazy world fields are decomposed before export, temporary buffers are released on failure, and hosts without the new calls keep the scalar path.

  • Static physics synchronization skips unchanged body groups. Authored Transform writes select individual static bodies, while each immediate parent's composed frame selects only its affected children. Unrelated dynamic or authored motion avoids per-body change checks and pose reads. Reparenting, re-enabling and pixels-per-unit edits refresh the correct bodies. Paused simulations release write history and refresh poses on resume; plugin cleanup releases the reader and frame/despawn observers.

Known issues

  • The Neon Ascension example failed Android and iOS template boot checks in 0.89.0 because the exported package could not load its entry scene. This release does not resolve or claim acceptance for that example on those platforms.

[0.89.0] - 2026-10-16

Fixed

  • Tile collision overlays project only visible local chunks. The editor culls cached local geometry before placing world points, uses each layer's current rotation, origin offset and depth, and updates moving-layer previews every frame. Chunk and shape bounds retain oversized shapes crossing the viewport. Large-map movement avoids tile readback and complete-map point allocation.

  • Tile collision follows painted and imported layer layouts. Static boxes, rich shapes and legacy polygon helpers share layout-aware cell placement. Projected box merging preserves the authored union without filling holes. Tiled runtime collision belongs to each derived layer and follows its transform, layout edits and lifetime through the same path as painted layers. Origin-offset edits move existing bodies without re-exporting tiles, and direct Tiled loads retain their grid metadata.

  • Staggered and hexagonal picking follows cell polygons. Core queries identify the containing diamond or hexagon instead of its rectangular partition, including negative coordinates and either stagger axis/index. Drawing and coordinate queries share native grid geometry, while editor outlines use the same effective hex side limit along the stagger axis. Shared edges resolve to a touching cell; rotation and translation preserve cell ownership. Picking examines at most three neighboring stagger lines without reading tile contents.

  • Rotated tile layers share one frame for drawing, picking and collision previews. World Z rotation, including parent rotation, applies to tile vertices, visible chunk selection, editor grids, brush ghosts and world-to-tile queries. Collision previews rotate cached local geometry and keep large shapes visible when their bounds overlap the viewport. Generated tile one-way platforms rotate their solid side with the physics body; ordinary one-way platforms retain world-space normals unless localSpace is enabled. Static-parent rotation needs no repeated normal submissions, and rebuilt shapes restore their pre-solve behavior.

[0.88.0] - 2026-10-15

Added

  • Post-process volumes blend effect colors. Volumes can override named RGBA parameters, blend from effect defaults by weight and priority, and apply colors to the rendered effect stack. Stable effect signatures include colors so unchanged frames keep the existing stack.

  • Neon Ascension adds a night-city grey-box example. Authored materials and an HDR panorama provide a scene for inspecting environment reflections, emissive bloom and warm/cool light contrast. Rain streaks and vent steam add animated scene content. Known scene limitations are documented with the example.

Fixed

  • Moving tile collision previews reuses local geometry. Layer and parent translations place cached local outlines without scanning tiles or rebuilding collision geometry. Polygons, circles, sensor flags and one-way normals retain their authored shapes, depth-only changes reuse placed coordinates, and earlier preview snapshots remain unchanged. Cell dimensions, collision metadata and tile edits still invalidate the corresponding local geometry.

  • Tile collision edits read only changed native chunks. Editor collision previews read a bounded coordinate/revision index and copy cells only for changed chunks, retaining independent arrays and geometry for untouched chunks. Edits avoid full-map serialization and decoding; imports, erasure, layer recreation and world changes refresh the correct data. Empty chunks retain only revision metadata. Temporary buffers are freed after each read, invalid output spans are rejected, and unavailable or failed readback falls back to the full-export path. Saved scene formats remain unchanged.

  • Stable tile collision previews reuse their native content and geometry. Editor refreshes skip tile export, decoding and plane mapping while the owning world, registry, core, layer generation and edit revision are unchanged. Metadata, cell size and origin changes reuse the encoded content; depth-only changes remap the existing geometry. Edits and undo retain incremental chunk rebuilds, replaced worlds and layers invalidate snapshots, and older cores without version stamps still read their current contents.

[0.87.2] - 2026-10-15

Fixed

  • Training resumes with gameplay keyboard focus. Starting or resuming a round releases the menu control's focus, updates its Focusable state and emits Blur, so Space fires instead of reopening a rewarded break after an ad. Blur callbacks remain effective and menu buttons retain keyboard navigation.

  • Tile collision previews follow unsaved tileset edits and undo. Editor outline models read the open tileset document and refresh on relevant document edits, undo/redo, disk changes and project switches. Ordinary scene edits and unrelated documents retain the cached model; obsolete requests stop loading later tilesets and cannot publish into the new preview. Closing a document restores the saved asset's collision metadata.

  • Windowed editor lists attach to the scroller that actually mounted. Resource grids and shared virtual windows subscribe after ancestor refs are available, reattach when their elements change, and retain scroll and size observation through StrictMode cleanup. Large lists keep updating visible rows instead of remaining on the first batch or using a single fallback column.

  • Editor row reveals finish after real grid measurements arrive. Explicit navigation follows measured row height, viewport height and column changes instead of stopping at an estimated offset. New user input cancels that follow-up, so later layout changes do not pull the user back; a new navigation request can reveal the row again.

  • Virtual joysticks follow the rendered transform through sheared UI hierarchies. Pointer coordinates use the complete 2D render matrix instead of decomposed rotation and scale, preserving local direction and strength under rotated, nonuniform ancestors and keeping follow-mode origins aligned. Singular or nonfinite transforms release capture until a fresh press. Dragging shares the same inverse-basis reader; its scratch allocation is reused, refreshed after heap growth and freed by its owning core.

  • Virtual controls share each sample's pointer projection. Stable buttons and joysticks group held pointers and completed taps once instead of cloning and scanning every pointer for every control. A change callback invalidates the grouping before later controls run, preserving capture cancellation and concurrent move/fire behavior.

  • Virtual controls stop when their authored UI is hidden. Buttons and joysticks read current display ancestry instead of the previous layout's hidden cache. Hiding a captured control releases its source on the next sample and showing it requires a fresh press; new presses on shown controls are accepted before layout catches up. Change callbacks invalidate shared visibility reads before later controls are sampled.

  • Named actions reach fixed simulation steps independently of render frames. Input maps sample before FixedUpdate instead of exposing the previous render frame's actions. Presses and releases survive frames without a fixed step, reach only the first catch-up step, and remain independently visible to Update. Pending flags use constant space per action, host cancellation drops buffered pulses, and current axis values are sampled for each cadence.

[0.87.1] - 2026-10-15

Fixed

  • Button actions retain complete keyboard and mouse taps between samples. A press and release within one frame produces both action edges once without leaving the action held, and each input map observes its own pulse. Ordered edges also retain release/repress cycles between samples while overlapping alternative bindings stay held. Frame cleanup and host cancellation drop pending pulses; a held alternative absorbs them without replay. Button alternatives use the strongest input so weak analog sources cannot combine into a false press or cancel a keyboard binding.

  • Screen-domain queries reject another world's cached entities. The UI binding checks registry identity and entity validity before using the resolved screen-domain cache, preventing reused IDs from borrowing a previous world's pointer coordinates and excluding despawned nodes before the next layout pass.

  • Authored UI hiding cancels dragging before another layout pass. Hiding a dragged node or its ancestor stops capture and emits one drag-end event immediately on the next sample, including visibility changes inside drag callbacks. Stale hover cannot start a hidden control, and showing it again does not resume an old capture. Dragging and keyboard focus share the same live visibility rules.

  • Dense change queries bind their live sequence index once. Added and Changed filters reuse component-specific matchers during entity iteration, avoiding repeated world and component lookups while retaining precise system boundaries, stable-frame skipping and visibility of later component replacements.

  • System change queries see additions and writes after earlier runs in the same frame. Added and Changed filters use completed-system mutation sequences while explicit tick-based query instances keep their existing windows. Systems consume their own writebacks without retriggering themselves; compiled writers and asynchronous reads share the same boundaries. Stable queries skip candidate enumeration, and live sequence stamps reuse tick records and disappear with removed components.

  • Removal queries retain events across system runs in the same frame. Removed component events use reader-owned sequence cursors, so removals after a system runs or after its last read remain available on its next run. Fresh readers start from registration, paused and async readers keep their claims, and fast readers skip retained history rather than repeatedly scanning a paused reader's backlog; explicit tick-based samplers keep their existing windows.

  • Recreated UI components start a fresh visibility baseline. Removing and reinserting a UINode no longer inherits its predecessor's shown/hidden state, including edits between frames or within one frame. Removed nodes leave the visibility cache; opted-in live component identities distinguish replacements without retaining removal history or adding resolved visibility reads on steady frames.

[0.87.0] - 2026-10-15

Added

  • Navigation replacements commit only from the latest request. Versioned surface-update handles reject cancelled and superseded results, retain destinations while the navigation driver waits, and resume after commit or cancellation. Route inspection explains pending updates; the courtyard workshop adds asset-backed terrain reload/cancel controls. Producers still own background computation and I/O cancellation.

Fixed

  • 2D navigation doors close without the mesh bake delay. Grid obstacle marking runs on the next navigation tick even when the previous obstacle update was less than 200 ms ago. Closing and reopening a passage immediately invalidates cached connectivity; polygon mesh baking keeps its existing throttle.

  • Couriers can pass occupied intermediate grid waypoints. A parked agent no longer traps a follower at an intermediate cell centre. The follower may join the next route segment only when its full body fits the connection through the static grid; final destinations still use the existing arrival rules.

  • Crowd followers honor the configured final arrival radius. Intermediate waypoint tolerances no longer complete a route before its final goal is within the agent's stop distance. Kinematic followers and character steering retain their intermediate reach behavior; zero arrival radius continues toward the actual endpoint.

  • Finished Web audio handles release their runtime references. Stopped and naturally completed voices drop decoded buffers, sources, pool nodes and contexts after releasing their pool slot. Retaining a finished handle keeps its ID and duration available without pinning PCM; terminal controls remain harmless, while paused voices retain the state needed to resume and natural completion still notifies once.

  • Audio aliases share decoded buffer ownership. References resolving to one source share pending decoding and PCM accounting while retaining independent asset leases. Releasing one reference leaves other holders playable; source invalidation retires all aliases without unloading a replacement, and trimming frees each physical allocation once.

  • Loading sound-effect handles preserve playback controls. Stopping before load completion prevents voice allocation and cannot be undone by Resume. Volume, pan, loop and playback rate apply to the initial backend play; queued Pause starts muted before pausing and restores the intended bus-adjusted gain. Resolved handles expose the real voice ID and forward completion callbacks, while later controls keep delegating normally.

  • Stop All stops every owned audio voice and pending start. Scripted effects, explicit tracks, paused voices and outgoing music fades are stopped once, and stopped handles cannot resume outside the voice registry. Pending effects and tracks requested before Stop All cannot start on load completion; cached buffers and the device remain reusable, and disposal uses the same shutdown path.

  • BGM playback follows the latest request instead of load completion order. New requests and stop commands invalidate older pending starts, including when the replacement is already cached. An immediate stop also ends a track already fading out, while repeated positive fade-out requests preserve the existing ramp. Loaded buffers remain available for later playback.

  • Web audio loads cannot cross disposed or replaced contexts. Async reads and decodes capture their context generation and validate it before decoding or publishing a buffer. Late work rejects without borrowing a new session's cached handle, replacing its source entry or repopulating disposed storage; current-session loads and same-session source revisions retain their existing behavior.

  • Web audio source records follow live buffer ownership. URL cache entries and invalidation identities retire after their current buffer and pending loads are released, instead of retaining every historical scene path. Distinct source records preserve overlapping invalidated loads, and unloading an older result leaves the replacement cached; failed loads release their records too.

  • Web UI getters can reach their generated pointer accessors. The optional UINode pointer export avoids full component object marshaling for pre-resolved readers, with existing generated layout assertions and fresh pointer resolution after pool growth. Live focus queries use compact per-query visibility flags and pre-resolved parent reads to reduce transient work; older cores retain the getter fallback.

  • Ineligible text fields reject late editing callbacks immediately. Hidden fields and controls outside a newly opened modal cannot commit delayed changes, composition endings or submissions. The rejected session releases its OS editing surface and preedit state, so eligibility returning before another frame reattaches the committed value instead of replaying stale input; fields inside the active dialog remain editable.

  • Keyboard focus observes authored visibility between layout passes. Focus traversal and single-target checks read current display ancestry, so hiding a tree or opening a previously hidden modal immediately changes eligibility without waiting for the cached layout bit. Per-query ancestry memoization and borrowed component reads share work across controls; hosts without authored UI ancestry retain their existing visibility fallback.

  • Text-input length limits preserve complete supplementary characters. Oversized host input still uses UTF-16 length limits, but truncation backs off when the boundary would split a valid surrogate pair. The corrected value and selection return to the editing surface together, preventing malformed emoji in committed input while preserving BMP limits and existing cursor semantics.

  • Text fields read only the editing surface they actually own. Newly focused fields retain their committed display until attached, and read-only fields never borrow a previous field's transient value. Switching a live field to read-only detaches the OS surface and hides its caret; restoring editability reattaches the committed value without replaying rejected input.

  • Grid path searches reuse their working memory. Repeated queries reuse per-grid score, parent, visitation and heap storage instead of allocating map-sized buffers each time. Search stamps isolate queries, nested searches receive separate storage, exceptions release leases, and returned routes remain caller-owned. Weighted paths, snapping and best-effort endpoints retain their behavior.

  • Native text measurement wraps without rescanning growing prefixes. The public measurement path appends ordered glyph advances through the shared greedy wrapper, avoiding quadratic cache queries and repeated host rasterization when long text exceeds the bounded working set. Whitespace, supplementary characters and signed spacing keep existing line breaks and metrics; Canvas retains whole-string measurement for non-additive typography.

  • Public native text measurement retains a bounded advance cache. Historical font revisions, sizes and missing-glyph estimates retire from a 4096-entry working set. A second-chance clock keeps recently queried advances reusable without reinserting Map entries on every character; failed host measurements leave retained entries intact. Widths, wrapping and the Canvas measurement path retain their existing behavior.

Added

  • Build and reroute deliveries in a textured 2D courtyard. The Citadel Route Workshop includes CC0 pixel art, editable gate/storehouse obstacles, touch buttons and eight/24 couriers. Built-in partial routes retain their destination and resume after reopening; parked-body avoidance can escape stationary solutions. Body-radius occupancy, fractional grid clearance and sampled movement checks stop corner cutting and recover blocked routes. The Web acceptance tool records pointer/touch input, per-frame footprint checks and export identities.

  • Agent replans share a fair per-frame budget. Navigation defaults to a FIFO queue with 16 plans and a 2 ms soft planning budget per tick; limits and last-tick counters are exposed on Nav and sampled in the Play inspector. Queued edits coalesce, agents without valid routes pause safely, periodic refreshes keep valid movement, and surface/grid/radius invalidation retires stale routes. Direct queries remain synchronous. A single query may exceed the budget, and spreading work adds route latency.

  • Inspect a live agent's current route on demand. The Play inspector reports partial routes, disconnected regions, insufficient clearance and baked-radius mismatches, with sampled world endpoints, radius and query cost. It queries only on request, discards results across selection/session changes, and identifies unsupported device sessions or custom implementations explicitly.

  • Navigation queries distinguish complete routes from best-effort paths. queryWorldPath reports missing surfaces or endpoints, disconnected regions, grid clearance failures and mesh radius mismatches; custom surfaces without diagnostics report unknown. Grid searches reuse revision-scoped connectivity after a failed search, while walkability and dynamic obstacles invalidate it. Dynamic blockers now contribute to body clearance; the legacy path API keeps returning partial approaches.

  • Spatial transform handles fade behind scene geometry. A persistent Viewport setting can restore always-visible handles; flat 2D widgets retain their appearance. Scoped immediate-draw depth state disables overlay depth writes and restores the previous state, including when drawing throws. Older cores keep their existing overlay fallback.

  • Spatial rotation adds a view-axis outer ring. The outer ring remains a screen circle and uses the presented camera axis captured at the press, with absolute twist snapping and the same undo/cancel path. Local inner rings use their rotated world axis; rotation writes, including Alt copies, convert through each target's parent frame. Flat 2D retains its existing Z ring.

[0.86.1] - 2026-10-15

Fixed

  • Font reloads retain independent handles and glyph caches. Each loaded revision uses its own platform family and runtime handle, so retiring an older asset cannot unregister its replacement or reuse stale glyph measurements. Failed and late registrations preserve live revisions; repeated outline-font unloads remain harmless. Platform font-face retention is unchanged.

  • Project font identities preserve complete asset paths. Reversible, CSS-safe UTF-16 encoding replaces the short path hash, separating same-named files, supplementary characters and escape boundaries without retaining a name registry. Loading a second font no longer overwrites another asset's browser family. Internal family strings change; derive them through familyNameFor rather than persisting generated names. Asset references and runtime font handles keep their existing interface.

  • Missing-glyph warning history follows the bounded cache. Diagnostic suppression retires when a family no longer has non-drawable glyphs in the 4096-entry CPU cache, preventing historical font names from accumulating. Cached-character queries keep their existing fast path, partial retirement and nested rasterization preserve reference counts, and cleanup releases the history. Unsupported-character warnings no longer claim the entire font cannot draw.

  • Automation projection settings persist across editor state changes. Programmatic perspective changes update the same state used by the editor toggle, so choosing a tool or changing display preferences no longer restores the previous projection. Repeating an unchanged setting avoids UI notifications while reapplying it to the engine; scene cameras remain unedited.

[0.86.0] - 2026-10-15

Fixed

  • Pointer dragging follows sheared parent transforms. World deltas use the inverse of the parent's complete flat transform for both local positions and UI insets, preserving pointer alignment through non-uniformly scaled, rotated hierarchies. Singular transforms end capture without modifying hidden coordinates. Per-App matrix scratch is allocated lazily, reused across frames and released with capture on plugin cleanup; cores without matrix access retain their existing fallback.

  • Web audio startup failures release pooled nodes and keep resumes retryable. Source creation, configuration and start errors return the acquired node before propagating the error, preventing failed plays from growing the pool. Failed resumes disconnect the rejected source while preserving the paused voice and playback offset; successful retries commit playback state only after startup succeeds.

  • Tilemap rectangle fills clip safely across integer coordinate bounds. Finite layers intersect the requested rectangle before visiting cells, avoiding work outside the map. Wide endpoint arithmetic preserves unsigned extents and clips infinite writes to representable coordinates; empty intersections return immediately. Negative chunk division avoids signed overflow, preserving tile storage and chunk import at both integer edges.

  • Paused sprite motions wait for actual completion before exit transitions. Animator exit-time checks require the matching SpriteAnimator completion latch and stopped playback. Pausing or seeking to a stopped frame preserves the current state; resumed one-shot playback can complete normally, while a pending replay does not count as an ended clip.

  • Measured lists locate visible items without scanning every preceding row. Ordered cached offsets use binary searches for both viewport boundaries. Non-monotone or non-finite offsets retain the existing scan semantics. Failed measurements do not publish a completed cache, and list synchronization stays dirty after errors so a subsequent update can retry.

  • Plain-text wrapping avoids repeated whole-line glyph measurements. The atlas-backed wrap path appends glyph advances in their original order while sharing the greedy wrap decisions with arbitrary string measurement. Long words and wide lines stay linear in glyph queries; spaces, supplementary characters and signed spacing preserve prior line breaks and geometry. Canvas string measurement retains its existing behavior.

  • Long plain-text overflow trims with linear glyph measurement work. Clip and Ellipsis reuse one pass of prefix advances instead of remeasuring every shorter candidate. Trimming retains whole code points, trailing-whitespace handling and signed letter spacing; matching prefix order preserves the existing glyph geometry.

  • Page-free text glyph caches stay bounded. Missing and oversized glyphs, whitespace metrics and measurement-only entries use a 4096-entry least-recently-used cache. Historical fonts and sizes retire without touching live drawable pages or cached layout coordinates; recently used measurements remain cached and retired entries rasterize again on demand.

Added

  • Spatial transform handles expose all three planes and distinct centers. Move/scale tools offer camera-facing XY, YZ and ZX parallelograms, hiding edge-on planes and sharing their projected corners with hit tests. Spatial move uses the presented camera's screen plane, spatial scale uses one XYZ factor, and Local drags use the rotated plane normal. Head-on 2D keeps its original handle set; Universal shares the spatial move planes.

  • Universal Transform combines move, rotate and scale handles. The viewport toolbar and Command Palette offer a combined tool on Y, preserving T for Rect. Move handles win overlaps, then outer scale boxes, then rotation rings; each drag captures one operation and highlights only its target. Scale boxes remain separate from arrow tips, and their drag sensitivity uses the captured box-arm length. Existing pivot, size, transaction and copy paths remain shared.

  • Alt-copy on transform handles reaches the tool. Camera orbit no longer consumes an Alt-left press on a visible, editable selected transform handle; the rest of the canvas retains its navigation behavior. Individual Origins starts duplicates at the originals' positions before applying rotation or scale, and CI saves intermediate observations even when a gesture check fails.

  • Multi-selection transforms support Individual Origins. The viewport pivot control cycles Center, active-object Pivot and Individual Origins, with direct View menu and Command Palette choices. Individual rotation and scale keep each transform target's position, while translation, hierarchy pruning, locks, snapping and the existing undo/Alt-copy path remain shared. Each gesture captures its pivot policy.

  • Transform handle size is configurable. Editor settings scale move/scale handles, rotation rings and hit areas together from 0.5 to 2, with the legacy size as default. The preference persists across sessions; active handle drags keep their captured size and sensitivity until release or cancellation.

[0.85.0] - 2026-10-15

Added

  • Transform handles preview the pointer's target before a drag. Move/scale axes, the center plane and rotation rings use the same hit decision for hovering and pressing. Hover uses the drag highlight and projected resize cursor; it follows camera and selection changes, clears outside the canvas, and yields to navigation, paint, picking and contributed tools. Hover does not edit scene data. Real editor pointer and screenshot acceptance runs in CI.

  • The WeChat starter's publishing profile minifies its game bundle. The named WeChat profile uses Shipping settings while Web authoring uses Development settings. Both preserve gameplay and host-service behavior. Headless observations record scene-initialization timing separately from actual device cold startup; unchanged-scene bundle comparisons measure the byte savings.

  • The WeChat Mini Game starter combines gameplay and host-service examples. A CC0 fleet game includes honest login-code/server-exchange status, sharing without false completion rewards, opt-in configured rewarded video and device-local credit restoration. Unreadable or changed saves are preserved. Named Web/WeChat profiles, compressed engine subpackaging, licenses and a creation-to-submission guide are included; real accounts, server authentication and device/platform approval remain separate.

  • The Playable Ad starter includes a complete editable game. New projects receive CC0 space art, three-ship selection, completion, replay and an explicit store button instead of a tap-anywhere redirect. Eight named network profiles, a configurable MRAID destination, licenses, a portrait/landscape headless scenario and a creation-to-submission guide ship together. Local mocks and size checks remain separate from official network approval and external publication exercises.

  • YouTube headless checks enforce the documented hosting policy. Training runs under the official CSP response header as well as its exported policy. Unexpected violations fail the check; an intentionally blocked external request proves that enforcement and reporting work. The publishing guide links the independent official bundle analyzer. SDK Test Suite and device acceptance remain separate.

  • YouTube exports check stored bundle constraints. Exports reject total packages at or above 250 MiB, individual files at or above 30 MiB, more than 8000 files and unsupported filenames. Cloud envelopes at exactly 3 MiB are rejected before staging. Recommendations and static initial-content estimates appear as warnings in both CLI and editor export results. Headless observations record local ready time and startup heap samples without claiming official transfer, peak heap or device certification.

  • YouTube Playables Web exports honor host readiness and persistence. The editor offers the channel and named example profile. Exports load the official SDK, report painted loading and interactive readiness, follow SDK pause/audio policy, and await cloud save acknowledgment before sending the saved highest score. Failed or unreadable cloud loads preserve progress; SDK no-ops disable host services. Headless SDK mock checks cover readiness, pause, reward credits and reloads; official certification and devices remain pending.

Fixed

  • UI inheritance stays current after leaving a Canvas. Hidden state, opacity and pointer policy refresh for UI nodes outside the layout tree, including detached Canvas subtrees and ancestors of nested canvases. Cached layout sizes and transforms remain unchanged until layout owns them again. Shared ancestry is resolved iteratively with reusable memo entries; fully covered Canvas trees keep their existing static layout path.

  • Bitmap text follows device pixel ratio changes during an App. World and screen text refresh bitmap atlas density from the current frame, rebuilding cached geometry for changed pixel sizes without restarting the App. Stable frames keep cached glyphs, SDF retains its fixed source size, and existing frame-boundary page retirement keeps referenced textures alive during transitions.

  • Nested UI stencil masks intersect their parents and restore clipping. Child masks enter only matching parent stencil pixels, and leaving a subtree replays its original geometry to restore the parent before siblings draw. Rotated and alpha-cutout shapes keep their intersections; mask replays preserve sampler bindings. Depth references are reused across siblings, with up to 255 nested levels when no SpriteMask references are reserved. Shared reference overflow clips affected subtrees instead of aliasing; restoration adds draws without allocating mask textures or duplicate vertices.

[0.84.0] - 2026-10-15

Added

  • App execution holds stop owned frames, input and media. Hosts can hold execution independently of user pause, with nested owners and idempotent releases. Interrupted startup retains systems that had not begun, and resumed frames wait for pending startup. Native gesture input is discarded while held; audio and video preserve player preferences. Game-owned timers and asynchronous work can cooperate through execution notifications.

  • Storage exposes asynchronous write acknowledgment. Games can await Storage.flush or SaveManager.saveAsync without changing synchronous save slots. The host bridge loads before writing, serializes cloud requests, preserves newer progress during pending saves and keeps failed writes retryable; an unsupported load is never replaced with an empty save. A synchronous adapter's flush does not imply cloud backup.

  • CrazyGames scores and saved training credits follow platform contracts. Optional Scores submission encrypts finite scores in the official HTML5 format; the editor exposes the client encryption key only for CrazyGames. The example saves earned credits through SDK Data, restores them on reload and preserves unreadable or externally changed progress. A sent score does not certify leaderboard acceptance, and SDK saving does not certify cloud backup.

  • CrazyGames Web exports connect the official v3 SDK. Channel profiles initialize loading notifications, rewarded and midgame ads, SDK Data storage and host audio mute. Failed initialization disables host services without blocking training; save errors remain explicit, and engine storage clearing preserves other publisher data. Unused achievement services defer their storage read so unavailable saving does not block startup. The editor offers channel selection and the Mobile Controls profile reports authored gameplay transitions. Leaderboards and official platform/device acceptance remain pending.

Changed

  • Poki training documents the official Inspector URL workflow. A localhost export can be checked with the real SDK without starting the editor. The guide distinguishes observed SDK initialization, loading, gameplay and reward events from the remaining manual QA, device acceptance and production ad behavior.

Fixed

  • Unused text atlas pages retire at frame boundaries. Cached layouts retain their referenced pages while obsolete sizes, replaced labels, hidden text and inactive bitmap/SDF modes release unreferenced GPU pages on a subsequent frame. Page restore callbacks capture their own placement lists, preserving live UVs after other pages are removed; stable text keeps its raster and geometry caches.

  • Bitmap glyphs survive enlarged text and camera zoom. Canvas scratch surfaces grow to fit glyphs within the configured atlas dimensions instead of dropping tiles larger than their initial size. Resizing restores font, bold/italic style and alignment before drawing; smaller requests reuse the grown surface, and oversized tiles remain bounded by the atlas limit.

  • AudioPlugin checks platform initialization before subscribing to host mute. Independent audio backend tests and direct construction no longer fail while reading an optional platform capability.

  • SDK text uploads only glyphs visible to the current draw pass. Bitmap and SDF caches retain the complete layout while block bounds reject camera-excluded runs and partial runs compact vertices with rebased indices. Culling uses the actual camera or screen-overlay projection with the full model matrix, preserving shear, shadows and clip-edge intersections; invalid or omitted projections retain the legacy submission path.

  • Text measurement avoids GPU glyph pages. Input caret measurements and inline rich-text layout retain the same rasterized glyph advances, bearings and dimensions in CPU caches without packing or uploading textures. Ordinary text drawing keeps its existing atlas; measurement-only atlases reject draw submission instead of emitting invalid texture references.

  • Inline rich text releases its own measurement atlas. Cleanup belongs to each App, so closing an older preview cannot remove a newer preview's inline image children. Exiting releases measurement glyph pages and repeated cleanup remains safe.

  • Input fields release their measurement glyph pages on exit. App teardown disposes the caret measurement atlas as well as the visible text atlas, preventing a 4 MiB page from accumulating on each preview restart. Cleanup stays scoped to the exiting App.

[0.83.0] - 2026-10-14

Fixed

  • Text atlases belong to each App and release their pages on exit. Preview restarts and separate runtime instances rasterize their own glyphs instead of reusing foreign texture IDs. Cleanup clears cached geometry, releases all owned pages and removes their restore callbacks without deleting a newer owner's registration.

  • SDK text follows the full parent transform and skips collapsed labels. Bitmap and SDF labels copy the engine's complete matrix instead of reconstructing decomposed TRS, retaining shear and mirrors. The shared Web/native bridge rejects known zero-area labels before atlas creation or layout, uses one reusable scratch matrix per render pass and handles childless roots without a stale matrix cache. Legacy cores retain their existing fallback.

  • Collapsed 2D hierarchies skip geometry and recover reliably. Transform composition propagates authored zero-area state through planar rotations and transformless groups, preventing floating-point residue from reviving degenerate boxes. Sprite, UI, native bitmap text, picking and empty scissor/stencil subtrees share the guard. Valid tiny spans and children that regain area through a 3D tilt remain available; hidden bitmap runs skip font layout and submission.

  • Web audio preserves the latest device pause intent. Late browser resume/suspend operations cannot undo a newer takeover request; initial autoplay-unlock gestures and ensureResumed respect explicit suspension. Reconciliation stops at the current request and ignores disposed contexts, preserving the user mixer and avoiding retry loops for blocked playback.

  • Advertising requests preserve a single active break. Rewarded and interstitial requests reject immediately while another ad is showing, before creating a competing unit. The active break retains its showing flag, clock pause and audio suspension until it closes; errors release the guard so a later request can proceed. Rejected requests are not queued for playback.

  • UI geometry, picking and scissors retain parent-induced shear. Solid, image, nine-slice, tiled and filled visuals use the complete parent basis for vertices and camera bounds. UI, editor and world-sprite picking test the same local boxes, and scissor bounds project their actual corners. Mirrored radial fills retain their wedges and UVs; axis-aligned positive UI keeps its existing geometry path.

  • Extreme sprite tile counts reach the bounded fallback on native hosts. Tile budgets are checked in floating point before converting loop counts to integers, preventing overflowing axes from bypassing the existing 16,384-quad cap. Tiny positive steps retain the single stretched quad; non-finite tile steps and sizes emit no geometry, and grids at the cap remain tiled.

  • Sprites retain parent-induced shear in every draw mode. Ordinary, nine-slice and tiled geometry follows the complete parent transform, and camera bounds use the same basis. Mirrored tiled grids retain positive tile steps before applying signed axes, including the capped fallback. Zero-area sprites skip geometry; existing material, UV and batch state is preserved.

Added

  • Poki training reports authored gameplay and ad outcomes. The mobile-controls example adds a named Poki Web profile with explicit start, pause, three-hit completion, replay and opt-in reward controls. Device actions and returning to the page never infer gameplay start; rewards require completion, background and scene cleanup preserve state, and missing SDKs leave training usable. Headless CI checks real input, event order, audio transitions, landscape rotation and the original standalone controls using SDK mocks.

  • Web exports can select the Poki channel. Project and named export settings inject its official SDK, initialize it with a bounded fallback, report loading after the scene is ready and connect rewarded/commercial breaks to the existing Ads service. The editor exposes the channel choice; standalone keeps its original resource policy. Game logic still reports gameplay transitions explicitly, and official Inspector/device acceptance remains pending.

  • Playable scenarios run in headless Chromium and save bound evidence. A CLI replays declared canvas clicks and host callbacks, records trusted pointers and user activation, checks hidden input and animation, and fails on unexpected requests, page errors, event mismatches, lost history or changed inputs. Reports and screenshots retain delivery/scenario/tool hashes and pending acceptance; eight network mocks run on the example in CI using that commit's Web runtime. No local editor or browser window is opened.

[0.82.0] - 2026-10-14

Added

  • Playable asset quality adapts to the measured delivery budget. Auto optimization tries lossless WebP, eligible lower MP3 bitrates and bounded WebP quality while preserving image dimensions and alpha. Each candidate is weighed as actual HTML/ZIP against the network, project and internal 3 MiB target; pixel art, font pages and data images stay lossless, and color-managed/animated/16-bit PNGs retain their original format. Reports and the editor show selected encodings, size changes and unmet targets; opt-outs and Skip are honored.

  • Playable creatives have a local container preview. A CLI server simulates MRAID, Mintegral and page-visibility callbacks, records store gestures without opening a store, and switches portrait/landscape viewports. It opens no browser and preserves the delivered HTML; export-report hashes prevent mixing records from different builds. Logs remain marked as local mocks rather than network approval.

  • Playable exports report static checks and pending acceptance. Export results and the editor package dialog show actual HTML/delivery hashes, network size limits, literal resource references and orientation config checks. Mandatory network SDK scripts are allowed explicitly. CTA, lifecycle, dynamic requests and device/network acceptance remain pending runtime evidence, including when static checks pass.

Fixed

  • Long native bitmap text preserves UTF-8 content without uploading hidden glyphs. Byte lengths and decoder offsets no longer wrap at 64KiB. Complete layouts retain their glyph positions and alignment; cached block bounds reject camera-excluded runs, and partially visible runs submit only visible quads with rebased indices. Fully visible text keeps its existing batching path.

  • Playable exports honor authored image and audio optimization. Automatic asset optimization applies PNG Max Size (including playable overrides) without loading a GPU texture encoder, and converts eligible WAV clips to MP3 at their authored bitrate. Per-clip opt-outs and the build's Skip setting preserve originals; failed asset cooking prevents a successful export.

  • Native bitmap text follows its complete world transform. Glyph vertices retain rotation, independent axis scales, mirrors and parent-induced shear while preserving parallax and batching. Cached ink bounds include alignment and glyph offsets, preventing visible edge text from being culled; layout no longer repeats a separate full-text measurement.

  • Playable preview records identify the delivered archive. Full export reports verify the adjacent ZIP hash before previewing, catching config changes even when HTML stays identical. Downloaded logs retain HTML/delivery hashes and explicitly disclose omitted events; HTML-only previews remain labeled accordingly.

  • UI masks handle deep hierarchies and empty viewports. Scissor and stencil propagation use reusable iterative work stacks instead of recursive calls, preserving nested and sibling stencil references. Zero-area rotated boxes remain empty clips; empty stencil subtrees and zero-area visuals skip geometry uploads and recover when their dimensions return.

  • World transforms preserve mirrored axes. Quaternion decomposition retains signed scale instead of converting reflected bases into invalid rotations. Planar transforms keep a Z rotation, including collapsed axes; mirrored UI pointer bounds and flat render bounds follow their displayed geometry.

  • Playable checks verify mandatory SDK scripts and placement. The report detects missing Google/TikTok/Pangle scripts, incorrect head/body placement and delayed TikTok/Pangle loading before game code. Script text and JSON metadata do not count as SDK tags. The editor shows the SDK finding separately, while interaction and availability remain pending runtime evidence.

  • Nine-slice texture flips preserve asymmetric borders. Flipped UV spans sample inside their original region and exchange opposing border widths, producing the complete mirrored texture. The shared geometry builder retains all cells for signed destination extents, including small boxes and rotated draws.

  • Small nine-slice visuals keep borders inside their box. Sprite and UI nine-slice geometry proportionally shrinks opposing borders when their total exceeds the destination size, retaining the texture's original border UVs. Zero-width or zero-height nine-slices emit no geometry; ordinary sizes retain their existing border widths.

  • Fully transparent UI visuals skip geometry uploads. Default-material solid, image, nine-slice, tiled and filled visuals stop generating vertices and indices when their own or inherited alpha is zero, and resume when visible. Stencil mask geometry and custom-material draws remain available for clipping and shader-defined output.

[0.81.0] - 2026-10-14

Added

  • TikTok and overseas Pangle package the same playable project. Network profiles include root orientation config, load the official host SDK before game scripts, and dispatch store gestures through the host. ZIP limits stay below 5MB; metadata paths and duplicate filenames are checked before archiving. The Playable Ad example includes named exports for all three new networks.

  • Playable exports handle Mintegral start, completion and retry. The network profile embeds resources in index.html and emits index.zip; the runtime waits for host start, pauses gameplay and audio on close, and preserves game-owned pause state. playableGameEnd() and playableRetry() report gameplay outcomes separately from installation. A responsive CC0 space fleet example demonstrates the complete flow.

Fixed

  • MRAID store clicks carry their destination. playableCta(url) forwards an explicit store link, with host-provided clickTag as the MRAID fallback. Missing and malformed destinations no longer call mraid.open with no URL. HTTP(S), Android market and iOS App Store schemes are supported; other networks retain their host-selected store destinations.

  • Long text preserves glyphs beyond the 16-bit index limit. Oversized atlas-page runs split into batches of at most 16,384 quads while retaining positions, colors and effect ordering. The text-submit ABI stays unchanged, and raw glyph builders reject oversized batches instead of silently wrapping indices.

  • UI text fades reuse cached geometry. Inherited opacity changes update vertex alpha without repeating glyph lookup, layout or index generation. Bitmap and SDF text retain their original fill, rich-text, shadow and outline alpha, restoring it without cumulative fading; authored color and layout changes still rebuild the cache.

  • MRAID playables wait for ready and viewable hosts. Unity, AppLovin and generic MRAID exports pause gameplay and audio until the host is ready and visible, stop when hidden, and release container callbacks on exit. Browser previews still run without an ad container.

  • Pointer carets keep supplementary characters intact. Clicking single-line, multiline or password fields no longer places the caret between the UTF-16 halves of an emoji or another supplementary code point. DOM selection offsets remain UTF-16-based, and existing prefix measurement behavior is preserved.

  • Native text-input notifications survive frame boundaries. Update systems can read browser and native Change and Submit events after UI interaction clears the previous frame. Subscription callbacks remain synchronous, including focus changes made on Submit; their records reach frame consumers without replaying callbacks. Destroyed fields and disposed editors discard queued records.

  • Rich-text colors no longer recolor shadows and outlines. Effect passes use their authored color and alpha on both bitmap and SDF atlases, including blurred shadows. The fill retains per-run colors, and inherited UI opacity continues to fade every pass.

  • UI text effects follow inherited opacity. Parent transparency now fades text shadows, outlines and explicit rich-text colors together with the fill. Authored color and layout changes invalidate cached batches; opacity-only changes reuse geometry, and fully transparent text skips glyph layout and submission until visible again.

  • Release websites wait for mirrored download metadata. Documentation deployment starts after the release mirror completes and rejects a latest.json version that differs from the site build, preventing a freshly published page from reverting its version label and download sizes to the previous release.

  • Hidden text and skeletal batches skip vertex conversion. Camera masks and empty scissors are checked before transforming caller-provided vertices, allocating transient storage or resolving shaders. The same visibility helper preserves SortingGroup layers and explicit text culling bits; visible batches retain their original geometry and per-type statistics.

  • Camera-excluded bulk draws skip transient geometry. Batch and shape submissions check the camera mask before copying vertices or rebasing indices. SortingGroup layers and explicit culling bits keep their existing behavior; resident-vertex submissions skip excluded indices without discarding geometry owned by their caller.

  • Full texture batches avoid unused index copies. Sorted 2D commands start a separate draw before copying indices when their new texture exceeds the available sampler slots, including slots reserved for masks. Existing textures still join full batches, preserving painter order and reducing transient index upload work.

[0.80.0] - 2026-10-14

Changed

  • Sprite rendering has a complete space art example. CC0 ships, meteors and stations replace the basic bars and dots, with editable labels and four demonstration areas. Tint, overlapping draw layers, orbital motion, alpha, texture flips and SortingGroup retain their original teaching behavior; the example includes asset sources and licenses.

Added

  • Mobile controls share InputMap and device capability results. Fixed/follow virtual joysticks and held buttons support independent touches, mouse Play preview, radial dead zones and cancellation. Web, mini-game and native adapters expose motion, vibration and screen wake with explicit unavailable/denied results; browser fullscreen and pointer lock observe exits. The Mobile Controls example distinguishes request success from raw sensor data and clears tilt when channels disappear. Physical device acceptance remains pending.

Fixed

  • Batch merging preserves depth bias and geometry bindings. Non-instanced commands with different depth offsets, vertex/index buffers or vertex layouts now stay separate, preventing one draw from inheriting another's GPU state even when their index ranges are adjacent.

  • Sorted 2D batches join across emission index gaps. Compatible transient quads reuse contiguous index ranges in painter order even when their producers emitted them apart, reducing UI and text draw calls without combining different clipping states or external buffers. Mixed sprite/text batches retain their original per-type entity statistics.

  • Runtime hierarchy inspection follows native parent additions and removals. The tree and selected details use current component membership before reading a parent, so native edits appear immediately even when the SDK's cached hierarchy membership is stale. Detaching a node clears its parent instead of reporting the empty getter's sentinel; disabled nodes remain included.

  • Runtime tree inspection indexes script component names once per snapshot. Large script catalogues no longer require a name search for every component on every entity. The index is rebuilt for each group read, so registration, removal, aliases and context changes remain visible; builtin membership is still read from the current core.

  • Selected runtime details reuse maintained hierarchy links. Refreshing one entity reads its own parent and children instead of scanning every entity's parent. Child ordering still follows world storage, including after reparenting and draw-order edits; disabled children remain inspectable and native reparenting is read from the current core.

  • Widget prefabs preserve sibling paint order. Serialization retains existing node identities while restoring children in authored order, so layered controls remain visible after scene loading. Virtual controls update before registered InputMap evaluation in the same frame.

  • Runtime inspectors clear destroyed entity selections. A selected entity that despawns now returns no detail row instead of an empty ghost entity, including when its native slot is reused. Requests without a live selection or tree avoid traversing the world; disabled live entities remain inspectable.

[0.79.0] - 2026-10-14

Added

  • Sprite playback can be tried independently of its state machine. The sprite-animation example uses P to pause and resume the two plain-clip bystanders while the player's Animator continues running. Its packaged interaction exercises both controls, and editor verification checks that paused frame indices and timers remain unchanged before resuming.

  • Disk cache budgets preserve offline content versions. Node and capable mini-game hosts report resource usage, hashes, version ownership and protected bytes. Cleanup previews and applies LRU eviction while keeping current, pending, rollback and explicitly retained versions, coordinating with downloads and reporting actual released bytes. The editor's connected-device Profiler provides scans, budget previews, cleanup and version retention. Hosts without management report unavailable usage; saves and unknown files remain protected.

Fixed

  • Runtime snapshots reuse visibility membership and direct readers. Live tree snapshots reuse each entity's component names and pre-resolve visibility getters instead of repeating renderer checks and marshaling a full component for every row. UI display priority and transient renderer visibility remain intact, missing reader values retain the normal read fallback, and only primitive visibility flags escape borrowed data. Selected component values remain independent of later snapshots.

  • Runtime inspection batches builtin membership across the core boundary. Generated web and native bindings report an entity's current builtin component names in one call. The SDK merges script and extension components, refreshes extension bindings on registration or reconnect, and falls back to individual checks on older cores. Entity destruction, id reuse and separate registries retain their live membership semantics.

  • Runtime inspection avoids duplicate builtin component checks. Entity component enumeration checks cached builtin bindings once and reads the shared builtin catalogue instead of allocating a merged builtin/script map for every entity. Live tree snapshots retain uncached membership checks and immediately reflect component additions and removals.

  • Unused transient streams no longer reserve GPU buffers. Renderer pools initialize pipeline layouts without reserving vertex/index buffers or CPU staging for every stream. Each stream allocates storage on its first non-empty write, preserving buffer reuse, growth and recovery while avoiding unused particle, shape and sky allocations in 2D scenes.

  • GPU memory estimates include buffers and render targets. Runtime reports and editor captures count live buffer capacity, texture mip chains, compressed blocks and target attachments without double-counting framebuffer references. WebGPU also includes private fallback, surface and readback resources. Lost or destroyed resources stop contributing; the profiler labels this as an estimate that excludes driver overhead, shader binaries and host-owned swapchain images.

  • Play-mode performance captures include every recorded frame. The editor's profile_frames command captures the running world's frame-end stream instead of its 250 ms telemetry snapshots, so frame counts, tail latency and system costs come from actual frames. Captures discard data if the play world is replaced, keep editor overhead visible, and can observe existing instrumentation without resetting timings or toggling another recorder's profiling switches.

  • Inactive 2D bodies retain pending collider and body edits. Physics reconciliation tracks the last synchronization of each body, so changes made while a parent or entity is inactive are applied on reactivation instead of being skipped by another body's newer global synchronization. Collider enable flags and rigid-body properties update in place, preserving the body and its existing simulation state.

  • Paused sprites refresh replaced animation clips. A sprite that has already applied a clip follows a newly published clip while paused, updating its displayed frame without advancing the frame index or timer or firing playback events. Unchanged paused frames avoid component writes, and an initially paused animator still leaves the authored sprite untouched until playback or an explicit frame selection.

  • Empty and collapsed scroll views keep finite scrollbar geometry. Thumb sizing handles zero content without dividing by zero and clamps the minimum thumb length to the available track. Clearing a list or collapsing its viewport no longer writes Infinity or NaN into native UI nodes, and tiny viewports keep their thumbs inside the track before normal sizing resumes on restore.

  • Idle scrollbars stop forcing UI layout work. Overlay thumbs write their node geometry only when position, length or units change, including during fade-out and after becoming invisible. Comparisons use the native float precision so fractional thumb sizes settle instead of dirtying layout every frame; scrolling and viewport/content resizing still refresh their geometry.

  • Running tilemaps follow published tileset updates. Tileset publication versions invalidate each app's cached render table, animations and collision model after a successful replacement, without requiring a reference edit or scene reload. Failed replacements keep the working version; unchanged frames read only a version counter and avoid rebuilding the table or resolving resource paths again.

  • Lazy tilemaps acquire and release tileset slots correctly. Runtime-only tileset references use owned slot acquisitions rather than the retired generic loader interface. Failed loads retry after the asset cooldown, shared references deduplicate requests, and removing the last layer or resetting the runtime releases both completed and late acquisitions.

  • Fractional tile cell edits refresh the drawn and hit grids. Tilemap layers compare width and height independently rather than combining them into a numeric cache key. Valid fractional dimensions no longer alias another size and leave stale geometry or coordinate conversion; unchanged frames still avoid native layer reinitialization.

  • Unloaded scene contexts reject late mutations. A context belongs to one scene instance: after unload, reload or reset, it cannot spawn or adopt entities, destroy another scene's objects, change persistence, or register callbacks and post-processing bindings. A late asset scope is released before cancellation is reported, so asynchronous setup cannot strand its acquisitions.

  • Scene adoption transfers existing entity ownership. Adopting an entity into another scene removes its outgoing scene records, retains its bound asset generation, and restores any outgoing sleep state before applying the destination's state. An outgoing parent is detached while preserving world placement. Unloading the source no longer destroys the adopted entity; the destination's final unload still releases it normally, and repeated adoption preserves the saved awake state.

  • Scenes forget runtime entities when the World destroys them. Scene ownership collections and saved render state now retire an entity on despawn, including runtime prefab copies destroyed through Commands or World. Repeated bullet spawning no longer accumulates dead scene entries for later unloads. Scene reset and plugin cleanup detach the observer, and subsequent loads restore tracking with one observer per manager.

  • Old audio asset leases do not release replacement clips. Each loaded audio result releases the buffer generation and audio device it actually retained. Releasing an outgoing scene's asset after a clip update no longer unpins or evicts the current clip under the same path, including when the warm-cache budget is zero. Final release still retires the current buffer normally.

  • Audio source updates retire pending decodes. Invalidating a clip starts a new load instead of joining its outdated request. Late results release their buffers without overwriting current audio or deleting the newer request's deduplication record. Web Audio also tracks source revisions across file reads and decode completion so old requests cannot restore stale URL-cache entries.

  • Late audio decodes do not repopulate closed devices. Audio preloads that finish after disposal release their decoded buffers instead of restoring cache entries. Concurrent callers still share one decode and one release, and new preloads on a closed API perform no backend work. Editor Stop now leaves the buffer count and resident bytes at zero even when a decode completes afterwards.

  • Missing skeletal sources keep their recovery paths. A failed viewport reload retains the last resolved skeleton, atlas and page dependencies so restoring an entire removed source directory triggers a fresh binding. Restored armatures draw their new image, and the viewport no longer remains on stale bindings that distort unrelated text.

  • Skeletal previews reload after directory changes. Directory notifications match the skeleton's actual source and page paths, including normalized Windows paths and trailing separators. Moving a page directory away and restoring it now refreshes the open viewport; similarly named sibling directories do not trigger a reload.

  • Deleted sprite images clear and restored images reload. The editor invalidates removed paths and reprojects missing or newly restored references, including directory-only watcher notifications. Browser texture loads use a new image-cache address after invalidation so restored pixels and dimensions replace the old image; ordinary loads and native image paths keep their existing addresses.

  • Late skeletal loads release obsolete viewport bindings. A skeleton fetch that finishes after scene replacement, entity deletion or skeletal component removal now drops its late instances before the next queued load. Surviving entities keep their bindings, and a replaced scene no longer receives the old load's panel refresh.

  • Open skeletal scenes refresh after source edits. The editor tracks the skeleton, atlas and page paths resolved by its shared loaders. Changes to those inputs rebind the affected skeletal runtime in the current viewport; unrelated image edits do no skeletal work, and queued refreshes from a replaced scene are discarded.

  • Skeletal atlas edits invalidate resident textures. Image changes also sever the bare-path residency used by skeletal atlas pages. Reopening a DragonBones scene loads the updated image instead of reviving stale pixels, while existing holders retain their texture until released.

  • DragonBones atlas textures follow skeleton ownership. Scene loading reuses a resident atlas page and transfers its reference to the skeleton that uses it. The last armature removal and manager disposal release the page; rejected armatures release otherwise unbound skeletons and uploads. Repeated editor scene switching no longer adds a new atlas texture on every load, while paused poses and device recovery continue drawing correctly.

  • Late scene-load errors roll back the new entities. A failing final spawn-phase observer or asset-reference publication step now despawns the entities created by that load and releases their owned resources before returning the original error. Existing unrelated entities remain intact and a later load can retry normally.

  • Prepared prefab spawns reject failed parent attachments. The synchronous spawn path rolls back its new hierarchy and entity-owned resources when its parent no longer accepts the root, matching asynchronous instantiation. Preparation resources remain available for later valid spawns, and live parents, position overrides and explicit unparented copies remain supported.

  • Standalone scene and prefab spawns release their resources. Loads without a scene collector transfer acquired resources to the entities that reference them, then release the preload receipts. Destroying or rolling back a spawned hierarchy retires those acquisitions. Prefab document reads also use scoped receipts, including nested sources, so repeated spawns no longer accumulate unowned references.

  • Prefab spawns roll back when their parent disappears. Runtime instantiation checks that its requested parent accepts the root after asynchronous loading. A rejected attachment despawns the newly created hierarchy and rejects the spawn instead of leaving an unparented instance behind; live parents and the explicit no-parent sentinel remain supported.

  • Scene completion errors settle the transition promise. A throwing fade-completion callback rejects the caller's promise with its original error after clearing the old overlay, so callers can recover and later scene switches remain available. A callback that starts another fade keeps that new transition intact.

  • Input cancellation stops released scroll flings. UI scrolling discards existing coast state when the host cancels input, so a list already gliding after release remains at its current offset when the app resumes. A new press can still start a fresh drag in the same frame.

  • Native input resets when the host hides. The native adapter cancels held touches, mouse buttons, keys and frame edges on hide or input teardown, resets the primary finger, removes its hide subscription and ignores late releases from the previous gesture.

  • Reused touch IDs preserve both gestures. When a host reuses a touch ID between frames, UI releases the old gesture before capturing the new one, retains quick-tap clicks and projects the held finger's current position for dragging and scrolling.

  • Cancelled touch input no longer becomes a click. Shared touch forwarding distinguishes primary cancellation from normal release, clears cancelled touch and fixed-step edges, and preserves other fingers. Mini-game hide and input teardown cancel held gestures and keys, reset the primary finger, and unregister the hide callback so resumed input starts cleanly.

  • Mini-game storage preserves empty strings. The adapter distinguishes an explicitly stored empty string from an absent key through the host's key list, matching Web storage and preserving empty text preferences across adapter restarts. Non-empty reads keep their direct path; unavailable host storage remains a safe absent result.

  • Audio preferences survive game restart. Audio-demo saves and restores master, music and SFX volumes through engine storage, validates saved values, and restores the displayed percentages and actual bus gains at startup. Golden verification uses independent browser processes with a stable origin and isolated profile, cycles master volume to mute and verifies that both the label and silent output survive restart.

  • Release optimization commits valid WASM artifacts atomically. A failed post-link optimizer now fails the build and preserves the original artifact. Cache scans can repair exact manifest references in a surviving legacy cache, and hosts without usable storage report unsupported cache writes.

  • Lightmap bounces reuse exact gather visibility. Later bounces and consecutive editor bakes reuse geometry hits while reading the new light field. A bounded cache falls back to tracing when it does not fit, and changed geometry or sample settings discard old references. The editor retires its worker after two idle minutes. On the same Bistro scene and machine, relighting fell from 28–29 seconds to 5.24 seconds with identical atlas bytes.

  • Command-line baking uses the editor's transform precision. Document transforms cross the same float32 boundary as the live world before their bake pose is composed, keeping decimal-scale fingerprints consistent between the two authoring paths. The physics-3d baked corpus is refreshed for those runtime poses.

  • Authored sound is verified in a packaged game. Audio-demo's existing spatial source starts through its authored Playing flag. A separate launch unlocks browser audio away from every sound control and reads all spectrum bars, proving output from the scene source while preserving the Beat toggle's independent API and fade demonstration. The golden registry requires this measured run before certifying authored sound.

  • Package verification resolves output folders consistently. Relative work and screenshot paths are resolved before child tools launch, so the editor and package runners write into the same requested folder instead of resolving paths against their own working directories.

  • Finite native tween loops hand off their sequences. Restart and ping-pong loops now resume a paused successor when their finite count completes, just like non-looping tweens. Completion leaves cancelled successors cancelled instead of reviving them and writing their target for another frame.

  • Looping tweens preserve long-frame remainder. JS value tweens and native property tweens skip completed cycles arithmetically, retain the current phase and ping-pong direction, and complete finite counts at their final endpoint. Exact cycle boundaries keep their endpoint behavior; delay remainder is preserved and very large frame sums are bounded instead of overflowing elapsed time.

  • Immediate value tweens produce their endpoint. Non-positive durations complete at the next eligible update, matching native tweens instead of emitting NaN or retaining a negative-duration tween forever. Delays and callback playback controls continue to apply.

  • Value tween callbacks preserve playback control. Callback-created tweens start on the next update, recursive updates cannot advance the same pass twice, and callback cancellation or pause is not overwritten by completion or sequence handoff. Existing sequence members still resume in the same frame, without allocating a snapshot of the tween map.

  • Animation callbacks respect entity activity immediately. Disabling an animator, entity or ancestor during a frame event stops remaining callbacks and sprite writes; later entries disabled by an earlier callback keep their playback position. Re-enabling applies deferred geometry without replaying handled events or restarting a completed one-shot.

  • Text submission preserves callback-selected focus. A submit handler can focus the next field without the previous field's default blur clearing it. Submission still closes the editing session when the handler leaves focus unchanged.

  • Text input events stay with the active editing session. Switching fields no longer lets the previous surface's blur clear the new focus or its queued input overwrite the next value. Web and native editors reset interrupted composition state when focus restarts, so normal typing resumes without requiring a composition-end event.

  • Text caret picking measures long strings once. Pointer placement in single-line, multiline and password fields accumulates glyph advances in linear time instead of repeatedly measuring every prefix. UTF-16 caret boundaries, glyph scaling, missing glyphs and masked password widths retain their existing positions.

  • Disabled text fields reject queued input. Text input checks effective entity activity and interaction state before accepting editor events, including disabled ancestors, and releases the editing surface on the next update.

  • Removed text fields release OS input focus. Deleting the focused entity or removing its TextInput component closes the editing surface even though the old component can no longer be updated.

  • Text input surfaces stay with their own apps. Closing an older app or a preview removes its own text-editor listeners and surface, preserving typing in other running apps. Repeated cleanup releases each surface once.

  • Tilemap atlas and grid edits refresh cached meshes. Changing columns, texture dimensions, atlas borders or grid layout updates UVs and geometry without repainting tile data. Cached meshes now compare their resolved layout inputs, while unchanged inputs retain their geometry; editor pixel checks compare live edits with a fresh repaint.

  • Static siblings reuse their parent transform snapshot. Unchanged static bodies sharing a parent avoid repeated child-world-pose reads while dynamic bodies keep composition active. Parent movement and direct child edits still update their poses in place, and cached parent snapshots are removed when no static body references them.

  • Transformless hierarchy groups preserve child world poses. A grouping entity without its own Transform no longer stops composition of its descendants. Root groups start from identity, intermediate groups carry the ancestor matrix through, and dirty propagation and traversal guards continue through those nodes.

  • Tilemap activity preserves painted data and owns generated collision. Disabling a layer or its ancestor retains its chunks and derived layers. Runtime colliders inherit the map's movement and activity, remain outside saved scenes, and resume with their existing identities; inactive tile animations stop advancing.

  • Static 2D bodies follow authored transforms and parent movement. Box2D updates changed static poses in place, preserving bodies and shapes without repeating writes for unchanged poses. Initial body creation composes the hierarchy first, and parented static bodies no longer force dynamic-body writeback out of its batch path.

  • Recreated tilemap layers discard old geometry and collision. A layer generation distinguishes replacement from ordinary edits, even when the same entity and edit count are reused. Reinitializing or immediately recreating a layer releases its old chunk meshes and rebuilds collision from the replacement; unchanged layers retain their caches.

  • Tilemap runtimes and saved chunks stay with their own worlds. Closing a preview or an older App no longer destroys another core's same-numbered layers or disables its collision updates. Scene codecs serialize each world's own tiles; closing the current runtime restores the previous live tooling interface and collision lookup, and releases the retired codec.

  • Native tilemap collisions follow live edits. Changing painted tiles, importing an empty map or removing its collision palette replaces obsolete runtime colliders. A native content revision keeps unchanged frames and repeated writes from exporting the map or rebuilding collision.

  • Unchanged tile writes preserve chunk caches. Repainting a tile with its existing value no longer advances the chunk revision or forces geometry rebuilding. Erasing untouched empty space does not allocate empty chunks, including negative coordinates in infinite maps.

  • Audio sources distinguish interrupted voices from completed clips. A refused or preempted voice lowers playing without setting the natural-completion latch. Only a backend end signal for a non-looping source marks it finished; existing backend completion callbacks remain attached and replays clear the latch.

  • Camera preview scheduling follows its current CPU budget. A preview waiting on an old slow interval now rechecks the live budget, so cheaper recurring captures resume without waiting for the stale deadline. A slower budget also defers the next capture instead of overspending, and unmounting cancels refreshes.

  • Mini-game verification unregisters keyboard callbacks. The launch host now removes the DOM listener belonging to each vendor keyboard callback. Repeated platform input binding no longer leaves retired keyboard subscribers active, and duplicate registrations do not multiply notifications.

  • Mini-game verification forwards touch gestures. The package launch host forwards real canvas touch events and unregisters individual subscribers. The UI controls project now verifies the mini-game touch path alongside Web mouse input, using the modal button's current position instead of the dropdown below it.

  • Inertial scrolling travels consistently across frame rates. Coast displacement integrates the exponentially decaying velocity instead of using its initial value for the whole frame. Frames that cross the stopping threshold integrate only the remaining motion, so a slow frame no longer extends a fling. Constant-speed and immediate-stop settings remain finite.

  • WASM video progress reaches the decoded endpoint. Playback ending after a seek or a large update no longer leaves the clock at its previous position. The decoder derives the final duration from the last frame, and the SDK refreshes it before notifying end-of-playback listeners. Looping and seeking back to the beginning retain their normal clocks.

  • Single-timestamp MPEG videos report duration and support seeking. Videos whose frames fit in one PES packet no longer report a zero duration or seek only to the first frame. The decoder counts picture headers without decoding frames at startup and uses frame-based seeking when packet timestamps cannot describe the timeline. Timestamp-based seeking remains in use for other streams.

  • Video component playback settings update live streams. Changing volume, mute, loop, or playback rate updates the current stream without reopening the decoder. Unchanged settings avoid repeated backend calls across frames; source changes still create a stream with the current settings.

  • Video plugin cleanup releases only the selected App. Shared plugin instances retain separate video backends and stream maps for each App, so closing a preview cannot stop another App's video or leave its own backend behind. Cleanup detaches the world subscription and disables its old update system. Stopping component streams also retires them from the video service instead of pumping stopped handles.

  • Video components switch streams when their source changes. Changing a live component's source releases its previous stream and opens the new source. Unchanged sources keep their stream across frames; clearing the source or removing the entity still releases the current stream.

  • WASM video exports fail when required transcoding fails. An unavailable or failed video converter no longer stages an original MP4 that the target's WASM decoder cannot play. The cook reports the failed asset, and mini-game exports propagate asset cooking failures as build errors instead of reporting a usable package.

  • Repeated exports remove obsolete cooked assets and packs. Web and mini-game exports compare the previous and current asset manifests, deleting old texture hashes, removed assets, and packs no longer referenced by the build. Shared current packs, project sources, and unlisted output files are preserved.

  • Repeated Web exports drop obsolete runtime files. Rebuilding into the same output replaces the shipped SDK and WASM trees, removing modules the project no longer needs and old SDK chunks. Turning off source maps removes maps from the previous build. Output-root configuration files are preserved, and a runtime output overlapping its input is rejected before removing that tree.

  • Editor export results report failed builds accurately. The automation export door returns exported: false when the exporter fails, retaining errors such as missing optional runtime modules instead of marking a partial package as successfully exported. Preflight refusals remain distinguishable from attempted builds.

  • Asset loaders release their App's resources on shutdown. Asset plugin cleanup releases the default loader and any runtime replacement, clearing reference bookkeeping and making held textures evictable before the renderer is reused. Shared plugin instances clean up only the selected App; stopped device recovery cannot continue through a later loader. Unused loaders can release safely before a native resource manager exists.

  • Particle gradient uploads survive WASM memory growth. Color, size, and speed LUT uploads read the current heap after allocating their staging memory, preventing detached-buffer errors when a large scene causes memory expansion. LUTs borrowed from the heap are preserved before allocation; independent arrays avoid this copy. Staging memory is still released if the native setter throws.

  • Web focus loss cancels held pointer input and pending edges. Blurring or hiding the game and replacing its input target releases host key, mouse, and touch tracking, clears stale render/fixed-step edges, and cancels UI presses without clicking them. The next touch can become the primary pointer, and late releases from the cancelled gesture are ignored.

  • Mini-game audio keeps playback ownership through device suspension. Device-paused voices remain live for AudioSource completion, bus gain updates, and priority budgets. New play requests and manual resumes wait for device recovery; manual pauses withdraw automatic recovery, while stopped or despawned voices never restart.

  • Async Box2D systems retain their physics performance category. Physics stepping, interpolation, contact event delivery, and character controllers now appear under physics after module loading completes. Deferred system registration can explicitly provide its profiling domain without changing the classification of later registrations.

  • Box2D initialization and shutdown belong to their App. Stopping an App before its module finishes loading prevents late physics initialization and system installation. Shared plugin instances keep independent bridges and module ownership, so an older App cannot shut down or replace a newer App's physics world; cancelled load failures do not change the stopped App's subsystem status.

  • Screen-excluded UI scissor regions no longer submit draws. Root scissor masks intersect the current view's viewport before propagating to descendants. Empty regions skip UI visual collection and batch geometry/index/command allocation, including text submissions; stencil-only entries remain drawable. Moving a masked subtree back into view restores its draws on the next frame.

  • Animation despawn subscriptions belong to their App. Shared animation plugins withdraw the quitting App's listener while preserving other Apps' tween cancellation, sprite-event cleanup, and animator removal callbacks. Repeated preview shutdowns no longer leave stale subscriptions on older worlds.

  • Sprite animation applies frames through direct component accessors. Running animation resolves the sprite read/write path once per update, avoiding per-frame embind snapshots and full component marshalling for every animated entity. Component write journals still observe frame changes, while editor observers, speculative updates, and rebound worlds retain the full mutation path.

  • Native audio completion subscriptions are independent. Multiple backends sharing one host bridge receive their own voice-end notifications, and preview shutdowns withdraw only their subscription. Dispatch skips listeners withdrawn during the event, defers new listeners to the next event, and notifies remaining listeners before propagating the first callback error.

  • Mini-game and native audio completion retires ownership before callbacks. Natural completion releases the player or voice record before calling user code, so callback exceptions and repeated end notifications cannot retain resources or deliver completion twice. Stopped, ended, and backend-disposed mini-game handles ignore later playback and parameter operations; retired native handles also stop sending host operations.

  • Audio device suspension freezes volume fades. Fade elapsed time stays at its current position while the device is suspended, preventing covered or interrupted playback from completing a fade-out before resume. Existing per-voice pause handling remains effective after the device resumes.

  • Mini-game device resume preserves manual audio pauses. The backend resumes only live contexts that were playing when device suspension began. Repeated suspension retains the original resume set, and stopped, ended, or disposed contexts are never restarted.

  • Audio plugin cleanup belongs to each App. Shared plugin instances release the quitting App's voices, backend, and memory/despawn subscriptions without stopping another App. Released systems stay inactive, and repeated preview shutdowns release every backend once.

  • Retired WebAudio handles cannot modify reused pool nodes. Gain and pan writes from stopped or completed handles are ignored, preserving the next voice's mix. Completion callbacks are checked against the currently playing source, so an old source cannot release the pool slot of a resumed voice.

  • Paused voices remain owned by the audio API. Paused handles retain their voice-budget slot, bus volume and mute updates, and disposal cleanup; stolen paused voices cannot resume outside the budget. Handle volume edits update the tracked base gain, fades stay associated with managed handles, and ended ramps stop writing to released backend voices.

  • WebAudio position stays continuous across playback-rate changes. Rate edits anchor the accumulated position before applying the new rate, so pause/resume and loop offsets use the time actually played at each rate. A rate rejected by the backend leaves the existing clock intact; paused edits apply when playback resumes.

  • Playing audio sources follow live parameter edits. Volume, pitch and loop changes update the existing voice without restarting it. Switching spatial sound off restores base gain and centered pan; stable nonspatial sources do not resend unchanged parameters, and voice cleanup avoids copying its key list every frame.

  • UI ancestor walks terminate on malformed hierarchy adapters. Depth counting and parent callbacks stop before repeating an entity or following an ancestor invalidated by a callback. Shallow chains use bounded array scans, deeper chains switch to a set, and long valid chains remain iterative with early callback termination preserved.

  • Unavailable dropdowns retire their open lists. Disabling, hiding, deactivating or removing a dropdown closes its popup even when the owner drops out of component queries. Keyboard input and stale row clicks cannot change an unavailable control; availability is checked again after popup teardown callbacks.

  • Dropdown labels and open rows follow live option edits. Renames and label replacements repaint without a false selection event; changed option lists or row heights rebuild an open popup and keep the selection in range. Stale rows cannot choose a newly substituted option, popup teardown cannot resurrect a disposed owner, and change callbacks may remove later controls safely.

  • Toggle indicators follow target replacements safely. Replacing a check entity immediately applies the current on/off state without a false change event. Change callbacks may dispose later toggles in the same update, while stable frames avoid repeated visual writes and reuse cached state during transitions.

  • Slider capture expires with input and target availability. Disabled, inactive or hidden tracks and lost pointer projections cancel capture before a value update, so restoring the control cannot resume an old drag. A consumed release followed by another press cannot retain capture, and track width is read from the slider's own World instead of shared UI helper bindings.

  • Slider visuals follow range and target edits. Changing min/max or replacing a fill/handle updates the displayed fraction even when the value is unchanged, without emitting a spurious value-change event. Stable frames do not rewrite visuals, cached display state is reused during value changes, and change callbacks may remove later sliders safely.

  • Object drags stop when their input or target becomes unavailable. Editor-consumed releases, disabled or removed drag components, hidden targets and lost pointer projections clear capture before another position write. Drag callbacks may disable or remove their target safely, and an active gesture emits its end once without resuming later.

  • Cancelled scroll gestures stop without flinging. Editor-consumed pointer releases cancel capture even after UI pointer sampling consumes its marker. Inactive, noninteractive or hidden viewports stop dragging and coasting; hidden layout boxes no longer clamp the saved scroll position to zero; losing all pointer projections discards motion instead of resuming an old drag when the view returns.

  • Scene scroll settings update while the game is running. Changes to axes, wheel speed, drag enablement and movement settings rebuild the adopted container while preserving legal offsets. Disabling both axes suspends scrolling, reactivation restores the content position, and replaced containers cannot inherit an old pointer drag or fling.

  • Scroll views follow content hierarchy edits. Reparenting a live content node switches an implicit scroll view to its new first child, and clearing an explicit content reference restores first-child selection. Retired containers stop moving the previous content; unchanged hierarchies do not reread native child vectors every frame.

  • Scroll views retain valid offsets across simultaneous resizes. Viewport and content dimensions update together before clamping, avoiding position jumps and duplicate scroll notifications. Destroyed content references detach their containers instead of leaving stale scroll targets.

  • Scene-authored scroll views receive hover and wheel input. Hit testing no longer inserts hidden interaction components outside the SDK's component index. The interaction system owns creation and query invalidation, so wheel scrolling and per-frame hover/press state work for controls placed in the editor.

  • Claimed input releases cannot leave gameplay controls held. Keyboard, mouse and touch releases consumed by an editor or UI handler silently retire the previous held state without manufacturing gameplay release edges. UI capture receives primary-pointer cancellation instead of a click, even across frame-edge clearing; unowned touch moves and releases do not create ghost contacts.

  • UI gesture bindings expire with their targets and App. App cleanup unregisters only its own input handler and clears captures. Despawn removes gesture callbacks and pending markers through one shared World observer; a cancelled frame click no longer suppresses a later click after the control is re-enabled.

  • Safe-area resize listeners belong to their App. Quitting an older App no longer removes a newer App's browser listener or leaves its own behind. Rebuilding replaces the same App's binding, cleanup uses the original host and WeChat callback identity, and older hosts without an unsubscribe API revoke the retained callback.

  • Camera fitting and editor previews use outer canvases consistently. A nested canvas appearing first no longer overrides the scene design resolution or becomes the default host for new UI. Scene-filtered camera collection uses a running scene's outer canvas, and preview selection queries Canvas components directly. The experimental canvasRootEntities helper shares root selection across runtime and editor workflows.

  • Nested canvases keep their parent layout and authored draw order. Only top-level eligible canvases start traversal, so a nested canvas is not laid out again against the full screen or assigned a second draw-order range. Descendants inherit the nearest canvas's sorting layer regardless of canvas creation order.

  • UI hierarchy walks tolerate deep scene groups and broken child links. Tree construction, screen-domain collection and draw-order assignment use iterative traversal. Repeated or cyclic child links stop revisiting entities while preserving the authored sibling order and nearest UI parent.

  • Large UI subtrees keep their full traversal span. Subtree lengths no longer wrap at 65536 nodes, preventing layout and visibility walks from freezing or skipping content at the 16-bit boundary.

  • Static UI layout preserves composed world transforms. Clean early and late layout passes keep the transform cache valid, and the SDK composes through the shared change-aware path. Moving a screen box, changing layout properties, tweening, and structural edits still invalidate the affected composition.

  • Touch hit caches release ended pointer IDs. Long-running touch sessions retain only the pointers present in the current input frame, including release-frame results needed by quick taps, instead of accumulating every historical finger ID.

  • Pointer callbacks cancel invalid UI interactions immediately. Disabling or deleting a control during hover, press or release stops later events from the same batch. Invalidated captures and interaction edges clear in the same frame, so re-enabling a button does not complete an old press.

  • UI focus transitions recheck callback changes. Removing or disabling a control and opening a modal during blur cannot focus a stale or excluded target. Focus callbacks that remove their control clear the manager in the same update. Blur handlers observe the cleared state, and single-target keyboard eligibility avoids sorting the entire Tab ring.

  • Sprite callbacks cannot recursively advance the same animation update. Nested updates are ignored and exceptions release the update guard. Clearing, replacing or shortening a clip's frame list inside a callback stops stale dispatch and reapplies a valid pose on a later update instead of reading a removed frame.

  • Sprite playback catches up without replaying a time backlog. Complete loop crossings deliver events in playback order, zero-time updates do not repeat the initial event, and single-frame completion does not fire it again. Long updates restore the correct phase while coalescing each declared event to one notification per update. Stopped frame/label seeks update the pose, and changed frames write existing component values without rebuilding defaults.

  • Sprite animation events tolerate listener and entity changes. Self-unsubscription no longer skips the next listener, and listeners registered during dispatch start with a later event. Callbacks that remove, replace or despawn an animator cannot have their changes overwritten by the old update. Listener lists use copy-on-write at registration rather than copying on each animated frame.

  • Tilemap edits respect layer locks and stroke ownership. Locked layers reject paints and tileset changes before taking snapshots. Live strokes require their original scene, layer binding and edit world; stale completion or cancellation cannot affect reused handles. Locking a layer rolls back its unfinished stroke.

  • Tilemap data is available before renderer initialization. Headless tile reads, edits and chunk serialization use the context's own data service without requiring graphics setup. Initializing the renderer keeps any preloaded maps; shutdown and reinitialization create a fresh service.

  • Tilemap bucket fills finish every discovered cell within the safety limit. A 16,384-cell region fills completely without a false warning, while larger or infinite regions remain bounded. Traversal uses a FIFO cursor and reads each boundary cell once. Flip flags participate in the brush comparison, and unchanged cells are omitted from the paint transaction.

  • Switching tilemap layers clears the previous palette before drawing. Palette loads restart when the project changes even if entity IDs are reused. Superseded reads stop requesting subsequent tilesets or atlas dimensions after a layer switch or panel close.

  • Tilemap palette refresh keeps the selected tileset. Editing or reloading a tileset retains the active tab and brush. The painter reuses the loaded palette asset instead of reading it again, and switching atlases clears the old preview until matching image dimensions are ready.

  • The website keeps its original editor showcase. The landing page and README again use the curated editor screenshot with their original proportions and captions; release acceptance captures remain separate.

  • Website download details load from the same origin. Deployment copies the mirror's release metadata onto the website, so package names and sizes display without depending on the mirror's bucket CORS permissions.

[0.78.0] - 2026-10-12

Added

  • Material state can be applied as one complete snapshot. Material.applyState restores missing base defaults, removes instance overrides and accepts ownership of edited texture leases. resolveDocumentRef exposes the shared document-relative and UUID reference resolver.

Fixed

  • Virtualized lists follow their resolved UI viewport. Layout constraints, window changes and safe areas update the visible range, linear row sizing and scroll limits together. Viewport and content changes clamp the offset once, preserving reachable final rows. The list sample fills its constrained panes so rows no longer overlap the footer.

  • Native UI follows the device safe area. iOS view insets and Android content bounds reach SafeArea in surface pixels, including delayed layouts and landscape side changes. The localization and virtualized-list samples place their text and controls inside authored safe-area containers so the iPhone cutout does not cover paragraphs or list rows.

  • The installed macOS MCP entry launches the bundled editor. It reads CFBundleExecutable from the app's Info.plist instead of assuming the product name matches the executable file.

  • Saving Prefab instances preserves authored draw order. Collapsed instances keep their root's position among ordinary entities instead of moving to the end of the scene. Unresolved instances also retain their original positions.

  • Camera previews keep a conservative CPU budget. A slow main-frame timing sample no longer increases the preview refresh rate. Preview scheduling retains the cheaper baseline for the current App and still restores the editor view after capture.

  • The website preview comes from the exported game. Release builds capture the Celestial Heights Web sample and publish its source commit and image checksum alongside the frame.

  • Stopping editor Play stops game audio. Single-player Stop now releases the game App and its plugins while keeping the engine renderer warm for re-Play. BGM and scripted/source voices are stopped, pending audio loads cannot resume playback, and a Stop during startup cancels the realm. This applies to both the editor UI and MCP (set_play: stopped).

  • Entity activity follows the hierarchy. Rendering, skeletal animation, particles and UI honor inherited activity, and transform updates remain consistent for deep hierarchies.

  • Scene assets have scoped ownership. Scene changes, prefab preparation, hot loads and Undo release superseded acquisitions. Texture bindings use resource identities across GPU replacement, and native component access preserves nontrivial C++ fields.

  • Live material texture edits match saved Play. Relative paths and UUIDs resolve consistently. Reset removes overrides and preserves future inheritance; deselecting an unsaved material keeps its edited textures alive until replacement or disposal.

  • Asset previews release obsolete work. Mesh and material previews serialize shared readbacks, prioritize inspection and cancel queued requests on scene changes. Thumbnail caches are bounded; stale material records and reconnected cores are rejected before GPU submission. Scene binding state still updates when resource cleanup throws.

  • Imported material textures resolve correctly. glTF material and texture import references stay consistent with the runtime asset loaders.

  • Audio preview failures stay with their own clip. A late failure cannot stop a replacement clip; synchronous playback failure clears preview state, and changing projects stops old browser previews.

  • Waveforms preserve every audio channel. Opposite-phase stereo and surround channels remain visible. Waveform fetches and scans are cancellable, decoding runs one file at a time without opening a live audio output device, and large scans yield background tasks so input can continue.

  • Compressed sprites keep their authored dimensions on WebGL. S3TC mip chains that violate WebGL block alignment decode to RGBA before upload instead of registering an incomplete texture. Odd-sized images such as 70×70 sprites remain visible; valid compressed chains and small tail mips still use compression.

[0.77.0] - 2026-10-10

Added

  • Text input hints can follow the game's language. TextInput and createTextInput accept placeholderI18nKey. An empty field resolves the key through Localization and responds to locale, catalog and preview changes; typed values and authored literal placeholders remain intact. Placeholder-only scenes also load localization tables.

  • The UI Debugger follows the live game. Pick a UI element in Play and inspect its hierarchy, layout bounds, input settings, text input and dialog state. Mask diagnostics show ancestor masks and rectangular clipping. Focus inspection follows runtime controls and Tab traversal. Event recording observes actual entity dispatch, shows propagation paths, and keeps recording when switching debugger tabs.

  • UI text inspection and pseudolocalization previews. The editor can inspect computed text boxes, show overflow before clipping or ellipsis, and select the authored entity. Runtime localization can opt into accent and length stress without changing catalogs or parameters. Complex scripts, rich text and custom fonts are marked for visual review. The multilingual sample documents the scope and remaining platform checks.

  • A selected camera has a preview without advancing gameplay. The preview uses the authored camera, restores the editor view afterwards, and can be pinned or closed. Refreshes run at most once per second and slow down when recurring render/readback work is expensive; initial shader and target setup do not set the ongoing refresh budget.

  • Tilemap edits can be reviewed before applying them. Preview replacements over a selection or layer, inspect terrain-rule mismatches, and keep reusable stamps with the project. The tilemap-workflows example demonstrates the workflow. The platformer example also demonstrates stretchable nine-slice sprites.

  • Device quality profiles can be previewed in the editor. An opt-in policy selects low, medium or high settings from device information and project rules. Profiles control render scale, MSAA, shadows, particles and post-processing, with optional dynamic resolution. The default remains off; projects keep their authored quality until they opt in.

Changed

  • Unchanged plain translations use a bounded cache. Up to 256 parameter-free string translations are reused per Localization instance. Locale, fallback, catalog and preview changes invalidate the cache. Parameterized, plural and missing-key messages remain live.

  • Gizmo controls keep a 2D scene easier to edit. Detailed geometry defaults to selected entities, inactive handles no longer intercept ordinary scene interaction, and visibility and icon size are saved per project. The menu separates common controls from advanced types. New preview, tilemap and debugger controls use the editor's shared button and theme styles; text entities put content and layout first in the Inspector.

  • Device reports can inspect prebuilt native apps. Android frame reports no longer require hooks in a project's source, and native boot verification can run a supplied application without a packaging template.

  • Full-editor MCP checks can run without showing windows. editor-mcp.mjs --editor --hidden keeps the real authoring and Play surface available without a desktop window. Local authoring checks use this mode by default; CI uses its virtual desktop for OS-focus acceptance.

Fixed

  • Keyboard and pointer focus stay with eligible UI controls. Web Tab traversal stays inside the game, nested modal dialogs constrain focus to the innermost modal, and hierarchically hidden dialogs no longer capture it. Hiding or disabling the focused control clears stale focus. A quick pointer press and release between frames still sets focus.

  • Text cache entries respect overflow and parameter boundaries. Changing clipping or ellipsis invalidates cached layout, and escaped localization parameters no longer collide with another parameter combination.

  • A project that moves keeps answering its textures from its own cache. The editor remembered where each compressed texture was kept as an absolute path, so a project copied elsewhere went on serving textures from the old folder, and from none once that was deleted. It is kept relative to the project now; a record written by 0.76.0 is still read.

  • Release checks compare the content that ships. Windows CRLF checkouts no longer appear to have stale generated bindings or baked scenes. Native-template verification compares the SDK hash embedded in bytecode instead of copy timestamps. First-screen timing presents the page before measuring browser paint, and gizmo checks explicitly choose the visibility they inspect. The tilemap workflow scene now ships in the current scene format.

[0.76.0] - 2026-10-01

Changed

  • A texture's Compression is Auto, GPU compressed or Original image, and a build does what it says. A build used to encode every texture with Compress on and then ship whichever file was smaller, overruling the row: ORCA Bistro's export shipped 321 of its textures as PNGs, 4.7 GiB decoded on a player's GPU. Every engine we looked at (Godot, Unity, Unreal, Cocos Creator) keeps the author's per-texture choice, and Godot's defaults are what Auto follows: a texture a mesh draws — directly, or through its material — is GPU compressed, where video memory is the cost; a sprite or UI image ships as its file, where a flat PNG is often a tenth of the KTX2. An explicit choice is kept whatever draws the texture. A .meta written before this keeps its meaning: its true was the default every fresh file got, so it reads as Auto, and false as Original image. Across the examples, the 2D ones ship the same bytes (tilemap-demo 6 KB more); a 3D one with a 1024 texture on a mesh ships it as a 1.3 MB KTX2 where the PNG was 14 KB. The Inspector says why a texture ships raw, and an export names the Original-image textures a mesh draws and what they cost decoded — a lightmap, kept exact by its bake, left out.

  • A bake uses every core, in C++. The ray casting runs in a compiled kernel (build-tools/lightmap, built from tools/lightmap-wasm) on every core, with a tree built for tracing rather than for building quickly. Its rules are the TypeScript solve's, rounding included, and a gate holds the two to the same atlas bytes; any thread count writes the same bytes. ORCA Bistro — 1.2 million lumels, 2.8 million triangles — bakes in 44 s on a 20-thread machine, where a pool of worker threads took 312 s and one thread twenty-five to fifty-five minutes; the solve itself is 36 s of that. The kernel also decodes the textures a surface's colour is averaged from, side by side: Bistro's 132 took 2 s instead of 20. The editor and bake-scene both use it. Two triangles a ray meets at the same distance now go to the lower-numbered one, so the answer no longer depends on how a tree is built; physics-3d's committed bake moved by one step in two texels.

Added

  • A directional light can be the environment's sun. An HDRI with a sun in it lit a scene twice when the scene also had a sun — once in the environment's diffuse light, spread across the whole sky and into every shadow, and once from the light — and the two pointed wherever each was set. Importing a .hdr now finds its sun: the compact region around its brightest texel, when it carries a real share of the light. The .esenv keeps the full irradiance and adds the sun's direction, its strength and the sky's irradiance without it. A Directional light with Follow Environment Sun takes its direction and strength from that sun, turned with the environment and scaled by the ambient light as the panorama is; its own colour and intensity scale it on top. The environment then lights with the sky alone. The editor draws the light along the sun, and a light following an environment with no sun is left out of the frame with the reason in the Inspector. Bakes resolve it the same way. Under ORCA Bistro's HDRI the sunlit street's colour now matches the reference render, and its shadows are blue sky rather than warm sun. Reimport a .hdr to add its sun.

  • Baked light is a lit surface's indirect light. A lit renderer — every imported model's is — reads its patch of the atlas in place of the environment's diffuse light and a probe volume's, and keeps its lamps, shadows and reflections live. The bake holds the sky as it reaches each point past whatever stands in the way, plus what the surfaces around give off, over as many bounces as asked: under ORCA Bistro's awnings and in its side streets the sky is now mostly hidden, where before every point got all of it. Before, a model's material never read the atlas at all, and a mesh drawn without one added it on top of the sky and the lamps and was lit twice. The sky a bake gathers is the environment's own irradiance, turned and tinted as the frame reads it, so an open floor bakes to exactly what the frame would light it with. An atlas holds light up to eight times a flat ambient of one, where eight plain bits stopped at one. A cutout lets the share of rays that meets its holes through, both faces of a two-sided surface give off light, and a layer lying closer above a surface than half a lumel — a decal, a wet sheen — no longer walls it off from the sky. A scene baked before reads as stale: its atlas is in the old encoding and must be baked again.

  • A model whose second UV set cannot be baked into gets a lightmap UV in its place. One that covers under 5% of its square pays for the empty rest — ORCA Bistro's road, 3533 m² in 0.5% of it, asked for more atlas than the rest of the town together — and one that lies on itself gives every copy the same texel's light: Bistro's curbs share one strip eighty layers deep, and a building's facades a hundred. Import unwraps either instead and says why; import-model --lightmap-uv turns generation on from the command line. A bake names a surface whose UVs overlap, and one that does not fit names the three surfaces taking the most room and how much of their square their UVs cover.

Fixed

  • physics-3d's lightmap is read as the light it is. Its .meta predated the bake owning an atlas's import settings, so it was sampled as sRGB and repeated at its edges. bake-scene --check now holds an atlas's import settings to the bake's too, which is how it was found.

  • A large project opens in minutes, not half an hour. The editor uploaded every texture as decoded pixels. ORCA Bistro's 224 2K textures came to 4.7 GiB of video memory, past what an 8 GB card had free, so Windows paged them in and out while the GPU sat idle. One frame stalled for up to 25 minutes, and Chromium's GPU watchdog then restarted the GPU process and the whole load began again. The editor, and the play realm beside it, now draw textures GPU-compressed, as a build does: the same KTX2, from the same cook cache, so the editor pays nothing for art an export already compressed and an export after an editing session encodes nothing. A texture the cache does not hold yet is drawn from a preview no larger than 1024 while it compresses in the background, then reloaded, and the editor does not report idle until it is. Textures with Compress off stay as they are. The editor draws each texture as the build ships it, by the same Compression rule. Bistro now opens with a cold GPU cache in about two minutes, where it took 20 to 36. Opening a project again reads and hashes no texture source: the editor remembers each texture's answer against the source's size and time, its import settings, whether a mesh draws it and the encoder, and streams the KTX2 from the cache file instead of copying it through its main process — Bistro's 1.3 GB of them had kept that process busy for most of the load.

  • A scene of thousands of meshes draws its first frame in seconds. Every mesh draw wrote its probe and instance blocks into a uniform buffer of its own, so a frame's first appearance created one per draw: ORCA Bistro's 8,000 draws made 16,000 buffers, 128 MB of them, and on Windows the GPU process spent 30 s of a 43 s project open creating them. A draw's blocks are now ranges of a few shared pages — a range starts where the last draw's bytes end, not a whole block later — and a pass stages every draw's blocks before it uploads each page once, where each draw had written its own. Bistro's frame now holds 18 pages and makes 56 uploads, where it made 15,924; it opens to idle in about 16 s.

  • bake-scene refuses a scene made of prefab instances instead of crashing on it. It cannot expand an instance, so it found nothing to bake and then threw on the instance entity; it now says to bake such a scene in the editor, as it already did for parented entities.

  • An environment is no longer mirrored. A panorama was read with its left and right swapped, so a camera facing its centre saw what the photographer saw on the left on its right — in the sky, in reflections and in the light the environment casts. ORCA Bistro's HDRI put its sun on the wrong side of the street. The sky, reflections and irradiance now read a panorama as it was shot, through one mapping, and a gate draws a panorama that is red left of its centre and blue right of it. Reimport a .hdr to pick it up; a scene that was turned to suit the mirror needs its environmentRotation set again.

  • A baked atlas ships at the size it was baked. Its import settings took the texture default of a 2048 cap, so a 4096 bake was halved on export and each object's light ran into its neighbours'. A bake now owns the atlas's import settings — linear, uncompressed, clamped, and never capped below the atlas — and puts them back on every bake, keeping the file's id.

  • Baked light lands where it was baked. The atlas file was written with its first texel row on top, and the engine uploads a picture bottom-up, so every surface read its light from the mirror-image place in the atlas — mostly empty, so a lit surface in shadow went near black and showed only its reflection of the sky. ORCA Bistro's awnings in the shade came out grey and its hedges blue-black; now they are red and green. A bake now writes its file bottom-up, and a gate draws an atlas that differs only by row the way a shipped game loads it. Rebake a scene to pick it up.

  • A shipped game samples normal maps and roughness maps as data. The engine's own upload — a web export, a mini-game, a native build, the editor's Play — made every image an sRGB colour texture in a linear project whatever its import settings said, so every normal map was bent (a flat one by about fifty degrees) and every packed occlusion, roughness and metal map gamma-darkened, while the editor's viewport, which uploads through its own path, looked right. ORCA Bistro's Vespa came out as dark chrome in an exported game and blue in the editor. Khronos's NormalTangentTest now draws each normal-mapped bump as its geometric twin does.

  • Normal maps stay on up close. The tangent frame taken from screen derivatives was refused below a fixed size, which shrinks with the fourth power of distance and scale, so in a metre-scale scene a surface a few metres from the camera silently lost its normal map.

  • A coloured light bakes the colour it lights with. In a linear project the frame linearizes a light's colour and the bake took it as written, so a warm sun baked a paler, pinker bounce than the one it cast in real time.

  • The editor stays responsive while it bakes. The solve ran on the main process, so a bake of minutes left the window and the automation surface unanswered until it finished; it runs on a worker thread now.

[0.75.0] - 2026-09-27

Added

  • A cutout's edge is antialiased. With multisampling on (the default), a material with an alpha cutoff turns its alpha into multisample coverage along the cut instead of testing it, so leaves, grass and fences stop stair-stepping at their edges. A shader opts in with #pragma coverage <param>, which the built-in Model shader declares for u_alphaCutoff; a material without a cutoff, and a blended one, draw as before. It holds in gamma projects with no post-processing too, which draw straight into the multisampled surface.
  • Project Health names the textures a material reads as data while they are still decoded as colour. In a linear project, a normal map or packed roughness marked sRGB is bent on the way in; models imported before 0.74 left every one of them that way. The report lists them in one finding and its Fix turns sRGB off on all of them. Which texture params hold numbers is the shader's to say: #pragma param … texture … texel(data), which the built-in Model and Lit shaders now declare. The same report names settings in project.esproject that nothing reads.
  • Importing a model brings its lights and cameras. A glTF's KHR_lights_punctual lights and its cameras, and an FBX's point, directional and spot lights and its cameras, become Light and Camera components on their nodes, turned to face -Z as the engine's do. Colour, cone angles, reach, field of view and clip planes carry over; intensity is carried over as the file states it, as Godot's importers do, since the engine's has no photometric unit. An imported camera is never the active one. ORCA Bistro's own camera arrives exactly where its official view was set up by hand; area and volume lights are named and skipped.
  • A cutout's mip levels keep its coverage. A texture a material cuts at an alpha threshold is encoded with each mip level's alpha rescaled so the share of texels past the cut stays what it is at full size; plain averaging thins it until distant railings and fences are gone. Bistro's wrought-iron texture keeps 14% of its texels past the cut at 32 and 16 px, where averaging leaves 4% and none. Importing a model sets it (Mip Coverage Cutoff, an advanced texture setting) on the base colour of every cutout material, also when a blended material shares the image. It applies to UASTC KTX2 textures, which such a texture now stays even when larger than its image.

Fixed

  • Textures are sampled through mip levels on WebGPU. The device built no chain for an image it uploaded, and the built-in material shaders read level 0 even of a KTX2 that carried one, so every texture drawn smaller than itself shimmered on WebGPU. An image now gets its chain on upload, rebuilt when its pixels change, and the Sprite, Lit, Outline, Dissolve, UV Scroll and Model shaders sample through it; Pixelate keeps level 0, which is its look. Khronos's AlphaBlendModeTest forty metres off shimmers as little on WebGPU as on WebGL2.
  • WebGPU post-processing keeps the picture the right way up. Every fullscreen pass sampled its input upside down, so a frame came out inverted whenever its chain had an odd number of them — a linear project with no post-process effect, for one — and an effect that reads depth, such as SSAO or distance fog, laid its result over the colour mirrored.
  • Ambient occlusion works behind another post-process effect. The scene's image went back to the pool after the last pass that read its colour, taking its depth with it, so an SSAO placed after a colour grade — as ORCA Bistro's volume has it — found no depth and occluded nothing, at any radius or intensity. The scene now lives until the chain's last pass.
  • A shipped game's textures are sampled through mip levels. An image the engine uploads itself — in a web export, a mini-game and the editor's Play — got no mip chain on WebGL2, so a texture drawn smaller than itself took one texel per pixel: in ORCA Bistro the trees turned to noise and the shutters to broken bright lines, while the editor's viewport, which uploads through its own path, looked right. The chain is now built from the pixels and rebuilt whenever they change, as that path does.

[0.74.0] - 2026-09-27

Added

  • Android release signing. A Shipping APK (and App Bundle) is signed with the release key the project names under Project Settings → Android → Signing — two PEM paths, the passphrase kept in this machine's keychain (the command line reads ESTELLA_ANDROID_KEY_PASSPHRASE); Development builds keep the development key. A Shipping build without one says it will be refused by Google Play.
  • EmscriptenGLX on WeChat. A WeChat project can ship the engine linked with WeChat's EmscriptenGLX (Project Settings → WeChat → Render through EmscriptenGLX, off by default), which issues the engine's GL calls natively instead of through JavaScript: a draw-heavy scene spent about 12% less time rendering on an Android phone. It adds about 310KB of wasm and needs base library 3.8.12 on Android, or iOS in 高性能+ mode; any other host renders through WebGL2 as before, and the log says which. The engine is built once with node build-tools/cli.js build -t wechat-glx, which fetches WeChat's library at a pinned version and hash, and emsdk 4.0.10 beside the main one; an export that asks for it without it says so.
  • A connected development build says which graphics API it draws through. WebGL2, EmscriptenGLX or WebGPU, once its game has started — the Profiler shows it beside the device's controls, the Output Log notes it, and device_targets returns it as graphics. A WeChat build set to EmscriptenGLX reports WebGL2 on a host that does not offer it.
  • A connected development build can be asked for the whole frame it composited. Every camera and the UI over them, as the player sees it — device_screenshot returns it as a PNG, read back by the device's own engine. The frame debugger's replay shows one pass of a captured frame.
  • Web and mini-game packages decode Zstandard-supercompressed KTX2. The native host already did. UASTC textures made outside Estella usually are supercompressed, and every one failed to decode; the transcoder module grows by about 21KB compressed, in packages that carry KTX2.
  • A single-level KTX2 made outside Estella ships with a mip chain. The cook encodes the levels below it and keeps the file's own level 0 byte for byte, so it no longer shimmers into the distance. Bistro's 2048² textures each took about 0.3 s; the package grows by the chain's third.
  • Exporting compresses textures on every core. The encoder runs on worker threads, as many as the machine lets this process use, and the pool widens only while the memory its workers have measured fits in half the machine's. The ORCA Bistro exterior's first web export on a 20-thread Windows machine took 5 min 25 s; one core had managed 184 of its 200 textures in 47 minutes. The encoded bytes are the same either way. ESTELLA_ENCODER_WORKERS sets the width, and 0 encodes on the calling thread.
  • Exporting again is fast when the art has not changed. The cook keeps what it encoded under .esengine/cache/cook/, keyed by the source, the settings and the encoder. Re-exporting Bistro took 24 s against 131 s the first time.
  • A scene's preload says what each asset type cost it. Per type it logs how many, their summed load time and the slowest one, and preloadSceneAssets returns the same as timings and wallMs. Bistro on a Windows machine: 132 materials 54 s, 107 textures 47 s and 1505 meshes 45 s of load time over 24 s of wall time.
  • KTX2 textures transcode on worker threads. On the web and in the editor, one to four of them by the machine's cores, instead of on the main thread. Bistro's assets loaded in 14 s instead of 24 s on a Windows machine, and the page stays responsive while they do. A realm with no workers (a mini-game host) transcodes on the main thread as before, and so does one whose workers fail, which says so once.
  • Web exports pack their small assets into a few files. Local meshes, materials, KTX2 textures, timelines and animation assets go into a few packs/*.pack files, one request each, and the runtime reads each asset out of its pack. A browser holds six connections to a site, so a scene of thousands of small files loaded at the pace of its requests: Bistro's 1505 meshes took 43 s of load time for 0.2 s of upload. Its first frame on a Windows machine went from 15.2 s to 7.3 s, pixel for pixel the same. An export with hot update configured keeps one file per asset, since an update downloads assets one by one; an update that meets a packed asset refuses it by name.
  • Importing a model converts its DDS textures to PNG. BC1 to BC5 and uncompressed, whether the file sits beside the model or inside an FBX, so a model shipped with DDS art arrives with every map instead of references nothing can load. BC5 normal maps get their Z rebuilt; BC6H and BC7 are named and skipped.
  • An FBX model's specular map can be read as packed ORM. Occlusion in red, roughness in green, metalness in blue (Specular Map → Packed ORM in its import settings, --specular-map orm on the command line), the way scenes authored for Falcor such as Bistro store it. Read as a colour, as before, it has no slot in metal/rough shading and is left out.
  • An FBX material takes its alpha from its base colour image. FBX has no alpha mode, so an image that is mostly clear where it is not solid imports as a cutout (alpha test 0.5), one that is mostly in between as blended, and one without a real alpha channel stays opaque. A material whose name ends in .DoubleSided, as Lumberyard-era exports such as Bistro mark it, draws both sides. Bistro's trees were leaf cards drawn opaque and one-sided — black squares with a few leaves on them.
  • A project file's settings that nothing reads are named instead of dropped. Opening the project in the editor and exporting from the command line both say which keys of project.esproject are ignored, and point a block written at the wrong level (a rendering beside features rather than inside it) to where it belongs. That misplaced block had left a linear, ACES project running in gamma with no tone curve and no word.
  • A model import says when a map's pixels contradict its slot. An occlusion map that is zero in every texel is left out with a warning, since it would take all ambient light from the surface, and a map that is one colour throughout is noted.
  • An export warns about a signing key committed with the project. It says so when a signing key the project names (a quick game's or Android's) sits inside the project and is committed to its repository, or is not ignored and would be committed next.
  • Export profiles. A project can name several exports of one target in packaging.profiles — a test and a production WeChat build, each with its own AppID, CDN root and development or shipping configuration, writing only what differs from the project's settings. The Build dialog creates, edits and deletes them per target, marking each setting a profile overrides with a reset that hands it back to the project; estella export --profile <name> and the agent's export_game build the same one, and the size history records which profile a build used.

Changed

  • The CDN root remote asset groups and hot updates use is a packaging setting of the project (packaging.remoteRoot, the Package dialog's CDN root field), and export profiles override it — a production profile carries the real CDN while the project stays same-origin. .esengine/asset-groups.json's activeProfile / profiles are still read for a project that sets no root of its own; hot-update-demo and the hot-update docs use the new shape.

Fixed

  • Normal, roughness/metalness and occlusion maps are sampled as data, not colour, under the linear pipeline. A KTX2 texture took sRGB decode from the project's colour space alone and ignored its own sRGB setting, and a model import never turned that setting off for the maps that hold numbers — so every normal map leaned and every roughness read glossier than authored. Imports now mark those maps not sRGB, and every upload path follows the setting. A model imported before keeps its textures' settings: turn sRGB off on its normal and packed maps.
  • A post-process effect placed before bloom or SSAO takes effect. Their last pass laid its result over the untouched scene instead of over what the chain had made so far, so a volume's colour grade, exposure or grayscale — and SSAO, under bloom — vanished whenever bloom or SSAO came after it. They now composite over their own input.
  • A double-sided mesh is lit on the side the camera sees. Its back faces took the front's normal, so a leaf, a flag or an awning turned away from the light went black on the side the light actually reached; the normal now flips for a back face, as glTF specifies, in the engine's mesh shader and in the material shaders an imported model uses.
  • Normal maps stored in two channels light correctly. The shader rebuilds Z from X and Y instead of reading blue, so a BC5 map, or one a converter wrote with blue at 0 — every normal map of Bistro's glTF conversion — no longer points its surface's normals inward, which left normal-mapped surfaces unlit by their sun.
  • Compressed (KTX2) textures on web and mini-games are sampled with their mip chain. The cook has always written one into every texture it compresses, and only level 0 reached the GPU: a compressed texture shimmered as it shrank into the distance, and the rest of its bytes shipped for nothing. A texture decoded to RGBA on a device with no compressed format gets its chain generated.
  • The package size report on Windows attributes the SDK's bytes to the directories they come from again: every module read as "project", since the source map's paths were spelled with backslashes.
  • A WeChat package registers every engine component and the built-in AI names again. The WeChat entries lost their start-up calls to the bundler, so a scene using a component with no typed definition — a rigged model's MeshSkin among them — loaded without it ("Unknown component type") and its character was never skinned.
  • Reading a component whose field is a list of entities — a node's Children, a skin's joints — returns an array from every read path and frees the engine's copy. world.tryGet and query iteration handed back the engine's vector: an animated rig leaked one per joint per frame, and on the WeChat EmscriptenGLX engine, whose vectors cannot be iterated, the animator threw every frame.
  • estella import-model registers the images a model references on disk, so an export ships them. It wrote the materials and prefab that name them and left the images themselves unregistered, and a package built from the command line carried none of its textures.
  • A WeChat or other mini-game package draws each sprite from a packed atlas as its own frame again, not as the whole atlas page shrunk into the sprite. The package's scenes now keep their @uuid: references as the web package does, and a reference by bare uuid finds its atlas frame too.
  • Sprite masks work in WeChat and other mini-game packages: the game's WebGL context was created without a stencil buffer, so every mask drew as if it were not there (space-shooter's hull bar read as empty). The web, playable and mini-game hosts now create the context with the same attributes.
  • On a host that compresses the engine binary (most CDNs and static hosts), the web boot bar no longer runs to the end of the engine download a third of the way through and stands there for the rest of it: the page divided decompressed bytes by the compressed Content-Length. The export now records the binary's own size (engineBytes in game.config.json) and the bar measures against that.
  • Project Settings says the start screen's logo is for web exports; a mini-game shows its host's own start screen and loading text.
  • The Profiler no longer reports a connected build's debug-channel cost as 0 ms when the device's clock is too coarse to measure it — a browser that is not cross-origin isolated steps by 0.1 ms. The device reports its clock's step, the row reads "< 0.100 ms", and profile_frames returns it as channelClockMs.
  • Opening a project no longer holds the editor behind "Preparing play realm…" for about ten seconds: the play realm's warm-up was being cut off and the editor waited out its deadline. A project now opens in under a second, and the first Play is still warm.
  • An export from the Build dialog and one from estella export now read the project the same way. The dialog's builds keep the engine modules a project includes or excludes, which they ignored; the command line's carry the project's app id (a native package was always com.estella.game, so two games replaced each other on a phone), its script entry and scenes folder, its desktop channel and Steam app, and a playable's ad network.
  • Android's "Android Studio project" and "App Bundle (.aab)" settings take effect: the project file never read them back, so every Android export wrote an APK and nothing else.
  • A native development build's Profiler shows its draw calls, triangles, sprites and VRAM, and what the debug channel costs it: all read 0 on a native build.

[0.73.0] - 2026-09-25

Added

  • A connected native build's frame can be captured and replayed. The Frame Debugger does it for desktop and Android builds as it does for a web or mini-game one.
  • A native development build names its device to the editor. macOS · Mac16,10, Android · Pixel 8 — as web and mini-game builds already did.
  • A native development build connects to the editor. Desktop and Android, like a web or mini-game one — log, profiler, the world, content status, pause and step. The native host gained a ws:// client for it.
  • The Profiler shows which content revision a connected build runs. Also the one its next launch starts on, and a hot update it has found but not applied; device_update_status answers the same for an agent.
  • The build's size report shows the start screen on its own line. The markup and any logo inlined into index.html, which is on screen before anything else loads.
  • Connected development builds are named by the device they run on. web (Chrome · Android), a phone's model on a mini-game — numbered when two read alike, in the Profiler, Outliner, Frame Debugger and device_targets.
  • The Profiler shows what the debug channel costs a connected build per frame. In its Frame section; profile_frames reports it as channelMs.
  • The Outliner can show a connected development build's world. Instead of this editor's — read-only, with live values in Details.
  • A development build connected to the editor can be watched and driven from it. Its log shows in the Output Log (from before the editor connected, too); it can be profiled in the Profiler on its own frame clock and paused, stepped and frame-capped from there; the log says which project and content version connected.
  • The Frame Debugger can capture and replay a frame of a development build running outside the editor. A browser or a mini-game host, on this machine or another on the network: export with the Development configuration and "Frame debugger connection", then pick the device in the panel.

Fixed

  • A native Android app can reach the network: its manifest never asked for it, so a remote group's assets, hot updates and the debug channel all failed on Android. A development build also allows plain http (a LAN CDN); a shipping build is held to https, and the export warns when its CDN is http.
  • A mini-game reads the host's pixel ratio once and again after a resize, instead of calling getSystemInfoSync several times a frame (on vivo, a synchronous call across its bridge each time).
  • createButton({ userGesture: true }) runs its click inside the host's own release event: on a WeChat phone, sharing a recording from a button was refused ("require user interaction (only in touchend event)"), because a click ran on the frame after the tap.
  • Mini-game exports name assets by their content, as web exports already did: a hot update to a remote texture now shows on a phone (it kept the old picture under the same URL), and a CDN can hold two versions without v1 players getting v2 files.
  • On a WeChat phone, a socket whose connection is refused now reports that it closed, so a development build keeps redialing the editor (and a game's socket reconnects) instead of giving up after the first refusal.
  • A shipping package no longer carries the development debug channel's code (13 KB on a WeChat package): only a development export that names an editor imports it, as esengine/debug-channel.
  • Capturing a development build whose tab is in the background says so at once, instead of waiting 30 seconds for a frame the browser will not draw.
  • A web game opened in a background tab starts paused and reports itself hidden until it is shown; before, it counted as visible.
  • The hot-update demo no longer says the remote manifest matches when it could not reach one; offline it says it keeps the local content.
  • On vivo's quick game the loading notice comes down once the game starts; it could stay over the running game.
  • A quick tap on a slow frame still clicks a button: a finger that landed and lifted between two frames was seen only lifting, so the button never saw a press.
  • A tap on vivo's quick game lands where the finger is: the host reports touches in physical pixels, and every tap landed off the screen.
  • Games on vivo's quick game run past their first frame: the frame loop now hands requestAnimationFrame a handler the runtime accepts.
  • The debug channel works on vivo's quick game: logs arrive in batches, and a replay is sent at the size the Frame Debugger shows instead of the whole screen.
  • A native build loads a remote group's textures from the CDN — they never loaded before — and after a hot update, from its disk cache when offline.
  • A WeChat development build connects to the editor from WeChat DevTools (the domain check is turned off for that build only), and frame replays come back from a mini-game.
  • Hot update works on mini-games: the update is fetched from the CDN, verified, applied and cached, and after a restart without a network the game starts on it with its updated art.
  • A frame-rate cap now holds: setTargetFrameRate(30) on a 60 Hz display runs at 30, not 24.
  • A hot update reports how far it got — verified, applied, stored for the next launch, cached for offline — instead of one ok; two updates at once no longer both commit or lose the newer one; and an update stored by an older build no longer covers a newer one the player installed.
  • A hot update on a mini-game is stored for the next launch and its assets are cached on the device, so the updated game starts offline; before, a mini-game went back to what shipped.
  • A Douyin recording the host ends on its own keeps its video, and an interruption is not counted as recorded time.

[0.72.0] - 2026-09-24

Added

  • A frame can be captured draw call by draw call, and replayed up to any one of them. The Frame Debugger panel (Window menu, or from the Profiler) captures the viewport or the running game and lists every draw by pass, with a chip per reason that filters to it; a scrubber steps through the draws, and the selected one shows its batch cause in words, what it drew — its material and every texture it bound, by the asset behind them — the entities it was made from — click one to select it — and the pass as it stood after it. capture_frame (MCP and the built-in agent) takes the next whole frame of the viewport or the running game — every camera's pass and the screen overlay — and names, for each draw, why it could not join the one before it (material, shader, a different mesh, the instancing cap, …), what it drew and the entities it was made from. frame_draws pages a large frame; replay_draw shows the pass as it stood after that draw, and refuses when the scene has changed since the capture rather than showing a later frame under the capture's numbering. The SDK's captureFrame / replayDraw are the same capture. The engine's capture used to keep no entities, report every material as none, see only the first camera, and could be taken by an asset preview instead of the frame.
  • A project can be packaged as a Huawei quick game (华为快游戏). The same signed .rpk as the quick-game alliance — Huawei's signtool writes the same block, and ours matches it byte for byte — with Huawei's manifest (appType: "fastgame", orientation under display) and its own package name, version code and release key in Project Settings. It packages the engine build without SIMD and is judged against 4 MB and the 20 MB AppGallery Connect takes. Subpackages are refused rather than packaged wrongly (Huawei packs each as its own .rpk); sign-in, purchase and share go through HMS Core with shapes of their own and are not offered. Huawei's loader asks Huawei's servers about a package before it runs one, so nothing has run without an app registered in AppGallery Connect.
  • A project can be packaged for Alipay (支付宝小游戏). game.json turns on iOS high-performance mode — the only iOS mode with MYWebAssembly, which the runtime instantiates through with an absolute package path — and project.config.json turns off the review build's own transpile and minify, since the bundle is already down-levelled; the appid is passed to Alipay's tool (minidev -a), not packaged. The profile hands the family my in WeChat's words — a rewarded unit through my.createRewardedAd, sign-in through my.getAuthCode, share through the card my.showSharePanel reads off my.onShareAppMessage. It packages the engine build without SIMD, judged against 4 MB and 20 MB. Nothing has run on a device; purchase is not offered (Android and Harmony only, keyed by a customId), and Taobao — which only supports Cocos and Laya — is not a target.
  • A project can be packaged as a quick game — one signed .rpk for vivo, OPPO, Xiaomi and Honor (快游戏联盟). Set the package name (it must end in .minigame) in Project Settings → Packaging → Quick game, and the export writes manifest.json (allianceVersion 1300), the project's icon (or Estella's mark), and <package>.rpk signed with your release key — or with Estella's public debug key, which a device debugger installs and a store refuses. It needs no vendor tool: the signing block is written here and matches the vendor CLI's byte for byte. The package runs on its own engine build (build -t quickgame) without wasm SIMD and BigInt i64, which the hosts' V8 8.3 refuses, and the runtime reads the hosts' window in physical pixels and turns WebAssembly on first. Verified end to end on vivo's engine in an Android emulator; OPPO grants WebGL2 only to a game that applied for it, and no device has run it yet.
  • A project can be packaged for Bilibili (B 站). game.json carries the appid (Project Settings → Packaging → Bilibili) and the project's version, and turns on all four high-performance switches — Bilibili runs WebGL2 nowhere else, and the engine renders on nothing less. Scripts are lowered below async/await, which Bilibili asks a game to polyfill, and files are staged against Bilibili's own upload whitelist. The build is judged against 4 MB for the main package, 4 MB for each subpackage and 30 MB in all; a per-subpackage limit is new, and the size panel names the heaviest subpackage's files when it is over. Ads (rewarded only), share and sign-in are forwarded to bl and marked unverified; purchase is not offered. wasm on iOS is contradicted in Bilibili's own docs and needs a device.
  • A mini-game host that asks to hear when the first screen has rendered is told, once, at the end of the first frame — Bilibili reviews a game by bl.launchSuccess.
  • A project can be packaged for Kuaishou (快手). The third mini-game vendor rides the same pipeline and runtime as WeChat and Douyin: a package of game.js + game.json (the appid is entered in Kuaishou's developer tool, not written into the package), judged against Kuaishou's 6 MB main package and 30 MB total. The recorder shares through Kuaishou's own publishVideo, whole — the host takes no ranges. Ads, share and sign-in are forwarded to ks and marked unverified; purchase is not offered, since ks.requestGamePayment needs an order signed by your server. It renders only where the host offers WebGL2, which Kuaishou still calls beta.
  • The record-share example. Record a run, mark a highlight every few seconds, stop, and share the clip; the share button hides where the host cannot share, which is what a real game wants too.
  • tsc and an outside editor type-check the official packages too. Opening a project mirrors the packages the editor ships into .esengine/packages/, beside the SDK's types, and a tsconfig maps them with "estella-plugin-*": ["./.esengine/packages/*"] — every template and example now carries it, and opening a project whose tsconfig is the shape Estella wrote adds the line when it is missing.
  • A game can record a run and share the clip. Recorder in estella-plugin-minigame-services starts, pauses, resumes and stops the host's screen recorder, and highlight(before, after) keeps the moment that just happened; share() then publishes the highlights, or the whole recording without any. WeChat keeps the video and shares it through its own call (at most 60 s of highlights); Douyin hands over a temp file and cuts the highlights on its side. available and canShare are separate answers, so a record button and a share button can each hide where the host lacks one. Every call resolves when the host says the thing happened, and a host that never answers is reported after 5 s rather than awaited forever. In the editor's play mode the recording is real — the canvas as WebM — and canShare is false there.

Changed

  • A Directional light's source is the sun's size by default, so its shadows have a penumbra. sourceAngle defaulted to 0 — a source with no size, whose shadow edge is a knife-cut however far it falls. It is now 0.53°, the real sun's: a shadow close to its caster stays crisp and one cast far softens, as it does outdoors. A light that sets 0 keeps its hard edge.
  • A paused game is no longer covered or dimmed. The PAUSED label sat over the middle of the game and the frame was darkened, which hid exactly what a pause is for looking at. The frame's ring turns amber instead; the toolbar and the status bar say paused.

Fixed

  • Retargeting works: one character's clips play on another's skeleton. A controller's avatar — the rig its clips were authored on — was never loaded, so no retarget ever ran and a second rig played the clips' raw values. It is loaded with the controller now, and the retarget carries each joint's turn through the two rigs' own spaces, so skeletons that stand on different axes (one Z-up under a turned root, one Y-up) read a clip alike, and a clip that moves the hips moves them from the target's own rest, scaled by the rigs' sizes. An avatar states this in two new optional fields, space and restPosition.
  • A prefab instance's override that names no entity of its prefab is reported. It was applied nowhere and said nothing; loading a scene now warns which instance and which entity, and check-prefab-overrides holds every shipped scene to it.
  • The character-rig example shows what it is for. Its hero's position and Animator were overridden on an entity the prefab does not have, so the hero stood at the origin in its bind pose; and without the retarget its knight lay on its back with its head at the camera. Both now stand side by side, both animated, and the camera frames them.
  • A hard shadow's edge is a clean line, not a row of stair-steps. Its four samples of the shadow map were weighted equally, so the edge moved in whole texels of the map, and wherever the shadow crossed the map's grid at an angle — which is almost everywhere — its edge showed the grid as dotted steps. It is now filtered over the 3×3 texels around each point, weighted by where it falls among them: on a shadow at 30° to the map the edge strays 0.05 px from a straight line, where it strayed 0.25.
  • A drawn sky is the panorama you imported, not a blur of it. The sky was drawn from the environment's reflection atlas — the whole sphere in 128 texels a side, laid out so a straight horizon became a staircase and a round sun an oval, and filtered in its encoded form, which blotted every sharp edge. Importing a .hdr now also writes the panorama at its own resolution (up to 2048 wide; skyWidth in the import settings, 0 for none), the sky is drawn from it, and a package carries it. Environments imported before draw their sky from the atlas as they did. The lighting-3d example draws its sky, from a panorama generated at 1024×512.
  • A drawn sky no longer vanishes, or half-vanishes, as the view turns. The sky was a quad on the far plane, and where rounding put it a hair past that plane it was clipped: in the editor, with its distant far plane, more than half the angles showed black behind the grid, or a sky cut along a diagonal. It now sits inside the view volume and fills the frame from every angle, in the editor and in the game.
  • With more than one camera, the profiler and the draw-call count cover the whole frame. Each camera reset the frame's tally and closed the profiler's frame, so a split screen, or a scene with a UI camera, reported only the last camera's draw calls, triangles, merge counts and C++ timings, and the batch-break reasons of the others were lost. The frame now counts every camera and the screen overlay, once, and an asset preview rendered in between counts toward none of them.
  • A game started right after the project opened no longer restarts itself about ten seconds in. Pressing Play while the editor was still warming the game's engine up handed the scene over twice: once when the engine greeted the editor, and again when the warm-up's ten-second wait ran out — so the game restarted, and everything that had happened in it was gone. It now starts once, as soon as the engine is up.
  • A mini-game whose host's WebGL2 context also offers OES_vertex_array_object renders instead of hanging: the WebGL1 extensions WebGL2 made core are withheld from a WebGL2 context, as the spec says, so Emscripten no longer swaps in the host's broken extension path (vivo's).
  • estella export writes a mini-game's appid and project version as the build dialog does — a headless Bilibili package came out with an empty appId.
  • A mini-game on any host but WeChat no longer throws at boot. The lifecycle plugin knew one vendor by name and sent every other one down the web path, where the document stub every mini-game carries has no addEventListener; foreground/background now come from the host's own onShow/onHide for the whole family, as they already did for the native shell.
  • A mini-game that fails to start says why. The generated entry now catches a boot that rejects — a host without onUnhandledRejection dropped it silently, leaving the loading screen up and nothing in the log — and a failed engine instantiation names the error instead of printing [object Object].
  • estella export --platform <id> packages a platform the project defines in .esengine/platforms/, as the build dialog does, and an id that is neither built in nor defined is refused instead of silently packaged as a web game.
  • A mini-game host that offers only WebGL1 is told the game cannot start there, instead of booting to shader failures and a black screen — the engine renders on WebGL2.
  • Sharing, in-game purchase, the friends leaderboard and the recorder can be used at all. They live in estella-plugin-minigame-services, which every doc page said to npm install — and it is on no registry, so the command failed and a project that imported it failed to build, in play and in every export. The editor already carried the package; now every bundle of a project's scripts resolves estella-plugin-* to that copy (play, web, desktop, native, WeChat, Douyin, playable, the open data context and component extraction), and the editor's script checking and the built-in agent see its types. A copy the project installs into its own node_modules still takes precedence, and an unknown estella-plugin-* names the ones that do ship.
  • The agent drawer's History button shows it is open with a grey press again, not the accent colour 0.71 gave it.

[0.71.0] - 2026-09-23

Added

  • Settings can find out whether a model reads pictures, instead of asking you to know. A model its vendor has not documented is sent no screenshot until you list it as one that takes images — which asked you for something only a request can answer. That list's row now has a button: it sends the model one small picture (a coloured square in a corner, both chosen at random) and asks what it shows. The row then says whether the model read it right, answered wrong, said it cannot see, or had the picture refused by the endpoint, with the model, the address and the time; a model that reads it right is added to the list for you. It is one billed request with no project data in it, sent only when you click.

  • The agent can take an overview and a close-up instead of one full-size picture. A capture always came back whole and at full resolution — on a Retina display a 2960×1840 window, which the model's endpoint shrinks to its own limit anyway — so the agent paid for pixels it could not use and had no way to ask for the part it needed to read. capture_viewport and screenshot now take maxEdge, which scales the whole picture down (the layout at a fraction of the cost), and region, which returns part of it at full resolution; the tools tell the agent to look at the overview first. MCP clients get the same two arguments.

  • Every screenshot in the agent's transcript says where it went. The transcript showed each frame the agent captured, which read as each frame the model saw — including the ones held back from an endpoint that takes no images, and the ones not resent because nothing had changed. A line under each frame now gives its size and what it costs in tokens, then whether it went out with the next request, was held back and why, or was taken by the endpoint once that request came back. Taken means the endpoint accepted it, not that the model read it right.

  • The build dialog says which engine services a target can provide. Ads, sign-in, share and in-game purchase all answer at runtime, by asking the host — the right answer for a game, and no answer at all for someone choosing a target, because there is no host yet. Each target now carries a line beside its size caps: WeChat's four are its own published API, and Douyin sells nothing, which is worth hearing before a store page is written rather than when the purchase call rejects on a device. A ? is a real verdict, not a shrug — it is what the engine wires with the host having the last word, and hovering quotes the source.

  • The build says what the start screen's logo costs the page. Inlined, the logo IS index.html, so a size report files it as page rather than as art — a start screen could quietly take a share of a main-package limit with nothing naming it. The export now states both numbers: the image on disk, and what it weighs in the page after base64.

  • You can tell the editor which models your account has seen take an image. A vendor that documents nothing leaves its models at "nobody has said", and no picture is sent to one of those — which used to mean waiting for us to ship a build. Settings › AI Agents now has a box per provider for the model names you have confirmed yourself.

Changed

  • The editor's tooltips are its own. Every hover hint in the editor was the operating system's: it ignored the editor's theme and zoom, took its own time to appear, and from a popped-out panel was placed against the main window. All 320 are now drawn by the editor — the same card the content browser's asset tips use, under the control, after the same delay, at once when the control is reached by keyboard, and gone the moment you press it. Icon-only buttons keep the name a screen reader announces, which that hint used to supply.

  • An agent told its screenshot was too big hears that, not "the request was refused". Every refusal read the same, so a turn that failed because the picture was too large for the endpoint was indistinguishable from one that failed on a bad tool argument — and it burned its retries on bytes that would be refused again. Too-large now says to capture a smaller region, and a refusal the endpoint itself blamed on an image says so and quotes it.

  • The loading bar moves while the engine downloads. It advanced only when a boot stage finished, and starting the engine is 40 of the 100 — so on a phone's connection a player watched it sit at 20% for 10.4 seconds of a 17.5-second start. The engine binary is now counted as it arrives (and still compiled while it downloads, which is the part that would have been easy to lose): 40 steps instead of one, and the longest the bar stands still drops from 16.7s to 6.0s. A portal's own loading screen sees the same movement through esengine:bootprogress, which now marks a step as partial while its stage is still running.

  • The Inspector's light and LOD explanations are readable. Why a light was left out of a frame, or why an LOD held its level, was set at 11px — a size the editor's type scale does not have — and in Chinese the denser characters blurred at it. They now use the Inspector's body size and stay quieter than the values above them by colour, not by being smaller. The last few sizes that sat between two steps now sit on one: the profiler's headline numbers step up to the title size, and the start-up task list and a toast's repeat count step down.

Fixed

  • Looking at its work no longer makes the agent forget the conversation. The context gauge counted a screenshot by the length of its encoded bytes — a viewport capture as some 36,000 tokens, where the model is billed 522 for it — so two window screenshots were enough to fold a conversation's earlier runs out of the model's memory. A picture now weighs what it costs. A turn that keeps looking also stays inside the endpoint's limit on pictures per request: past 20, the oldest leave the model's view and both the model and the transcript are told. A screenshot identical to the one before it is sent as that fact, not as the same picture again.

  • A game started paused is handed the scene already held. Asking the editor to start a game paused — what the built-in agent and the automation surface do to read a world that is standing still — waited for the game to report ready and paused it then, so it ran for however long that round trip took. On the physics playground the cart had already driven 6px up its ramp in three runs out of four, and in the fourth it had not moved at all: the state you read was never quite the state your scene authored. The pause now travels with the scene, and the world holds at its authored positions every time.

  • Pressing Play while the editor is still warming up no longer loses the engine. The editor brings the play realm's engine up in the background so the first Play is quick. "Is the engine up" is false for the whole of that bring-up, so a Play that landed inside it was treated as a cold start and reloaded the page that was doing the work — and the replacement then waited on a load the abandoned one still held. It waits for the warm-up it is about to use instead. This is likeliest on a loaded machine, where the warm-up takes longer than it takes you to click.

  • The on-device crash check runs on whatever Android you have. It built its test handler for arm64 no matter what was attached, so an emulator — the only Android most machines can offer — was pushed a binary it cannot execute and the check failed for a reason that had nothing to do with the crash handler. It asks the device which ABI it runs now, which is why a release criterion that read "needs a phone plugged in" is answered here: the record came back with its phase and a backtrace.

  • A packaged native game gets the subsystems its project uses. Every optional subsystem reaches an App through one registry, and the native factory read none of it — it named Spine and DragonBones by hand and stopped there. So a game on a phone ran with no navigation, no tilemaps and no replication while the same game worked on the web: enemy-ai threw on a null nav surface, celestial-heights refused its own tilemap data, and multiplayer-arena threw on a null net role. Found by booting all 52 examples on an emulator.

  • Nothing claims a model cannot see when nobody has said so. Attaching a picture to a model whose sight is unconfirmed said "this endpoint does not accept images", and the turn itself told the agent it "cannot carry images" — both of which read as the vendor having answered. They now say what is true of the turn: no image is being sent. The attachment notice keeps the two apart, because a vendor saying no is a reason to pick another model and nobody having said is a reason to go and find out.

  • A model that can see is no longer told it cannot. Whether a screenshot could reach the agent was one answer per provider, and DeepSeek publishes a Flash that takes images beside a Pro its vision guide does not name — so the one boolean was wrong about one of them, and wrong the quiet way: the model that can see was told to read screenshot's coarse text grid instead of looking at the picture. It is resolved per model now, in three states, because "the vendor says no" and "nobody has said" are different answers and only the second is worth going to find out about. deepseek-flash is the recommended name and the retired deepseek-v4-flash still resolves, since the vendor still serves it.

  • A packaged game answers "how do I get there?" again. The host's pathBetween — what a driven playthrough and the automation ask for a route — looked Nav up in the registry of COMPONENTS when the AI runtimes moved to their own subpath. Nav is a resource and has never been in that one, so the lookup answered nothing rather than throwing, every route came back as no route, and a game that walks fine by hand could not be driven anywhere. It asks the resource door now.

  • Pressing Play could kill the session it was starting. The editor hands the scene to the realm from two doors — directly on a warm re-Play, and on the realm's greeting when it cold-boots — and a greeting that lands while start() is still rebuilding scripts goes through both. The realm read the second hand-over as a re-Play and quit the App the first was still booting on, which surfaced a few steps later as a null read and a session that never reached a frame. It now ignores a hand-over that arrives during its own boot; both are still posted, because the first is lost often enough that dropping either strands the realm.

[0.70.0] - 2026-09-22

Added

  • The start screen is yours: a logo, a background and a minimum display time. The exported page has shown real boot progress for a while, but always as the game's name on the engine's own dark ground. A project can now put its logo there — inlined into the page, because an image fetched over the network arrives in the same window the engine does, with nothing left to cover — pick the colour behind it, and hold the screen for a minimum time, so a boot that finishes in 120ms stops flashing a bar that appears and vanishes. The page also emits esengine:bootprogress and esengine:firstframe, which a portal's own loading screen can listen for before the game's bundle has run.

  • The build dialog states a platform's size caps before you package. They were reported only after a package existed, in the size panel, so the ceiling a build had to fit under was visible only once it was too late to plan around — and the difference matters: a package that fits WeChat's 30MB is 10MB over Douyin's 20MB. Each target's caps now sit under its description, and hovering them gives the platform's own wording rather than our paraphrase. A platform a project defines itself states the caps it declared.

  • A UI node can keep clear of WeChat's capsule menu, which the safe area does not cover. SafeArea.avoidHostMenu pushes the top inset past the host's own overlay. Measured on the iPhone 12 the simulator offers, the capsule's bottom edge is 29px inside the safe area, so a node anchored to the top of the safe area can still be under it. No engine offers this: every game converts the rect to layout units by hand, which is the arithmetic the safe area already does here.

  • Douyin is selectable in the build dialog and has its own texture Import Settings tab. The export existed — the same runtime as WeChat, judged against Douyin's own 20MB cap — but the editor's platform list was written by hand, so nothing offered the target that had shipped. The list is the platform registry's now, in its order.

  • A mini-game says how far along its boot is, not just that it is loading. The web export got a start screen with a real progress bar; a mini-game could not have one, because the display canvas is already the GL surface and nothing can be drawn over it. It now reports through the host's own loading indicator instead — Starting the engine 54% — driven by the same eight weighted stages the web overlay uses, from one list, so the two cannot disagree about how far along the same boot is. A host without that API boots exactly as before: an indicator is something a boot shows, never something it can fail on.

  • A project can be exported as a Douyin (抖音) mini-game. Pick Douyin in Package Project and the same content that makes a WeChat package makes a Douyin one, judged against Douyin's own caps — 4MB for the main package and 20MB in total, ten less than WeChat allows, which is the number that catches a package out. Three things are deliberately not claimed yet, because this release cannot cite them: the suffix list its packer accepts, .wasm.br for the engine binary, and a wasm loader of the host's own. Each is something only a real device settles, and a package that claimed one early would build clean and fail at upload or at boot. Douyin needs no separate engine build — the web artifact is what a tt host runs.

  • A sprite can be drawn whole even when its texture carries a 9-slice border. The texture decided, not the entity using it: import a panel image with slice borders and every Sprite showing it was 9-sliced, with nothing on the entity able to say otherwise. Sprites now have a Draw Mode — Auto is the old inference (tile size decides tiling, the texture's border decides 9-slice) and stays the default, so nothing you have drawn changes; Simple, Tiled and 9-Slice say it outright. An override cannot invent what it needs, so Tiled with no tile size and 9-Slice on a texture with no border both draw the plain quad, which is what the sprite would have drawn anyway.

  • A WeChat mini-game now carries only the optional subsystems its project uses. The engine binary was never the only thing a package paid for whether it needed it or not: the JavaScript bundle carried Spine, DragonBones, 2D physics, 3D physics and video in every build, because the runtime that starts your game named all of them. It no longer does — the export reads the same scan that already decides which .wasm side modules ship, and builds on an SDK entry that installs only those. hello-world drops 91KB of a 1.4MB bundle; a project that does use Spine keeps Spine and drops what it does not. There is more to win here and it is measured: SpinePlugin registers a named resource when its module loads, which a bundler cannot remove, and that alone is 47KB no package can currently shed.

  • A packaged game now says it is loading. Between the page opening and the first frame an export showed its background colour and nothing else — and on a cold start that gap is the whole download of a 1.7MB engine binary, which reads to a player as a page that did not work. Web and desktop packages now open on a start screen carrying the project's name and a bar moving through the eight stages the boot actually has, weighted by what each one costs rather than counted evenly: reading the build, scripts, the asset list, the scene, the engine, the renderer, assets, ready. It fades as the first frame arrives. A start screen still standing after a package settles now fails that package's check, because everything else about it passes — the canvas painted underneath, nothing errored — and what it leaves on screen looks exactly like a game that is still loading.

  • The engine can ship outside a WeChat mini-game's main package entirely. Compressing it left 0.35MB of the 4MB limit spent before any of your content; Engine in a subpackage moves the binary into a 分包 the host loads at startup, and the main package keeps only the 162KB of glue that starts it — 4% of the limit, down from 47.5% with neither setting on. The two stack: compression shrinks what the 分包 downloads. Off by default, because startup then waits on that load, which is a trade worth making when the main package is what you are fighting and not otherwise.

  • A WeChat mini-game can ship its engine compressed, freeing a third of the main package. The engine binary is the largest single file such a package carries — 1.74MB against WeChat's 4MB main-package limit, 43.6% of it spent before any of your content. WeChat's loader accepts a brotli-compressed .wasm.br path, so turning on Compress engine binary on the WeChat page of Package Project ships 0.35MB instead: 8.7% of the limit, with 1.40MB handed back to the game. The package carries one file, not both, and the host decompresses it on load. Off by default, since it costs about two seconds of build time and only pays where a main-package limit is being fought. Needs WeChat base library 2.14.0.

Changed

  • A mini-game says it is starting before it parses the game. The host's loading indicator only appeared once initMiniGameRuntime ran, which is after the entry has required a megabyte of bundle — the longest silent stretch of a cold start. The generated entry now raises it on its first line.

  • A mini-game's side modules compress too, not just its engine. Brotli was applied to the engine binary alone, so a package that transcodes KTX2 textures still carried Basis at its full 1.1MB — 27% of WeChat's 4MB main-package cap on its own. They compress on the same switch now, and the loader is told which suffix the build staged instead of spelling .wasm itself. Measured on the platformer template: its WeChat package was 108% of the cap and is now 51.5%, with the side modules accounting for 902KB of that.

  • The build's size bar stopped borrowing Play's green. Within budget was drawn in the transport's running-green, which reads as a state the build is in rather than as a measurement — and a green bar invites "fine, keep going" where the honest message is that there is nothing to report yet. It is now the panel's own neutral, and goes amber then red, which is the whole vocabulary it needs. The two progress bars in that panel were also 6px and 8px side by side; they are one shape now.

  • A dialog's title now looks like one. The editor's type scale stopped at 14px and used it five times in the whole application, while 10px carried most of the text — so a dialog header at 13px read as bold body text rather than as a title. Window titles now have a step of their own, which is what every editor this size gives them.

  • A web package ships only the subsystems its project uses. Every web package staged all eleven engine subpaths and loaded the entry that installs every optional subsystem, so a UI-only game carried Spine, both physics runtimes, tilemaps, script graphs, gameplay AI and replication — 215KB of JavaScript nothing in it could reach. The page's import map is now built for the project: it names the subpaths the content, the cooked assets, the wasm scan and the game's own scripts reach, the package carries those and no others, and the game host imports them — staging a subpath only makes it resolvable, and something has to install it. A project using a subsystem no subpath installs (video today) takes the whole entry as before. Measured on the UI-game template: 1,305KB → 1,090KB, 57 files → 32.

  • Forcing a module in now ships its wasm binary too, not just its JavaScript. A project that spawns bodies from a script — the case Include exists for — got the solver's JavaScript staged and no wasm to run it. The wasm scan was reading the older physics.enabled directly, so only that flag reached it and only for that one module.

  • A build target can include or exclude an engine module without changing the project's answer. A playable ad has a size cap a web build does not, so refusing 3D physics there should not refuse it everywhere. packaging.modulesByPlatform lays a target's answer over the project's, keyed by target the way the output directory and the size budget already are.

  • The Engine Modules page says which of your documents put each module in use. The switch alone left "will this ship?" to be answered by exporting. What the row shows is the export's own walk, so the page and the build cannot disagree — and "not used by this project" is kept apart from "nobody has looked yet", because printing the first when it means the second tells a project it can safely exclude something.

  • A component whose module Project Settings excludes is greyed out in Add Component, not hidden. The export refuses a build whose content uses an excluded module, which is the last possible moment to find out; the editor knows the same thing when the menu opens. Greyed rather than hidden, because a component that vanished reads as one the engine does not have.

  • Excluding 3D physics, DragonBones or script graphs is now enforced like every other module. The refusal works by detecting the components that put a module in use, and those three had no such list — so excluding one passed silently and shipped the package the refusal exists to prevent.

  • Project Settings has an Engine Modules page: force a module into the build, or refuse one. A build works out which subsystems a package needs from what the content uses, which is right for almost everything — but not for a module only a script reaches, and not when a build must not carry one at all. physics.enabled was that answer for exactly one module; every module has it now. Refusing one is enforced: an export whose content uses an excluded module fails and names the scene, asset or script that argued, rather than shipping a package quietly missing the subsystem its own scene needs.

  • The gameplay runtime is a subpath: import { Health } from 'esengine/gameplay'. The third-person controller, the camera, health, melee and the hunter were in every package: 10,567 bytes of a WeChat build with no character in it. What stays on esengine is the vocabulary — the animator parameter names, the input keys, the combat event names — because an AnimatorController asset names the parameters and an event binding names the events, and neither needs a solver. Playthrough moves the other way, onto esengine: it is the fact a game publishes about its own run, read by the observation seam every packaged game carries.

  • Replication is a subpath: import { Net, Replicated } from 'esengine/replication'. The base plugin set named the replication plugin, so every package carried the wire protocol, the codec, the interest query and the prediction replay — 64KB of a single-player game that nothing in it can reach. A game that opens no session now pays 2.9KB; one that does pays what it did before. The sockets stay on esengine: createSocket, GameSocket and the platform sockets are where they were, because a game may talk to a server over a channel with no replication at all.

  • The AI runtimes are a subpath: import { NavAgent } from 'esengine/ai'. Navigation, perception, state machines and behaviour trees were 77KB in every package. What stays on esengine is the verb vocabulary — registerAction, aiRegistry, Blackboard — because an authored event binding and a UI controller register actions with no runtime behind them, and the UI-game template does exactly that. A game with no agents now carries 14KB of registry instead of 91KB of runtime.

  • Script graphs are a subpath: import { … } from 'esengine/logic'. Same reason as tilemaps below: 65 names re-exported as values put the graph compiler and its node library in every package, 23KB in a game with no graph, plus the asset loader the registry constructed whether or not a project had an .esgraph.

  • Tilemaps are a subpath: import { Tilemap } from 'esengine/tilemap'. esengine re-exported 105 tilemap names as values, so every package carried the subsystem behind them — 44KB of parser and plugin in a game with no tilemap, plus the two asset loaders the registry constructed whether or not a project had a .tmj. A package now pays for tilemaps by importing them, the way it already did for Spine and physics. The names are unchanged and all were @beta; the whole entry still installs everything, so anything that imports esengine alone behaves as before.

Fixed

  • A group that failed to load says so instead of handing back an empty bundle. Assets.loadGroup settled every asset and returned whatever survived, so a subpackage that downloaded but staged nothing — or a CDN answering 404 — read exactly like a group that was always empty. It now names the assets that failed, the way a scene preload already did.

  • A package whose engine ships in a 分包 now starts. Its generated entry called the host's loading indicator on its first line without checking the host has one — and that call is optional in the API — so on a host that does not implement it the game died before reaching loadSubpackage. Every indicator call in a generated entry is guarded now; a progress message must never be what takes a boot down.

  • When a 分包 will not come down, the package says which one and why. The generated entry logged the vendor's error object, which reaches a device's console as [object Object] — the one place you get to look. It is stringified now, and the headless launcher can be told to refuse a named 分包 (--fail-subpackage) so the path a bad network takes is something a build can be run against rather than waited for.

  • A Play session that times out now says whether it ever started. The realm announces itself when its page runs, before a line of the engine is read — previously its only signal was the host module's last statement, so a machine still parsing the SDK and a frame that never ran gave the same ninety seconds of silence, and both were reported as the editor being broken. The two now read differently, and only one of them is the machine's.

  • The Engine Modules page no longer calls a module unused that the build then carries. It read only the components a scene names, while the build also reads the extensions of the assets that ship and the imports your scripts write — so a behaviour tree an agent is handed at runtime, which leaves no component behind, showed as "not used by this project" in a package that had it. The page now reads the same asset table the build installs from, and says what it can see rather than what will ship.

  • A Douyin package could not start. It shipped the browser engine artifact, which is an ES module, and a mini-game host loads its JavaScript with require — so game.js threw SyntaxError: Unexpected token 'export' on its first line and the package never reached a frame. Every mini-game host takes the same engine build, and now every mini-game target asks for it: the two built-in vendors, and a platform a project defines itself, which had the same browser default. The export also refuses an ES module engine by reading the file rather than trusting its name, since the name was the thing that was wrong.

  • A mini-game that fetches its engine from a 分包 shows the download's progress. The host fetches it before the game bundle is parsed, so the runtime's own loading indicator could not say anything yet and the player watched a still screen for the length of a 1.8MB download. It is also the one part of a cold start with real byte progress rather than a weighted guess.

  • A Douyin package carries Douyin's config file and Douyin's appid. It emitted project.tt.json, a name nothing published uses — Douyin's own CLI and its Godot adaptation doc both name project.config.json. And it was handed the WeChat appid whatever it was building, so the console answered "不存在此 AppID"; Douyin has its own setting now.

  • A mini-game vendor whose purchase call is not WeChat's can supply its own. The family's payment is WeChat's requestMidasPayment with WeChat's rules, so purchase reported itself unavailable on a host that does sell things, and a vendor profile had no way to correct it. Douyin still reports unavailable — there is no published source here for its call — but the slot that will hold the answer exists.

  • The build size report says what compressing the engine binary actually saved. A mini-game limit is judged on packed bytes, so every figure in the report was the packed one and the number that says whether compressWasm was worth turning on appeared nowhere. Each file the export packed now carries what it weighed before, and the panel sums them — on the UI-game template's WeChat package, 1,828,959 → 363,617 bytes.

  • When the play realm never comes up, the editor says more about why. The trace behind that message used to drop every aborted load as teardown noise; an abort is also what a second navigation over an in-flight one leaves behind, which is the likeliest reason a realm is served twice and then says nothing. Console lines now name the file that logged them, so the editor's own warnings are no longer read as the game's, and the offsets carry the clock time they start from.

  • The build size report no longer blames content for a packaging change. A build is compared against the last one of the same target, and the settings ride along so that packing the same content differently is not read as content that grew. Three settings that do exactly that — source maps, the engine's Brotli, the engine 分包 — were never recorded: turning on compressWasm takes the UI-game template's WeChat package from 3,132,164 to 1,666,825 bytes, and the report attributed 1.4MB of that to content nobody wrote.

  • The built-in agent is no longer told that the Spine runtime setting decides what a build ships. set_project_settings described spineVersion as deciding which runtime the build bundles. It decides nothing: a build detects each skeleton's own version. The Project Settings row already said so; the agent was the one reader still being told otherwise.

  • A dedicated server built on esengine/node replicates again. esengine/node was built outside the SDK's shared chunk graph, so a process importing it and esengine/replication got two copies of the core: the subpath registered the replication plugin in one registry and the headless app read the other, and the authority came up with no Net resource.

  • Two games in one process no longer share an optional subsystem's plugin. Tilemaps, script graphs and the four AI runtimes each registered their module-level plugin singleton, so a second app installed the first app's instance and the app state it carries.

  • A project whose art weighs less than the transcoder no longer compresses any of it. Reading a KTX2 costs a package about a megabyte of Basis transcoder, and compressing can never save more than the textures themselves weigh — so a project lighter than that is answered before anything is encoded. The tilemap example was compressing one tileset to save 6KB and carrying 1.09MB to read it back; its WeChat main package went from 4.70MB, over the platform's cap, to 3.63MB. A project that authored a KTX2 itself pays for the transcoder either way, and goes on compressing.

  • A texture that encodes larger than its source now ships as the source. Compressing to KTX2 is a win on detailed art and a loss on flat art — Basis writes about a byte per pixel where PNG writes almost nothing, so the space-shooter example's 512px background came out 35× its PNG and its atlas page 9×. The build encodes, compares, and keeps whichever is smaller, the way it has always done for audio. Nothing needing a transcoder also means the package stops carrying one: that example's WeChat main package went from 4.83MB — over the platform's 4MB cap, so it could not be uploaded at all — to 3.29MB, with no project setting changed. The build log says how many textures it left raw and what that saved.

  • A WeChat mini-game boots again. Its package had no platform in it: the SDK entry installed one as a module side effect, and the lean entry added for smaller packages is pure re-exports — so the install sat in a shared chunk the bundler was free to drop, and every WeChat package threw [ESEngine] Platform not initialized on the first frame. The generated entry now calls for the platform the way the Douyin one already did.

  • A mini-game export no longer fails on a project whose sprites are atlased. Names that a vendor's packer will not upload are shipped with a .bin suffix, and the rename walked the manifest one asset at a time — so the seven sprites packed into one atlas page tried to move the same file seven times, and the export died on the second. Any 2D project with an atlas, which is most of them.

  • The size report says which subsystem each byte of the scripts came from. A mini-game inlines the engine's JavaScript, and the report grouped it by the bundler's own chunks — so two thirds of it sat in one row named after one of the four hundred modules inside it. Rows are now subsystems: ai, tilemap, physics, with the number of files each brought.

  • A web build no longer carries the mini-game and native SDKs. The SDK ships every target's build in one directory, and staging copied all of it — plus whatever an earlier build had left there, since the build never cleaned up after itself. A web package now carries the entry the page loads and the chunks that entry reaches: 412KB less for the space-shooter example, and the same for every web build.

  • The build's size panel marks which files are in a subpackage. Now that the engine binary can move into one, a reader could not tell the bytes a 4MB cap is judged on from the bytes it is not: the composition bar is 100% of the whole package and said so nowhere, and a subpackage row looked like a main-package row. The bar names its total and each subpackage row is tagged.

  • The size report counts a mini-game's main package without its subpackages. Everything on disk that the asset manifest did not claim was counted as "downloaded before anything runs", so a binary moved into a subpackage was still judged against the 4MB it had just been moved off — the setting that moves it looked like it did nothing. The export names its subpackage roots now. On hello-world the main package reads 1.55MB against a 1.91MB total, where it read 1.91MB for both. A compressed .wasm.br also reads as the engine again rather than as "other", so the biggest file in the package is no longer missing from the chart that finds it.

  • A WeChat package can put its engine binary in a compressed subpackage. The settings for both — compressWasm and engineSubpackage — existed, had a row in Project Settings and were honoured by the exporter, and the manifest parser read neither, so turning them on did nothing anywhere. Five other packaging settings were dropped the same way, assetCompression among them. On hello-world the engine goes from 1.83MB uncompressed in the main package to 363KB in a subpackage, and the main package from 80% of WeChat's 4MB cap to 37%.

  • A game that fails to start says what its frame actually did. A realm that never reports in left the editor with one sentence and no cause — the case CI hits about every third build. The failure now carries the frame's own navigation, the HTTP status it was served, any load error and its console, with timings: a 404 from the staging path reads as served 404, and the retries are visible too.

  • The editor's smaller labels are readable — one body size instead of three within 2px. The type scale had eight steps, six of them between 9px and 14px, and three of those carried 89% of the text: which one a panel used was whichever its stylesheet had been written with. It has four, each named for its job — micro, detail, body, title — and the 11px tier joined the body rather than the metadata one, so the labels that were smallest are the ones that grew.

  • A web build stops shipping the WeChat SDK entries next to the one its page loads. sdk/dist holds every target's build side by side and the staging step filtered them by an enumerated list of filenames, so an entry added after that list — index.wechat.lean — went out in every web package, along with the WeChat open-data script. The kept set is derived from the page's own import map now.

  • A page no longer carries a module mapping that resolves to a file it does not have. The exported page's import map listed esengine/factory → sdk/webAppFactory.js; the SDK has never published that subpath and dist/ has never emitted that file, so a game importing it would have failed at load. The map and the bundler's aliases are derived from one list now, and a gate holds that list against what the package actually exports.

  • A build that ships Spine or DragonBones installs one of each again, not two. Making registration a call rather than a module's side effect gave it two callers — the esengine/spine subpath and an entry's own install — and the plugin list appended both, so the editor built every app with two SpinePlugins and said so once in a log nobody reads. The list is keyed by subsystem now, so a second registration replaces.

  • An optional subsystem is installed again in builds where a bundler had dropped it. Making the core runtime name no optional subsystem left each one registering itself when its module was imported — and a bare side-effect import is something a bundler may drop unless every layer has been told the file is impure. Neither layer had been, so the code shipped in every package and ran in none of them: a scene full of rigid bodies loaded with no solver, and said so only in a log nobody reads. Registration is a call now, which no tree-shake in any layer may drop, and every published entry declares itself side-effectful so a game's own bundler cannot repeat it with esengine/physics3d.

  • A plugin styled from the manual gets the editor's real colours instead of none. The plugin guide told authors to style against --bg and --accent; the editor has neither, so a panel written to the manual got no background and its overlay example drew a black circle on a dark viewport. It names the tokens that exist, and a gate refuses the next var() — in a stylesheet, a plugin or the docs — whose variable nothing defines.

  • The Inspector's effect stack draws its toggle, its rows and its Add button again. Ten declarations named six CSS variables this editor does not have — --accent where the token is --acc, --bg-inset where it is --inset, and four more. CSS has no unknown-variable error, so each one simply did not draw: a checked toggle with no fill, a row with no background, and an "Add effect" button whose dashed box was never there.

  • space-shooter's background no longer stretches a 256px starfield over the whole screen. The texture was drawn to tile — 256×256, wrap mode repeat — and the scene stretched it over a 600×1080 box, so every star drew 2.3× wider and 4.2× taller than it was painted. It tiles.

  • Sprite.drawMode is optional, so existing SpriteData code still compiles. The field shipped required, which breaks any object literal written before it existed. Auto is the default; naming it was never meant to be mandatory.

  • Record, mute, delete and unsaved read as what they are, not as viewport colours. The editor's viewport palette is chosen so a gizmo survives any backdrop, and its tokens name particular things — the X axis, a collider, the selection. Five panel elements had borrowed one for want of a token of their own, so a sequencer's record button was X-axis red and a muted track was too. Record now has its own colour, the rest use the ones that already existed, and a gate refuses the next borrowing.

  • A WeChat package no longer carries files the upload would refuse. WeChat publishes the file types its packer accepts, and an authored format outside that list — a behaviour tree, a locale table, a tileset, a prefab — was staged under its own suffix. Such a package builds clean and runs in devtools, and is rejected at the moment it is uploaded, which is the one step nobody automates. The flagship shipped six such files. They now travel under a name the packer takes, with their real suffix kept in it, and which suffixes those are is derived from the published list rather than from the two that happened to be known.

  • An asset that fails to load says so. A reference pointing at nothing already warned, but an asset whose load actually threw was recorded silently: the scene opened with no texture, no environment and no complaint anywhere, which looks exactly like a scene that has none. A report from a 0.69.0 user showed the shape of it — a 3D template open for six minutes with zero textures loaded, zero render targets and not one warning in the whole diagnostic bundle. The failures are now warned once, with what failed and why.

[0.69.0] - 2026-09-18

Added

  • The build size chart's video slice stops shouting. That one series was drawn in a viewport gizmo colour — the bright kind, built to read over a lit 3D scene — because the panel's own label ramp had six members and the chart needed seven. It now has a seventh, pitched with the other six, and a gate holds that ramp quieter than the viewport's from here on.

  • The editor's faintest label colour is readable. The colour most labels in the editor are drawn in — file rows, legends, budget captions, hints — sat at 3.26:1 against a panel, below the 4.5:1 that body text needs, so a whole tier of the interface was technically present and practically hard to read. It is now 4.96:1 on a panel body and 4.54:1 on the raised strips, and a gate holds the whole text ramp there, because the visual layer was the one part of this project with no check of its own to drift against.

  • A build the preflight objects to can be packaged anyway. Pressing Package with a blocker standing used to show a list and stop there, on a verdict you never agreed to — a dead reference in a scene you are not shipping yet, or an entry scene you are mid-rename on, cost a trip back through the editor before you could get a package at all. Findings about your content now offer "Package anyway", which makes the package exactly as it stands and says so. The one exception is a target this machine cannot build: pressing on there produces no package, only a slower failure, so it still stops. export_game takes the same decision as acknowledgeBlockers, so an agent has the door the dialog has.

  • Geometry edges are anti-aliased on WebGPU, which is every native build. MSAA was wired on WebGL2 only, so an iOS, Android, desktop or Steam package — all of which run on WebGPU — drew hard stairstep edges. The WebGPU backend now renders the scene and the backbuffer multisampled (4× by default, createWebApp({ msaaSamples }) to change or turn off) and resolves both, including the depth buffer WebGPU cannot resolve by itself, so effects that read scene depth keep working.

  • The build size report says why a file is in your package, and what changed since the last build. A big texture now names the chain that pulled it in — the scene, prefab or material that references it, or the rule that force-included it (a subpackage group, an always-include folder, a locale table, a data file). Each platform's whole per-file measurement is kept with the project, so the next build of that target reports what is new, gone or resized, and says when a compression or minify setting changed rather than reading it as content that grew. A limit that is over now lists the files filling it, with what can be done about each.

  • getResourceStats() reports the memory kept to survive a lost GPU. To bring the picture back after a graphics reset, the engine keeps a CPU copy of some textures and buffers — a cost no GPU figure shows, and a real one on a mini-game's memory budget. retainedBytes says how large it is, the resource census tracks it, and each frame reports it as the render.retained.bytes counter. The engine warns once when it grows past RuntimeConfig.retainedBudget — 16 MB by default, retainedBudget in the build config, or setRetainedBudget().

Fixed

  • A Meta playable can spend all 5MB Meta allows. The export refused one over 2MB and quoted that figure as Meta's cap. It is not: Meta's specification says "Maximum file size: 5MB" for a playable HTML5 file, and 5MB again for a whole ZIP of at most 100 files. The 2MB is folklore, repeated across the web and published nowhere, and every Meta playable was built against half the budget it had. The unnamed-network default moves to 5MB with it, that being what every network cited here accepts, and each network's enforced cap is now held to the sentence quoted beside it — the two had drifted apart in silence.

  • A sprite with no texture is no longer reported as unfinished. The editor called Sprite.texture a required field, so every coloured quad — a health bar, a panel, a placeholder — raised a finding in the Details panel, the diagnostics sweep and the build preflight. Drawing a tinted white texture is what a sprite with no texture is for.

  • The picture comes back after the GPU is lost. When the graphics context went away — a driver reset, Chrome's GPU process crashing on Windows, a laptop switching GPUs — the engine reported "Device recovered" while the view stayed blank or came back without its grid, meshes, materials or text. Each part of the renderer rebuilt its own GPU objects, and the ones nothing rebuilt drew with dead handles. The device now rebuilds everything it issued behind the same handles, puts back the contents it kept, and reloads the rest from their assets, on WebGL2 and WebGPU alike. Text pages are repainted from their glyphs and skeleton atlas pages decoded again from their images, so neither keeps a second copy in memory — 4 MiB for every 1024×1024 page. A video and an open-data leaderboard come back too: their frames were going into a texture the lost context had already destroyed, so a paused video stayed blank for good. What the engine cannot put back — a render texture the game drew itself — is now the game's to redraw: onDeviceRestored says when, and RenderTexture.contentLost says which target is blank.

  • A hot update on iOS, Android and desktop builds is still there after a restart without a network. The native host only stores cache files under plain names, and hot update asked to store each downloaded asset under its full URL; every write was refused and nothing said so, so an updated game needed the CDN again on its next launch. Entries are now stored under a hash of the key on every platform, and a refused write is reported once in the log.

  • 3D meshes draw on Windows with WebGL2 again. 0.68.0 broke every mesh there: WebGL2 on Windows runs on Direct3D 11, which reuses one vertex input layout for every shader with the same vertex format, and the mesh shaders named their instance index before their vertex attributes. Whichever mesh shader compiled first decided where every other one read its positions, so meshes collapsed, vanished or covered the view. The engine now names the instance index only after a shader's attributes.

  • An imported model lit by an environment with a reflection draws on Windows. WebGL2 on Windows runs on Direct3D 11, where the block holding each object's indirect light was compiled into a buffer that needed one more texture slot than a model material leaves free. Chrome's GPU process aborted on the first frame, so the editor viewport and exported web games showed nothing; lighting-3d was the first template to hit it.

  • A material parameter changed after its first frame takes effect on WebGPU. The new value was uploaded but never bound, so the frame kept drawing the first one. The editor grid was where it showed: orbiting a WebGPU viewport moved the scene and left the grid where the view had first looked.

  • A WeChat mini-game is judged against WeChat's real 30MB total. The size report flagged a package over 20MB across its main package and subpackages, a limit WeChat no longer has; the 4MB main-package limit is unchanged.

[0.68.0] - 2026-09-17

Added

  • Gameplay you can draw. A .esgraph is logic as a picture: an event lights the white wire, the wire runs one node after another, and the coloured wires carry values between them. It is the entry non-programmers have in every other engine, and the one Estella did not have.

    The vocabulary is not new, which is the whole point. A node that DOES something is an aiRegistry action and a node that ANSWERS something is the generalisation of a condition — so one registerAction in your project shows up in a state machine's hook, a behaviour tree's leaf, an event wire AND the graph palette, with the pins it declares. registerValue is the same door for a name that computes: declare what it takes and what it hands back, and the editor draws the node. There is no privileged built-in set to imitate; the engine's own maths, comparisons and property.get come through that door too.

    What the interpreter promises is what the picture shows: a sequence finishes pin 0's whole chain before pin 1 starts; one wire carries one value (a pure node is evaluated once per activation of the node reading it, and asked again on the next, which is how a while condition can become false); a node whose input wire leads to something this build could not make does not run at all; and a graph that loops forever spends a step budget, stops that instance, and names the node. The play realm is the editor's own process — "the author will not draw that" is not a safety story.

    A .esgraph IS the runtime definition. Nothing compiles it, so the graph the editor runs and the graph the package ships are the same bytes, and a graph is attached to an entity the way an FSM is: a ScriptGraphAgent naming it.

    The vocabulary reaches what a game needs: the keyboard (input.axis, input.down, input.pressed, input.pointer), another entity (entity.byName, and an optional target on property.get/property.set), who else an event named (event.on publishes other, which is the contact's partner on a physics event), and entity.despawn. Input arrives through the context every authored surface shares, so a state machine's hook and a behaviour tree's leaf can read the keyboard now too — AiContext was documented as a BehaviorContext superset and was missing the one thing gameplay is written against.

    A graph can SPAWN. entity.spawn hands the new entity to the next node on the wire, so it cannot wait for a load — and loading is all instantiatePrefab is asynchronous for. The wait moved to where the graph itself is loaded: the loader prepares every prefab its spawn nodes name (loaded, flattened, asset handles written in) through the context door that records the acquisition, so the prefab is owned by that graph's era and given back when it retires. preparePrefab / spawnPrepared are the same pair for code — the scene path reused rather than reimplemented, so a prefab spawned at runtime and one placed in a scene resolve identically.

    Two projects carry it. examples/script-graph-demo is two squares that move because of what they were drawn to do, one of them through a value node the project registered itself. examples/dodge-graph is a GAME — move with the arrows, dodge the falling blocks, score, lose, press Space to start over — with no gameplay code at all: one component declares what the run remembers (graph variables belong to one entity; a score the blocks and the HUD agree on does not), and four graphs do the rest — including the one that spawns the blocks, of which the scene contains none. A gate plays it: holds a key and the player moves, releases it and they stop, dodges and the score rises, chases a block and the run ends, presses Space and it begins again on a clear board.

  • A scene can hold a thousand of something again. The renderer merges draws of one mesh into a single instanced draw, and one LightProbeVolume anywhere in the scene turned that off completely: indirect light was bound PER DRAW, and the merge refuses a draw carrying it — "a record per object says everything that differs between them, and irradiance is not in that record". So 200 copies of one crate cost 200 draw calls in any scene lit by probes, and nothing said so.

    Irradiance is in the record now. A draw's block carries a run of coefficients per INSTANCE rather than one for the draw, the vertex stage hands the fragment its instance's slot, and the merge stopped refusing. The same 200 copies cost 2 more draw calls, with the volume still in the scene; the scale corpus went from 43 draws to 1 for its 4225 meshes.

    What bounds a run is what one uniform block holds — 100 instances, inside the 16KB WebGL2 guarantees — and only for runs that actually stand in a volume: a scene with no probes merges without limit, which is what the 4225 are. A run longer than the cap carries no irradiance by construction, so its tail reads the zeroes and falls back to the environment, which is its answer anyway.

    Per-instance, not per-object-record, because the record was out of room at the time. The entry below is the change that moved it.

  • What a shiny thing reflects indoors is the room, not the sky. A ReflectionProbe is a box inside which reflections come from a bake — the specular half of the question LightProbeVolume already answered for the diffuse one. Bake Lighting captures a sphere from each probe, prefilters it with the environment importer's own code, and packs every probe into ONE atlas whose column 0 is the sky the scene was baked under. A surface carries which column it reflects as a number per instance, so a room full of shiny things is still one draw; a texture per probe would have been a bind per draw.

    The reflection is PROJECTED onto the probe's box, which is what slides it across a wall as the eye moves instead of painting it on. Outside every box the sky answers exactly as before, and a scene with no bake is byte-for-byte the frame it always was.

    Both bake doors produce it — bake-scene on the command line and the editor's Bake Lighting — and both write the same two files beside the lightmap.

  • The bake's ray tracer walked its own tree wrong. The traversal took the left child to be the node after the parent, which is true only of the root: a left subtree allocates everything under it first. Held against brute force over 600 rays, the tree missed 154 of them — it reported open sky where a triangle stood. Every bake in the corpus carried it: shadows that leaked, bounces that never arrived, probes gathering light through walls. The tree now stores the left child and reads the right beside it, and agrees with brute force on every ray; the shipped bakes are rebaked. Two more ways the same walk went wrong are closed with it: a scene with no surfaces at all (probes only) is one empty leaf, which the walk read as an inner node and circled forever, and a tree deeper than the walk's fixed 64-entry stack silently dropped its deepest nodes. Inner nodes are now marked apart from leaves, the stack is sized to the tree, and a walk that revisits a node throws instead of hanging.

  • A material-shaded surface shaded itself at z = 0. The Model shader passed vec3(v_worldPos, 0) as the place it stands — which a directional light cannot tell from the truth, and a point light, a probe volume and a reflection's box projection all can. It uses the position the vertex stage already hands it. On WebGPU the same shader never told the injected header which instance it was, so every material-shaded draw read instance 0's indirect light — one probe volume's worth for the lot.

  • A wall can stop a frame from drawing what is behind it. Occluder declares a box sight does not pass through. Every camera rasterises the ones it can see onto a small depth grid before collecting, and a renderable whose bounds are behind that grid never becomes a draw. Nine cubes behind a wall and two beside it: three draws with the component, twelve without, and the same four pixels either way — an occluder changes what a frame COSTS and never what it shows.

    The box is authored rather than taken from the geometry, and that is the design. A mesh's bounds CONTAIN the mesh: a box around a pillar or a rock claims the air at its corners, and whatever stands in that air would stop being drawn while the player can plainly see it. Only whoever built the wall can say where the inside of it is, so halfExtents is theirs to place — in world units, turned by the entity, and drawn in the viewport like every other extent.

    What it refuses is bounded on purpose. Only draws a depth test would have hidden anyway, so sprites, UI and anything whose material turns depth off are never taken away; only the camera's own collect, so a caster keeps casting into a shadow map the player cannot see; and never a box the camera stands inside, which would otherwise declare the whole view blocked. A scene that declares no occluder — every 2D one — pays one comparison per renderable.

    Two questions now have one answer. RenderCollectContext::visible asks "outside the view" and "behind something solid" together; the mesh collect had been testing the frustum itself and would have missed the second entirely. Three counters say which is which: render.cull.occluders (boxes taken), render.cull.occluded (renderables refused), render.culled (every cull).

    Measuring it is what set its own resolution: read four grid texels a side rather than two, because a level's texels align to the grid and not to the object, and at two the region read overhangs by the object's own width — six of nine cubes standing squarely behind a wall went uncalled.

  • Decals you can place. Put a DecalProjector on an entity, point its box at something, and Bake Decal cuts what it covers into a mesh on that same entity — drawn with the decal's own material, won on depth by that material's bias. The box IS the entity's transform, so a decal is placed, turned and sized with the gizmo everything else uses.

    The example ships one: a target printed across a floor and up onto the step beside it, at two different heights — which is what says it CONFORMS. A quad hovering in front of a wall cannot do that, and the check reads it off the written mesh rather than off a picture of it.

    Looking at the picture found a bug nothing else would have: the mesh was minted, the ref stored, and nothing drew — the registry had not indexed the file yet, so a freshly baked decal appeared only after the scene was opened again. The ref is stored after the index knows the file now.

  • A decal's geometry, cut. What a projector produces here is not a sticker hovering in front of a wall — it is the wall, cut to the projector's box and drawn again with the decal's own material, won on depth by that material's bias. So a decal is ordinary geometry: lit and shadowed exactly as the surface under it, instanced, culled and picked like anything else, with no pass, no depth read and no G-buffer anywhere in it.

    bakeDecalMesh takes the surfaces under a projector and its transform — the box IS the entity's own transform, so a decal is placed with the gizmo everything else uses — and answers one mesh in the projector's space. Nothing authors one yet; that is the next piece.

    Two things only a test could have found, both from the placement an author actually makes. A receiver lying FLUSH with a face of the box — which is where a projector is put — had every vertex on a clip plane, and whether it counted as inside was decided by the last bit of the transform: a floor came out ±6e-16 either side and half the decal was clipped away. And a vertex exactly on a plane was emitted twice, fanning into zero-area triangles the mesh would have carried forever.

  • A surface can say it goes ON another one. Two coplanar surfaces — a decal on a wall, a marking on a road, a patch on a floor — had no way to settle which one the depth test keeps. Whichever drew first won, which is not a thing an author can say. A material now carries depthBias, in units of the depth buffer's own resolution, and both backends apply it to the constant and the slope-scaled term (a constant alone stops separating them at a grazing angle).

    It is the piece a decal cannot be built without, and it has none of a decal's other machinery: no new pass, no depth read, no G-buffer. Two pixel scenes hold it — the same wall and the same patch, differing in that one number, showing the patch in one and the wall in the other.

  • A scatter brush. Drag across the ground and copies of the selected object land across it, turned and sized a little differently each — the first of the authoring tools ruling 03 is about, since everything the renderer needed for scale was already there and nothing an author could do reached it.

    What it lays down are ORDINARY entities, which is the whole architecture. That was measured rather than assumed: the editor opens, walks and saves a scene of eight thousand of them in well under a second, so nothing new had to be invented, and instancing, LOD, culling, prefab overrides and selecting one of them all keep working on what the brush makes. What they cost is disk — about 634 bytes each, against maybe 40 bytes of information — and a check now holds that number so a field added to every scattered object is reported.

    One stroke is one undo step. It was not, and could not have been: the editor's transaction coalesced field EDITS, so a gesture that created things recorded one step per creation — a brush placing two hundred objects would have left two hundred rows in History and two hundred keystrokes to take back. Strokes now span a history group, which every drag gesture gets, not only this one.

    Contributed tools also have somewhere to live now: the registry has always taken them, and nothing showed them, so a plugin could register a viewport tool no human could arm. The floating tool palette lists them, and the brush reaches the palette and a keybinding through commands like any other action.

  • A mesh has somewhere to put its own vertex attributes. All 16 vertex attribute slots had a semantic owner — 0-7 the mesh's own channels (serialised in .esmesh), 8-15 the engine's per-object record — so a mesh that wanted to carry anything else had nowhere to carry it, and neither did the record when it wanted to grow.

    The record is a texture now, read by index rather than by whichever instance the hardware happens to be on, and slots 8-15 are free. A draw says where its own run of records begins (gl_InstanceID restarts every draw while the frame's records are one run), and the whole layout collapses to one fixed eight-texel shape: the stride the layout, the allocation and the packer each used to derive for themselves is gone, and so is every variant of it.

    Full floats, because what a record carries is a world-space translation and a half loses whole units of one a thousand away — so RGBA32F is a format the engine has now, on both backends. On WebGPU it is unfilterable, which the bind-group layout has to say: a unit that declares no sampler cannot be filtered, so that is the answer read out of the shader itself rather than a second table to keep.

    Every one of the 174 pixel scenes draws what it drew before, on both backends, and 200 copies of a crate still cost 1-2 draw calls.

  • Automation can read what a frame cost. A probe could ask what a game was doing and not what it was paying: Stats is installed by StatsPlugin, which a play realm does not build, so the reading came back as a materialised default — a frame that drew nothing and a frame that drew a thousand things are the same zeroes. renderStats() reads the renderer directly and stands in the probe scope beside find and step.

    The first thing it was asked is the claim every scale feature rests on: 200 copies of one mesh cost 1 more draw call, 212 runs coalesced into their neighbours. The instanced merge works, and now a check says so instead of the code saying so.

    It also found what turns it off. Indirect light is bound PER DRAW and the merge refuses a draw carrying it, so a single LightProbeVolume anywhere in the scene costs those same 200 copies 200 draw calls — nothing merges at all. The check takes the volume away and records why; closing that is what the scale work starts from.

  • A graph can call another graph. The last thing a .esgraph could not do was reuse itself: a long graph could only be tidied by moving nodes around, and the same four nodes were redrawn everywhere the same question got asked.

    A graph that carries a graph.input is one a call can enter, and what it declares as inputs/outputs IS the signature — so a graph.call elsewhere draws exactly those pins, and changing the signature redraws every caller rather than leaving one on a stale shape. It is a built-in node kind rather than a registered name, for the reason entity.spawn is: a graph is an asset of the realm that loaded it, and the registry is process-wide.

    What it promises is a call, not a coroutine. The callee runs to completion inside the caller's step; it keeps its OWN frame per call site, so its variables are local to the call and survive between calls the way an entity's graph does; and it spends the CALLER's budget, or calling often would buy the unbounded work that looping cannot. A graph that reaches itself stops at a call depth rather than on the JS stack, and a flow.delay inside a called graph is refused at compile: the call returns within the caller's step, so there is no later tick for a timer to expire on.

    The signature travels with the ACQUISITION. A loader takes the graphs its call nodes name — which is what makes them owned by this era and there to run — and reads their declaration off the same door, because the caller's pins are the callee's declaration and the two facts have to arrive together.

    examples/dodge-graph now asks one question through one graph: three of its graphs drew the same "is the run still alive" four nodes, and now they call alive.esgraph instead.

  • A graph can change the scene. It is the one thing gameplay needs that no component can express — the write would retire the world the component lives in — so an authored surface could reach everything about a game except its shape: a menu that starts the level, a death that restarts it. scene.load and scene.reload close that, with the fade as a declared parameter. reload is its own verb rather than loading the active scene by name: asked for the scene already running, a switch does nothing, which is the right answer for a gate and the wrong one for every retry there is.

    What they reach through is the door every authored surface already holds. Commands carries the world's services as well as its structural edits, so commands.resource(SceneManager) is how an FSM hook, a behaviour-tree leaf, a graph node AND a defineBehavior reach one — the last of those could not reach a service at all before, which is why "switch scene" was a defineSystem holding Res(SceneManager) and nothing else. A service nobody installed answers null rather than materialising its default, so a verb in an app assembled without that plugin says so instead of acting on a value no plugin put there.

  • A sound anything authored can start. An AudioSource could only ever be played by playOnAwake. Once the entity existed, nothing an author can reach — a state machine's hook, a behaviour tree's leaf, an event wire, a graph node, the inspector — could make it sound again, and the engine's own answer to "play a sound" was a system holding Res(Audio), which is code.

    It now carries the flag contract TimelinePlayer and SpriteAnimator already keep: raise playing and the clip sounds, lower it and the voice stops, and the engine lowers it again when a non-looping clip ends — so the field reads as "is this sounding" rather than "was it ever asked to". finished latches beside it, which is what a state lasting exactly as long as its sound needs. playOnAwake is now one trigger expressed through that same switch rather than a second road into the backend.

    audio.play, audio.stop and audio.finished are that flag as vocabulary, registered the way every other verb is, so one name reaches all four authored surfaces at once. audio.play takes the clip as a DECLARED parameter, which is what gives it an input pin in a graph instead of only a hand-typed argument — and spriteAnim.play and spriteAnim.restart declare theirs now too, so the three play verbs are one shape. Naming a different clip while a voice is in flight is a second sound, not a no-op: the voice is a play OF a clip, so the old one stops and the new one starts, which is what a character with a hurt clip and a death clip is.

Fixed

  • A baked decal draws on devices and under WebGPU. A decal bake writes its mesh without a vertex colour, and every mesh shader reads one: WebGL2 read black, while WebGPU and the native hosts rejected the pipeline, so physics-3d drew nothing at all on Android. A mesh with no colour channel now draws as white vertices, which is what an import without vertex colours already meant.

  • A material that writes only its fragment stage draws on a mesh under WebGPU and on devices. Its generated WebGPU twin carried a copy of the vertex stage made for sprites, so on a mesh the device rejected the pipeline and the surface never drew. Twins for such materials now carry only the fragment stage, and the engine supplies the vertex stage for every source; an older twin is regenerated when the project is opened or exported.

  • Opening a project from inside the editor no longer leaves the loading screen up. An agent's open_project while a project was already open — once that project had finished loading — put the loading screen back over the editor with nothing left to lift it, not even the timeout that lets you in when loading runs long. Every open now loads to the end, from the launcher or not.

  • An agent's picture of the editor shows the edit it made. screenshot and capture_viewport captured whatever was on screen the moment they were called: a texture still loading, a bake landing, a scene half adopted, the loading overlay fading out. They now wait until nothing the editor started is still in flight and the engine has drawn since, and wait_idle answers the same question on its own — naming what is still busy when it gives up.

  • The navmesh preview catches up with an edit. An edit made within the preview's rebake window left the old mesh on screen until something else repainted the viewport, and a preview asked for before the scene's meshes had loaded showed nothing until the scene changed again. Both now redraw once the mesh can be baked.

  • Play waits for the asset index when scenes are opened in quick succession. A second open while the first confirmation scan was still running replaced the wait Play takes with one already finished, so Play could start from an index that had not been checked against the files.

  • A new prefab, material, animation clip or graph keeps the id it was created with. Each was written file first and .meta second, and the project watcher adopts a file it finds without a .meta by minting one of its own. When it looked in between, the new asset was registered under an id nobody had been given — a prefab just created could be missing from the asset list — and when its write landed last, the id the editor had handed back referred to nothing on disk. New assets now land their .meta first, through one door that mints it, and adopting a file never replaces a .meta that appeared after it looked.

  • Play started while the editor was still preparing it gets a whole game. Opening a project prepares the play realm in the background, and preparing it deletes the copy it is about to replace. A Play pressed before that finished prepared the same directory at the same time, so one of the two could fail halfway and the game could load files from both. A project's play realm and its script bundle are now prepared one at a time.

  • A layer hidden in Tiled stays hidden. A map placed with the Tilemap component drew every layer at full strength, in the editor and in every package: the asset loader kept a layer's tiles and size and dropped what Tiled says about drawing it — visibility, opacity, tint and parallax. They now reach the layer, through the same mapping the older loadTiledMap path already used.

  • An editor an agent started closes when the agent does. The editor the MCP server launches outlived it: an agent that exited, crashed or was killed left its editor running, and an unattended one with unsaved edits sat at the "save changes?" prompt forever. The editor now watches the process that launched it and quits when that process is gone, and a run nobody attends never asks to save.

  • A Play that never comes up says how far it got. A game that stayed silent for 90 seconds was always reported as "handed the scene but never reported ready", and pointed at an Output Log with nothing in it — including a game that never loaded, so was never handed anything. Now a game that never loaded says so; one that did is asked where its start-up is, and the message names the step and how long it has been on it ("loading the scene and its assets for 90s"), or says the game stopped answering. The reason also stays on the failed session rather than only in a toast: the game is torn down the moment its session fails, which cleared the one error anything could read back.

    A game the editor had already replaced could also answer for its replacement — both post from the same frame — so a Play could report running before its own game had loaded. Every message now carries the page it came from.

  • A native build runs a script that holds a NUL character. The desktop and mobile hosts measured the embedded SDK and the project's scripts with strlen, so the first NUL byte ended them. The script-graph runner carried three, and every packaged desktop game stopped at a SyntaxError in the SDK and drew nothing. Both are now evaluated by their size, and the runner writes its separator as an escape.

  • A mirror has no seam across it on WebGL2. The prefiltered atlas stacks its own mips, and the WebGL2 shader let the hardware pick one: wherever the octahedral fold makes the derivatives jump, it read the neighbouring column, and a thin grey arc and a vertical line crossed every shiny sphere. It now reads level 0 by name, as the WebGPU shader always did.

  • A half-transparent texture looks the same on WebGPU as on WebGL2. Without a WebGL2 context a texture was read through a 2D canvas, whose pixels already come back unpremultiplied, and then divided by alpha a second time. Every half-transparent texel on WebGPU came out brighter — (200,100,40) at half alpha drew as (128,100,40) where WebGL2 drew (100,50,20) — and a baked reflection atlas, whose alpha IS its brightness, turned a room's red and green walls grey. That read now goes through the one image-decode path every other texture already uses, and the reflection-room gate runs on both backends.

  • The editor packages playable ads again. Since 0.65 a playable's game travels deflated and a small loader starts it, and the exporter looked for that loader beside the playable host. The editor exports from the host bundles it prebuilds (an installed editor ships no sources), and that prebuild kept its own list of hosts, without the loader — so every playable export from the editor stopped at "Could not resolve …/hosts/playableLoader.js" (#62). The command line and every exporter test bundle the hosts from their sources, where the loader was always right there.

    The hosts an export bundles are now named once, in the pipeline, and the editor's prebuild takes its entries from that list; an export is told the one directory the hosts are in, not a path per host. A test now exports a playable from a prebuilt host tree, and an editor check packages the playable-ad template through the editor's own export.

  • Two nodes under one id are reported instead of one replacing the other. Every lookup in a compiled graph is by node id, so a file carrying the same id twice quietly kept whichever came last, and any wire drawn to either landed on it. dodge-graph carried such a pair — harmlessly, because both nodes did the same thing, which is exactly how a graph where they did not would have gone unnoticed.

  • A sound stops when whatever owned it goes away. Switching an AudioSource off, clearing its clip, or removing the component dropped the handle to the voice WITHOUT stopping it. The sound kept playing with nothing anywhere able to reach it again — a looping one until the session ended. The pass that notices a source left now stops its voice rather than forgetting it.

  • Run works from wherever you are standing. The running game's frame is parented by whichever panel hosts it — a Game tab, or the Viewport itself in play-in-viewport mode. Opening any asset document puts it in the tab over the Viewport, and Run then started a session with nothing to attach to: the editor sat on "Starting" until the deadline with no error to show for it. Both modes now bring the panel hosting the game forward, which is what Play does everywhere else.

    Nothing could see this. Every play gate starts from a fresh project with the Viewport in front, and every document gate opens a document and never plays — the two halves of the ordinary authoring loop, each green on its own. The new check is the loop itself: open a document, press Run.

  • A mini-game package can read its own prefabs and materials. The mini-game filesystem adapter rewrote every custom extension whose content is JSON — .esprefab, .esmaterial, .estileset, .esanimator, .eslocale — to .json before handing the name to the host. That was how a long-replaced exporter staged them; the cook keeps the authored extension, and the export declares it in packOptions.include so the packer ships it under that name. So a WeChat build resolved a prefab to exactly the right file, asked the device for one it had never written, and died on the first load with File not found: "assets/…/Foo.json" — a name the project does not contain anywhere, which is why it read as a culled asset rather than a wrong spelling. The adapter now reads the path the manifest gives it. (#61)

    The two halves of this — what the exporter NAMES a file and what the runtime ASKS for — never read each other, so only a build can show that they agree: a new export gate walks the real resolution a packaged runtime performs over the manifest an export actually wrote, and asserts every spelling of every asset lands on a file the package carries.

[0.67.0] - 2026-09-15

Added

  • A scene says how it is lit, and whether its light still describes it. The bake's knobs — atlas size, density, bounces, samples — had no home: both doors fell back to the same defaults and neither could be told otherwise. A BakedLighting component is that home, on the shape StreamedWorld has, and both doors read it.

    It also records what the last bake READ, as a fingerprint of every value a bake takes: the meshes and where they stand, the lights, the volumes, the knobs. Comparing it to what the scene fingerprints to now answers "is this light out of date" without re-running the bake to find out — and both collectors fingerprint the REFS a document spells rather than the paths they resolve to, so a project in two checkouts fingerprints alike.

    A Lighting panel shows that answer, with what a bake would take and what it would refuse, and the knobs beside it. It is a view of the one component, not a second home for the numbers: editing there goes through the same write door as any inspector edit. get_bake_status is the same reading, for automation.

  • A bake now solves the probes too, and refuses to light what moves. One pass over one light field produces both: the atlas the surfaces read, and nine coefficients at every point of each LightProbeVolume's grid. A probe gathers the whole sphere where a lumel gathers a hemisphere, and reads the same atlas a bounce does — so a character standing in a red room is lit red by the walls that are lit.

    What a bake may hold still is the physics components' to say, and nothing else declares it: a CharacterController3D exists to walk, and a RigidBody3D that is not Static is moved by the solver. Those objects are refused an atlas patch — a bake writes light into a PLACE, and they will not be there — and take the volume's light instead. Bake Lighting and estella.mjs bake-scene go through the same rule, so the editor and CI cannot disagree about which objects moved.

    physics-3d now carries a volume. It also stopped baking its thirteen moving bodies, its hero among them — a character had been wearing the light of the spot it spawns at.

  • Light probes: what lights a thing a bake cannot hold still. A bake answers "what light reaches this surface" for geometry that never moves, and nothing answered it for a character — a figure walking out of a lit room kept the one flat environment the whole scene shares. A LightProbeVolume is a box of that answer solved on a grid: a draw standing inside takes its indirect light from the eight probes around it, read trilinearly, instead of from the frame's environment.

    The grid is the same nine spherical-harmonic coefficients an .esenv already carries, evaluated by the same expression — an environment is this field held constant, and a volume is it sampled. That is why the two are one function and not two: they differ in where the nine came from, not in what they mean.

    Per DRAW and not per object, which is the opposite of a lightmap's rectangle and for the reason that decides it: a rectangle belongs to an object, because one mesh placed twice occupies two patches of one atlas, while irradiance is a function of WHERE — and a batch of instances has only one position to speak of. A draw standing in a volume is therefore its own draw.

    A surface that reads its own atlas does not also read a volume: the bake already holds every bounce that reached those texels, and taking both counts them twice. Skinned meshes never take a bake, so they always take this.

    The reading side goes first on purpose, as the lightmap's did: a grid written by hand can falsify it, where a solver built first would have nothing to say whether it solved the right thing. Baking one is the next step.

  • A room in the corpus is actually lit. physics-3d — twenty-two boxes and two lamps — now ships with its lighting baked: an atlas beside the scene, and a MeshLightmap on every object saying where in it to read. It is the first shipped scene that carries one, and what closes the last debt check-corpus-authoring was tracking.

    estella.mjs bake-scene is the door CI and a rebake go through, beside the editor's Bake Lighting for a creator. It reads the document rather than a world, so it refuses a scene with a hierarchy — resolving one is the editor's answer, and an atlas lit for a place nothing is at looks like a bake that is wrong rather than one never run.

    A gate holds the result, because a baked room rots the moment the baker changes and a stale atlas looks exactly like a correct one. The bake is deterministic, so what is committed is simply compared to what a bake of it produces now — red if either the atlas or the scene has drifted, with the command to fix it.

  • Stock geometry takes a bake, and the density suits this engine's units. Trying to bake a real example found both. physics-3d is twenty-two builtin cubes and two lights — the most ordinary lightmap candidate there is — and every one of them was skipped, because a builtin has no .esmesh to read a UV set out of and no import setting anyone could turn on for it. Its UVs are derived per bake instead, which rewrites nothing: stock geometry is rebuilt from code every run.

    Then the bake refused the scene. A world unit here is a design pixel, so a builtin cube is a hundred units across and the old default of two texels per unit asked for a patch larger than the whole atlas. The defaults are now a 1024 atlas at a quarter texel per unit, which is a lumel every few design pixels. A refused bake also says so where the user is, rather than as a console line nobody reads.

  • A bounce carries the colour of what it came off. Baked light reflected a neutral grey whatever it hit, so a red wall lit a white floor white — most of the difference between a bounce and a flat ambient term. A surface's albedo now comes from both of the things a shader multiplies: the base colour factor (for an imported model, the material's own, which the import writes onto the component) and the mean of its base colour texture, decoded out of sRGB first so the average is of light rather than of what a screen shows. A surface with neither is still a neutral grey, and says so rather than guessing quietly.

  • Bake Lighting. The trigger the bake was missing: a command that collects the open scene, solves it, writes the atlas beside the scene file, and records on each object where in that atlas it reads. Sixteen lights is what a frame carries; past that, this is the way they still reach the picture.

    It runs in the editor's main process rather than the window, because a bake is seconds of ray casting and the editor has to stay answerable while it happens. The collector reads the document for what a mesh IS (a ref survives a reload where a handle does not) and the world for where it STANDS (already resolved through the hierarchy and through every prefab instance).

    What it cannot light, it names. An object with no second UV set is called out by name with the setting that fixes it, because in a result it looks exactly like one the bake simply missed — and only the author can turn that setting on.

    An end-to-end check holds it, because nothing shorter reaches the chain: it bakes a real scene in the real editor and reads the saved document back.

  • The bake itself: lights become an atlas. bakeLightmap takes surfaces and lights and returns the texture a MeshLightmap reads, plus the rectangle each object occupies in it. It runs the way the navmesh builder does — plain TypeScript, a stage per file, one orchestration: lay out, rasterise, solve direct, bounce, dilate, encode.

    Direct light is a shadow ray per lamp per texel, so what stands in the way leaves a shadow, and there is no ceiling on how many lamps there are — which is the whole point, since a frame carries sixteen and drops the seventeenth by brightness. The bounce reads the atlas the pass before it wrote, so each round carries light one surface further and costs what the first did; that is the term a real-time frame here has no way to compute at all. Irradiance is what is stored, not colour: the surface's own texture is applied where the bake is read, so one atlas survives a retexture.

    Every object's patch is sized by the surface it actually has, at one world-to-texel ratio across the whole atlas — the same rule the unwrap follows inside one mesh, applied between them. Surfaces that do not fit are refused rather than quietly shrunk: a wall lit at a different resolution from the floor it meets is a seam, and choosing between a bigger atlas and a coarser density is the author's call.

    Five gates, one claim each: twenty lights all reach the picture, a wall leaves a shadow, a panel facing away from every lamp is lit only once light may bounce, two objects occupy two patches, and the same scene bakes to the same bytes twice. Five sabotages, each red only where it should be — including one that stayed green until the determinism gate was given a scene that actually bounces, since over a lone plane every ray misses and a random hemisphere passes too.

    There is still nothing in the editor that triggers a bake. The pieces are a library the next step drives.

  • A model can be given somewhere to receive baked light. A bake is read through a second UV set, and it has to be one where no two surfaces share a texel — which the UV set the art is wrapped in deliberately is not: two arms share one arm's pixels, and given the same lightmap texels one arm's shadow falls on the other. Almost no model carries a second set, so until now the reading side shipped in 0.67 could be pointed at nothing.

    Generate Lightmap UVs, in a model's import settings, unwraps one. The surface is cut into nearly-flat charts, each is projected onto its own plane, and they are packed into the unit square at one world-to-texel ratio — so a wall is lit at the same resolution as the floor it meets, which is what stops a seam showing where they join. Vertices on a chart boundary are split, so the mesh comes back with more of them than the source had; nothing moves, and every shape, skin weight and vertex colour follows its vertex.

    Off by default, because most models are never baked and a split vertex costs memory whether or not anything reads the channel. Two never get one: a skinned mesh, because bones move it and a bake cannot follow; and a model that already carries a second set, because that layout is the author's and the art may be painted against it.

    What it must guarantee is one property rather than a resemblance, so that is what the gates check — every triangle rasterised into a grid of lumels, and not one of them covered twice. Four more hold the rest of it: a cube comes back as six charts with all eight corners split three ways, the UVs stay inside the unit square, every face is lit at the same resolution, and no vertex moves. A sixth runs the whole thing over a model out of the corpus, because a cube's charts are six flat quads and a real one's are neither.

  • A mesh can be read through the light that was baked into it. Sixteen lights reach one frame; the seventeenth is dropped by brightness, with a warning naming what was refused. That ceiling is not a quality setting — a room with thirty lamps in it cannot be lit in real time at all — and a bake is the way past it: light that never moves is computed once and stored as a texture, so a hundred lamps cost what one costs, and what they cost is a sample.

    A MeshLightmap says where an object's bake is: lightmap is the atlas, and scaleOffset is the rectangle of it this object occupies. The rectangle rides the per-object record beside the model matrix, and that is the reason it is a component rather than part of the mesh — the same mesh placed twice is lit twice, differently, and occupies two patches of one atlas.

    It is read through the second UV set, which a model has been carrying since 0.63 and which nothing read: the first UV set overlaps on purpose, and a bake cannot, so TEXCOORD_1 leaves meshShaderReads' exclusion list now that it has a reader. A mesh without one draws exactly as before.

    What the bake MEANS depends on whether the draw also takes real-time light, and the two are worth telling apart: a lit surface adds it as the indirect term, so a sun's contribution survives; an unlit one takes it as all of its light, which is the case a bake is for — a scene whose lights all went into the atlas pays for none of them. An object with no bake is not darkened by the difference: the rectangle reads as zero, and the shader takes that as "none" rather than as an atlas of black.

    There is no lightmapper yet — nothing in the editor produces an atlas. This is the reading side, and it went first on purpose: a bake authored by hand can falsify it, where a baker built first would have nothing to say whether it baked the right thing. Three pixel gates hold it, one claim each — which UV set was read, that the bake adds to real-time light rather than replacing it, and that one mesh drawn twice reads two different halves of one atlas.

    Skinned meshes take no bake: bones move a character, and a bake cannot hold one still long enough to light it.

Fixed

  • A baked room is lit in the package too. bake-scene wrote the atlas's file NAME into every MeshLightmap, and an asset ref resolves from the PROJECT root — so the name meant something beside the scene and nothing anywhere else. The editor drew the room correctly, because it reads the file off the disk it is sitting on. The packaged game asked its server for main_lightmap.png, got a 404, and ran the room unlit with the atlas sitting right there in the package under its content hash. The probe grid went the same way. Both doors now write the @uuid: the product's own .meta carries, which is what the editor's bake already did — of the two halves of "an asset ref is project-relative", the reading one was fixed this release and the writing one was not.

    check-asset-refs holds every asset-valued field in the corpus to a ref a package can resolve: a @uuid:, a builtin:, or a path from the project root. Which fields those are it reads from component.assetFields, not a list of its own. Nothing shorter reaches this: the bake is deterministic and its own gate compares a fresh bake to the committed one, so both sides spelled the same wrong name and agreed.

  • The command line bakes the meshes a scene actually names. An asset ref is PROJECT-relative, and bake-scene resolved it against the scene's own folder — so every object drawing a real .esmesh fell out of the bake with "draws no mesh asset", and only scenes built from stock geometry came out lit. It now resolves against the project root and reads @uuid: refs out of the .meta index, which is what the editor's own collector does.

  • Both bake doors read a light the same way. A spot's inner angle defaults to 30 degrees, and the command line filled an unstated one in with 45. One reading now serves both — the document's values over the component's own defaults — along with one transform compose and one .esprobes writer. Three places where the editor and CI could quietly disagree about the same scene.

  • A scene's ambient light reaches its bake. LightType.Ambient is the third value of the enum and Spot the fourth, and both bake collectors read the third as a spot lamp — so the sky lit nothing it was not standing next to. An ambient light occupies no slot and aims nowhere; it is now the bake's ambient term, the way the renderer already folds it into its own. Outdoors this is most of the indirect light there is: physics-3d's probes go from black to carrying its sky's blue.

  • A bake's products can be carried by a package. bake-scene wrote the atlas and nothing else — no .meta, so the cook had no identity to carry it by, and the export said so in a warning nobody reads. The scene named an atlas the package did not hold, and the room shipped unlit. The check now fails on a product with no .meta and says which command mints one; the editor's own bake already minted them.

  • A gather reads the lit side of a surface. Light bounced off the BACK of a wall as readily as off its front, because an atlas is per triangle and has no side. A ray arriving at a face from behind now finds it unlit, which is what keeps a probe standing behind a wall from being lit by what the wall hides.

  • A per-draw block reaches the draw that wrote it. The pose of a skinned draw, the shapes of a morphed one and (now) the indirect light of a probe-lit one shared one buffer each, rewritten immediately before the draw that reads it. That is correct where an upload takes effect at the call, and wrong on a backend that QUEUES them: on WebGPU the writes land together when the pass is submitted, so every draw in that pass read whatever the LAST of them wrote — one pose on every character in the room, one set of shapes on every face.

    Every skin and morph gate in the suite drew a single object, so none of them could see it. Each draw now takes a buffer of its own from a frame-scoped pool, and a draw with nothing to say binds a zeroed block that is never written — "none" as an object rather than an erasure someone has to remember to perform. Two morphed draws in one frame, blended different amounts, is now a gate.

  • A hot reload no longer empties the running game of every resource (#60). Edit a script while the game is playing and the editor re-imports the bundle and swaps the system bodies in place, keeping the live World. The re-imported defineResource minted a fresh identity, so every swapped system addressed a slot nothing had filled — and a resource read that misses does not fail, it materialises the default, which for the usual defineResource<T>(null!, 'Name') is null. The symptom was the whole project throwing Cannot read properties of null from every system, every frame, one edit after Play, until something forced a full restart. defineEvent had the same flaw: its re-import wrote to a bus nothing resolving the event by name could reach, and left the old one behind.

    Both are now interned by NAME, module-globally, the way component identity already was — so two declarations of one name are one resource (one event), and a re-evaluated bundle lands on the live world's storage. A name was already the address a compiled manifest, getResourceByName and the editor's resource list used; the symbol was the one door that disagreed, which is why declaredResource needed an "ambiguous" state to cope. That state is gone with the disagreement.

    check-reload-identity is the gate: every public define* door owes an answer about what its second evaluation addresses — read from its source, not from a list — so a door added later cannot be silent about it.

[0.66.0] - 2026-09-14

Added

  • A model brings the shapes it can be blended towards. A glTF morph target was reported at the door and dropped; now the .esmesh carries one delta per vertex per target beside the vertices it moves, and the prefab an import writes gives the entity a MeshMorph whose weights say what shape it is in. The deltas deform on the GPU, before the pose — a face can be posed by bones and shaped by its expressions at once — and the material path deforms with the engine's own, so a mesh drawn by a custom shader moves the same way.

    The weights are a budget on what is live, not on what a mesh carries: the eight heaviest are blended and the rest read as zero, which is what an untouched weight already means. Four pixel gates hold it — the same quad, the same two points, and the weight the only thing that differs.

    A weights animation channel comes with the model too: it becomes a track per primitive that node draws, one channel per target, and the clip that raises the example robot's banner now furls it as it rises.

    FBX brings its blend shapes too, through the same door: ufbx's sparse per-vertex offsets become the same .esmesh section a glTF's targets do, at the weight the file left each channel on. Neither front end is the one that carries shapes.

    The inspector shows a slider per shape, under the name the mesh gave it — a weight is positional, so a column of unlabelled numbers would be unusable for the thing morph targets are for. The labels come from a source the field declares, read through the same .esmesh reader the asset panel uses.

  • A controller is a stack of machines, not one. One state machine can say a character is running or that it is waving, never both. A .esanimator now carries layers over its base one — each a machine with its own clock, its own transitions and its own active state — and what the entity ends up as is the whole stack, written once. The editor's rail picks which machine the canvas edits, top of the list being the top of the stack.

    Composition is ordered, and that is the point. The pose mixer a crossfade and a blend tree share is a weighted average that commutes, which is why its answer cannot depend on sample order. A stack must not: an aim layer at weight 0.3 is three tenths of the way from whatever is under it to what it says, and swapping two layers is a different character. A gate runs the same pair in both orders and demands two answers, so the two cannot quietly collapse into one.

    A field the layer wrote and nothing under it did still interpolates, against the world's own value — mixing gives a lone writer its field whole, a layer never does. An additive layer adds what its clip departed from its own first frame rather than from the layer below, so one lean clip means the same thing over a walk and over a run. Where the character goes keeps one author: root motion is the base layer's alone. A trigger is one event every layer is told about, spent after all of them have been asked rather than by whichever was stepped first.

  • A layer writes the part of the rig it was given. A mask needs no vocabulary of its own: a rig's joints are its entity hierarchy and a clip already names them by childPath, so a mask is a set of those same paths, each standing for the subtree under it. Outside the mask the layer is absent, not quiet — the gate demands the joints below arrive as the same number the layer under them wrote. Having no mask and having an empty one are different and do not read the same: no mask writes the whole rig, an empty one writes nothing.

  • A blend mixes its neighbours instead of picking one. A 1D blend stated values and then selected: at 0.5 between walk and run the character walked, and crossed to run the instant the threshold did. It mixes now, at a shared PHASE rather than a shared second — a 2s idle and a 0.6s run share a clock only once each is measured against its own length, and without that the faster clip's feet slide. The blend's own duration is those lengths interpolated, which is what an exit-time transition now waits for. A motion that can only be switched to still picks, a sprite sheet having nothing to be halfway between.

  • A blend over a plane. blend2d places its stops where two parameters put them and shares the result among the ones that reach it, which is the only way to state a locomotion that turns — forward speed and strafe stacked as two 1D blends makes the character pick a direction and a speed independently and land between the clips describing neither. Gradient-band weights, so a sample standing on a clip plays that clip alone and one outside the hull is held by its nearest edge instead of falling to nothing. It adds no second way to blend: the phase rule, the pose mixer and the picks-versus-mixes split are the 1D blend's.

  • The third-person rig runs and swings at the same time. The shipped controller carries an upper-body layer masked to the one joint no other clip in that rig touches, answering the same attack trigger the base machine does — so the mask is observable rather than merely configured.

  • A clip means the same thing on a rig bound differently. A name map alone is only right between rigs that happen to share a bind pose. An avatar records that pose, and a controller names the avatar its clips came from, so a stated rotation is read as what it means — the offset from where that joint rests — and restated from where this rig's joint rests. The editor can describe a rig it already has: Create Avatar from Rig reads the pose the joints are standing in, which is the bind pose, because nobody was going to type a quaternion per joint.

    And a step travels the distance the rig it is on would travel. An avatar measures its rig — root to the joint furthest from it, one measure every avatar uses, since two measured differently give a ratio that means nothing — and root motion is scaled by the ratio. The turn beside it is not: a taller character covers more ground per step and turns by the same angle. A rig that states no size is not guessed at; the clip travels as authored.

  • One clip drives rigs that do not share its bone names. A clip addresses what it animates by the name whoever exported the model chose, so two characters rigged by two people share no clip at all — an enemy has to be rigged with the names its clips already use. A .esavatar is the translation, and it belongs to the rig: one controller drives many characters, and what each calls its left hand is each of their own business. The New menu creates a blank one and an Animator takes it like any other asset reference.

    It applies at the one place a path becomes an entity — no retarget stage and no rewritten clip, because a clip is data several rigs read at once and rewriting it on load would make a copy per rig. Everything a controller says about a rig goes through that seam: the clip's tracks, a constraint's joints, and a layer's mask. An entry mapping a name to itself is dropped when the file is read, that being what having no entry already means.

  • The posed skeleton can be made to reach something. A clip states where a foot goes; the ground states where it belongs, and nothing could reconcile the two. Two constraints land: two-bone, which puts a limb's tip on a target, and look-at, which turns a joint until its own axis points at one. Both name what they touch by childPath — the spelling a clip and a mask already use — and both are authored beside the parameters, with a weight a float parameter can fade.

    Constraints belong to the controller, not to a layer. A layer answers who is speaking; a constraint is what reality imposes on what was said, and a foot belongs on the ground whichever layer decided how the leg swings — so they run once, between composing the stack and writing it. They read the pose this frame stated: Transform.worldPosition is last frame's, computed before the animator wrote anything, and a solver reading it plants the foot against a character that has already moved on.

    The two-bone solve is constructed, not corrected: the elbow lies on a circle about the root-to-target line, the law of cosines fixes where along it and how far off, and the pole picks the point. Weight is a share of the answer, in local rotations — the same thing a layer's weight is — rather than a share of a correction applied joint by joint, which compounds down a chain.

  • A blend is something an author can make. blend1d shipped long before layers and blend2d arrived with them, and neither could be written anywhere but the file: the state inspector had one Clip box. An engine capability nobody can author reads as present in every census and answers no author's question. The kind picker now offers None / Clip / Blend 1D / Blend 2D; a clip says which runtime plays it (a sprite sheet is switched to, a timeline states values and can be blended); a 1D blend edits its stops and a 2D one places its points; and a clip already typed is carried into the blend as its first stop rather than dropped.

  • A step of gameplay nobody has seen yet, and can take it back. A small mutation can now be expressed as begin → mutate → commit or abandon, with nothing left behind when it is abandoned — and the three ways a step leaks fail differently, so each is closed where it happens. Structural change goes to a command queue the scope owns and flushes only on commit, so an abandoned step never allocates an identity; events sit in the write half of their bus until the next swap, where a watermark un-writes them; values are copied on first touch, and the first touch is where the HANDLE leaves rather than where the write lands, because script storage hands out the stored object itself.

    It arrives as a service, not as new vocabulary: Res(Speculation) hands a system its scope the way Res(Time) hands it the clock. A parameter kind would have changed SystemParam and InferParam, both frozen — the freeze bar refused it, and the refusal was right. 570 public promises kept.

  • A step can be asked whether it is a function of the world. The engine already replays: a replication client rebuilds an owned entity from authority plus its unacknowledged inputs, and that only works if a predicted step depends on nothing but world state, actions and dt. A step that reads a clock or a random source breaks the promise and stays green until a client desyncs somewhere nobody is looking.

    replay asks the question rather than adding a second answer. It runs the step twice through the speculation scope and compares the three surfaces that scope already aligns — where every touched component was left, what the command queue holds, what was announced — then takes both runs back, so asking costs the world nothing. A step that wanders in values, in structure or in what it announces is reported unstable with the surface named.

    predictionReplays puts the same machine beside PredictionOptions.apply, whose doc comment has always carried that promise with nothing able to report it broken. A game can now hold its own rule from its own test.

Changed

  • A state says what it plays one way, from the file in. A controller written before motions existed spells a state's motion as clip, blend or spine — each one kind's own word for what motion says generally — and every reader after the runtime was on its own to remember all four. Migration folds them now, down nested machines and inside layers, and removes the older fields rather than shadowing them. The editor opens through that same migration, so a file opened and saved comes back current and the panel reads one field.

  • One place knows how to average a rotation. The pose mixer, the layer stack and a blend's displacement had each written out the hemisphere alignment that makes {q} and {-q} average to the short way round — a rule that is easy to get subtly right in one place and subtly wrong in the next.

  • .esanimator carries a format version, and the guard that matters is the upward one: a file from a later build is refused rather than read for the parts this one recognises, because layers it cannot see would animate a visibly wrong character and nothing would say so. A file written before layers existed reads as a stack of one.

Fixed

  • A layer's clips reach the game that plays them. Driving the real editor found what every unit gate had missed: the base layer animated and the upper layer did nothing. Two readers walked def.states and called that the whole controller — the asset loader, which therefore fetched and resolved no clip any layer played, and the cook's ref rewriter, which staged a layer's clip under the name the author typed rather than the one the package carries. Both fail in silence, the first in any real project and the second in builds only. animatorScopes is now the one way to walk a controller's machines. The dependency scan needed nothing: it recurses over a document's values rather than its shape, which is why it saw a layer's clip all along.

  • A blend weights its displacement the way it weights its pose. The pose crossed from walk to run smoothly while root motion still picked the dominant stop, so a character crossing run's threshold changed speed in one frame — the one thing a locomotion tree exists to prevent.

  • A canvas node names what its state plays. The label read only the older single-kind fields, so every node of a controller written in the motion shape — which is every controller the engine writes — showed as playing nothing.

  • check-animator-parameters could not see into a layer. A parameter consumed only by a layer read as a dead knob. It also states something new: a mask admitting no track of its own layer's clips poses nothing, and in the editor that looks exactly like a layer that works.

  • isBlend1D was never on the public surface while its twin was, so nothing outside the SDK could ask which of the two a motion is.

  • An unexpected error no longer takes the editor with it. The handler that exists so the editor keeps running long enough to save your work put up a modal dialog to say so — and a modal dialog holds the main process until someone clicks it. Every menu, every panel and every save queued behind it while the window carried on drawing frames, so the editor looked alive and answered nothing. Only a dialog attached to a window is safe; without one it goes application-modal and blocks just the same, so a windowless process now takes the log entry alone.

    What raised those errors was the project watcher. fs.watch takes no exclude list, so watching the project root necessarily descends into .esengine/play, which is rebuilt from scratch on every Play — and a directory deleted mid-scan throws from inside the watcher's own callback, where no caller can catch it. The ignore rule that was meant to cover it filters events, and the descent happens before any event exists. Each top-level content directory is now watched in its own right, which puts the rule where the descent is.

  • step reports the frames that ran, not the number it was asked for. The reply restated the request, so a realm that gave up part way through was indistinguishable from one that finished — and a driver reading the world afterwards blamed whatever it found. It now carries the realm's own count and frame clock. The bail-out behind it was 30 seconds under a comment calling it generous for 600 frames of gameplay; on a software rasteriser a 210-frame 3D step takes closer to four minutes.

[0.65.0] - 2026-09-13

Added

  • A spatial source's reach is drawn. AudioSource.minDistance and maxDistance each declared a sphere and the viewport drew neither, so how far a sound carries was two numbers in the Inspector with nothing on screen to measure them against. Two spheres rather than one: full volume inside the first, inaudible past the second, and the fall-off between them is all either number means. A source that is not spatial gets none, the way a global PostProcessVolume gets no box — it is heard the same everywhere.

  • The outliner switches an entity off. Right-click → Disable writes the engine's Disabled tag onto that entity, and the row is struck through — the eye beside it means something else, and always did: hiding stops the drawing and leaves the entity in the world. Only the entity the author picked carries the tag; which of its descendants that takes out of the game is derived while it runs, so switching a boss back on cannot un-switch a prop that was switched off on its own. set_entity_active is the same door for automation.

  • A bitmap font is an asset the editor knows. BitmapText has shipped with a font slot since it existed, and no .fnt could fill it: the editor had no type for one, so a bitmap font read as an unknown file and the slot refused it. The pixel-RPG template's signpost is lettered with one now — the first bitmap text in the corpus.

  • The starfield drifts by Velocity. Forty stars each had their y decremented by a system every frame, which is the one thing the engine's own Velocity component does — and nothing in the corpus had ever carried it. The prefab does now; the scroll system is down to putting a star that has left the bottom back at the top, and Star is the tag it always was.

  • Six components a shipped scene now authors. The hull bar's mask in space-shooter, all three trails in trail-demo, a crosswind through the third-person demo's ambient motes, a costly patch of mud in the 3D AI example, and that example's patrol posts — Marker entities the scene places, so where a hunter waits is level design rather than a number in a system. One of those posts ships switched off, which is the first thing in the corpus to use Disabled and the only place it can be watched working: a query answers with three of the scene's four posts, and no hunter is ever sent to the fourth.

  • A build keeps the page a bitmap font names. The cook has a rule for this — a .fnt names its page as a sibling in TEXT, nothing else in a project names that image, and an unscanned one ships a font that 404s. The rule compared the .meta type against bitmapFont, which no importer has ever written; the pipeline test supplied that spelling in its own fixture, so the rule and the test agreed about a value no real asset could carry. A gate now holds every type the cook reads against the ones an import actually writes, which turned up a second: json — a game's own data table — was a .meta type the editor's own list did not have, so a spawn table read as an unknown file.

  • A disabled entity is actually skipped. Disabled's doc promised that "the engine's systems skip it" and nothing read the tag: setEntityActive returned, every query went on answering with the entity, and the only record of this was a comment in the UI builtins explaining that a verb built on it "would look right in the inspector and change nothing on screen". Queries now exclude disabled entities — the one place every system, including the AOT-compiled ones, meets the world — and the query cache watches the tag, so switching one invalidates what was already found — charged against the tag rather than the hierarchy, which moves on every despawn and would have dropped every cached query on unrelated churn. A query that names Disabled still sees them, because managing the switch means reaching what is switched off, and setEntityActive takes the whole subtree with it: a character switched off with its sword still swinging is not switched off.

  • A sorting group in the sprite demo. The component that makes a subtree sort as one unit — the fix for a character whose sword draws behind the wrong prop — had a pixel criterion of its own and no instance in any shipped scene. sprite-rendering now carries one whose member claims a layer nine levels above the group's, so what the group takes over is visible on screen.

  • Every 2D collider shape and joint, authored in a scene. The capsule, segment, chain and polygon colliders and three of the six joints had no instance in any scene either. physics-playground's showcase now hangs a pendulum on a distance joint, drops a capsule onto a segment rail, welds two crates, lays a chain of edges as terrain, and drives a motorised cart up a polygon ramp — which is the one of those a box cannot be.

  • A joint's anchors say whose body they are on. anchorA is on the CONNECTED body and anchorB on the joint's own entity, and nothing said so: the fields are two identical-looking vectors whose defaults pin both centres to a single point rather than keeping the offset they were placed with. Both now carry that in their tooltip, along with the 3D joints' single anchor, which is in its own entity's frame instead.

  • Every 3D collider shape and joint, authored in a scene. physics-3d carried 45 boxes and one hinge, and that was the whole corpus: the sphere, capsule, convex and mesh colliders and four of the five joints shipped with no instance in any scene anywhere, not even a fixture. The example now rolls a ball down a mesh ramp, topples a capsule, hangs a lamp on a distance joint, welds two crates together, pins a ball-and-socket and runs a lift along a slider.

  • The UI controls demo authors its widgets instead of building them. Every built-in widget shipped twice — a factory a game calls, and a prefab the editor's Create → UI menu drops, generated from that factory — and only the first was ever exercised: no scene in the corpus carried a UIToggle, a UISlider, a UIDropdown, a UIDialog, a UIScroll or a TextInput, so "place one and it works" was a claim nobody had made twice. The demo now places all nine, exclusivity included (a UIToggleGroup on the toggles' common ancestor), and its code answers what they do rather than building them.

  • A 3D body is the shape its collider names. Only BoxCollider3D had ever worked. Reading a builtin component off an entity that does not carry one answers with a default-constructed value rather than nothing — and its enabled is true, so the body builder took the box branch for every entity and built a sphere, a capsule, a hull and a mesh alike as a 0.5-metre box. Nothing noticed because no scene in the corpus had ever authored any other shape: a ball sank to the floor and sat there, and a capsule stood where it landed. Every collider read is now behind the has check its sibling in ColliderShape3D already had.

  • A ScrollView scrolls where the editor drops it. The widget builds its parts and its behaviour together in code, so the prefab behind Create → UI → ScrollView carried only the parts: a box that clipped its content and never moved unless game code went looking for it. UIScroll — the component whose whole purpose is to be authored in a scene, and which the behaviour plugin already adopts into a live scroller — was the missing half, and the prefab now carries it, pointed at the frame that moves rather than the window it moves behind.

  • A spatial source you can hear in the audio demo. Nothing in the shipped corpus had ever set AudioSource.spatial, and no scene anywhere carried an AudioListener — so the warning the engine logs for a spatial sound with no ear in the world had never been seen by anyone, and neither had the feature. The demo now orbits one around the camera that carries the listener; the scene authors the clip, the distances and playOnAwake, and the code only moves the entity.

Changed

  • A playable ships its game deflated. The engine's glue and its wasm already travelled compressed; the game's own bundle — the largest span in the page — travelled as source, and against the 2MB cap the strictest network enforces that is the difference between fitting and not. The corpus's biggest playable had crossed it, at 2.10MB. The bundle packs like everything else now, and a 3KB loader starts it through the same blob script the engine module already needs, so a page that can boot a playable at all can boot this one — nothing new to allow, no eval. That playable is 1.56MB.

  • The audio demo authors its beat's clip on an AudioSource. Which sound the beat is now comes from the scene rather than a path in code, so the asset system brings the clip in with the scene the way a game's own audio arrives. No example or template scene used AudioSource at all — the engine's own audio component had no coverage in the shipped corpus, which is the door #59's silence came in by.

  • The hot-update demo now ships a real 分包. Its two groups take the two modes their flows need: cdn stays remote, because a hot update has to replace it after the game shipped, and pack — the DLC tile strip the 下载资源包 button pulls on demand — is a subpackage, which is what shipping optional content inside a mini-game package means. Nothing in the corpus delivered a group lazily before, so no project produced a subPackage root for anyone to check.

Removed

  • CacheAsBitmap and the bitmap-cache helpers. The component, CacheBitmap, and the per-entity cache store had exactly one consumer between them: their own two test files. Nothing in any render path read them, no scene in the corpus carried one, and the component sat in Add Component offering a performance trade it could not make — its dirty flag was runtime state in an authored document. RenderTexture, which is what the helpers wrapped, is unchanged and documented; caching a subtree by hand goes through it. All four of check-component-fields' declared gaps were this component's fields, and that list is now empty.

Fixed

  • A spatial source is heard where it IS. Audio read Transform.position — an entity's offset from its parent — while every other subsystem reads worldPosition. A hum parented to anything stayed at its parent's origin, and a listener on a child of the camera heard from the camera rig rather than the camera: exactly the two arrangements a game reaches for first, and the only ones that made the alias WorldTransform read like what it was not.

  • An authored playOnAwake brings in its own clip. The scene had already said to play it, but the frame looked the buffer up once and gave up for good if nothing had preloaded that url, leaving a component that silently did nothing and one line in the log. It now loads the clip it names — once per clip, not once a frame, and once only for a clip that cannot load at all.

  • A mini-game's canvas follows its window. It was sized once at boot from getSystemInfoSync and never again, so any later change — a rotation, a foldable, split screen, or a host that opens in the other orientation from the one game.json asked for — left the canvas in the old coordinate space while touches kept arriving in the window's. The game still rendered, and stopped answering taps entirely.

  • A remote group with no CDN root loads from the package. Its bytes ship inside the build (editor Play, a mini-game with no CDN), but the load path fell through to the asset's IDENTITY, which for a remote group is its authored address — a name the package does not carry. A hot-update demo exported to WeChat could not draw its own remote texture: Failed to load image: assets/cdn/art.png, while the file beside it was remote/cdn/assets/cdn/art.ktx2.bin. Where the bytes are is the realm's question, so its resolver answers it.

  • A mini-game reads an unset storage key as absent. wx.getStorageSync answers a key that was never written with '', and the adapter passed that up as a stored value — so Storage.getJSON handed it to JSON.parse, which throws on it. A game booted with one warning per JSON key it had not written yet (Failed to parse JSON for key "achievements"), and has() reported keys that do not exist. null means absent, as it does on the web.

  • A WeChat 分包 root carries the entry file the vendor demands. With the phantom roots gone, the export hit the next requirement behind them: devtools refuses to compile a package whose subpackage root has no game.js, naming the missing file rather than the rule (未找到 ["subPackages"][0]["root"] 对应的 /subpackages/pack/game.js 文件). A root of pure assets is not a subpackage to WeChat. The profile declares what its vendor wants there and the export writes it, so a criterion can hold every declared root to it.

    Nothing could have found this before a real root existed — the check never got far enough to run.

  • A folder that is no longer a 分包 stops being declared as one. A group is a name plus a delivery, and the name outlives the delivery: a folder marked always include keeps its group after its mode goes back to local. The WeChat export read the name and declared subpackages/<name> for it, so a project with no subpackages at all could still fail to open with ["subPackages"][0]["root"] 不存在. Only lazy delivery is a 分包 now.

  • Play always reaches a stage you can read. Pressing 运行 could sit at "启动中" with no error, no game, and nothing to do but restart the editor (#57). Three independent causes, each enough on its own: two of the boot's three legs had no deadline while the third did, so a hung leg was indistinguishable from a slow cold project; the effect that runs the boot was keyed on a projection of the stage, so an attempt could exist that nothing would ever settle; and start() resolved when the realm had been HANDED the scene, so the toolbar said "running" while the Game panel still said "正在启动游戏…".

    Every leg carries a deadline and names itself when it gives up, the boot is keyed on the attempt, and a session is "running" when the realm reports ready — or failed, with what stopped it.

  • Multi-touch: two on-screen buttons can be held at once. On a packaged Android or iOS game, pressing a second button let go of the first — "the last press cancels the others" (#56). Two layers were single-finger.

    The hosts collapsed every finger onto one id: Android read pointer index 0 whatever the event was about, and iOS set multipleTouchEnabled = NO and dispatched anyObject. Both now feed one id per finger, alive from its start to its end, over the contract in native/host/platform/touch_stream.hpp that a test holds off-device.

    Above them the UI hit-test read the synthesized mouse, so only the primary finger could press anything. It now tracks one pointer per finger: each holds and releases its own control, a control two fingers hold stays pressed until the last lifts, and a finger that slides off before letting go releases without clicking. Gestures — drag, scroll, sliders — stay on the primary pointer.

    InputState.touchesEnded is a Map<number, TouchPoint> rather than a Set<number> (@beta): a release is hit-tested where the finger lifted, and the live touches no longer hold it.

  • A WeChat 分包 is a directory the package carries. A folder marked subpackage in the editor staged its assets where they were authored (assets/level2/), while game.json declared the root subpackages/level2 — a directory that was never written. WeChat refuses the whole game for it: ["subPackages"][0]["root"] 不存在 (#58).

    Delivery now decides the layout, so a lazy group's files land under its root whether or not the build content-addresses names; and the subPackages list is read off the STAGED paths, so a root the package lacks can no longer be declared. A member that cannot travel in a subpackage — a scene, which every exporter addresses by its logical path — is named in the build warnings instead of silently breaking the load.

  • A cooked mini-game plays its sound effects. The cook re-encodes tap.wav to assets/<hash>.mp3, and a mini-game player is handed a URL rather than bytes — but the asset loader handed it the AUTHORED path, which is the cache key, not a file the package carries. Every preloaded clip pointed at a name that no longer existed, so an uploaded WeChat build was silent (#59).

    A backend now declares what it needs to play a clip (PlatformAudioBackend.delivery: bytes or url), the resolved source is what reaches it, and a url backend is no longer made to wait on a fetch whose bytes it then drops.

[0.64.0] - 2026-09-12

Added

  • A 2D light can take the shape of a texture. Every light was a circle or a cone, and a lantern's ragged glow or a window's shaft was not expressible at all. Light.cookie is a texture whose ALPHA is the shape: drawn where the light is, turned by its entity, sized by cookieSize or by the light's own reach, and multiplied into the falloff rather than replacing it — so a shaped light still fades out at radius.

    It is drawn into a screen-space mask, a channel per shaped light, which is the machine the 2D shadows already are: one quad per light instead of a texture slot per light, and any number of distinct cookies without an atlas to pack them into. Four shaped lights fit a frame; past that a light lights without a shape, the way a fifth caster keeps lighting without casting.

  • A 2D light can be shaped, and its shadows can be less than total. A Point or Spot light faded from its own centre to nothing at radius, in a straight line, and there was no other line available. innerRadius holds it at full strength out to a radius of its own and fades over the band that is left; falloff is the power that ramp is raised to — above 1 the light pools near its source, below it the light reaches further and then ends. shadowStrength says how much of the light a shadow takes away, because real shade is lit by everything that bounced and 1 is the only value that cannot be.

    All three default to what the engine already did, so every scene renders as it did; the criterion that says so runs beside the three that change one field each.

  • A .psd file imports. A layered document is how 2D art is actually authored, and the engine could read none of it: the way across was Photoshop's own export, a folder of PNGs whose arrangement nothing records, so a character came back as a pile of parts to be placed by hand again every time the art changed. A PSD now becomes ordinary project files — a PNG per layer and the .esprefab that assembles them — so nothing downstream has to learn what a PSD is. The parsing is ag-psd's; what the engine owns is the translation, the same division the FBX import draws.

  • A sprite states where it sits inside its sorting layer. A painter layer already ordered by transform z, so within one layer the answer was "move it in Z". A Y-sorted layer drops z from the key entirely, and there the hole had no workaround at all: nothing an author could write kept a shadow under its owner or a weapon over the hand holding it, except moving the sprite in Y and lying about where it stands. Sprite.order is the explicit answer and it outranks both — layer, then order, then stage, then depth or world Y.

  • A polygon collider takes any ring, concave and unbounded. Box2D builds only convex polygons of at most eight vertices, and that was the COLLIDER's limit too: an authored notch was filled in by the hull and a ninth vertex was dropped in silence — the limit of a shape standing in for the limit of what an author may draw. A ring is now split into convex pieces that each fit, every piece a shape on the same body.

  • An .aseprite file imports. Aseprite is where most pixel art is drawn, and its documents are frames and tags — "walk is 1 to 6, and it ping-pongs" — where a PSD is a stack. Bringing one into a project meant exporting a sheet by hand, typing the cell size into the texture's settings, and then re-typing each tag's range as a clip; three transcriptions of facts the file already carried, all of them stale the next time the artist added a frame.

    Dropping one in now writes the composited sheet and one .esanim per tag beside it, with each frame's own duration, the direction the tag states (a ping-pong turns around on its ends rather than repeating them), and the anchor of a slice that carries a pivot. Re-importing is the same door, so an edited file reaches the game by saving it.

    The frame composite is the artwork: layers exist so the artist can work, and what plays is what they see — so the stack collapses at import, with every blend mode the format can store, the group switches that hide what is inside them, and linked cels resolved. A tilemap layer is drawn from a tileset rather than from pixels and says so instead of arriving blank.

    The sheet arrives asking for nearest filtering and no GPU compression, which is the one kind of image where both defaults are wrong: a bilinear filter blurs the pixels the artist placed, and a lossy format invents colours a small palette does not have. Its cell grid is re-derived on every import — a resized canvas that kept the old cell size would leave every cell index in the project pointing at the wrong pixels — while the filter and the compression stay whatever the project set them to.

  • A polygon collider can take the sprite's own silhouette. Drawing a collider around art by hand is the one authoring step where the answer is already in the file: the artist drew the shape, and every vertex placed by eye is a chance to disagree with it. Trace Collider From Sprite — on the component and in the palette — traces the outer boundary of the opaque region, simplifies it, and writes the ring. What Box2D does with a concave ring was settled when polygon colliders learned to partition; this only had to produce one.

    Holes and separate islands are deliberately not traced. They are not a coarser version of this answer but a different component count, which is the author's decision rather than a trace's.

  • A texture's geometry is one picture. The 9-slice border had a canvas in the asset inspector — drag the guides on the sprite — and the sheet grid, added alongside it, had four numbers in a list. A grid is the case where numbers are least sufficient: cellWidth is easy to type and impossible to check without seeing the cells land on the art. The canvas draws both now, and is named for what it is rather than for one of the two.

    Where the cells fall is not decided there. sheetGrid in the SDK is the one author of that and the runtime cuts by the same function, so a grid that reads right in the inspector cannot cut differently at load — the editor only carries the cells across the letterbox fit the border is already drawn through.

  • A sprite can be cut by another sprite's shape. 2D needed a hole and had no way to make one: a blood bar that fills, a torch clearing fog, a character seen through a window. SpriteMask turns an entity's OWN Sprite into the stencil — not a second texture field on a mask component, because everything a mask shape needs (texture, size, pivot, flips, 9-slice) the sprite already says, and a second one is a second thing to keep in step with what the author sees. While it is masking, the mask's sprite is not drawn; turning it off puts the picture back, which is what makes "is this masking?" answerable by looking.

    Cutting is opt-in per sprite (Sprite.maskInteraction: VisibleInside for a window, VisibleOutside for a hole), so a mask added to a scene can never make an unrelated sprite vanish.

    Reach is a RANGE, not a subtree. What a 2D mask cuts is rarely its own children — fog belongs to no part of the torch clearing it — so a mask reaches the sprites drawn after it, in the order the author already arranges by layer and order. That is also the order its stencil is written in, so nothing had to be added to the sort key to make the mask come first; a sprite at the mask's exact layer AND order is not cut at all, because those two have no order between them. UIMask keeps the subtree rule, because a UI tree IS its containment.

    GfxStencilMode gains TestOutside (compare NotEqual) on both backends — the engine could only ever test INSIDE a stencil, so a hole was not expressible. The state flags now resolve to a mode through one function rather than in each caller's words: the first version of that mapping had no criterion over it, and sabotage proved it — ignoring the outside bit entirely left every test green.

    The stencil clears on the same terms as depth, which it shares an attachment with. A frame keeping the last one's stencil cuts along a mask that has since moved.

    The reach rule is a pure header (SpriteMaskRange.hpp) held by test_sprite_mask_range, because a frame can show that SOME mask won and never which one the rule chose. Four sabotages, each reddening its own case: reaching backwards, choosing the farthest mask instead of the nearest, ignoring a stated range, and picking a mask that never got a stencil ref — which would test ref 0, every unmasked pixel in the frame.

    What a frame CAN show is held by the sprite-mask pixel scene: one mask, both its sides, and a bar that never asked to be cut. Dropping the resolver paints the frame red; mapping TestOutside to Equal leaves the right half black. An editor check carries it the rest of the way — through the scene file, the reconciler and the Add Component list — and asks what no picture can: that the component can be added at all, and that its range fields stay hidden until limitRange turns them on. And space-shooter now draws its hull as one, because a capability no game has called is a promise with nothing behind it — the fill is cut rather than scaled, so the art never stretches with the number, and the lost segment is the same mask's other side.

  • A subtree can sort as one unit. sprite.order is a promise about one sprite against everything else in its layer, and that stops scaling the moment two assembled characters overlap: raising a weapon over the other character raises it over its own body too, and the only way out was globally unique orders across every entity that might ever meet. SortingGroup states the layer and order a whole subtree presents outward, and each member's own order becomes its place INSIDE the group — so nothing outside can land between two members, which is the one thing a per-sprite order cannot offer.

    The group takes over everything DERIVED from a layer, not just the key: the camera's culling bit and the layer's ordering rule are asked of the group's layer too. Leaving either on the member y-sorts a group through one sprite and not the next.

    Groups nest, and an inner one does not start a fresh identity — a weapon prefab rigged under an arm would drift out of the character. It becomes one BLOCK in the outer group instead, so it stays whole wherever the arm goes.

    Where the member's order LIVES is the whole design. The group owns the key's top fields, so the member needs the highest field left, and it must be the same field in every packing or two members of one group are incomparable — a group holds an opaque prop under a blended character. [37:30] is the only field directly under stage in all three layouts, and it is stamped there after the fact, which costs nothing outside a group and inside one replaces a projection (depth, shader, world Y) the author's order was overriding anyway.

    Held at four levels, each watched failing first: the bit layout in a new header-only test_sort_key harness, the draw path's resolution in test_batch_builder, the editor's picking — which mirrors all of this in layerOrder.ts, or a click selects what the person cannot see — and an editor check on real pixels, where a member whose own layer would put it on top is drawn underneath and a click agrees. Two of the engine cases were TRIVIALLY satisfied when first written (a stated order outranks both depth and world Y, so it cannot be what makes two layer rules disagree) and were rebuilt until sabotage reddened them.

Fixed

  • Opening a project no longer strands the loading overlay. Two callers arm the project-open gate — the entry seam that reveals the shell, and the effect that runs the work — and only one of them joined an attempt already in flight. Open a project and then enter the editor, the order automation uses, and the gate was left on a ticket nobody owned: nothing could settle it, and the only safety timer belonged to the attempt it had replaced. The overlay never lifted.

  • A shader's comments stay out of the binary. A third of the engine's embedded shader source was comment — ten kilobytes of prose riding into every game, and into a playable's single file where the budget is 2MB. Comment lines are emptied at embed time rather than removed, so a shader's diagnostics still name the line they came from.

  • A WGSL twin no longer declares the engine's own texture bindings. A twin that writes its own vertex stage had to spell out every tN/sN it touched — a convention the engine owns, where forgetting one is an invalid pipeline that mentions no shader. The assembler now completes the set from what the stage reaches, leaving anything the twin declared itself alone, so a cooked (wgsl full) shader assembles unchanged.

    The rule had been copied into three places — the assembler's emitters, the WebGPU backend's bind-group reflection, and the twin generator. The unit→binding convention and the two source scans are one header now (rhi/WgslBindings.hpp), which the assembler emits from and the backend reads back with.

    check-wgsl-twin asked twins for those declarations; that question cannot fail any more, so it stopped asking and lost eighty lines. What it still holds is the varying struct, which is nobody else's to supply.

  • A shader that fails to compile says why. ResourceManager asked the device to build a program, got a reason back, and logged "Failed to create shader from source" without it — so the one thing that could have named the problem was the one thing dropped. It prints the device's own log now, for both backends.

    And on WebGPU the device refuses a WGSL stage that reaches a tN/sN binding it does not declare, naming it. That is an unresolved identifier, which WebGPU reports as an invalid pipeline with no shader named anywhere in it — an error that costs an hour to place and reads as a renderer bug. The repo's own shaders are held to the same rule by check-wgsl-twin before a push; this is what answers for a material somebody else wrote, where no gate of ours runs at all.

  • A 2D shadow caster can carry its own outline. Every occluder was a box, so a round prop threw a rectangle and a wall that was not rectangular threw the wrong wall. ShadowCaster2D.path is the shape itself — three points or more in the entity's own space, placed and turned by its Transform, and the box stands where there is none. The shadow pass already drew rings rather than boxes, so a polygon costs what its point count costs and nothing else.

    The editor's Trace Sprite button produces one: the same silhouette trace the polygon collider has had, now writing into whichever ring is asked for. The one thing the two do not share is units — a collider speaks physics metres, a caster the world's own — so the target states which, and an editor check measures a traced disc's rim to hold it.

    What it needed was a boundary that can carry a point list. One now crosses to the web as a JS array and to a native host through a generated pair of bindings — its storage is a pointer, so it can never travel in the zero-copy component buffer the rest of a component's fields cross in. A field type the boundary cannot carry is refused at generation time instead of failing when a scene adds the component.

  • A 2D shadow caster turns with the entity it is on. Its box was built from the entity's world position and its own size, and from nothing else: a wall laid at an angle cast the shadow of an upright wall, and turning the wall changed nothing on screen. The box now turns the way a collider on the same entity does — the size stays the caster's own, so scaling the entity still does not resize the occluder. The editor's shadow extent turns with it, or it would draw a box that is not the one casting.

  • A camera drawing half the screen now keeps to its half. A camera states the rect it draws into when it opens its frame; the engine took that rect back off the DEVICE later, after the collect, where it was whatever the last thing to touch the device had left behind. So a second camera covered the first, and split screen — two cameras with half the frame each — drew one of them over the whole of it. What it looked like was the second camera's view at full size, which reads as a camera that was never set up rather than as a viewport that was ignored.

    The rect is now taken where it is stated, and a zero size still means the whole target. Two criteria cover it: two cameras with a half each, and the same split with 2D shadows in it — the mask is screen space, so what a fragment reads has to be the part of it its own camera filled.

  • A polygon collider is drawn as the polygon it collides as. The overlay drew the authored ring while the solver saw the pieces it was split into, so the two disagreed exactly where an author would look to find out why.

  • A ring of more than eight points keeps its collider. A twelve-point ring whose first eight are collinear — what the editor's insert makes of one edge subdivided repeatedly — decomposed into no pieces at all, and the collider silently ceased to exist.

Changed

  • 2D shadows are drawn, not solved. A 2D shadow used to be an analytic test inside every lit fragment: eight axis-aligned boxes rode in the lighting block, and each one was intersected against the segment from the pixel to the light — for every pixel, for every light. Eight is a room with two walls in it, and the way to raise the number was to make every pixel on the screen pay for it. The engine's own lighting example capped the obstacles a player could place at six and said so in its README.

    The shadow is now rasterised. Each frame the engine takes every enabled ShadowCaster2D, finds the silhouette each casting light sees it by, and draws the region behind it into a screen-sized mask that a lit surface reads one texel of. So the occluder count is a vertex count rather than a shader constant — a scene may hold as many walls as it has — and an occluder's SHAPE stops being a constraint of the test, because the shadow is geometry.

    What is capped now is how many lights cast at once: the mask has four channels, so the first four casting lights get one each and a light past that lights the scene without shadowing it. That is a failure a 2D scene can look at and understand, which "some of the walls stopped casting" was not.

    Softness is the same knob and a better shadow: a source with width is sampled across, each sample throws the silhouette it sees at its own share of the strength, and the shares add — so the penumbra is whole where the whole source is hidden and a fraction where only part of it is. A directional light's shadowDistance is now how far its shadows are CARRIED rather than how far a fragment searched back for an occluder.

    The engine's Lit shaders spend their top texture unit on the mask while one exists, which costs a sprite batch one merge slot in a scene that has 2D shadows and nothing at all in one that does not.

    The mask is a target the frame renders and then samples, and the two backends store the rows of one in opposite order — so the height in the lighting block carries a SIGN saying which. It cannot be a compile-time branch: one shader source serves both backends, because the WGSL a material runs is translated from the GLSL. Read upside down the effect is invisible in any scene that is symmetric about its middle, which every criterion here was until one of them stopped being.

  • One curve, sampled by everything that has one. A timeline channel carried keys with tangents and six interpolations, drawn by an editor that understood them; a particle's size-over-life carried {t, v} pairs joined by straight lines; and the Inspector's curve control carried a third copy of the second. Three shapes for "a value that changes over a span", and the seam between them was invisible because each half worked — a particle curve simply could not be told to ease, and nothing said so.

    math/keyframes now owns the shape and the sampler. evaluateChannel is one call into it, bakeCurve is another, and TimelineTypes re-exports rather than restates. A particle curve gains tangents and all six interpolations by arriving; where time runs stays the caller's — seconds for a timeline, 0..1 of a life for a particle.

    The editor's curve control now DRAWS through the same sampler instead of connecting its points with straight lines. An eased or hermite segment used to look straight while bending in the game; what an author sees is now what the sim bakes, by construction rather than by keeping two renderings in step. Its selected key gained an interpolation picker, which is the field the old shape had nowhere to put.

    BREAKING (@beta): ParticleEmitterData.sizeCurve keys are { time, value, inTangent, outTangent, interpolation? } rather than { t, v }. Nothing exported the old type, so a curve could only be written as a literal; the two fixture scenes that held one are migrated. A curve whose keys are not finite is now REFUSED with a warning rather than baked — the old shape read as NaN, and a particle sized NaN does not draw, so the emitter vanished with nothing said. Falling back to start/end size is wrong, but it is visible.

    GradientStop is deliberately NOT folded in: a colour stop is not a scalar key, and one shape for both would be a name over two things.

[0.63.0] - 2026-09-10

Added

  • One number turns the sky, the irradiance and the reflection. An HDRI arrives in the frame its photographer stood in, and moving a reflection to the other side of a model meant re-authoring the image outside Estella — nothing in the Light schema, the .hdr import settings or the .esenv document expressed an orientation. Light.environmentRotation is degrees about +Y, on the light rather than in the .esenv, so one bake is reusable at a different angle in another scene. Every direction that asks the environment anything passes through one envDirection, which rules out turning the sky without turning the reflection by construction; the alternative — a rotation applied at each call site — is three chances to forget one. The fixtures had to be built before anything could be claimed: every environment scene in the tree is azimuthally symmetric, so a rotation reads identically at every angle and any criterion over them passes a rotation that does nothing.

  • A second UV set survives the import boundary, through glTF and FBX both. An unwrap produces a UV1 for a lightmap, a detail pass or an AO atlas, and every exporter writes it. Estella read TEXCOORD_0 and dropped the rest, with no warning — the AI-DCC walkthrough measured it: Blender made two sets, the GLB carried two, the .esmesh had one, and nothing said so. This is the one loss worth closing before it is needed. A missing feature can be added whenever; information discarded at import cannot be recovered without re-importing every asset that came through in the meantime, and by then there are thousands. Nothing reads UV1 yet, and that is deliberate — no lightmapper, no graph node, no material change. The bytes are kept. The format was built for it: the channel table is written into the file rather than implied, so TexCoord1 = 7 is an append to the vocabulary and not a version, and it sits at the last location before the per-object record, which is fixed precisely so a mesh gaining a channel cannot move it.

  • The camera a frame was drawn with is a value anyone can hold. UICameraInfo is rewritten in place twice a frame — an early peek that must not tick the director's blend, then the authoritative resolve the renderer draws from — so a reader on its own clock could hold a camera no frame was ever drawn with. Not the previous one: a third state, arrived at and discarded inside one frame. CameraCommit is published once after the submit, carrying a COPY, and PresentedCameraView projects over it. One near plane, two cameras: a wireframe cut by one and drawn by the other comes apart exactly where a segment leaves the view.

  • A commit says when the camera CHANGED, not when one happened. A commit is published on every drawn frame, so "a commit happened" is true sixty times a second and says nothing about what is on screen. commitCamera compares the projection it is about to publish against the one already there and announces only a difference — exactly, because the question is whether the projection moved, and an epsilon drops a slow drift a frame at a time. The editor's viewport has sixteen places that can move the eye, and announcing from each of them is a rule sixteen callers have to remember.

  • A renderer-owned geometric overlay, with colliders, extents and the transform gizmos as its consumers. The editor's 3D overlay geometry leaves the DOM and is drawn by the engine, inside the same pass and from the same resolve as the scene — so there is no second camera to keep in step with the one that drew the picture. Screen-space overlay lines are part of that surface, so a gizmo keeps its pixel width without a projection of its own. The geometry is also clipped to the viewport it belongs to now: worldToScreen keeps the coordinates of a point outside the view and nothing clipped it, so on world-streaming-3d 322 of 496 endpoints were outside the canvas and the SVG drew every one, over the editor's other panels.

  • A capture carries the brackets inside a phase, apart from it. An editor phase can be timed in parts — a viewport tick split into the grid, the collider wires and the rest. A part is time its parent already counted, so folding it in with the phases would inflate the frame it belongs to and let the largest bracket be read as the frame's dominant phase. parts is its own map, and optional: a capture written before they existed has none. profile_frames can answer for the editor itself, which is how the overlay work above was measured.

  • A volume's effects are an authored field, not just scene data. Fifteen effects shipped, the scene format carried them, the 3D flagship used SSAO, and a creator could reach none of it: PostProcessVolume's Inspector showed only where the volume applies while effects, the list that says WHAT it applies, was refused by name — value-shape inference drops a list of objects. The opt-in says what the list IS, so the rows are generated from the effect registry and an effect the engine registers becomes authorable with no UI of its own. A panel per effect would be a second place to forget one. Nothing about the runtime changes.

  • Go to Anything — assets, entities, panels, commands and settings in one place. The editor's search was strong and scattered, and nothing could take the word "player" and show the entity, the prefab and the script at once. Three ownerships are kept apart on purpose: a provider owns DISCOVERY, a domain owns the EFFECT — accepting an asset row calls the same opener a double-click does, an entity row selects, reveals and frames through view.frameSelected — and Quick Open owns ranking and presentation and nothing else. Discovery happens once per opening rather than per keystroke, which makes the list stale by the time Enter lands; that is the correct trade, because a row is an intent and the door it calls decides against the world as it is then.

  • Third Person Character is something you can ask for. The runtime has had every part of this for a while — a character controller, a controller that reads the stick against a camera, a camera that orbits a target. What it had no way to express was the ASK: an author had to know the four component names, that a body goes underneath, that the camera is a second root, and that the two halves point at each other. Create ▸ Gameplay ▸ Third Person Character produces the composition the flagship example actually uses, read off its scene rather than invented — a second "recommended setup" that drifts from the one the engine is exercised with would be worse than none.

  • Every open document reconciles a change made on disk. The watcher reconciled the scene, and the prefab in Prefab Mode. Every other open document — behaviour tree, state machine, animator, material, material graph, tileset, flipbook, timeline — kept editing a file that no longer said what it held, silently, until a save overwrote the other version. A git checkout, a generator, an edit in another program: all invisible. Clean reloads seamlessly, dirty asks and takes "keep mine" as an answer rather than a deferral. "Is this our own write coming back?" is answered by comparing the bytes on disk with what the document WOULD write, rather than by remembering what we last wrote — which is a second copy of the answer to keep in step.

  • A build belongs to the editor, not to the window that asked for it. Everything about a package job lived as React state inside the Build dialog, so preflight counted as idle: a second click started a second preflight and could reach a second export into the same directory, and closing the dialog cancelled nothing — it only removed the one surface that knew. The attempt now begins at the first click and lives outside the window, and its spec is frozen when it starts, because a build reports on what it was asked to make rather than on whatever the form has been edited to since.

  • A slow plugin says so where the plugins are listed. PluginHost already timed every plugin callback and nothing read it, so "why did the editor get slow" was answerable only by someone who thought to open the profiler, while the list of suspects sat one panel away saying nothing. The panel projects the plugin's costliest callback over the window, when it is past a fraction of a frame — no second timing, because a plugin measured twice is two answers to one question.

  • A health report says which moment it is a reading of. The panel takes a reading on open and holds it still on purpose; what it also did was keep LOOKING current after the project moved, and an old verdict worn as the present one is the failure this preflight exists against. The report carries a pulse of the inputs it was made from, and the header says so beside the Re-check it belongs to. Freshness is "has anything the verdict was made of moved", never "would the verdict differ" — the second question is running the checks again.

  • A drop target answers while the pointer is still down. An asset slot called preventDefault on every dragover — the browser-level promise that a drop will be taken — and only checked the type on drop, where the write door refused it: a font lit a texture slot green and then produced an error toast. During dragover the DnD data store is protected and a target genuinely cannot see what it is being offered, so the payload now lives in the process for the length of the gesture, and the answer is produced while hovering and CONSUMED by the drop rather than recomputed. The viewport stage, the Outliner row and the last two targets all answer from the payload rather than from the shape of the drag.

  • Every discrete camera intent travels, and automation still lands exactly. Frame Selected, Frame Design Screen, the axis presets and the user's view reset all go through one drive; Frame Design Screen derives its whole target before anything moves, so its position and zoom cannot come apart. Reduced motion arrives in the call that asked for it, and Frame Selected lets go the moment a hand arrives.

Changed

  • One palette. Two palettes with two enablement projections is how Ctrl+P comes to say Build is enabled while Ctrl+Shift+P says it is disabled, so the command palette is gone rather than kept alongside: both keys open the same component, one showing everything and one scoped to commands. palette.open survives as a command id — that is the user's vocabulary, and what a keybinding, a menu entry and a plugin all name; only the surface behind it changed.

  • The load overlay lets go for a reason, and says so afterwards. The gate recomputed whether it was blocking from the pending list, so "you may come in" and "everything finished" were the same fact: a safety timeout that had let someone in was undone by the next task to report, and a task that FAILED never settled at all. Release is terminal now and carries why — ready, degraded, timeout, aborted — and the tasks keep reporting after it.

  • The build gate follows the run out of the dialog, meshShaderReads is held against the shader it is a claim about, and comment-style weighs the block rather than the lines a commit happened to touch.

Fixed

  • A scene holding an instance of a re-imported model can be saved again. The override diff took the UNION of the base's and the instance's component keys, so a key the base carried and the instance did not was diffed as an override whose value is undefined — and the diff's deep clone cannot serialise that (JSON.stringify(undefined) is undefined). save_scene threw "undefined" is not valid JSON and went on throwing on every attempt after, so a creator whose DCC model round-tripped could no longer write the scene at all, and the preflight then correctly refused the package because a build reads what is on disk. Re-importing a model nothing references saved normally; what broke it was having an INSTANCE of the re-imported asset in the open scene, which is the whole point of a round trip. A component's schema owns which keys exist — which is why the vocabulary has metadata_removed and no property_removed — so an instance captured before the base gained a field now INHERITS it. Shipped in every release since 0.13.0; the AI-DCC corpus is what finally walked into it.

  • The editor document loads as a transaction, newest intent only. Five paths reach the two irreversible sections — project adoption, an external-change reload, openScene, openPrefab, newScene — and none was ordered against the others, so two scene opens, or a scene open crossing a prefab open, interleaved releasing the outgoing scene's assets, clearing history and selection, and rebuilding the World. A lane is not enough for a document whose steps cannot be abandoned halfway: loads never overlap, and only the newest intent runs.

  • One project open at a time, claimed in the store. A project root is process-wide authority — adopting one flushes the previous project's workspace session, re-points the main process and arms a scene bootstrap — and two of those interleaved leave the last writer's state beside an earlier one's bootstrap: one project's scene loaded into another. Clicking a recent project called through with no busy identity at all. The claim is in the STORE because five callers reach it, and a gate on one of them is not a gate.

  • The document a surface opens is the last one asked for. Opening a document is read-before-open, and two opens inside that window raced: double-clicking B while A was still reading left you looking at A, and A's later failure popped an error about a file you had already navigated away from.

  • A scrub the OS takes away aborts instead of hanging open. useScrub heard pointerdown, move and up. A pointercancel — a pen leaving the digitiser, a touch the system turns into its own gesture — left the drag in the ref and the transaction open for the rest of the session, so every later edit folded into that one undo step and the value it happened to stop at stayed.

  • A retired play attempt cannot speak for the one that replaced it. The settles asked whether the stage was still starting, which two different attempts both answer yes to: stop a session mid-boot and start another, and the first realm's "it came up" landed on the second, marking a session running that had not begun.

  • A residency reading is published when it changes, not when it is taken. The poll built a fresh object every 400ms and handed it to the store unread, waking every subscriber four times a second for a world that had not moved — and in the edit realm there is no running world at all, so the same absence was being announced as news.

  • A health finding's asset location is reachable. scene.entry emits an asset location — the entry scene the manifest names but the project does not have — and every consumer read only the entity, so the finding that most needs somewhere to go was the one with no way to get there.

  • The export door stays one door the health gate can read. Splitting a private implementation out of exportGame moved the preflight, the refusal reason and the cook-option derivation past where check-project-health looks; it reads the door as one method on purpose, because adjudicating after the cook leaves half a package behind.

  • Reduced motion skips the transitional phases, not just the hold — an opening surface used to spend entering waiting out two frames, which with transitions near zero is a delay before anything appears rather than a gentler animation.

  • Gizmos align with the presented camera and are built from world geometry, so what a gizmo is drawn over is what the frame was drawn with.

  • A Windows path is not a module specifier; the census criteria can fail on the platform they guard; the open-race contract holds under load, not only alone; and the signing-mechanism rule can read a checkout whose line breaks are CRLF, rather than reporting the step it cannot match as one the workflow lacks. The workspace-continuity probe no longer copies the source example's own .esengine/workspace.json into the project it calls session-less — gitignored, so whether it existed depended on whether anyone had opened that example on the machine, which is why the isolation clause was red locally and green on CI.

Performance

  • A settled viewport paints nothing. The overlay rewrote every gizmo, wire and grid line on each browser frame whether or not anything had moved. Measured on world-streaming-3d — eighteen entities — that held the editor at 7-15fps with gizmos on and 60 with them off, on 0.55ms of JS: the cost is not the JS, it is what Chromium does with the SVG afterwards, which no bracket inside the frame can see and only not writing avoids. The overlay is quiescent rather than "wake and check", because a hundred later overlay features cannot each poll for their own changes, and the camera announces instead of being polled — a scheduler keyed on CameraCommit.revision never settles, since that advances on every drawn frame. At rest: 60fps and two paints in 2500ms, where it was fifteen hundred.

  • What a necessary overlay paint costs, settled by counterfactual. A frame carrying one committed camera change cost 116.7ms with the overlay on and 16.7ms without, over four arms on the same stimulus — one camera change per frame, so a slow arm is not measured on a smaller stimulus than a fast one:

    arm frame rate what it did
    A 116.7ms 9fps projections, writes, rendered (as shipped)
    B 16.7ms 60fps projections, no write
    C 16.7ms 60fps projections, only the transform gizmo's own root
    D 16.7ms 60fps projections, every write, layers display:none

    Overlay JS is 0.7-1.05ms per paint in all four. D lands 26,397 writes and still holds 60fps, so the mutation calls are not the cost; C lets the gizmo root's own 344 through and holds 60fps, so no single gizmo is. What remains is the browser rendering 28 mutated geometric layers — which is the case for owning them in the renderer rather than making the writes cheaper, and is what the renderer-owned overlay above does.

[0.62.0] - 2026-09-08

Added

  • Play streams the world the way a package does. The editor's Play realm used to load a streamed scene whole, so the one thing a creator could not rehearse was the thing streaming exists for: what is resident when. Play now cuts the world through the same partition the cook uses — one author, one set of cells — and worldResidencyReport(app) answers in both realms. Verified by reconciling the two rather than comparing pictures: a package and the editor boot the same four cells, resident on the same one, holding the same documents, because a place that is not drawn and a place that is not there look identical from a camera.

  • World Workspace: the report says where its cells are. Every list in the residency report was names, and a name cannot be drawn — a viewport that wanted to shade a cell had to find its coordinates in a second copy of the partition. cells and cellSize carry the manifest's own answer, so there is one, and the editor's World panel reads it rather than deriving its own. unavailable now owes a citation: the premise behind residency's ("neither the edit realm nor playHost passes a cooked world") had outlived the release that removed it, in a green gate.

  • Readying is a named preparation phase. settleReadiness_ emitted no onPhase, so its ~6.5 ms showed only as the gap between issue → prepared and the phases that had names — 68.4% of the interval accounted for. Named, the interval closes to 98.7%, and the claim becomes positive: the compile is THERE, in preparation, on the shipping build.

  • Workspace Continuity: a project reopens where it was left. WorkspaceState held a last scene and a panel layout nothing ever wrote. It now carries the authored working context — open documents, the selection (an authored id, never a runtime handle), the camera, the browser folder, the World view — and RecentEntry reads the document a project was last on from that project's own workspace. It deliberately carries no residency, no prefetch counters and no "was playing": those ended with the play session, and restoring one would present a stopped game as the state of the world. A scaffolded project keeps .esengine/ out of source control, without which the zero-diff claim held only for whoever wrote their own .gitignore.

  • Project Health / Preflight: whether a project can ship has one author. The answer used to be spread across a build's own output, the scene validator, the cook's decisions and the platform probes, with each consumer asking its own half. The checks are now a declared list, every consumer reads the report, and each finding declares the world it is true in — "this viewport got 1x multisampling" is a fact about the machine the editor runs on and says nothing about what an Android package will do.

Changed

  • A build is adjudicated once, at every door that can package. The Build dialog asked the preflight and refused past a blocker; export_game — the agent's door, and what an automated build uses — called the exporter underneath the store and asked nothing. Both now pass through ProjectStore.preflightBuild, and a refused build answers { exported: false, reason: 'preflight-blocked', blockers, warnings } before the exporter is called, so nothing is written. Warnings do not refuse and ask for no force.

  • An edit that will not be in the build stops it. Play reads the unsaved authoring snapshot and a build reads what is saved. The divergence is right — packaging memory would give up reproducible builds — and the silence was not: moving an entity across a cell boundary and leaving it unsaved, Play re-partitioned while the package was written from the older state, and the build reported success. project.dirtyBuildInputs is a blocker, and counts build inputs only.

  • The Spine runtime-version row says what it does. It promised that "a build ships the one named here and no other"; a build detects the version of each skeleton and carries the runtimes those need, and nothing reads the field. The setting stays — removing it would break every project that holds one — and the claim does not.

  • The gate list can be surveyed as well as gated on (--keep-going, --matrix, --only), and a gate that could not answer is no longer counted as one that passed: run-gates speaks the same three exit states as the release runner.

Fixed

  • An empty required field no longer refuses a build. required is soft where it is declared, and the engine tints a white texture when a Sprite has none, so a coloured quad is not a mistake. As a blocker it refused to build the flagship — 28 of them, including the player — while that project plays through all ten of its legs and draws 324 pixel scenes.

  • Seven asset types could not live-load in the editor. Timeline, tilemap, tileset, state machine, behaviour tree, animator controller and anim clip publish BY NAME, and Assets.loadX rejects exactly those; the failure was recorded against the path and read later as a reference resolving to nothing. Three golden projects could not be built through either Build door.

  • A voice cap reaches a package without a bus to carry it. Both gates on the way asked only about buses, so a project setting maxVoices and declaring no bus was dropped twice and shipped the default.

  • The two Build doors produced the same game. The dialog derived cook options from the project; the tool forwarded what it was given, and undefined reads as false all the way down. The same project through the two doors shipped a raw PNG and no basis transcoder one way, and a KTX2 with one the other.

  • set_field no longer demands the type argument its own description calls advisory and its implementation never reads.

  • A point behind the eye has no screen position, rather than a mirrored one inside the viewport; a canvas's pixel ratio is its own window's, not the ambient one; and the transform tool's fake viewport answers the call it makes.

  • A failed export says what the exporter said rather than how its report ended — a run whose only red was a missing wechat runtime used to end with — }.

  • The comment scan reads the editor too and says what it read; the source census is about the directory it runs in rather than the one GIT_DIR pins, which is why it passed standalone and failed only inside a push.

[0.61.0] - 2026-09-06

Added

  • World streaming: a place exists because something is near it, and stops existing when nothing is. A scene loads whole, which is right until the world is bigger than a machine wants resident at once — and then the question stops being what is DRAWN and becomes what EXISTS. The cook cuts an authored world into square cells on the XZ plane; at runtime WorldStreamingSource asks for the places near it, and WorldStreamer is the one thing that decides.

    Three authored declarations and no policy: StreamedWorld says a scene is cut and how big the cells are, WorldPersistent keeps a subtree out of the cutting, and WorldStreamingSource states one need. Several sources are UNIONED rather than folded — a fold lets the last one written decide, and the frame after a second camera exists it deletes the world the first is standing in — which makes split screen, a spectator, a cinematic camera and an editor preview one kind of thing. Distance is measured to a cell's box, not its centre, because a centre answers the same for a source on a diagonal corner as for one a whole cell away. A cell comes in at loadRadius and leaves only past unloadRadius, so a source breathing on a boundary does not rebuild a place every frame.

    Unloading is a real destroy. A cell is an additively-loaded scene, so it leaves through the scene lifecycle transaction that already exists: its entities, its physics bodies, its navigating agents and its asset receipts all go. A place that is merely hidden still costs memory, still collides, and still lets an enemy nobody can see attack the player.

    A subtree is the unit of residency. Only top-level entities are placed, so a door cannot be sorted away from its house even when its own world position falls in the next cell — the version that places each entity separately strands children when their parent unloads. Hard entity references may not cross a residency boundary: same cell is fine, and so is a cell naming the persistent world, but one cell naming another's entity fails the build rather than shipping a handle that dangles the first time a player walks away.

    Residency owns existence and not continuity: a reloaded cell is rebuilt from what was authored, so an enemy you walked away from comes back at full health. What survives is the authored identity, which a save system can be built on. worldResidencyReport(app) publishes counts of things that ARE, per cell, because a cell that is not drawn and a cell that is not there look the same from a camera. See the guide: World → World Streaming.

    A place is readied before it is asked for. prefetchRadius marks cells worth PREPARING — fetched, decoded, their assets acquired — while creating not one entity, so nothing in the world can observe them: no query, no renderer, no body, no enemy deciding anything. Publication is the only thing that makes entities, and it happens when a source actually reaches loadRadius. Measured on Estella's own fixture, walking into a readied place costs 0.6 ms where the same walk cost 19 ms of fetching and decoding.

    Preparation is speculation and never authority: a cell readied for a player who turns around is thrown away and its assets given back, rather than published because it happened to be ready — and a preparation that finishes asks again whether the cell is still wanted instead of assuming the answer from when it started.

    A target that cannot cut worlds now REFUSES a streamed one. Mini-game, WeChat and playable-ad builds return before the cook that cuts cells, so shipping them a streamed world would succeed and quietly deliver the whole thing; that is the same shape as a declaration the runtime never receives, and it is an error now.

    Not in this version: HLOD, an admission budget (measured: the largest atomic main-thread phase of a heavy cell is 7 ms, and the frame it lands on 3.5 ms — there is nothing to slice), an asset memory budget, navmesh or texture streaming, and world origin rebasing.

  • Level of detail: an object can hand over to a cheaper mesh once it is small on screen. A rock a hundred units away and a rock two thousand units away were drawn with the same number of triangles, and at two thousand almost all of them landed inside one pixel. LODGroup sits beside a MeshRenderer — the renderer's own mesh stays level 0, and the group names the stand-ins.

    The thresholds are fractions of the viewport HEIGHT, not distances, and that is the whole design. A distance answers the same for a tower and a pebble, the same at 30 degrees of field of view and at 60, and does not vary at all under an orthographic camera; a screen fraction covers all three and is free of the resolution besides. Each boundary carries a hysteresis band, so a camera merely breathing across one does not swap the mesh every frame.

    The choice belongs to the camera, not the entity. Two cameras in one frame see one object at two sizes and may draw it at two levels; there is no currentLOD on the entity to read or to set. Bounds come from the union of every level, so what is measured does not change with what is drawn — bounds read off the current mesh feed back into the choice that picked it. Culling runs first, and instancing is untouched: choosing a level changes which geometry a draw names and nothing else, so props sharing a level still fold into one instanced call.

    Measured on a receding field (bench/lod/): at ten thousand props, 1.91M triangles and 3.5 ms of GPU become 42k and 0.27 ms, for a quarter of a millisecond of selection CPU. Ten pixel/counter gates cover it, each shown red under the mistake it exists to catch — a world distance tuned to pass the level gate still fails the field-of-view one; bounds read off the current level still fail the level gate; a level memory shared between views fails only the two-camera gate. The third-person sample carries a field of 35 rocks, and verify-third-person reads the levels the PACKAGED game chose.

  • An inventory of what the engine's runtime contract facts actually are. The EsEventOut hole above was not thin test coverage — the ABI compatibility system did not know a fact lived there. Those are different severities and nothing could tell them apart, because nothing enumerated the facts.

    tools/contract-inventory.mjs enumerates them: fourteen, each declaring who AUTHORS it, what is PROJECTED from it, what independently VERIFIES it, and whether a digest covers it. It is deliberately descriptive — no authority moves and nothing is generated from it. What exists comes first; which authorities are worth merging is a decision that needs this list to make.

    Two kinds of finding, and the second is what keeps it from becoming a list somebody remembers. A CLAIM that no longer holds: every citation carries a probe, so an entry pointing at a fact that has moved is red rather than stale documentation. And GROUND with no claim over it: a generated artifact no fact projects, or a C++ contract: pin no fact names, is a fact nobody wrote down.

    The three roles are kept apart, and the checker refuses to let them merge — a file cited as both a projection and the verification of the same fact is a generator being asked whether it generated correctly. That rule caught one on its first run: es_check_sysctx proves the emitted C struct matches the emitted constant, which is the generator agreeing with itself; the independent verification is the sabotage suite.

    Five facts carry a declared gap, so the list reads as work rather than as permission — entityRepresentation and mathPolicy are in no digest at all, and three hand-copied constants are pinned by a test rather than a handshake. Two authors is not automatically a defect: mathPolicy is two independent implementations held together by a bit-exact differential, which proves more than generating one from the other would.

  • Two ways out of an animation: what happened, and how far it asks to move. A clip could declare custom events and nothing read them, and a clip that animated its own Transform posed a character straight through the physics world. Both are answered by the driver now, because only the driver knows how long a clip runs and whether it repeats: events fire on the interval a step CROSSED rather than the instant it landed on and belong to the state being entered, so an attack cancelled into a dodge stops landing; root motion is a REQUEST, published on AnimatorRootMotion in world space with the seconds it covers, for a controller that does not run on the animator's clock.

    Around them, the rest of the loop those two make possible. A melee swing is three separate facts — the clip says the swing reached its moment, physics says what was in that space, gameplay says what that does — so it can be re-aimed, re-timed and re-balanced independently, and one swing is an INSTANCE with its own hit set, because "the event only fires once" breaks as double damage the first time a hit window spans two frames. A hunting character is the twin of ThirdPersonController: perception becomes the same request input does, down the same navigation, the same character controller, the same animator trigger.

  • Emission asks the shape where and which way, instead of asking for an angle. The simulation was already three-dimensional while emission ended at a planar polar angle, and an emitter's rotation reached the spawn as 2*atan2(q.z, q.w) — the quaternion's z and nothing else, so pitching an emitter to spray dust up off the ground kept firing along the plane it was authored in, silently.

    There is no ParticleEmitter3D. There is one question — SpawnSample { position, direction } in emitter local space — so a new shape cannot teach the integrator a new kind of aim. Point and Box keep the planar spread they had, which IS the 2D case; Circle moves into the emitter's own plane; Cone, Hemisphere and Sphere are one cap of half-angle θ about local +Y, where a 2D cone has always pointed. An unrotated emitter is unchanged to the pixel.

  • Screen-space ambient occlusion, over the depth the post chain already binds. No G-buffer, no history, no motion vectors: a sample goes back to the world and the estimator asks what fraction of its neighbourhood is closed off, which is bounded and scale-free — an open plane reads 0 and a wall base about a half, with no per-scene constant to tune. 0.65ms at 1080p.

    Per-pass resolution came with it: rg::TargetDesc::scale was implemented in the render graph and had never had a caller. The AO and blur passes take it.

  • The hitch when something first becomes visible has an author, and it is one shader compile. Splitting collect.mesh five ways showed 242 program asks, ONE compile, and six milliseconds — a variant built the first time anything drew with it. A streamed cell now declares the variants its materials will need while it is being prepared, and PREPARED means those obligations are paid, not just that the assets arrived. The splice measured 12.7ms down to 0.8ms.

  • A mesh comes back after a device loss, into the handle it left. A lost device used to leave every Mesh record pointing at buffers that died with it, and the draw path bound them: invalid-operation errors, frame after frame, for geometry that was never returning. The realization ends and the identity stays, so components go on naming the mesh by the same handle while the geometry is put back underneath them from the source it was loaded from.

  • A texture's compression is two decisions, and each records its own. A cooked KTX2 the device cannot sample is decoded to RGBA and uploaded — correctly, four times larger, and with nothing saying so. A PNG whose Compress row reads ON but is 70x70 ships raw for an entirely different reason. Both read as "not compressed", which is the one thing an author cannot act on.

    The cook's decision and the upload's are recorded apart, and the Inspector shows both: what a build of this project would ship for this texture, with the reason named (the build, the asset, its folder, its dimensions, its file type), and what a cooked payload becomes on this machine.

  • The shadow atlas and the light cap name who they turned away. A caster the atlas could not fit cast nothing, and "why does this object have no shadow" had no answer anywhere in the engine — the frame counted the tiles it handed out. Both refusals are recorded per caster and per light now, with the reason.

  • The post chain commits to one intermediate format per frame, and the effective sample count is readable. interFormat() re-read the colour-space flag and the device's float capability every time it was asked, so a linear project on a backend without renderable float targets ran the whole chain at 8-bit precision with nothing recording it — and a flip between begin() and declareChain() could give one frame two formats. MSAA reports { effective, max }, kept apart because one number cannot separate "that is what was asked for" from "that is all this machine gives".

  • The built-in audio buses are declared once, and the backend says what it can do. The five buses every mixer starts with — their parents and their resting levels — were spelled out in the constructor, so an editor showing a project's OVERRIDES had to copy them to know what an override was a change from. AudioAPI.hasMixerGraph is the fact behind every false the bus calls return, reported once rather than inferred from a failed write.

  • A saved map says which encoding it was painted under. The tile cell encoding was written nowhere in a .esscene, so widening the id mask by one bit — which 8191 tiles makes a plausible change — would leave every byte where it was while every cell that carried a flip flag became a different tile. The blob now carries its chunk side and its four cell constants ahead of anything whose size depends on them, and a map saved under another encoding is translated on load rather than refused.

  • An event payload has a shape, so it is a project shape. defineComponent and defineResource carry theirs as a value; defineEvent<T>(name) erased T, so every mechanism that needed an event's layout invented a channel of its own and the AOT handshake was simply the first. Renaming a payload field left a compiled module reading a field by its old name and delivering undefined.

  • A game can state what its own run has reached. The observation seam could see the engine's side of a frame — where a character stands, what an animator plays, whether a swing landed — but a checkpoint armed, a core taken, a gate opened or a victory lived nowhere it could reach, so a driver inferred completion from an entity going missing. A game publishes its own facts, in its own names; the resource is always there, so empty means "this game says nothing" rather than "the seam is broken".

  • The multiplayer example ships the server it always claimed to. The README and the manual both said the same code runs against a real WebSocket server, and the only place that was ever demonstrated was a test file. examples/multiplayer-arena/server/ imports the project's own src/main.ts through the door the web runtime uses, so the authority runs the game's real systems rather than a second copy of them.

  • The packaged native host answers the AOT conformance fixture too. Three executors agreed and none of them was a game: what a player runs is a packaged app embedding QuickJS and the engine, stepping frames through its own loop, and nothing had asked that road what the fixture computes. It now runs twice on the machine's runtime template — interpreted, and with its systems compiled and dlopened — against the trace the interpreter recorded.

  • An inventory of the decisions the engine takes on a creator's behalf. A LODGroup, an MSAA request and a streaming radius are not three features; they are three places the engine chooses something a creator authored and then could not watch. Each declared decision names the three surfaces that could answer for it — the runtime recording why, the editor showing it where the value was typed, the automation surface answering the same question — and every claim carries a probe, so an entry that stops being true is a finding rather than documentation nobody reread.

Changed

  • BREAKING: the screen is drawn by the screen, and no camera is consulted. Screen UI was world content that a 2D camera happened to frame exactly. The layout box was the camera's world rect, so "follows the camera" and "is on the screen" were one picture — and a 3D camera tells them apart completely: a perspective view has no world rect, so every HUD element resolved to 0x0 and a HUD whose layout was entirely correct drew nothing at all.

    The screen now has a coordinate authority of its own, published from the design fit and the surface unconditionally — a frame between cameras still has a screen — and one projection is read by the pass that draws it and inverted by the pointer, so "the HUD is where it looks" holds by construction. Screen UI is one RenderGraph pass after the post chain, and which entities the screen owns is decided per Canvas and inherited down the TRANSFORM hierarchy, so a bare Sprite parented into a HUD comes with it. Camera.cullingMask survives: the overlay takes the union of the rendering cameras' masks, because whether a Canvas' layer is shown at all is still a camera's business.

    A 2D project is unchanged. A project that reached into the camera to place its own HUD is not: screen roots are placed in layout pixels about the origin.

  • BREAKING: a spawn stops being a scene snapshot — replication protocol v4. A spawn was built by the SCENE projection, which answers "how is this entity restored in full", while replication answers "which facts is this client authorized and declared to know". One function answered both, so a third question got answered by accident — what a ghost needs in order to exist — by shipping whatever the authority happened to be holding, an AI blackboard and an unrevealed objective included.

    Construction is declared now: registerReplicationArchetype(key, build) says what a ghost of that key is, and the server names one per entity through Replicated.archetype. Ownership rides the spawn as identity rather than arriving inside a component dump. The baseline is built FROM the replication table rather than filtered against it, which is where the cost went: a spawn payload of 9,877 bytes becomes 2,368, and the sample beside it drops 39%.

    A v3 endpoint parses a v4 spawn without complaint and builds a different world from it, so the handshake is the only place the difference can be seen. A game relying on a non-replicated component reaching clients must declare an archetype for it, or declare the fields replicated and mean it.

  • BREAKING: a component name is claimed once. defineComponent returned the existing definition when a name was already taken, which is right for a tag and silent data loss for a component with fields: the loser's fields are dropped wherever a scene carries them, and nothing says so.

    The engine keeps taking new names — this release alone added MeleeAttack, Health, Hunter, Perception and more to the SDK — so a project that declared one of them first stopped receiving its own fields. In the flagship example that read as a boss dying from 916 units away: reach and cooldown were not in the winning schema, so overlapCircle got undefined for a radius and no swing was ever on cooldown.

    Declaring the same name twice with the SAME fields is still a reuse — one module reached through two import paths, or a hot reload re-running a declaration. Different fields now throws, naming both field lists. If you hit it, rename your component: the two shipped examples that collided became Vitality/Swing and Hull.

  • Interest is prepare-once, query-many. An InterestPolicy is handed the population per connection, so whatever it reads it reads C times — and the shipped radius policy reads a position through the builtin Transform. Measured, that is 46 cores per simulated second at 100k entities and 32 connections; reading each position once per sample and answering every connection from that one snapshot is 1.8. InterestProvider is that shape, radiusInterestProvider() is the built-in rules in it, and the two share one slot — policies still work.

  • World transforms have an authority, and it is not the renderer. Composition was scheduled by renderer_beginFrame, so an authoritative server, which installs no renderer, never composed at all — every worldPosition on it sat at the origin — and a second fixed step inside one frame silently reused the first one's answer while replication sampled on every step. It is a staleness epoch now: producers advance it, consumers call ensureComposed, and one generation costs one composition however many consumers ask. 100k unchanged transforms go from 0.85ms to 0.01ms, and a headless server composes at all.

    Physics is a producer of transform INPUTS and no longer an author of the output. The editor's field setter says it is a producer too.

  • world.update(e, C, draft => …) is the write path for "read it, adjust a field, keep the rest". The census found 43 writes that changed a component with nothing observing them — the shape set cannot express without a whole value, done through a read accessor instead. The draft is BORROWED and must not be retained; the call reports whether the callback wrote; a throwing callback does not roll back, because what it wrote is already in the component and a half-write nobody hears about is the failure this path exists to remove.

Fixed

  • A packaged native game receives what it imports from an esengine/* subpath. A native build has no module loader, so the exporter rewrites each esengine import to something the host already evaluated — and it matched the bare specifier and everything under it with one rule, handing every match the core namespace. import { Physics3D } from 'esengine/physics3d' therefore arrived as undefined, along with 49 exports across physics, physics3d, spine and dragonbones. Res holds what it is given without looking, so nothing said so until a frame resolved it: the third-person example threw cannot read property '_id' of undefined on every frame it ran on a device, and spine's formatSpineDiagnostics was quietly absent.

    Each specifier is now looked up rather than matched, and a subpath resolves to its own namespace from the SDK graph the host is already running. That last part is the point: a resource token is a JS identity, so a separately bundled copy would mint a second Physics3D and the runtime would install a resource the game could never find. An esengine/* specifier the SDK does not publish, or one a game script must not use, now fails while the game is being packaged.

  • Physics3D is reachable from the main entry, like the other three subsystems. Physics2D, Spine and DragonBones are re-exported onto the flat surface and Physics3D never was, so import { Physics3D } from 'esengine' did not work while its three siblings did.

  • A streamed world's emitters name the fields ParticleEmitter actually has. emissionRate and playing are not among them; rate and playOnStart are. The scene loader dropped both and applied the defaults, which are the opposite of what was authored — two emitters written to stay off were emitting ten particles a second, on every platform, since they were written.

  • The tween enums are generated now, and an enum may live outside the reflected directory. Easing curves, tween state, loop mode and tween target were each written once in C++ and again in TypeScript, tied only by a test. They cross as bare numbers, so a drift is a different curve or a tween reported in the wrong state — never an error.

    EHT parsed enums only under src/esengine/ecs/components, which is why these were hand-copied: they live in animation/TweenData.hpp. It scans for ES_ENUM across the engine now, the same way it scans for ES_CONST — enum-only, because a component outside the reflected directory would need its bindings, storage and editor surface too, and that decision must not be made quietly. Enum values were already in the ABI layout hash, so marking them was enough to put them behind the connect() handshake. ABI_LAYOUT_HASH changes: rebuild the engine.

    Two things had to be fixed for an enum to live anywhere. The generated binding derived its #include list from components, so an enum declared away from one was registered by a C++ type the translation unit could not name — a latent build break for any such enum, now that one exists. And TweenTarget's C++ members were renamed to the SDK's shorter spelling (PositionX, not TransformPositionX) so one vocabulary serves both sides; the values, which are the contract, are unchanged. The dead COUNT sentinels went with it — nothing in C++ read them, and a generated member that is not a target is a value the boundary invites you to send.

    The pins in cpp-contract.test.ts become identity pins, the idiom the other fifteen generated enums already use: same-values-different-object is the drift a re-export eliminates, and only toBe sees it.

  • A recursive delete on Windows now retries, so the temp-tree flake is gone. Deleting on Windows is not synchronous at the filesystem level: an unlinked file sits in a pending-delete state with its directory entry still there, so the rmdir that follows sees a directory that is not empty. A test that writes a temp tree and removes it then fails with ENOTEMPTY at random — more often on a machine with an indexer or a virus scanner — and it reads as a bug in whatever ran last, which is how it costs an afternoon.

    Node's fs.rm already carries a retry loop for exactly these errors. But maxRetries defaults to 0, so every call written the obvious way has it switched off, and force: true does not help — that suppresses ENOENT and nothing else. There were 133 recursive removes in the engine and 76 in the editor, and not one set it. All of them do now.

    check-rm-retries keeps it that way, and reads the editor checkout too, so the next one is caught wherever it is written.

  • Two more hand-copied boundary constants, and a way to stop the next one. The tile cell encoding (13-bit id, three flip bits, the chunk stride) and the particle colour LUT size were each written once in C++ and again in TypeScript, tied only by a test. Neither fails when it drifts: a wrong mask decodes a stored cell into a different tile, and a wrong LUT size over- or under-runs a fixed-size upload.

    ES_CONST marks a constant that crosses, beside ES_COMPONENT and ES_ENUM. EHT scans for it — found by scanning, not from a list, because a list of what to extract is the thing that goes stale — and emits sdk/src/wasm/constants.generated.ts, which the two TS files now re-export. The values join the ABI layout hash, so a binary and a bundle built from different ones refuse each other at connect(). ABI_LAYOUT_HASH changes: rebuild the engine.

    A marker the extractor cannot read is a hard failure, not a skip: a silently ungenerated constant is exactly the drift this exists to stop. Two headers claiming one TS name is refused for the same reason. And EHT's build cache now hashes every header it reads rather than the component directory alone — otherwise editing a constant is answered with "no changes detected" and the old value stays in the hash.

    What is still owed is written down: the hash pairs a binary with a bundle, and says nothing about a saved map. Widening the id mask still reads every older .esscene into the wrong cells; that half needs a format version of its own.

  • The entity split had two authors and no handshake. A handle crosses the boundary as a bare u32, so a side that disagrees about where the index ends does not fail — it decodes to another entity's index and the frame is merely wrong. That has happened: installNativeAot assembled a 20-bit mask by hand against a 22-bit truth, and every world over 2^20 entities read one component off another entity's row.

    22 was written in sdk/src/types.ts and again as PackedId<22, 10> in core/Types.hpp, tied only by a test that parses the header. EHT now reads Entity::Layout and emits sdk/src/wasm/entityLayout.generated.ts, so the C++ header is the one author and types.ts re-exports. The split is in the ABI layout hash, which means a WASM binary and an SDK bundle built from different splits refuse each other at connect() instead of decoding each other's handles. ABI_LAYOUT_HASH therefore changes: rebuild the engine.

    Not found is a failure, never a default — a fallback would emit a plausible split from a header it could not read, which is the one outcome worse than stopping. And core/Types.hpp joins EHT's cache inputs: it is not under the component directory, so without that, editing the split is answered with "no changes detected" and the old split stays in the hash.

    cpp-contract.test.ts keeps its pin with a changed job: it reads the header with a second parser, so what it now catches is a checked-in projection gone stale, or an extraction bug — rather than a plausible number nobody re-derived.

  • The engine's specified arithmetic was in no digest, so a module built against a different polynomial loaded. The AOT subset SPECIFIES sin and cos, because ECMAScript does not, and a compiled module carries its own copy of that polynomial inside it. A host whose interpreter runs a different one therefore makes the same system answer differently depending on whether it was compiled — one ulp, which is one pixel, and a differential pixel gate reports it as a bug in the engine rather than as two builds that were never the same build.

    engineAbiDigest now covers it, in two halves because one alone misses. The CONSTANTS go in exactly, so a coefficient change counts whether or not it moves any answer — measured, and this is why: a 1-ulp nudge to S3 moved none of 250 probed answers while still being different arithmetic that a long enough run disagrees on. The ANSWERS go in for what the constants are not — the quadrant choice, the tie in the range reduction, the order the polynomial is summed in — which a restructure changes while every constant stays put.

    exact-trig.test.ts proves the sensitivity exhaustively over the real constant list rather than against a second copy of it: every constant the algorithm is, one ulp, must move the digest. The engine ABI digest changes again, so an AOT module built against 0.60.0 or earlier is refused and must be rebuilt.

    What is still owed is written down in the inventory: the digest is taken of the TypeScript side, so a change to the C half alone moves nothing and only the bit-exact differential sees it — and that needs a host C compiler, so a checkout without one verifies the two implementations against nothing.

  • A fourth ABI struct was outside the compatibility system entirely. Three of the structs a compiled system is handed carry the same three things: a word count authored once in abiDigest.ts, a typedef char es_check_*[...] in the generated C that refuses to compile if the struct stops matching it, and a term in the engine ABI digest so a module built against the old shape is turned away rather than loaded. EsEventOut — the header a system's event queue starts with — had none of them.

    The number three was instead written twice and bound to nothing: once in the runtime that lays the block out (AotContext) and once in the differential host (compiler/src/abi.ts, as a bare 3 * 4). A field appended to the struct by either one is a header the other keeps stepping over — silently, since the addresses stay valid and only the values are wrong. Nothing would have said so: the digest did not know the struct existed, so a module compiled before the change kept loading.

    EVENT_OUT_WORDS now has the one author its three siblings have, both layout sites derive from it, the generated header declares es_check_eventout, and the digest names it. The engine ABI digest changes, so an AOT module built against 0.60.0 or earlier is refused by a 0.61 host and must be rebuilt — which is the mechanism working, not a regression.

    Every check is now sabotaged in both directions in compiler/tests/abi-structs.test.ts — a field added and a field dropped must each fail to compile, naming that check — and the same file compares the ground against the claim: every all-address struct in the contract header must be one the digest covers, so the next one added without a check is a red rather than a silence.

  • Antialiasing was never the engine's, and turning on a post chain walked away from it. An identity post-process effect cost the frame every antialiased edge it had — and diagnosing it turned up something worse than a missed resolve: there was no resolve to miss. WebGL2's smooth edges came from the browser's default framebuffer, which a post chain stops drawing into; WebGPU never had any. Multisampling is now the engine's own, requested by the project and reported as what it actually got, because a device's ceiling is a capability and not a policy.

  • A lit mesh had its specular lobe switched off rather than turned down. The builtin mesh shader asked for specular 0, which removes the direct highlight AND the environment reflection — so the same model was PBR when it came out of a glTF (which writes specular 1) and Lambert when its material said nothing. The default is a rough dielectric now: the 4% every dielectric reflects, plus the IBL term that reflection gates. A cheaper surface is a material to name, not a constant that quietly redefines one.

  • The 3D solver answers in world space, and its answer was being written as local. createBody hands the solver a composed world pose, and both writebacks put what came back straight into Transform.position and Transform.rotation — the LOCAL inputs the composer builds a world pose from. A parented body had its parent's transform applied a second time, and a character controller with it. The fixture that shows it needs no solver: hand a body over, ask for nothing, publish the same pose back. It moved seventeen units.

  • A spatial query can see the characters standing in the space. A CharacterVirtual is swept against the world and is not in it, so the narrow phase had no body to find — and every player and every enemy is one. So overlapSphere answered "nothing is there" about the only things a swing is ever aimed at, and a melee attack could only hit scenery. Overlap only: what a ray meets is a separate question, with its own consumers.

  • A query row no longer outlives the row after it. toArray() on an engine-backed component returned three rows that were one object, every value equal to the last entity's — the pointer fast path fills one preallocated object per resolver, and the query put that object into every row it handed out. A reader that never writes was still getting the wrong answer.

  • A client joining a quiet server is told the world as it is. sample() returns early with no connections, so the registry stops following the world while nobody is listening — and the initial state is built from that registry and never re-reads the world. After any period with zero clients, the next client's first frame described the world as the last one left it, with anything spawned in between simply absent. A network identity also survives a membership round trip now, and a connection that cannot be sent to stops counting as a participant.

  • A frame is closed once. beginFrame() closed a frame a host might have left open, so a host that honours the pairing closed it twice — and the second close failed the capture booked for the frame about to be rendered against a texture the first had already released. Invisible on WebGL2, whose endFrame is a no-op, while every WebGPU readback came back empty. A host that opens a frame without closing it is a bug to report, not one to absorb.

  • A recovered material's samplers point where they did before. A device recovery relinks every program, and a relink clears uniform state — including the sampler unit each texture param reads. Those units were seeded once at material registration and nowhere else, so after a recovery every material sampled from unit 0 and a normal-mapped material behaved permanently like one with no normal map.

  • A package that cannot load its own code says so. The host imported the project's bundle inside a bare try/catch, because a build with no project code has nothing to import — so a project whose module THREW at load booted an empty world, painted a frame and reported errors=0. The cost is not hypothetical: a user component colliding with a builtin threw a clear message from the engine, the catch ate it, and the missing systems read for hours as a renderer problem and then a gameplay one.

[0.60.0] - 2026-09-02

Added

  • A sprite frame draws at its own size, so one clip can hold different pictures. A clip owned the UV window and, since 1.4, the anchor — never the size. Every frame therefore drew at the one size the entity carried, which is right for a sheet whose cells are all alike and wrong for a flipbook built from separate images: they came out stretched to a common box. Three of the engine's own examples are that shape.

    .esanim 1.5 gives a frame size and offset, and the clip frameSizing. Absent size means the frame's natural one — its sheet cell, or its texture's pixels, which the loader already held and threw away. An offset is a shift in the same units, folded into the frame's anchor at load, so nothing downstream learns a new field: the runtime writes Sprite.size and Sprite.pivot and that is all.

    Authoring the shift in units rather than as a normalized anchor is the point. The same offset is the same visual shift on frames of any size; the same anchor is not. That is also why an offset makes the clip own size — there is no fraction to express a shift as until something says what it is a fraction of. Clips written before 1.5 own neither, so they play exactly as before.

  • A flipbook editor that reads in frames, sizes and offsets. The panel was a strip of equal-width thumbnails with a bare number in each, and a preview that scaled every frame into one square. Time was a field to type in, geometry had nowhere to live, and a clip of separate images could not be authored at all — the only way to make one was to slice a sheet, and the only way to add a frame was to click a grid cell.

    It is now a viewport that draws the frame at its true size against the clip's anchor, with the neighbours ghosted in THEIR places (a frame that does not line up shows it, which is the entire job of onion skin); a timeline whose blocks are as wide as their frames are long, with a frame ruler, a playhead, and a right edge to drag for retiming; and the frame's own properties — duration, size, offset, anchor — in the Details inspector, through the same ComponentSection engine as entities and materials. Frames come from separate images too: multi-select in the Content Browser (file-name order, counting numerically, so run_2 precedes run_10), or drop images onto the timeline. Edit-mode preview and the spawn path handle texture frames as well now; both used to skip them.

    The lane mapping is the Sequencer's, extracted and covered by criteria first — a lane that draws at one inset and reads a scrub back at another puts every keyframe beside the pointer that placed it, and nothing said so.

  • A spine skeleton nobody can see costs an advance and nothing else. Posing a skeleton is two jobs that were one call: advancing the animation — track time, mixing, events, attachment and draw-order timelines, all of it local — and resolving those local transforms into world ones with every constraint solved. The second is most of the cost and the only one an off-screen entity has no use for.

    It is now demanded rather than computed. A world pose is a DEBT, owed against a revision that moves when an advance happens or when something changes what the pose would come out as (a retargeted constraint, a swapped attachment) — not against a frame, which would be right almost always and wrong exactly where it matters. Consumers ask, the first asker pays, and the rest find it settled. A playing=false entity keeps its world across as many frames as it likes, because its revision never moves.

    What may be skipped needs two proofs and neither is a heuristic. The runtime answers whether its constraints carry state across a pose — physics ones do, IK/transform/path ones do not — and a person answers with a CERTIFIED extent: a rectangle somebody promises the skeleton never leaves, recorded as the cullingBounds import setting, carried to the runtime by the manifest that already delivers texture settings. A scan over every animation of every skin is how you propose one, and its result is typed as an OBSERVATION that no function can turn into a promise: a mix of two animations is not the union of their extents, and the failure mode of guessing here is geometry silently disappearing. An asset with no contract behaves exactly as it did.

    Visibility is asked of the renderer rather than of a second vocabulary — RenderFrame::visibleToCamera, the frame's own frustum and culling mask, with the certified extent transformed through all four of its corners. Only a NO removes work; an entity whose extent is unknown has unknown visibility and is drawn.

    Milliseconds per frame at a thousand entities, against resolving every frame:

      scene                  eager  demand-driven
      all visible             3.39           3.36
      200 visible, 800 not    3.29           1.06
      none visible            3.26           0.49
    

    The first row is the one that had to be checked — a fully visible scene pays for the culling authority and saves nothing — and the cost is one ABI crossing, 0.2% of that frame. Sixty unseen frames followed by a camera that wants the entity draw byte-for-byte what never deferring draws.

  • A spine frame that can say what it cost, and which asset to act on. The runtime had good facts and no way to ask it anything: frameMetrics() had zero callers and the per-asset half was reachable one entity at a time, so a scene that felt expensive still needed a profiler to say why.

    The report is entirely DERIVED — the frame's metrics joined to the residencies' facts, read at the moment somebody asks, with no counter added and nothing remembered between calls. A diagnostic that kept its own tally would be a second authority about the same frame, and the first thing to go wrong with one is that it disagrees with what it is explaining.

    Two things it can say that neither half said alone. worldPoseDebt is a STATE, not a tally — enabled entities owing a world pose, read after a submit, which is exactly the resolves the frame did not do with no counterfactual accounting. And the findings split the two blockers: an asset whose world pose carries state is never reported as wanting a certificate, because certifying it would change nothing. Only the assets a promise would actually unlock are named as work, each by the (skeleton, atlas) PAIR it is, so a panel can open the right one.

    It carries the 120-frame windows too (last/mean/p50/p95/max, per runtime, since a percentile does not add) — a single frame's clock is a sample, and a report built on one is an anecdote. Counted-fine, timed-coarse: every count is exact and free, and the clock is read twice per runtime per frame whatever the entity count, because eleven clock reads per entity is the observer becoming the thing worth observing. spine-demo prints the report on D.

    A clip budget comes with it, charged for what the engine still pays: three quantities rather than one score (rawVertices prices opening a region, edgeWork prices the cut, amplification is what clipping hands the stages after it), taken AFTER the fast paths so an artist is never sent after a cost nothing pays any more.

  • A skeleton an editor can pose without the frame posing it. openPreview makes an instance outside the map the frame's tick and the frame's submit both walk, and hands back the same batch walk a scene entity gets — a preview that posed a skeleton its own way would be showing something the game will not draw.

    Two things it needed, both of which were missing for everyone. playAnimation reset nothing, so a bone the next animation does not key kept whatever the last pose left it at and replaying to a time gave a pose that depended on where you had been; setToSetupPose is the missing state and it belongs to the side module, since only the runtime that owns the skeleton can put it back where its data says it starts. And the preview owed a world pose like everything else does — asking for the geometry is the demand that resolves it. Without that the editor drew a pose one seek behind, which looks like a lagging canvas rather than an unresolved transform.

  • A hot update reaches what was built from what it changed. applyUpdate swapped the manifest and told the rebinder which handles ended. That is enough for the changed asset itself — it is content-addressed, so its next load finds the update — and nothing at all for an era already built from it: a tilemap that folded in a tileset, a material's parent, a texture composed into an atlas. Updated on the CDN, stale on screen, for the life of the app.

    The graph that answers this is recorded by the doors rather than declared beside the work. One recorder per preparation wraps its load context: acquireTexture/acquireAsset/createOwnedTexture record an OWNED edge and hold the receipt, readSource records a SOURCE edge and holds nothing — the .tsj folded into a map is causality, not ownership, and destroying anything on its behalf would be wrong. A loader cannot have the ownership without the edge, because sealing them together is the only way to get either.

    The reverse direction is computed, never tabled: dependentsOf walks the live eras and reads the receipts that are already there, so there is no map to be silently wrong the first time an update path forgets it. What comes out is a PLAN, not a loop — read before anything is dropped (invalidating the first asset retires the era whose receipts name the second), deepest dependency first with each group awaiting the one before it (a parent re-prepared too early acquires the child era it already had), and cycles as groups rather than errors, since A imports B while B's metadata names A is a real project.

    applyUpdate now has two barriers because there are genuinely two things to wait for. The ASSET graph settles with no frames involved, so it is safe to await from anywhere and applyUpdate resolves only once the manifest and the graph agree. The LIVE BINDINGS that read it converge on a frame, so awaiting them inside applyUpdate would hang exactly the app showing an update screen: they are the LiveBindings resource's settled() instead.

  • A live binding follows the asset, whatever kind it is. The rebinder opened with if (event.type !== 'texture') return, so a material, a font, a mesh or an environment ending its era left every component bound to the handle from before the update, with nothing reporting a failure.

    The distinction that makes it general is worth stating: a RECEIPT is exact-generation ownership and never becomes another era under its holder, while a live BINDING is a field that names an asset and follows what that name means now. Only the second is migrated. Which kinds those are is read rather than listed — an asset held by handle has a load door, one held by ref has a slot that swaps under the name the field already carries — so a project's own loader is covered the day it is registered.

  • A persistent entity owns what it carries out of its scene. A persistent entity outlives its scene and keeps rendering, and neither owner that existed could answer for what it is bound to: the scene's scope is given back a line later, and the app's ownership never ends. The documented answer was for the game to preload the asset itself, or keep an additive scene loaded forever — engine lifetime, charged to the user.

    Promotion now SPLITS the scene's acquisition. retain joins the era the entity's fields actually hold — after a hot update this scene did not follow, that is not the one its path resolves to, so re-acquiring by path would receipt an instance nothing on screen is using and free the one that is. One receipt per source lease rather than per field, because a scene acquires a shared texture once. Ref-bound fields come out too: a ref names a SLOT, and a slot receipt carries the names it answers to, so the match is exact without resolving anything. The scope ends at World.onDespawn, including when the entity goes down as part of a subtree, so per-entity ownership never quietly becomes app lifetime.

  • A ref-bound asset is owned as a slot, not as a generation. Two asset models had one ownership vocabulary between them. A sprite holds texture = 17 — the field names an exact instance, so its owner holds a receipt for that generation. A SpriteAnimator holds clip = "walk.esanim" — the field names an ASSET, and every lookup asks what that name means now. Such a holder never had a generation to own: give it one and the moment a hot update republishes, ownership says one era while the component is using another.

    So what it owns is the slot: the stable identity, however many eras pass under it. An era owns what it acquired for itself, publication belongs to the SLOT, and a retiring era therefore cannot unpublish the newer one that replaced it. A slot is keyed by what the asset IS — the three spellings a manifest gives one asset folded together — and not by the load path, which for a remote, content-addressed asset carries the revision and would make it one slot per revision.

  • A render-graph pass can name a resource the graph must not bind. A reads entry is wired to a texture unit, which is right for a fullscreen pass whose shader samples input N and wrong for a geometry pass: a scene reaches the shadow atlas through the material each draw already carries, so binding it would claim unit 0 out from under the batch. Declaring it nowhere is not an option either — culling walks back from the final target through what passes name. dependencies is counted by culling and by the last-read that recycles a target, exactly as reads is, and never bound. clearDepth comes with it.

  • An offscreen preview is addressed by its handle, never entered. Reading renderToTarget settled the API shape by removing the alternative: it clears the draw list on the way in, so a begin/submit/end protocol over the shared frame could never have worked. A preview HOLDS its batches and they are replayed after the collect. The five loose fields that made up the existing seam — target, readback, pixels and two dimensions, kept consistent by whoever remembered to — are one PreviewSurface now, so a caller that needs its own preview owns one instead of overwriting the material preview's.

Changed

  • The shadow atlas is filled by a declared graph pass, not during collect. The maps were rendered from inside collectAll: a render pass opened there, drawn through the frame's own camera, frustum, draw list and buffer pool, and every one of those put back by hand afterwards. Two shipped bugs came out of that restore rather than out of any shadow maths — a packaged game whose scene was drawn into the atlas because the target was not put back, and a WebGPU frame rejected for sampling an attachment it was writing.

    Planning, declaring and executing are three things now: the plan allocates the squares and drops the views whose frustum misses the scene (CPU only), the declaration puts the pass in the graph so the scene naming the atlas is what orders the two, and the execution draws through its own pool, its own list and its own frustum — so there is nothing to put back. The atlas is a graph resource borrowed from the same pool as every other target, and its lifetime ends after the pass that reads it rather than at the end of the frame, so a second camera reuses the same physical target. ctx.shadow_pass becomes ctx.purpose: the phase a collect is for, not a feature its geometry has.

  • A spine asset is a preparation, and one runtime is one Spine version. Spine had an asset system of its own — loadSpine bypassed the typed door, kept its own caches, took atlas pages through the plain load door without acquiring them, built native skeletons the asset layer could answer no questions about, and left AssetBundle unable to release a spine at all because it could not tell whether a live entity was still using one.

    A spine asset is now the PAIR (a skeleton and the atlas it is drawn with — the component authors both fields, so a scene can say so), its preparation reads the two documents and acquires the pages, and the ordinary rules apply to it unchanged: a failed preparation gives the pages back, an era holds them until its last holder lets go, and a change to the atlas or a page reaches the pair through the graph. One algorithm, two transports — the asset layer's recording context and a host's own file access run the same prepareSpine.

    The runtime side lost a layer with no lifetime of its own. SpineManager is the App-level authority over which runtime poses which entity, SpineRuntime IS one loaded Spine version, and the ABI adapter is private to it. With the assembly went getModuleBackend as a door (it is a diagnostic and says so), the adapter's second, never-dispatched SpineEvent vocabulary, and the two names for one teardown. frameMetrics() and runtimeForDiagnostics() are absorbed by the frame report, which is what they were built for and what neither had a caller of.

  • A registry-backed asset belongs to the realm that loaded it. Clips, animator controllers, timelines, FSMs, behaviour trees, tilemaps and tilesets were published into module-global stores, so two Apps in one process — an editor world beside a play world — shared them: whichever loaded a key last decided what BOTH ran. Worse than reading the wrong graph, fsmTouches and btTouches derive what a system reaches by walking every loaded graph, so one app's asset was deciding what another app's system declared it touches.

    Publication is the realm's slot table now, read through the ref the component carries or the path the realm resolved it to — two names of one slot, so no lookup site re-derives a resolved key. Code registrations are untouched: registerFsm('patrol', …) is not an asset, has no realm, and every app still sees it. Migration for the doors that moved:

    getTilemapSource(path)              -> tilemapSource(assets, ref)
    registerTimelineAsset(path, asset)  -> Timeline resource, per app
    TimelineAssetRegistry               -> removed with the pointer it held
    AnimatorControllerAPI.update(world, resolveKey?)  -> update(world)
    

    TilemapPlugin is a stateless installer; the thirteen entity-keyed collections it held are a TilemapRuntime per app, since two apps count entities from 1 and were writing each other's entries.

  • Ownership is a receipt, not a path. Two generations of one path are live at once after an invalidate() — the holders of the outgoing one still owe a release — and a path-addressed release cannot tell them apart, so it took the oldest, which is somebody else's. An acquire hands back a LEASE and releasing means giving the receipt back; the generation id is minted by the ledger rather than taken from the value, because a loader may hand out an === equal value for a later era and two eras must never merge.

    releaseValue(key, value) is gone — value equality was not a strong enough identity to keep. The path-addressed doors stay for callers that only ever knew a path, now named releaseOldest(), which is exact while a key has one generation and says so out loud when it had to guess. LoadContext gains acquireTexture and acquireAsset; releaseTexture stays documented as the compatibility door, and unload's context parameter is gone with the sub-asset releasing it existed for — a loader destroys what it MADE, and the era gives back what it TOOK.

    Assets.setAssetRegistry is retired along with the path it fed. Asset metadata reaches a realm through the MANIFEST, which is how texture import settings have always arrived; spine's culling contract now travels that road with them.

  • A run that cannot reach an engine build fails instead of skipping. A skip says "this does not apply to how you are configured"; it was also saying "I could not get at the thing this needs", and the two read identically — one SDK invocation reported 5110 passed and 309 skipped with no failures while 43 suites had not collected at all. The requirement is decided once at the entry now, and reachability is a property of the working directory rather than of --root. A skip is a declaration (SDK_TEST_MODE=no-wasm) and nothing else, and CI's fast job prints the caveat beside its green line so "79/79" cannot quietly mean "79/79 minus 300".

Fixed

  • A native smoke run that could not judge a frame counted as one that had. The Android check waits for a launched example to reach the frame it judges at, and if the capture landed first it reported too slow to judge here and passed the example anyway. So a black frame that was also slow was indistinguishable from a game that drew: 0.59.0 shipped with audio-demo black on Android — 1 colors, at 10 frames — and nothing in that run said so.

    It is a third state now. Neither a pass nor a verdict on the game, it survives a second launch with a longer budget or the run exits 2, which says this machine did not answer for every example it was given.

    A frame of one flat colour earns that second launch too, because it was measured to vary: across four runs of one commit, chat and collision-layers took turns being the black one, each drew normally in the runs it was not, and either drew every time it was launched by itself — with the boot record reporting the same 1 draw(s), 14 tri, 7 sprite either way. What varies is whether the frame reached the surface, and one launch cannot tell that from a game that draws nothing. Only those two verdicts are repeated: a crash, a launch that never reported ready and a dialog with the focus all stand on the first, since relaunching those would turn a broken build into a slow green one. The reported line names what the first launch said, so an example that starts needing two every night reads as a defect rather than as weather.

  • Every spine in a released build drew nothing. A spine atlas names its page images as siblings — spineboy.png — and a content-addressed pack renames every asset to a hash under one flat directory, so resolving that sibling against the STAGED path asked for assets/spineboy.png and got a 404. The skeleton then posed with no texture: a package that starts, paints, and shows nothing.

    The scene-loading door had been fixed for exactly this and the registry door had not, with the regression test covering only the first of the two. Both now resolve pages against the atlas's AUTHORED address, and the test asks the question of both. Only content-addressed packs were affected — which is what a release build is, and why no pr-tier run ever saw it.

  • Every point-light and cascaded shadow drew through the wrong view matrix. Six cube faces and every cascade past the first drew with whichever view was set up last, so a point light shadowed the wrong half of its scene and a cascaded sun shadowed too much. Four of the four point-light pixel gates and two cascade ones had never passed on WebGPU.

    The pass renders every view inside ONE render pass, and between views it wrote the view matrix to one uniform buffer and reset one vertex pool. Both writes reach the GPU on the queue, which does not interleave with draws already recorded into an open pass: six writes to one buffer leave the sixth, and six pool resets hand six draws the same offsets. Only the viewport, an encoder command, varied — which is why the atlas held six correctly placed squares of one face's depth. Each view has its own frame-constants buffer now, and the pool is reset once for the pass so each view claims a range of its own. Not a Metal defect: the failures reproduce bit-identically on D3D12, and the WGSL receiver was correct all along. WebGPU's pixel tier goes 96/102 to 102/102.

  • A hot update rebound two fields out of seven, and nothing else at all. The rebinder named Sprite.texture and MeshRenderer.texture, so MeshRenderer.normalMap, UIVisual.texture, TilemapLayer.tileset, ParticleEmitter.texture and TrailRenderer.texture kept drawing the pre-update image, along with every project and plugin component. Which fields carry an asset is already authored in one place, assetFields, and the walk reads it now — derived when asked rather than kept as state a plain field write can invalidate. The system's touches comes from the same source, so its declared reach cannot drift from what it walks.

  • A hot update that changed the bytes and moved no pixel. An update names its changed asset by the manifest's bare key; a scene serializes the same asset as @uuid:<key>, and the two went down different routes — the prefixed spelling through the remote index, the bare one through the catalog — answering with two different paths. The pre-swap handle capture therefore looked in a cache slot nothing had ever written, the invalidation carried oldValue: undefined, the rebinder dropped it, and no live binding was ever queued. The caller was told applied: true, failed: 0, which was true. Only the screen disagreed.

    Every stage of that was silent, and four hypotheses died against the silence before any of it said anything: the verifier now separates a REFUSED update from one that landed and rebound nothing, applyUpdate warns when assets changed and none was bound to a live texture (naming the keys and what they resolved to), and the rebinder warns when it is told to move a binding and finds nobody holding it. The capture asks both spellings, and verify:hotupdate goes green for the first time. The 31 unit tests over this path were green throughout — they build an Assets whose two spellings already agree, which is the gap that verifier exists to cover.

  • Five loaders published assets and released nothing. A clip, a timeline, an FSM, a tree, a controller — and every frame texture an anim clip or timeline had resolved — stayed loaded for the life of the app, because unload() was a comment saying the asset is registered globally. A hot update reached none of them. They go through the slot now: the last holder takes the publication with it and the era's dependencies with that, and invalidate publishes a NEW era under the same names rather than dropping a cache entry, which is what a hot update means for an asset a component holds by ref.

  • Tilemaps and tilesets leaked every texture they resolved. Both loaders called loadTexture and released nothing, so a tileset atlas and every Tiled tileset image stayed on the GPU for the life of the app, while one realm's unregister deleted the other's cache entry. The folded image-collection atlas needed something new: it is composed here — decoded, packed, uploaded, with no path and no reference row — so there was no receipt to take and nothing could ever give it back. createOwnedTexture hands out one whose release destroys it, and the era holds it like any other dependency.

  • A packaged scene leaked every material it acquired. The runtime scene loader preloads through preloadSceneAssets, which hands back a receipt per successful acquire, and then reported the discovered path list to the scene instead — so unload released by path, materials are skipped by the path door, and after a hot update a path-addressed release gave back the OLDEST generation, which by then belongs to a scene that loaded before the update. Ownership transfers as a scope now.

  • A scene released what it declared, not what it acquired. SceneInstance owned a set of paths seeded from discovery, which is not what it holds three ways over: a declared asset whose load failed was never acquired, a path resolves to a different instance once an invalidate has minted a new generation, and only material handles were ever written back. Ownership is the scope of receipts the preload produced.

  • A group bundle released what the manifest says now. releaseGroup(name) re-read the manifest to decide what to give back, so with atomic manifest updates and content-addressed remote assets it released keys nobody holds while stranding the ones it does — and both halves look exactly like a working release. The bundle carries its receipts and a release() of its own.

  • A live replacement moved two owners onto one acquisition. The rebinder acquired the replacement once and swapped the handle world-wide. Ownership is per scope — two scenes holding one texture hold two receipts — so the other scope's receipt named an era nothing was drawing while the era both were drawing had one holder where two were needed, and every successful rebind leaked one acquisition besides. It is one acquisition per owning scope now, all of a scope's bindings or none, with a rollback that puts back EVERY binding rather than the ones whose write returned. Who owns what an entity holds is one function, entity → scene → app.

  • A load that threw left its scene behind. A successful unload was a complete teardown; a failed load rolled back the entities and the registry slot and nothing else, so a scene whose setup threw left its preload's receipts held, its systems registered, its draw callbacks and post-process bindings live — all under a scene that does not exist. The retry then looked like it worked, on top of a ghost whose system ran too. Both doors share one idempotent teardown protocol now, and rollback keeps nothing persistent: persistence is a property of a COMMITTED scene, so an entity marked persistent inside a setup that then threw must not escape the failed transaction as a global one.

  • A persistent entity died at its parent's turn in the loop. despawn takes the whole subtree with it and unload walked the scene's entities destroying as it went, so whether a persistent entity under a non-persistent parent survived came down to which of the two the iteration reached first. Unload now decides who lives before it destroys anything: partition, extract every survivor whose parent is doomed — preserving the world transform, because a local position relative to a parent that is no longer there is not where the thing was — and only then despawn.

  • An entity promoted out of a sleeping scene came out invisible. sleep() disables every entity and keeps the record of what each one looked like awake on the instance; unloading with keepPersistent promoted them still carrying Disabled, and the instance holding the record was dropped a line later. A persistent camera or HUD survived its scene as a permanently invisible entity with no state left anywhere to explain why.

  • A preparation that failed kept what it took. The recorder held the receipts for everything a preparation acquired and only the era it produced could give them back, so a load that acquired two textures and then threw while parsing left both held by an object that never existed — and nothing in the realm could name those textures again. The recorder IS the transaction now: it settles exactly once, and an acquisition that lands after the settlement is released rather than thrown over.

  • A preparation published into a world that had stopped asking. A republish took whatever came back and installed it, so with two updates in flight — which propagation makes ordinary — the older preparation landing last won, leaving the newer era published nowhere and its receipts held forever. A realm torn down mid-load handed the caller a claim nobody could ever release. Slots count their refreshes, and a preparation that is not the current one gives itself back.

  • A material instance built its parent instead of acquiring it. The loader called its own load for the parent and kept the raw handle in a field, so the parent was not an asset of the realm at all: two instances of one parent built it twice, a hot update to the parent could never reach the instances that diff against it, and the dependency graph stopped at the instance.

  • Two spine entities on one asset both reloaded to the old bytes. The runtime shared one native skeleton per asset REF, so an update to a spine asset two entities were using dropped the refcount to one on the first reload, kept the entry, and handed back the skeleton parsed from the old bytes — twice. Both entities reloaded successfully, the new data was passed in and dropped on the floor, and nothing reported anything. Sharing is by ERA now, which is the identity of one preparation of the pair.

  • An entity that changed Spine runtime version was posed by both. A version backend can only see its own entities, so when an entity moved from the 4.1 runtime to the 4.2 one the instance in 4.1 was left behind — updated every frame, submitted every frame, and unreachable by a despawn, which routes through the entity's current version. The manager keeps the binding rather than the version name and retires the old one itself. Replacing a binding is also commit-after-success now: a skeleton that failed to parse used to leave the entity with no binding at all.

  • A scene could free the atlas pages under a live skeleton. "Despawn the spine entities before the scene gives its assets back" was a protocol nothing enforced, and the only reason it had never happened is that teardown happens to run in the right order. A residency holds a claim on its era — one per residency, taken before anything is parsed and given back after the native object is unloaded, with every failure path in between putting it back.

  • playAnimation returned true for an animation that does not exist. The C backends built a track entry around a null lookup, and the entry is not null, so the check was vacuous: the track then posed a null animation every frame, reading address zero — which on wasm is mapped, so it neither crashed nor drew. What it hid is that three benchmark harnesses had been splitting the animation list on a comma and taking ["walk" as a name, so every extraction figure in that file's history was measured on a SETUP pose.

  • Spine 4.1 and later did not build. spAnimation::timelinesCount is 3.8's spelling; from 4.1 the list is an array type, so a counter added for the pose work compiled for spine38 and broke build -t all.

  • A split screen reported its last camera's pass as the whole frame. Extraction runs once per camera and posing runs once, so the pass that measures itself is not the one that can close the frame — it was closing it anyway, and the 120-frame windows took one sample per camera rather than one per frame. Both are invisible at one camera, which is why they survived. The clock accumulates now, and the windows are fed from the START of the next frame, which is the first moment the last one is whole.

  • A box that mounts after a panel's empty state was measured as 0×0. useElementSize bound its observer on mount and never again, so a panel that returns an empty state first — every asset editor does — attached to a null ref and reported nothing for the rest of the session. Anything placed against the box then landed at 0,0: the rebuilt Flipbook viewport drew its frame in the top-left corner instead of on the anchor, which is how this was found.

[0.59.0] - 2026-08-28

Changed

  • rendering's stability verdict says something that is still true. Its reason had been "as AI — and the render graph behind it is still moving", and the second half stopped being true a release ago: the scene is a declared pass, the target pool has lifetimes, depth is sampleable, and this release grows the first real effect on top of it. What decides the tier now is only the ordering — a game is built OUT of the layers under this one and they freeze first — so that is what it says. The TIER is unchanged: moving it out of experimental is a promise to creators and a decision of its own.

Fixed

  • The sprite-seam pair proved nothing on WebGPU, and one half of it said so. sprite-seam asserts the pixel-exact render policy removes a seam; sprite-seam-off is its negative control, and it was red on WebGPU — the same ratio every run, and the same one with the release's engine changes stashed.

    The two backends' frames are identical except at ONE pixel. On the third boundary, WebGL2 draws [81,65,206] between neighbours of [59,47,219] and [41,32,230] — a line stepping back up, which is the seam — where WebGPU draws [44,35,228], on the ramp. Interior step is ~31 on both; the worst boundary is 94.1 against 51.5.

    So there is no seam on WebGPU to control for — and the POSITIVE gate is vacuous there too: 1.357 with the policy and 1.683 without, both under its limit of 2, so it passes whether or not the thing it tests is applied. The pair runs on WebGL2 only now, carrying those numbers, and what makes the backends differ is written down rather than guessed at (it is not the address mode: both default to ClampToEdge and GL applies it).

Added

  • A sampled depth can be put back in the world. FrameConstants carries the inverse of the matrix it already carries, and the injected shader header gains worldFromDepth(uv, depth) in both languages. Depth-reading effects — fog, depth of field, ambient occlusion — become ordinary shader work; before this a sampled depth was a number with no length in it, which is why the one effect that read depth compared raw samples as a RATIO instead of a distance.

    The inverse uploaded is of the matrix the SHADER sees, not the engine's: what a shader un-projects is the clip space its own device rasterised into. The GLSL and WGSL helpers differ in exactly one line — GL clips z to [-1, 1] and WebGPU to [0, 1] — because both draw the same screen triangle, where uv is the clip position remapped and nothing else.

  • distanceFog — the first effect built on it, and the gate that holds it. Fog is a DISTANCE, and the same depth sample is a metre away up close and a hundred out; this un-projects twice, at the sample and at the near plane along the same ray, so it needs no eye point and works under both projections.

    Its pixel gate is the interesting part. Two of its four points are on the SAME flat wall at ONE constant depth, where a 90-degree eye stands 1.41x further from the frame's edge than from its centre — so an effect reading depth rather than distance paints them alike, and the tolerance does not reach between them. Verified by sabotage in both directions: measuring along z instead of along the ray leaves the two quads passing and turns that one point red. webgl2, WebGPU and the software rasterizer agree on all four to the byte.

  • distanceFog was the sixteenth post-process effect and the count still said fifteen. shader-twins asserts how many embedded .esshader sources each file contributes, which is how it notices one going missing — and the effect that landed this release left the number behind, so the SDK suite has been red on master since. Counted right, 5107 tests pass.

  • The cooked-build check was failing about two runs in three, and the reason looked like arithmetic. verify:cooked — an exit criterion, and a gate on every PR — steps a fixture 60 fixed frames in a compiled build and in an interpreted one and compares the displacements to a part in 100,000. It reads the two probes from separate executeJavaScript calls, and stepFrames puts the game's loop back on rAF before it resolves (deliberately: a frame begun inside its own microtask drain swallows an injected input edge). So real frames landed between the two readings.

    Measured across runs, either side came back 0.00, 0.02 or 0.03 units long at random, against a 0.001 tolerance — neither build systematically ahead, which is what says it is the clock and not the code. Reading it inside ONE expression puts the continuation on the microtask queue, where no frame can run: five runs now agree to 4e-5, where before they scattered.

  • tilemap and particles are @beta. They were the two rows whose reason for being experimental was "the runtime surface has not been read for a tier yet". Read against the new bar, each was short of exactly one thing: its own component carried no written contract. Both have one now, and their Data interfaces — the fields you actually write — are promised with them, which is what check-data-tiers insists on.

    The breadth judgement is the part no machine makes, so it is argued rather than asserted: tilemap is certified by two games and one of them runs on every change, which is more evidence than four rows already at this tier; and particles is certified by one, the same evidence spine and scene were published on. What each why records now is the young half — tilemap's multi-tileset layer, whose singular field is still carried for older scenes, and the particle curves that only one game has authored.

  • Where the built wasm lives is answered by tools/lib/wasmDir.mjs and by nobody else. Three benches carried their own copy of the search order, each slightly different in what it probed for and what it did when it found nothing. The order is the library's now; what to say when the engine is not built stays with each caller, which is the half that is actually theirs.

  • An enum can say how strongly it is promised, and ten now do. Typing those fields made a hole visible that was always there: a @beta component whose field values are governed by an enum nobody promised. ES_ENUM(stability=) answers it at the C++ declaration, the way ES_COMPONENT(stability=) already did — untagged still means experimental. check-enum-twins refuses a shape promised at beta or better whose vocabulary is weaker.

    Chasing it turned up types a creator could read on the surface and not name: TilemapLayerData.orientation said TilemapOrientation, which the SDK published only under the alias TileOrientation; staggerAxis and staggerIndex named enums exported nowhere at all; so did UIVisualData.fit. The alias is gone, the three are exported, and the editor — which restated STAGGER_AXIS_Y = 0 and three more of the same numbers under a comment saying they match C++ — reads the engine's enums now.

  • A component field that IS an enum is typed as one — 33 of them were number. The generator had the answer and threw it away: if is_enum(t): return 'number', with ES_PROPERTY(enum=) naming the enum for the fields stored as a u8. So Camera.projectionType, Light.type, ParticleEmitter.shape, TilemapLayer.orientation, the five FlexContainer fields and 24 more could hold any number at all, and the enum spelling next to them was decoration.

    They carry their enum now, imported from the generated module like the struct types already were. Tightening found nothing wrong — the SDK, the editor, the plugins and the examples all compile unchanged, which says the values were right and the types could not say so. The behaviour is pinned by a test that walks the C++ annotations, so putting number back turns it red.

  • check-enum-twins — nine TS enums that restate a C++ one are held to it, and a machine says which ones nobody was holding. These cross the boundary as bare numbers, so a drift raises nothing: the SDK writes 1 where the renderer reads 2 and the picture is merely wrong. cpp-contract pinned the seven somebody remembered, which is the problem with a list somebody remembers.

    Nine more were not on it. MaskMode, ScrollMovement and the five flex enums (FlexDirection, FlexWrap, JustifyContent, AlignItems, AlignContent) are re-exports of the generated enum now, so there is one declaration and the test pins its IDENTITY — a copy cannot come back looking equal. TileOrientation is the generated TilemapOrientation under its own name; its comment used to promise the values matched, which is a contract with nothing keeping it.

    TextAlign stays its own declaration and pays for it with a value pin: it is @public, the generated enums carry no tier, and re-exporting it would quietly demote a frozen promise. All nine agreed today — this is about the day they stop. The gate catches both shapes that hid them: a declaration with a generated enum's name, and a doc that promises to match one. Sabotage-verified on both, and on the identity pin the re-exports rest on.

  • The output curve's number is worked out in one place. OutputTransform is a string union at the API and a number at the wasm boundary, and the translation — 'aces' ? 1 : 0 — was written at both call sites. A third curve would have reached one of them and been read as none by the other. Found by sweeping for fields whose meaning is spelled in a comment over a bare number; the only other two hits document the DOM's own button numbering, which is a foreign convention and belongs in prose.

  • "Tested" now means named in a test's CODE, and three mirrors of one enum are gone. The evidence behind every stability promise counted any identifier appearing anywhere in a test file — a comment, a describe() title. Measured, nothing was passing on a comment alone, but TextOverflow was @public and its only appearance was describe('TextOverflow', …): a title is prose, and nothing was pinning the enum's shape.

    What it was hiding is why: the tests exercised TEXT_OVERFLOW_VISIBLE/CLIP/ ELLIPSIS, three constants in layout.ts whose own comment called them a mirror of TextOverflow. Three numbers written twice are two answers the day somebody reorders them. They are gone; layout.ts reads the component's spelling, and so do DrawTextParams.align, .verticalAlign and .overflow, which had the mapping written out a third time in prose over a bare number.

    Tightening those types found nothing wrong — the values were already right, the types were just too loose to say so. Dimension and SceneContext came out of the same sweep: one test shadowed the SDK's own px/percent/auto with hand-written {value, unit} pairs, and one annotated nothing with the shape its subject returns.

  • check-tier-bar — a tier above experimental has to be earned, and now something asks. check-subsystem-tiers holds the table against the tags: a verdict and the code carrying it are one answer. Nothing could say whether the verdict was EARNED, so a promotion was a judgement made once, argued in prose and never re-asked — two rows said only "the runtime surface has not been read for a tier yet", which is a note to self.

    The bar is the one check-freeze-bar already applies to a @public symbol, asked of the entry a subsystem publishes its verdict on: documented, tested, and — for values — called by a golden project. It is a floor, not a promotion. Clearing it makes a tier permissible; whether the evidence is BROAD enough to promise on stays a judgement, in why. What it removes is the other case: a claim that could not have been earned, made because nobody had a way to ask.

    It is calibrated rather than invented: all six public subsystems clear it. Ten of the sixteen above experimental do; the six that do not were published before the bar and carry what they still owe, each line checked to still be true, so the day a gap closes the gate says so instead of the entry becoming a lie. Sabotage-verified three ways — promoting an unearned row, dropping a debt that is still owed, and claiming one that is not.

    The three evidences moved to tools/lib/apiEvidence.mjs, since two bars now ask for them and two copies would be two bars under one name; check-freeze-bar prints byte-identically across the move.

  • check-verifier-owners — a checker nobody runs is a checker that rots. check-release-gate holds one direction: every exit criterion has something answering it. Nothing held the other, and verify:aot fell through it — a verifier with no workflow, no gate, no criterion and no script calling it, failing against a package shape that had changed under it.

    So every tools/check-*.mjs and tools/verify-*.mjs owes a caller: a workflow, the gate list, a package script, another tool that spawns it, or an exit criterion saying who runs it and why a machine cannot. Prose does not count — a tool named only in a comment is exactly the case. 60 checkers, one orphan, now owned. Sabotage-verified both ways: a new unowned checker turns it red, and so does taking an existing one out of the gate list.

    It refuses to shrink its own corpus in silence, too: git ls-files names files a checkout may not have — a submodule, a deletion not yet committed — and those are reported rather than skipped past.

  • A crash on a device is an exit criterion, and asking for it can no longer answer "skipped". verify-bootlog-crash builds the real handler for arm64, pushes it, faults on purpose and reads the record back — the claim that a game dying on someone else's phone leaves something they can send. It was the one orphan above. It still skips on a laptop with no phone, which is right, and --require-device turns that into a failure, which is what a release asking the question came for.

  • An exported WEB game is checked for running its systems compiled, and the checker that was supposed to do it had rotted. verify:aot exports examples/ecs-basics through the CLI, boots the package and asks the host how many times a twin was CALLED — the claim verify-aot-native makes for the desktop road, and the one the web road had nobody making. Parity cannot see it: a twin that loads and is never called moves the entity to the same place.

    It had been failing with "the package carries no systems.json" since the manifest moved inline into game.config.json, and nothing noticed because nothing ran it — no workflow, no gate, no criterion. It reads the config the host reads now, the script clears its output directory (a systems.wasm two days stale was sitting beside the new one), and it runs in CI and is an exit criterion, so it cannot go quiet again. The web road was fine all along: MoveSystem installed, 91 twin calls.

  • aotArtifacts.ts described a wire that no longer exists. Its file comment said the two names are "for both ends", warning that a name written twice makes the host's fetch 404. The host has not fetched either by name since the manifest was inlined — it reads the module path out of the config. They are build-step names, and the one checker that believed otherwise is the entry above.

  • A frame that WAITED is refused, not reported. Every number the native bench publishes comes from the host's own frame span, and that span can be spent waiting: a frame the compositor throttles reads 16.6 ms whatever the scene holds — 200 entities or 2,000, one draw or none. There was nothing in the report that could tell that from a frame which cost 16.6 ms, and the render pair above then read 1.00x and passed, having compared two frames that were both the display's.

    The host reports busy now: CPU actually burned inside the span, over its wall, from the thread's own clock. Below half, the run is refused with what it measured instead. A throttled run reads 8-11%. Two causes seen here — a covered window, which a benched window now asks not to be (SDL_WINDOW_ALWAYS_ON_TOP), and a virtual display, where a remote session hands out drawables at its own rate however fast the frame is and the flag does not help.

    The cheapest frame in each comparison trips first, which is the right way round: it is the one a throttle can pin while the other still has work in it.

    And a refused run gets no verdict passed on it. A throttled compiled half used to read 2.87 ms and draw a second failure — "a system is reaching the interpreter" — which is an accusation about the engine that a frame spent waiting cannot support. Both pairs now measure the same way (interleaved, three reps, PAIR_REPS in one place) and skip their timing verdict when either half was refused. Counts still judge: the checksums, whether a compiled system was dispatched to at all, walked, and whether the render pair is a pair.

  • A frame's TIME has a ceiling, and what it bounds is the drawing. Counts were the only thing holding a frame: sprite-scale-cost and its siblings bound draws, meshes and triangles, every one of which a frame can honour while costing twice the CPU it used to. A count says how many sprites were submitted and nothing about what submitting one cost.

    frame-bench --gate runs a pair now — one scene twice, differing only in whether its entities carry a Sprite. Both halves hold the same entities and run the same schedule, so the machine and the engine's own per-frame cost sit in the denominator and only the numerator carries the drawing; the assertion is the ratio, for the reason the AOT one is a ratio. Measured here, 128,000 sprites make the frame 3.7-4.2x the one that only holds them, at 59-61 ns/sprite.

    The entity count is what makes the ratio steady, not what makes it large. The denominator is the small number and its noise is the ratio's: at 32,000 it read 1.03 and 1.19 ms across runs, the healthy ratio spanned 2.85-3.01, and a sabotage read 3.90 — overlapping. At 128,000 the numerator repeats to 1% and the same sabotage, submitting every sprite twice, takes 59 ns/sprite to 115 and the pair to 6.97x. Red on both sabotaged runs against the ceiling of 5, green on three healthy ones.

  • view.frameCanvas — "Frame Design Screen" is a command now. The viewport has had the button since design mode shipped and nothing behind it, so the command palette, a keybinding and a driver could all reach every other view action and not that one.

Fixed

  • Framing the design screen under-framed it from any turned eye. frameCanvas fitted the authored rect by its own half-extents, while frameSelection right beside it fits "the box as the EYE sees it" — so pressing the frame button in a turned or perspective view left most of the screen off the viewport. It fits by what the rect COVERS now, which is the rule the neighbouring code already states: from a turned eye the extent is what the view covers, not the footprint that coverage has on the plane. Head-on is unchanged, which is why this went unnoticed.

  • design-frame had never passed, and it was not measuring the frame. The check asserts that the authored screen is drawn as a trapezoid from a turned eye. Turning the eye pushed the screen off the viewport, so on most rows only ONE of its two side strokes was visible and the span it measured ran from that stroke to whatever sat at the viewport's edge — a number pinned by the window, not by the frame. That is why it failed at one window size and "passed" at another: the passing size was a false positive. It frames the screen after turning now, and passes on the shape it is actually about — 42/42 editor checks.

  • RELEASE in the release gate is derived from the shipped version. It was a literal, and 0.58 shipped under a list headed "0.57 exit criteria" because cutting the notes bumped every other version and not this one. The file exists to stop a list and its checks drifting apart; it cannot be a second place the version is written.

  • A benched frame on Metal was the panel's, not the engine's. The native host asks the swapchain to stop waiting for the display before it times anything, and the mode it picked was Mailbox — which every macOS surface advertises, and which Dawn's Metal backend leaves display-synced: SwapChainMTL.mm clears displaySyncEnabled for Immediate ALONE. So the request succeeded and changed nothing.

    Nothing said so, because a throttled frame reads as a frame that cost the refresh interval. Every span came back at 16.6 ms whatever was in the scene — 200 entities or 2,000, one draw or none — and the interpreted and compiled builds of the AOT benchmark read 1.00x apart, which the gate reported as a compiled system falling back to the interpreter. What settled it was the process's own clocks: 6.25 s of wall for 0.69 s of CPU, so the frame was WAITING for 89% of itself.

    Immediate is preferred over Mailbox now, and the order is load-bearing rather than a taste: tearing is exactly what a measurement is buying. The same frame reads 3.03 ms, and the AOT ratio 9.3x. The configure step also says which mode it was actually granted, because a fallback here makes a number wrong rather than absent.

  • Three release criteria could not pass on a Mac, and one of them blamed the engine for it. verify-aot-native and the native frame bench both located the app they had just exported by searching it for "a file with no extension". Every signed macOS bundle carries Contents/_CodeSignature/CodeResources, which has that shape, and which of the two a directory walk reached first was decided by directory order — so both runners launched the signature manifest. The bench said the host printed no bench line; verify-aot-native said the game had installed no module, dispatched to no compiled system and never drawn a frame. All three were true of a text file.

    The executable is found through desktopExecutableIn now — the same LAYOUT table the assembler used to put it there, so there is one answer to where it is rather than a search and a guess. Signing has been unconditional on darwin since the desktop assembler landed, which means these criteria had never been answerable on the platform they were written on.

  • World.layoutEpoch() answers on a native host. It returned null there — "assume everything moved" — because the epoch was reachable only as a function on the wasm module, and a native host has no module. It is a registry binding now (es_registryLayoutEpoch), so one door answers the same question on both cores and the AOT runtime stops re-reporting every script pool every frame.

  • The native row table is kept across frames, so both AOT roads now answer the same two questions. AotDispatch.ts states the model the web road has always worked to: a row table is a function of two things — which entities match, and where their components are — and each has an authority that answers cheaply. The native road answered neither until this release; the narrowing above settled the first, and this settles the second.

    Each side supplies the half it owns. The engine's pool versions are read in the host, per call, because a despawn applied by the system before this one moves them; the script pools' epoch can only come from the language that owns them, so es_aot_run takes it. A host that cannot be told repacks every frame, which is the same rule the web road follows — trusting an address because nobody could say it moved is how compiled code reads somebody else's bytes.

    Two conditions, not one, and the second is the one that is easy to miss. Registry::layoutEpoch() says whether ADDRESSES moved, and it is deliberately not a membership signal: SparseSet::emplace bumps no version when the buffer does not reallocate, so an entity can join a pool without moving the epoch. So every column a query names is also watched by identity — not just the shortest one, because a query matches on all of them and the one it narrowed on need not be the one that changed. Both conditions are sabotage-verified: dropping either turns a test red, and neither test was red before the corresponding check existed.

    Measured at 100,000 movers on this host, packing costs about 3.4 ns per entity per frame: a thin system goes from 11.4 to 8.0 ns/entity and a heavy one from 14.6 to 12.5. That is not the web road's 27.5 to under 2, and the reason is worth keeping: packing there is JavaScript resolving an address per component per entity, and here it is C++ doing the same work an order of magnitude cheaper. A conclusion measured on one host does not carry to the other.

    aotPacked is published beside aotCandidates, and --gate requires it to be zero in a scene that does not move — repacking a standing world is the other silent way to pay for the frame.

  • A compiled system is paid over what it matches, not over the world. On the native road every compiled system was handed EVERY LIVE ENTITY as a candidate each frame and resolved every component of each one. The absence of a component is the row filter, so the answer was always right — it was the bill that was wrong, and it grew with the game rather than with the system. Two numbers say it: the same 5,000 movers cost 2.9x more once 45,000 entities no query could match were put around them, and at 20,000 entities a system matching 200 of them spends 96% of its frame on entities it does not touch.

    A query now walks the shortest column it names. AotHost.hpp had said the caller "passes the smallest pool it has" since the day it was written; the native caller never did, because it had names and View's narrowing takes types. Registry::entitiesWith<T>() opens that door, EHT emits a second table (engineComponentCandidates) beside the resolver one, and ScriptPool grows a slot-to-entity column so a project component can answer the same question — which is the half that matters, since the component that narrows a gameplay query is usually the project's own.

    Narrowing cannot change which rows a system sees, so the two answers a column can give are kept apart: an empty column means nobody has it and the query matches nothing, while "this host cannot enumerate that one" means widen. A host that answers neither binds and runs exactly as before.

    Measured on the same machine, 20,000 movers in a 200,000-entity world: the system's own cost is unchanged from a world with no scenery at all (0.43 ms against 0.51 ms), where before the columns existed it was 1.29 ms.

  • aotCandidates — what a compiled frame was charged for. The regression above is invisible to everything the engine had: it raises no error, refuses no module and changes no pixel. It is also badly served by a clock, because the extra work is proportional to the world and on a busy machine that reads as a bad minute — measured, the fixed and broken frames above are 1.45 ms and 2.31 ms, a 1.6x the noise reaches into. So the host publishes the COUNT instead, and the count moves 20,001 to 200,001.

    bench/aot-native/frame-bench.mjs --gate asserts it as a second release criterion, with scenery in the world — a run whose world IS its matched set cannot tell the two apart. Verified in both directions: dropping the candidate lookup takes walked from 2,000 to 20,001 and the gate goes red.

  • BENCH_BUILDS — export and run one side of the comparison instead of both. The interpreted build is where the time goes (seconds per frame at 100,000 entities), and a question about the compiled side alone should not pay for it.

Fixed

  • A script component aliased to another entity's row above 2^20 entities. installNativeAot spelled its own entity index mask as 20 bits against the SDK's real 22, so an entity whose index passed 1,048,575 masked down onto a row belonging to a different entity — a wrong component, silently, in a world large enough to reach it. It imports the constant now rather than respelling it.

  • The no-JIT frame, measured — the number AOT was built for. Every frame number this engine had published came from a host with a JIT: V8 on the desktop, Chromium on a phone. The plan's way to get the other one was a Mac running JavaScriptCore with the JIT off, and after that an iPhone.

    Neither is needed. The native host embeds QuickJS-ng, which has no JIT, and it is the same host on iOS, Android and the desktop — one platform seam apart. So the interpreter an iOS build ships is the interpreter a Windows build ships; only the CPU differs. And since the AOT native road landed, that host dispatches to compiled systems, so both halves of the comparison ship.

    bench/aot-native/frame-bench.mjs exports one project twice from one tree (export and export --no-aot, which compiles nothing at all), runs both under the real host, and reads the host's own frame clock off each. At 5,000 entities, one system doing three multiply-adds costs 51 ms interpreted — 19 fps, missing 60 fps by 3.1x — and 1.7 ms compiled, of which 1.5 ms is everything else in the frame.

    Three things the JIT numbers could not say. The no-JIT penalty on a real frame is 61x (9,907 ns/entity here against 162 on V8) where a bare loop in Stage 0 said 154–385x. A script component is 3.6x CHEAPER than an engine one on this host — the opposite sign from the web, because the SDK is given the engine's heap as one ArrayBuffer while an engine component's address is a QuickJS→C++ call per entity per frame. And a body that writes position.z turns one draw call into 4,998, so most of its "compiled frame" is render: the report carries a draws column because a cost that lands where the report cannot see it reads as the system's.

    --gate makes it a release criterion, because the failure this road can have is silent. AotDispatcher.run returns whether it took the system, and false sends it back to the interpreter — deliberately, the no-cliff rule — so a regression that unbinds every system raises no error, refuses no module and changes no pixel. It only costs time, and nothing was measuring time. Verified in both directions: taking the @compiled marker off the body drops the ratio from 15.2x to 1.01x and the gate goes red.

  • WebGPUDevice::setPresentUncapped — a swapchain that does not wait for the display. Off by default and a shipped game should leave it off; it exists so a frame can be measured at all. Under Fifo every frame cheaper than the refresh interval reads as exactly the refresh interval and every frame dearer than it reads as a multiple of one: before this existed, the 51 ms frame above and the 1.7 ms one read as "52 ms" and "16.5 ms" — a 30x difference quantised into a 3x one. Best effort, from what the surface advertises: Mailbox, then Immediate, then Fifo.

  • native/host/Bench.{hpp,cpp} — the host's own frame clock, driven by the environment so nothing about a shipped game changes. It reports four spans, and update is one of them only so that nobody mistakes it for the tick again: App.tick is async, so the update call returns at its first await and is ~8 µs of a 51 ms frame. The systems, and the render they drive, run in the microtask drain after it.

[0.58.0] - 2026-08-26

Added

  • A system can promise to compile, and a shipped build keeps it. Mark one @compiled in its JSDoc and the export lowers it to C, builds it with emcc, and ships a few-hundred-byte wasm module beside the bundle; the scheduler then calls that instead of the closure. The module imports the ENGINE's memory rather than owning one, so the engine wasm stays prebuilt and there is nothing to link — it reads the components where they already are.

    The marker is a promise, not a hint: anything the subset cannot lower is a build error naming the file and the line, because an export is the shipping build and a promise someone is collecting on. A machine with no emsdk is told so BEFORE the export rather than during it — the targets that would compile are offered as not-ready with the toolchain named, which a silent fallback to the interpreter could never say. The editor's preview keeps interpreting either way, and a project that marks nothing is unaffected: no toolchain, no build step, no file.

    estella.mjs export --no-aot packages the same project WITHOUT compiling what it marked, so one tree yields the two builds a differential needs — the compiled frame and the interpreted one, held against each other by verify-aot-parity. It is the AOT step's own dev mode under a name an export can ask for.

    Loading refuses rather than degrades. A module built against other engine offsets, or other defineComponent shapes, does not produce a wrong answer — it reads a different field — so the two digests it carries are checked before anything is registered, and the message says which one moved: rebuild the module, or rebuild the project.

    A system may also declare ResMut(X) to write a resource, and may ask a SERVICE a question with a compile-time key: input.isKeyDown('KeyW') compiles to a load and a mask, because the runtime mirrors the answer the method would have given into one bit. That is what makes input-reading systems compilable at all — 117 of the 120 such calls in the examples pass a literal. A key the table does not declare, or one computed at run time, is refused and the system keeps interpreting. Input and UICameraInfo gained the layout that needs; UICameraInfo.viewProjection is deliberately not in it, since a member has to have a fixed width.

    exact.sin / exact.cos (@beta) — trigonometry that answers the same bits everywhere. Math.sin is implementation-defined, so an interpreted build and a compiled one may both be right and disagree; a differential pixel gate then goes red on trigonometry rather than on a bug. These are specified instead — one range reduction, one polynomial, one order of operations, written in sdk/src/math/exact.ts and again in the compiler's runtime header, and held together bit for bit by a gate. The AOT subset admits them and still refuses Math.sin, naming the replacement in the refusal. Determinism is the promise, not accuracy: a very large argument loses digits, identically on both sides.

    A resource the PROJECT declares compiles as well, with no engine change per resource: defineResource({ value: 0 }, 'Score') has literal defaults, so the build derives the layout from the declaration the same way it does for a component, and carries it in the manifest. The runtime lays the block out at that layout and refuses a module whose field ORDER no longer matches, because a moved field is not an error — it is a read of a different one.

    Events compile too, both directions. EventWriter(E) and EventReader(E) are parameters a compiled system may declare: writer.send({ … }) flattens the payload into the fields the event declares and appends one record, and for (const e of reader) walks this frame's payloads as memory. A payload's shape comes from the TYPE argument of defineEvent, including one named by an interface and one that nests — color: { r, g, b } is three fields, not a refusal. Fields must be number, boolean or Entity.

    Hosts embedding the runtime themselves can do the same through App.useCompiledSystems, and App.compiledSystems reports which systems are running compiled and how many twin calls have happened (both @experimental). Installed and dispatched are separate questions: a module can load and never be reached, and comparing results cannot tell, because the closure a twin replaced computes the same answer.

  • A playable ad now fits the networks it is made for. The single-file transport inlined its engine as plain base64 — a +33% tax on a payload that is mostly a 1.5MB wasm — and never minified the bundle, because the CLI had no flag to ask for it and only the editor's Shipping configuration passed one. Every payload is deflated before encoding now (the engine module goes 2.056MB → 0.597MB), side modules inflate on first use rather than at boot, and the target minifies unless told otherwise. hello-world packages at 1.38MB against 2.82MB before, video-puzzle at 1.78MB and spine-demo at 1.91MB — all three under Meta's 2MB cap, which nothing in the corpus had ever met. Every package was launched and compared: platformer and spine-demo are identical to the pixel, and spine-demo also matches its own web export, which shares none of this path.

    The decoder is the engine's own rather than DecompressionStream, which landed in Safari 16.4: a playable that white-screens on an older WebView is worse than a larger one, since the impression is paid for either way. One path runs on every device, so every device runs what the tests run.

  • estella.mjs export --minify, for the targets whose default it is not.

  • A frame states what it draws in one place, and runs it once. The scene was not a pass: openPass bound a target, flush drew into whatever was bound, and end ran the post chain through a graph of its own — three places, and a fourth wart where the shadow pass had to hand the frame's target back after drawing through one of its own. The render graph belongs to the FRAME now, not to the post-process pipeline, and the scene is a declared pass on it beside the effects that read it: the graph binds its target, sets the camera's rect, and calls the draw. One execute() per camera runs the lot.

    A pass carries its viewport (PassDesc.viewportW/H), which a fullscreen effect leaves at zero to mean "all of my target". That is not decoration: opening a render pass resets the viewport, so a scene drawing into one camera's slice of a shared target has to carry the rect rather than inherit it.

    RenderGraph compiles unconditionally now rather than behind ES_ENABLE_POSTPROCESS — the frame declares its own passes to it whether or not a post stack was built in. The frame's GPU time is the graph's, because the scene runs inside it.

    That is now the frame's ONLY GPU timer, and render.submit is no longer reported as a GPU scope. A second timer opened around the scene sat inside the graph's own span, which is not a thing either backend does: GL has one global TIME_ELAPSED target, so the inner query failed to open, the inner endQuery closed the OUTER one, and both numbers were wrong; WebGPU says nothing and let the two drain one queue in turns, each reporting whichever pass came next. The scene's own share was never a nested region — it is a pass of the graph, and a per-pass question. Nothing read the submit key, and one that always read -1 was worse than an absent one.

  • An effect can read the scene's DEPTH. Nothing could: the depth attachment was written every frame and sampled by nothing, and on WebGPU it was not even sampleable — createTexture gave depth formats RenderAttachment alone, with a comment saying the engine never reads them. So the whole family of effects that needs to know how far away a pixel is — outlines that follow geometry, fog, depth of field, anything screen-space — had no way to exist.

    The scene's depth now reaches a PostProcess pass at texture unit 7. On WebGPU that meant three things a colour texture never needed: the texture carries TextureBinding; a depth-only view stands under the binding, and its format is the ASPECT's (depth24plus) rather than the texture's, which Dawn rejects as incompatible; and the bind-group layout learns which of its units are depth (sampleType = Depth) by scanning the WGSL for texture_depth_2d, with a depth dummy to back a declared-but-unbound one — a white RGBA8 dummy under a depth entry is a validation error, not a blank sample. Depth is read by texel (texelFetch / textureLoad): a fullscreen pass is 1:1 with the scene, and a depth texture is not filterable.

  • depthOutline, a post effect that outlines geometry rather than shading. The existing outline runs a Sobel over scene luma, so it draws an edge wherever the picture changes — texture detail, a shadow's border, two shades of one wall — and misses a silhouette between two surfaces of the same colour. This one reads depth, so an edge is a place the geometry steps, at any contrast including none. Depth is compared as a RATIO to the nearest neighbour, which is what lets one threshold hold across the whole view: an absolute difference of 0.001 is a wall's thickness up close and a kilometre out.

    Two gates, both backends. depth-outline puts two SAME-COLOURED quads at different depths, so the edge in the middle of the frame came from depth or it came from nowhere — sabotage-verified by moving the near quad back to the far one's z, which is a change to the fixture and needs no rebuild. depth-outline-flat runs the same effect over a scene that writes no depth and requires the frame to come out exactly as it went in.

    One thing that did not survive its own test. The pipeline first forced the scene target to carry depth whenever an enabled effect read it — a sensible safety net that turned out to change nothing: with it removed, the flat gate still passed on both backends, because an unbound depth unit reads zero and an effect that finds no step draws no edge. It was deleted rather than kept, on the rule this repo already holds its budgets to: a guard nothing can fail is a guard nothing is checking.

  • The shadow atlas is a loan now, not a framebuffer held for the run. It was created on the first frame that cast a shadow and never given back — 2048² with depth, ~32MB, for as long as the process lived, so a game that walked out of its one shadowed room went on paying for it. It comes out of the frame's target pool instead: borrowed once per frame, spanning every camera that reads it, returned before the next one, and released for good when nothing has asked for it in 120 frames.

    What made that possible is that a RenderGraph is one CHAIN and a frame holds several — one per camera, plus the screen stack — and the pool used to live inside the graph, so every begin() handed every target back and nothing could be held across two chains. The pool is its own object now (rg::TargetPool), owned by the frame and borrowed by each chain: the atlas and the post-process intermediates come out of the same physical targets, and a target's lifetime is the borrower's to state rather than a side effect of which chain began last. Its handles carry a generation, so one held across a resize (which reclaims every target at the old size) comes back naming nothing rather than naming whatever refilled its slot.

    rg::TargetDesc gained a width/height in pixels for targets that are not a fraction of the frame: an atlas is 2048² because that is what its tiling divides, and as a scale it would have been a different resource on every monitor.

  • render.targets and render.targets.bytes — what a frame's render targets cost, which no counter answered for. point-shadow pins a shadowed frame at exactly one target and 33,554,432 bytes, and shadow-scale-cost holds 3249 casters to the same ceiling. Sabotage-checked: a frame stranding its atlas each frame reaches 3 targets and 96MB with every pixel probe still passing — target memory is invisible in the image, which is why it needed a number.

Changed

  • EmbeddedSideModuleEntry carries decoded bytes (glue, wasm) rather than base64 strings. How a payload survived a trip inside an HTML file is the host page's business; with the SDK naming the encoding, the transport could not change without changing the SDK. @experimental, and its only consumer is the playable host.

Fixed

  • A playable's size report described an empty directory. The report excludes each package written inside the output dir, since an .apk sits beside the loose files it was made from and counting both doubles the build — and it excluded the uploaded file on the same rule. For every other target that was merely redundant, but a playable's index.html repackages nothing and nothing else is in the directory, so excluding it excluded everything. On the one target where size is a hard cap, an export could say "over by 64%" without naming a byte of where it went. It now reports what the assembly joined, so a playable composes in the same vocabulary as the web and WeChat builds.

  • The golden chain never weighed what it packaged. verify-golden gets a size stage holding every pair to the limits its own export reports, so Meta's 2MB and WeChat's 4MB are judged by a criterion rather than by whoever reads the output. With it in place startup-size stops being a declared gap — it was one because the runtime floor exceeded the cap — and the corpus certifies 38/39 capabilities.

[0.57.0] - 2026-08-24

Added

  • 3D physics had no door. A scene could hold a RigidBody3D and a collider, and the runtime loader wired a world behind it — but Physics3DPlugin, the Physics3D queries resource and Physics3DEvents reached no entry point, so a game could drop a body on the floor and had no way to cast a ray at it or hear it land. Every spatial query the 3D solver gained was unreachable from user code. esengine/physics3d now mirrors esengine/physics entry for entry, and the new check-plugin-door gate holds every plugin the SDK defines to reaching an entry or being composed by one that does.

  • A MeshRenderer could not be clicked. Runtime hit testing took a world point resolved on the z = 0 plane, matched it against UI boxes and then sprite boxes, and had no mesh pass at all. uiHitTest_update takes the world ray a screen point names: UI nodes and sprites resolve it against their own plane, meshes against their oriented bounds, and world content ranks by distance along the ray. Orthographically every plane gives the same answer, so a flat game picks exactly as it did. Camera.screenRay finally has a consumer.

  • Six subsystems had no published maturity verdict, all of them the engine's newer half: 3D physics, 3D models, DragonBones, math, localization and platform services. The table said what a creator can build on and its gate read it only forwards, so a whole dimension could ship with no row naming it.

Changed

  • The two physics worlds named the same joint differently, each after its own solver: Box2D says revolute/prismatic/weld, Jolt says hinge/slider/fixed, so a hinge answered to RevoluteJoint2D or HingeJoint3D depending on which plane it was in. The flat set takes the solid one's words — HingeJoint2D, SliderJoint2D, FixedJoint2D — which are also what Unity and Godot call them. MotorJoint2D and WheelJoint2D keep their names, having no 3D twin to disagree with, and the Box2D binding layer keeps the solver's own vocabulary. Scene format 4; both earlier spellings migrate, and a pre-suffix RevoluteJoint reaches the current name in the single pass migration makes.

Fixed

  • verify-legacy read every rename as content loss. It opens a project as an older engine released it and holds the result against the file that went out, so nothing is quietly dropped — but it compared the RELEASED spelling of each component against the spelling the editor reports after loading, with the migration in between. The day the flat physics set took its 2D suffix, the v0.20.0 platformer's seventeen BoxCollider/RigidBody components became "gone", every one of them present under its new name. It reads the migration's own tables now, and excludes the deliberately retired types.

  • Fifteen shaders carried a WGSL twin stamped older than their own GLSL — ten fixtures and five of effects-gallery's shipped materials. Every regenerated twin is byte-identical in its WGSL body, so no WebGPU output moved; what was stale was the stamp saying the translation had been checked. They accumulated because only CI asked, and gen-shader-twins --check now runs in the local gate scope too.

  • A release exit criterion named a command that no longer runs. hot-update-lands-or-rolls-back — the one proving a shipped build takes an update and refuses a broken one whole — pointed at a script that had moved to the root package, so running it produced a crash where a verdict should be. check-release-gate held the criterion to the files it lives in, which all still existed; it now also resolves every pnpm run script an answeredBy names against that package's real scripts.

  • A motion trail was drawn flat, at the wrong depth. TrailPoint stored a vec2 sampled from worldPosition.x/y, and every ribbon vertex was then given the emitter's current z — so a trail on anything moving in depth was flattened and dragged its whole history through depth each frame. The centreline is a vec3 now, minVertexDistance measures the distance actually travelled, and both ribbon paths widen along a side vector perpendicular to the path and the viewer instead of an XY perpendicular each computed for itself.

  • Scene streaming measured proximity in the plane, so every floor of a tower was the same place and a world stacked in depth held all of it resident at once. StreamCell takes a z and setFocus a third coordinate, both defaulting to the plane a flat game sits on.

  • Fourteen components promised something their fields did not. Each was @beta while the <Name>Data interface holding its fields was @experimental — and none of the fourteen was a decision, since untagged is Experimental by design. check-data-tiers holds the pair together now. 3D physics carried @beta on whichever of its symbols happened to have a doc comment, which made the least-exercised half of the engine the one with the stronger promise; the family reads @experimental throughout.

  • The ACES tone curve had no criterion left. The only assertion on it looked for the Narkowicz constant in an effect's authored source, which stopped being true when the curve moved behind one injected acesFilmic() definition — so it had been failing, and the obvious fix would have removed the operator's last check. Pinned where the curve is now defined, in both dialects.

  • ResourceStats.cacheHits and .cacheMisses counted a loading path the engine no longer takes. They are written by loadTexture, loadShader and loadTextureByGUID — the file-loading model, of which loadShader and loadTextureByGUID have no caller at all and loadTexture has exactly one (a bitmap font page). A shipped build decodes in the host and registers an id, so both numbers read ~0 for every game while being published in an @experimental interface every SDK user can read — the same shape as render.culled one layer out. The project's own census reads six fields of ResourceStats and pointedly not these two.

    acquireTextureByPath is where a shipped frame actually decides: a resident path hands back the texture and an upload does not happen; anything else and one does. It books the hit and the miss now, so the pair means "requests that avoided an upload" — which is what the names always said.

    New harness test_texture_cache pins it: ResourceManager.cpp against MockGfxDevice, no GL and no engine link. Reverted, four of its assertions go red at once.

  • check-cpp-tests could not run on any machine that has a compiler. It strips the options no plain cmake can honour (EMSCRIPTEN, ES_BUILD_WEB, ES_SANITIZE) from its configure and then asked for the targets DECLARED behind them anyway, so it died on test_webgpu_device with No rule to make target — a red gate about the machine rather than the code. It drops those targets now, and reports 18 harnesses built and passing here with the 9 that link the engine left to CI.

  • Deleted RenderContextStats. Two fields, a reset(), and two accessors on RenderContext — never written, never read, by anything in the repo. Its drawCalls and triangleCount are the ones RenderFrame::Stats actually maintains, so what it offered was a second answer that could only ever be zero.

Added

  • Nothing anywhere put a ceiling on what a frame COSTS. The counters landed earlier this release, but every one of them is an EXACT value on a scene small enough to enumerate — nine cubes, nineteen sprites. The scale harness (desktop/tests/scale/) is headless by construction, so the whole draw-submission half was unmeasured at any size, 2D and 3D alike, and a batcher that stopped merging above some threshold, or a shadow atlas that started drawing per caster, would have reached a shipped game before it reached a check.

    Three gates now ask what a frame costs when the scene is big: sprite-scale-cost (9801 sprites → batch.draws ≤ 8, measured 1), mesh-scale-cost (4225 cubes → ≤ 8, measured 1, with render.triangles at 50700 exactly) and shadow-scale-cost (3249 shadow casters → render.shadow.draws ≤ 8, measured 2). Sabotage-verified together by inverting both merge conditions in DrawCommand::mergeBlocker: the three counters go to 9801, 4225 and 3250 while every pixel probe in all three frames stays exactly right — which is the whole reason a cost gate has to exist next to a pixel one.

    ESTELLA_VERIFY_COUNTERS_MAX is the ceiling form of ESTELLA_VERIFY_COUNTERS, and it is a different claim rather than a looser one. An exact value pins a scene whose every draw can be counted, and either direction is a regression. At ten thousand sprites nobody can count them, and the useful question is not how many draws but whether submission stayed bounded — which a ceiling answers and an exact value turns into a number that every benign scene edit rewrites. Both forms fail on a counter the frame never set: a budget nothing reports is not an under-budget frame.

    The scenes are a fixture plus a COUNT (ESTELLA_VERIFY_SCALE), not a file. Ten thousand entities of JSON would be a megabyte in every clone of this repository, storing what is a pure function of one small scene and an integer — so each fixture holds ONE of the thing being measured and the host lays copies of it on a centred grid. Entities named or componented as furniture (Camera, Light, a ground plane) are placed once; everything else is the content.

    Two things the geometry had to be measured into rather than reasoned into. sprite-scale-cost is 99x99 and not 100x100 because a sprite is two pixels wide at this scale, and an even grid puts the centre of the frame BETWEEN four of them — the middle pixel then reads half coverage, which is a rasteriser's answer and not the engine's. And shadow-scale-cost probes only the two edges of its grid: the sun's throw is 100 units and the lattice is 10, so everywhere in between each shadow lands exactly behind the caster ten cells along and the frame is uniformly lit. Bare ground survives only past the left edge, where no caster stands 100 units further left, and past the right, where one does.

  • The batcher is held to what it achieves. DrawList has been publishing batch.draws, batch.merged and a counter per break REASON for a while, and nothing read any of them — so the oldest performance promise in the engine, that sprites sharing a texture reach the GPU as one draw, was the one thing no gate could see. sprite-batch reads them: nineteen sprites over two textures, three draws, sixteen merges, and the three draws accounted for to their reason — one run head and two index gaps, no state break of any kind.

    Sabotaged on the fixture rather than argued: give ONE of the nineteen sprites lit: true and it needs a different program, so the batch breaks. batch.draws goes 3 → 4 and batch.merged 16 → 15, while render.sprites stays at 19 — the picture is complete and sprite-default, the smoke gate on the very same scene, passes. That is the whole shape of the problem: a batching regression ships as a slower game and nothing goes red.

    check-render-scenes counts a counter as an assertion now. It listed the pixel, grid and preview forms and not ESTELLA_VERIFY_COUNTERS, so a gate whose whole subject is cost had to carry a probe it did not need to be allowed to exist.

Changed

  • Every rasterizer draws the same penumbra, and sun-shadow now says so. A sample step of disagreement on a wide sun disc had been recorded rather than hidden — the gate carried tolerances wide enough to hold whichever rasterizer ran, and its comment said as much. Re-measured on all three: webgl2, webgpu and the software rasterizer CI runs on read the ramp 0 / 70 / 116 / 170 / 209 / 247 to the value. The shadow-pass work is the only thing that has touched where an ortho map lands in the atlas since, so that is where the credit goes.

    So the tolerance sized to that divergence was the thing left to fix: it was hiding a real invariant. The gate pins the whole ramp now — the two midpoints are new — at ±10 instead of ±35 and ±25.

    What that buys, measured by sabotaging the fixture rather than argued: a sun a quarter narrower (sourceAngle 5.6 → 4.2) reshapes the penumbra to 0 / 46 / 116 / 186 / 224 / 247 and the old gate passes it — every probe it had stayed inside tolerance. The new one fails at two points. A third wider (7.5) is caught squarely in the ramp rather than by the umbra probe alone.

  • A new 3D project starts in linear light with an ACES output transform. The 3d-starter template ships rendering.colorSpace: linear and rendering.outputTransform: aces, and its two lights are re-authored for that world: the sun goes 1.05 → 0.52 and the sky 0.42 → 0.09.

    The template is where this belongs and the only place it does. A manifest expresses a default by ABSENCE, and the engine default has to stay gamma — flat content wants an exact round trip, and every 2D project relies on it. So the door for "3D is lit physically" is the thing a new 3D project is made from, not a flag flipped under everyone. Existing 3D examples keep the look their golden pixels pin; changing them would cost a re-baseline and buy nothing.

    Why those numbers: intensities tuned in gamma are not light units, and reused in linear they over-light everything — measured on the packaged template, the ground went from 88,106,91 to 179,188,178 and the whole frame lost its colour. Solving the ACES curve backwards for the ground says roughly a third of the energy, and the pair above lands it at 125,133,115: readable daylight rather than the old dusk, colours intact, and nothing above ~150 — so the first light a creator adds rolls off the shoulder instead of clipping, which is the whole point of being here.

Fixed

  • A packaged game in linear colour space rendered one flat black frame, and always had. Not a look problem and not new: the same package built at 2c40bf011, before any of this release's render work, produces a byte-identical black PNG. Turning a 3D project to linear was the thing this release was building toward, and it could not have shipped.

    RenderFrame::openPass exists to hand the frame its target back after the shadow pass has drawn through one of its own. Down the captured path it only did so when the camera also had something to CLEAR; the other two branches always bind. So a camera that clears nothing left the shadow atlas current, the scene drew into that, and the final blit then painted an untouched capture over the top. Gamma never showed it because with no capture the scene goes straight to the surface, which the atlas hand-back restores anyway.

    Why no gate held it: it needs a shadow pass INSIDE a capture, and the suite had each axis alone — every linear gate was a flat scene that casts nothing, every shadow gate was gamma. mesh-shadow-linear is that crossing, and it reproduces the packaged symptom exactly: reverted, the frame comes back with zero non-black pixels while mesh-shadow, linear-lit and linear-midtone all still pass.

Changed

  • The render graph owns the scene target now, not the post-process pipeline. RenderGraph.hpp used to say so in its own header — "The graph does NOT own scene geometry" — and the reason was real: one frame reaches the host as several calls (renderer_begin, submitAll, flush, end) with the geometry drawn between them, so the scene cannot be filled from inside a pass callback the way every full-screen pass is. The pipeline answered that by owning a private fboOriginal_ and handing the graph a texture afterwards.

    It did not need a private framebuffer, it needed a target it could draw into BEFORE the graph runs. createExternalTarget is that: the graph allocates it from the same pool, at the same declared format and scale, and recycles it at its last read like any other transient — the exception is WHEN it is filled, not who owns it. The graph now opens at begin() rather than at end(), because the scene target is its first resource.

    What that deletes: the bespoke lifecycle around that one framebuffer. fboOriginal_, fboOriginalCreated_, its re-creation in resize and recreateGpuResources, and the FBO surgery inside setSceneNeedsDepth — which dropped and rebuilt the framebuffer to change one attachment — are gone; depth is a field in the desc the next frame declares. Format follows the same way, so a colour-space change no longer has to invalidate anything.

    One predicate for "is the capture engaged". RenderFrame spelled the same three-term expression out twice, at both ends of the frame, and had to agree with itself or leave a capture opened and never resolved. It asks PostProcessPipeline::isEngaged() at both ends now.

    No pixel moves: same format, same passes, same order. Verified on the pr tier, both backends (98/98 webgl2, 96/96 webgpu) — device loss and resize included, which is where a pooled scene target would fail if it were going to.

Added

  • A frame has an output transform, and it belongs to the pipeline. Project Settings → Rendering → Output transform, rendering.outputTransform in the manifest, PostProcess.setOutputTransform('aces') at runtime — one setting, which puts the ACES filmic curve on the way out: once, last, after the effects (which want scene values) and before the OETF (which is a transfer function, not a look). It rides in the blit that was always going to run, so it costs no extra full-screen pass, and it engages the capture on its own — a project that asks for a curve gets one with an empty effect stack.

    ACES now has one definition. acesFilmic() joins srgbToLinear / linearToSrgb in the helpers every fragment stage is given, in GLSL and in WGSL, and the standalone tonemap post effect calls it instead of carrying its own copy of the constants. Two spellings of one curve was one edit from two different curves. The effect stays: it is the manual placement, with an exposure. Carry that OR the output transform, never both — the curve is not idempotent.

    The default is none, and that is a decision, not caution. The obvious rule — tonemap whenever the pipeline is linear — is wrong, and the suite already says why: linear-midtone exists to prove 0.502 sRGB survives the linear round trip and comes back 128. A standing filmic curve destroys exactly that. Linear light is not the same claim as HDR scene radiance, and flat content wants the round trip.

    Measured on that one scene, all four values hand-derived: no transform reads 128, ACES in gamma reads 157, ACES in linear reads 154 (0.502 → 0.2158 linear → 0.3242 through the curve → encoded), and applying it twice would read 182. Gates output-aces and output-aces-linear, both backends, agreeing to the value — which is also what says the WGSL twin of the curve is the same curve.

    It reaches everything a setting has to reach: one derivation in runtimeConfigOf, read by the edit viewport, the play realm and every export. check-project-settings counts 13 settings now and declares no gap for this one — unlike colorSpace, which is boot-fixed because shaders compile against it, the curve is a shader VARIANT chosen per frame, so the viewport shows the shipped look live rather than asking for a reload.

  • The 3D path can be held to what it COST, not just to what it drew. render.meshes and render.triangles join the counters a pixel gate can pin through ESTELLA_VERIFY_COUNTERS, and the new gate mesh-cost pins them: nine 50-unit cubes inside an ortho view, six more a thousand units out either side, same mesh and same material — where they stand is the only thing that separates them. It asserts 9 meshes, 6 culled, 108 triangles and ONE draw call.

    Why a gate for numbers no pixel shows: with the mesh frustum cull disabled entirely, mesh-instanced, mesh-shadow and mesh-builtin all still pass. Measured, not argued — the whole 3D corpus is blind to a cull that stopped working, because instancing merges the extra geometry into the same one draw call and the extra cubes land behind the ones in front. mesh-cost catches it as 15 meshes and 0 culled. The other direction is a data sabotage: move one of the six off-screen cubes in behind a visible one and all four pixel probes and batch.draws still pass, while the three counters read 10 / 5 / 120.

Fixed

  • render.culled counted nothing, and had never counted anything. It is published every frame, read back by renderer_getCulled(), and printed in the editor’s stats overlay as "Culled" — and stats_.culled had no ++ anywhere in the engine, so all three read zero for every scene ever profiled. Six render plugins cull (sprite, mesh, shape, text, trail, UI element) and not one of them recorded doing it.

    A cull is the one part of a frame’s cost that leaves no draw, no pixel and no trace of itself, so the only place it can be counted is where it happens: the collect context carries the tally and each plugin bumps it at its continue. The camera’s collect only — a shadow face has a context of its own, and what its frustum skipped is already render.shadow.collects.

  • triangles meant two different things on the two draw paths. A batched command merges its indices in and draws once, so index_count / 3 is the whole truth for it; an instanced command holds ONE copy of the geometry and draws it instance_count times, and counting its indices once under-reports by exactly the factor instancing saved. Measured on mesh-instanced: four cubes reported 12 triangles, which is one cube. It reports 48 now, in the counter and in the editor’s stats overlay.

  • The editor grid stops changing plane mid-orbit. Turning a 3D view down toward the horizon used to swap the grid off the ground and onto a vertical plane as it passed about 6 degrees: the frame you judge a scene against turned over under the drag. One function was answering two questions. A GESTURE does need to hand over — a drag on a plane seen edge-on turns a pixel of cursor travel into unbounded world motion — and editorViewWorkPlane still does, unchanged. The grid now asks editorViewGridPlane, which is the plane the view is about and nothing else: the ground in a 3D view, the 2D plane in a flat one, at every angle. Held edge-on it converges into the horizon and the shader's existing fade takes it, which is what every editor does and what the plane saying where you are standing looks like.

    Measured across the old threshold, quadrant by quadrant: at 4° above the ground the grid was near-uniform (a plane turned to meet the eye) and is now bottom-heavy by 1.7× (a floor receding to a horizon); exactly head-on, where this scene's eye lies IN the ground, it drew a full frame and now correctly draws nothing.

    The three grid pixel gates moved from the editor host to the engine's own — the grid is SDK code (installEditorGrid draws through the EditorView resource), so tools/render-host opens those doors now and the gates run without a private editor checkout, on both backends. A fourth (editor-grid-grazing) pins the angle the bug lived at, with a grazing verdict that tells a lopsided floor from an evenly-lit wall — the old behaviour passed the frame-coverage check, so nothing in the suite could have caught this.

Changed

  • The flat physics components take the 2D suffix the solid ones already had. Every component of the flat physics subsystem: the body (RigidBody2D), the six collider shapes (box, circle, capsule, segment, polygon, chain), the mover (CharacterController2D), OneWayPlatform2D, and all six joints — of which DistanceJoint differed from DistanceJoint3D by three characters and one solver.

    Physics is the one place in the engine where two worlds genuinely exist, and the bare names belonged to the flat one: a BoxCollider dropped on a mesh was a flat box in a scene that is not flat. Now neither set owns the unsuffixed name, which is the opposite conclusion from Light2D → Light and reached the same way — a name says which of the things it is, and only stays bare when there is one.

    BodyType did not take a suffix: a body is static, kinematic or dynamic in either world, and both components read the same enum. It moves to a header of its own, so RigidBody3D.hpp no longer includes the flat body's header to reach it.

    Scenes and prefabs migrate themselves, through the door Light2D used: the loader upgrades the old names on the way in, and the scene format is version 3. An engine older than the rename REFUSES a version-3 file rather than dropping the bodies it does not recognise and loading a level whose floor nothing collides with.

    Breaking for code. A script importing any of these from esengine must import the new name; the data interfaces follow their component (RigidBodyData → RigidBody2DData). The three hand-written pointer accessors follow their component too — getRigidBodyPtr is getRigidBody2DPtr, and the box and circle collider ones with it — so the zero-copy path reaches the same names the generated layout table asks for.

  • The SDK's flat physics surface follows, spelled the way physics3d/ already spells its own. Physics → Physics2D, PhysicsAPI → Physics2DAPI, PhysicsPlugin / physicsPlugin → Physics2DPlugin / physics2dPlugin, PhysicsEvents, PhysicsEventType, PhysicsDebugDraw, drawPhysicsDebug, setupPhysicsDebugDraw and the config/event data interfaces all take the suffix; ColliderShape / ColliderInstance / ColliderOutline become Collider2DShape / Collider2DInstance / Collider2DOutline, matching Collider3DShape beside them. Res(Physics) is Res(Physics2D).

    What kept its name, and why: loadPhysicsModule, PhysicsWasmModule, PhysicsModuleFactory and PhysicsBridge name the side module, whose id is still physics and whose artifact is still physics.wasm — a type that names a file should be spelled like the file. The esengine/physics entry point is unchanged for the same reason. Nothing on disk was keyed by any of this, so there is no migration: it is an import-line change.

[0.56.0] - 2026-08-23

Changed

  • A camera can render into a texture. Camera.renderTarget takes a RenderTexture handle and that camera draws there instead of the screen — a minimap, a mirror, a portrait, the scene half of cache-as-bitmap. The engine could always open a pass on an offscreen target; what was missing is that no camera ever named one, so Renderer.begin was called with 0 every time. Such a camera does not compete to be the main view (a camera drawing elsewhere is not a candidate for the screen) and renders BEFORE the screen cameras, because what it draws is usually what they are about to sample. Its viewport fractions are of the target, whose own size sets the resolution, and a released target falls back to the screen rather than drawing nowhere.

    WebGL2 today. On WebGPU the target now reaches a Sprite — adopting a texture the backend already owns is a lookup, not an import, and that stub is gone — but the frame readback returns nothing when one frame holds both an offscreen and a surface pass, so the pixel criterion runs on WebGL2 until that is found.

  • Removed: 26 engine entry points no host called. Five of them (renderer_submitSprites / submitUIElements / submitBitmapText / submitShapes / submitParticles) had bodies that were (void)registry; — collection moved to renderer_submitAll and the per-type doors were left standing. The rest were an internal mechanism exposed twice (the seven clip-rect / stencil entries: UI masks are resolved inside the frame, never from JS), a set of incremental post-process calls under a pipeline the SDK rebuilds whole (removePass / setPassEnabled / isPassEnabled / getPassCount / isBypassed / setOutputTarget), superseded entries (initRendererWithCanvas, renderFrameWithMatrix, mesh_create, the per-entity meshRenderer_setMesh / makeResident beside their …All forms), and three queries nothing read.

    New gate check-engine-exports: every emscripten::function must have a caller in the SDK, the editor, the tools or the tests — the pointer accessors are exempted from the generated layout table itself, so a new component cannot make one look dead.

  • Removed: three machines nothing ever drove. SubmitSkipFlags named two render plugins to skip — one of which (Spine) has had no plugin to skip since spine moved to side modules — and the only submitAll in the engine passed 0; the C++ side of it (RenderTypePlugin::skipFlag, and the parameter) is gone with it, so renderer_submitAll takes a viewport and nothing else. registerAssetBuildTransform / getAssetBuildTransform were a registry with no registrar and no reader — what actually transforms an asset for a build is the cook pipeline. sceneErrors filtered diagnostics for no one. PreviewPlugin / previewPlugin fetched a scene over HTTP and watched it over an EventSource: the editor previews through EngineHost in-process, and nothing had assembled this one since.

  • A Text that names no family is drawn in the project's. fontFamily defaults to empty now, and empty means "whatever this project uses" — resolved where the family is already decided (resolveTextFamily), so the measured wrap and the rendered glyphs cannot end up on different fonts. A scene that stored "Arial" still asks for Arial; nothing on disk changes meaning.

    RuntimeConfig.canvasScaleMode and canvasMatchWidthOrHeight are removed, along with applyRuntimeConfig and the two matching RuntimeBuildConfig fields: the project's canvas fit reaches a runtime as screenFit, and these were the leftovers of the path it replaced.

  • AudioSource.priority decides something now: there is a voice ceiling. Nothing limited how many sounds played at once, so the field described an ordering that never happened. 32 voices by default (features.audio.maxVoices in project.esproject sets your own; 0 = no cap). When the pool is full the sound worth least is dropped for one worth more, ties go to the older voice — which is what keeps a repeated sound audible — and a new sound worth less than everything already playing is simply not started, returning a handle that reports itself as not playing rather than throwing.

  • A particle can be drawn with a material, and the billboard it is drawn on is one piece of arithmetic. ParticleEmitter.material was the last authorable material field with nothing reading it. A material is compiled per vertex source — the engine's canonical vertex stage under a feature, with the author's fragment untouched — and that stage now has a PARTICLE shape beside MESH and SKINNED, reading the instance's position, size, rotation, colour and sheet frame. The built-in particle shader became fragment-only and goes through the very same stage, so the billboard maths that faces a quad at the viewer exists once rather than in the built-in shader and again in every material. MaterialStore compiles both variants through one path now (meshProgram and particleProgram differ only in which features they ask for).

  • A skeleton can be drawn with a material. SpineAnimation.material and DragonBonesAnimation.material were authorable and unread: a skeleton always drew with the built-in batch shader. Both now resolve the same way a Sprite's material does — its program, blend mode, depth flags and cull, plus its #pragma param values — because posed geometry arrives in the very same batch vertex format a sprite does. The material is read from the entity per frame, not mirrored into the runtime, so writing the field takes effect on the next frame. ParticleEmitter.material is still unread and still declared as a gap: a particle is drawn from an instanced vertex source, and nothing compiles a material for that one yet.

  • Render stats count skeletal triangles, not "spine" ones. RenderStats.spine is RenderStats.skeletal, and the wasm export behind it is renderer_getSkeletal — DragonBones geometry was always counted there too. Two dead exports went with it: renderer_submitSpine (an empty function) and renderer_submitSpineBatch (no caller since spine moved to side modules).

  • The lit material domains lose the plane from their names too. #pragma domain Lit2D is Lit and Unlit2D is Unlit. Lit was never the flat half of anything either: a 3D mesh, its PBR shading, its environment reflection and its shadow map all arrive through it, and its "2D vertex stage" is the one that handles MESH, MESH_NORMALS and SKINNED. A .esshader carries no format version to migrate by, so the old spellings are still read as these two — normalized at the parser, in the engine and the SDK alike, so nothing downstream sees two names for one domain. A material graph saved with the old domain compiles to the new one.

    The injected helpers keep their names: applyLighting2D and shadowFactor2D really are the flat lighting model, and they sit beside applyLightingPBR and shadowFactor3D, which are not. What changed is the GPU-side light record, now Light rather than Light2D — the same one both models read.

  • The engine's light and mesh components are no longer named after a plane. Light2D is now Light and Mesh2D is now MeshRenderer. They were never a second, flat pair of components — they are the only light and the only mesh renderer the engine has, and PBR, IBL, cascaded shadow maps, imported glTF models and GPU skinning all go through them. Light2DType is LightType, and the resource, plugin and geometry types follow (MeshRendererAPI, MeshRenderers, MeshRendererPlugin, MeshRendererGeometry). The mesh component is not Mesh, because Mesh/MeshData already name the .esmesh asset — MeshRenderer says which of the two it is, and matches the ShapeRenderer / TrailRenderer the engine already had.

    Scenes and prefabs migrate themselves. A component's name is the key its data is stored under, so a rename is a change to every file holding one: the loader now upgrades the old names on the way in, for scenes and prefabs alike, and the scene format version is 2. An engine older than the rename REFUSES a version-2 scene rather than reading Light as a component it has never heard of and loading a level with no lights in it.

    Breaking for code. A script that imports Light2D or Mesh2D from esengine must import the new name. What the shader dialects inject is untouched: a .esshader still declares #pragma domain Lit2D and still reads a Light2D from the light block, because that is the GPU-side lighting model, not the component.

  • Particles are simulated and drawn in three dimensions. A particle's position and velocity, an emitter's gravity and shapeSize, and a force field's direction are all three-axis now, and the field's zone is a ball rather than a column. The quad is a BILLBOARD: it faces the viewer wherever it is seen from, built from the viewDirection helper both shader dialects already had — and head-on under an orthographic camera those axes come out (1,0,0) and (0,1,0), which is the flat quad every 2D scene has always drawn. A billboard is not a second path; the flat quad is the corner of it a 2D scene sits in.

    Breaking for code, not for data. gravity / shapeSize / direction are Vec3 in TypeScript, so { x, y } written in a script no longer type-checks — add z: 0 for what it meant. Scenes, prefabs and saves already on disk are unaffected: component data is now merged one level into nested objects, so a pair written before the field grew an axis reads back with a zero depth.

    What stayed two-dimensional, and why: the curl-noise field is a flow sampled on the plane a particle is over, an emitter's own rotation is a turn about Z as a flat scene's is, and a trail ribbon is widened in the scene's plane rather than toward the eye (a per-segment billboard is a turn its vertex path has no room for). Emission aims in the emitter's own plane; a 3D emitter is turned, not given a second angle nobody authored.

  • Draggable is an engine component. It was a script component, so it never reached the inspector's reflection table, the scene file or the editor's usual component list the way engine components do. Its optional bounds changed shape in the move: constraintMin/constraintMax were {x, y} | null and are now a Vec2 paired with a constrainMin/constrainMax flag, because zero is a usable limit and cannot double as "no limit". DragState stays a script component — it is per-frame state, never authored and never persisted.

  • The visual editor is no longer open source. It moved to a private repository (esengine/estella-editor) and is mounted back at desktop/ as an optional submodule; the engine — runtime, SDK, asset pipeline, CLI, project templates and the editor plugin API — stays Apache-2.0 in this repository. Everything released through 0.55.0 keeps its irrevocable Apache-2.0 grant, including the editor, which is why the per-file SPDX headers on pre-split files are left as they are. BUSINESS_MODEL.md says what was promised before and what changed, in the place the old promise was written.

  • The engine verifies its own renderer. All 108 pixel gates used to run on the editor: the runner served desktop/dist, whose entry pulled in EngineHost + EditorSession, so the gates asserted about the renderer as the EDITOR drives it rather than as a shipped game does. tools/render-host/ is the engine's own headless host, built out of shipped SDK calls with no authoring model between the scene file and the World. 100 gates now run engine-side; the 8 whose subject is an editor door declare host: 'editor'. verify-render.mjs --host engine|editor picks a list.

  • Project templates and scene fixtures are engine-side. desktop/templates → templates/ (the root templates/ it replaced was dead — nothing substituted its placeholders), and desktop/public/{scenes,assets} → fixtures/.

  • The plugin type surface is its own package. desktop/src/plugins/types.ts → editor-api/index.ts (@estella/editor-api), so plugin authors and plugins/* need no private code to build against the contract VERSIONING.md makes promises about.

  • The engine's version is the root package.json. desktop/package.json was the single source for the CLI's engine version, the native template stamp, the docs site and the release-metadata gate — none of which can depend on a submodule that may not be checked out.

Fixed

  • WebGPU reused one pipeline for two different colour formats. The pipeline variant key mapped every 8-bit unorm format to one slot, so a pipeline built for the surface (BGRA8Unorm) was handed to a pass on a render target (RGBA8Unorm) — which WebGPU rejects outright, taking the whole command buffer with it. Nothing had drawn a scene into an offscreen target on that backend before, so nothing had asked.

  • The manual taught an import that does not exist. facingFromQuat was removed when perception moved to a dot-product cone, and four pages went on importing it — including a complete turret example a reader would copy. It is quaternionToAngle2D, the same arithmetic under the name that survived. Two more imports named symbols that exist but were never exported: VideoBackendContext (what a replacement video backend is handed) and wechatProfile (the host profile you spread to change one thing) — both are extension points the same pages teach, so they are exported now rather than written out of the docs. New gate check-doc-imports: an import line in the manual must name something the SDK exports, because a reader copies it verbatim.

  • A C++ harness that had never been compiled. test_bitmap_font asserts the guard on BitmapFont::createLabelAtlas against degenerate dimensions — a divide-by-zero that traps on wasm and fills the atlas with garbage where it does not — and its own header explained it was left out of CMake because the BitmapFont TU references the resource stack. It references exactly two symbols from it, through a loader this never calls; the harness stubs them, and it builds, runs and passes with the rest. check-cpp-tests now also compares the harness SOURCES against what CMake declares: it used to compare CI's list with CMake's list, and a file neither mentions is invisible to both.

  • Three physics smokes had nothing to run them. The 2D character mover (resting height, skin width, floor snap, ceiling), the joint and mouse-drag features, and sensor overlap each had a headless smoke sitting in sdk/tests that no gate, script or workflow scheduled — 30 assertions against the real wasm, none of them ever asked. They all pass, which is the point: nothing was checking, so the day they stopped passing would have been a day nobody noticed. New gate check-physics2d runs them, in CI where the binary is. It also refuses a smoke that no gate names, so the same hole cannot reopen by someone adding a fourth file.

  • 2D shadows had no pixel criterion at all. Four fixture scenes exercise ShadowCaster2D — a hard point-light shadow, a soft one, a directional one — and nothing drove any of them: the criteria that once did are gone, and the scenes staying behind made the coverage look whole. All four run now, on both backends, probing either side of the occluder on the light's axis; removing the caster turns the shadowed probe from black to lit, which is what says they are looking at the shadow rather than at the scene.

    New gate check-fixture-scenes: a fixture with no criterion behind it must be named, with what it would prove. Four more of those fixtures now run: a KTX2 transcode is checked against the same image as a PNG, half by half, so one arriving upside down is caught (the existing KTX2 criterion reads colour, which a flip does not change); a parallax factor of 1 must leave a sprite where the world put it; anchored UI panels must land on the edge they name; and a Text's UINode box must keep its width. Four remain, three because what they would prove is a glyph — a probe on one reads the host's font, not the engine. Two other fixtures were neither driven nor worth driving: platformer.esscene and space-shooter.esscene were copies of golden project scenes, built out of game script components that do not exist in the fixture corpus.

  • The UI hit test took three mouse flags and threw them away. uiHitTestWorld(world, x, y, mouseDown, mousePressed, mouseReleased) carried them into the engine, which (void)-ed all three: it is a raycast, and what a press or a hover MEANS is the interaction system's, in TypeScript. The doc comment said the flags "drive hover/press state", and a test asserted they reached the engine — which is exactly what a test that checks the seam rather than the behaviour can prove about a parameter nothing reads. The flags are gone from the SDK function, the binding and the C++ method.

  • The project's default font family never took effect. It was written into RuntimeConfig and read by exactly one function — applyRuntimeConfig, which nothing called — so setting it changed no text anywhere. Two more places answered "which font" with their own hard-coded 'Arial' (widget composition, text measurement), which is how it stayed unnoticed: everything looked right because everything independently agreed on Arial. There is one default now, and it is the configurable one.

  • An AudioSource in the scene was outside everything the audio API decides. It was played straight at the backend, so on a backend with no mixer graph — WeChat, a device — the bus volume and mute the API folds into each voice never reached it: turning the sfx bus down left every scene sound at full volume. It goes through Audio.playBuffer now, the same door a scripted playSFX comes through, which is also how it came to be counted against the voice cap.

  • A build with DragonBones but no Spine had no way to draw a skeleton. The binding every skeletal runtime submits its posed geometry through was compiled only when ES_ENABLE_SPINE was on — so with Spine off, DragonBones handed its vertices to an export that was not there and drew nothing, silently. The core links neither runtime (each is a standalone side module), so that door is now always open, and a new gate check-sidemodule-gates refuses any side module's build option that decides how the core compiles. No released build is affected: every shipping configuration has Spine on. The one that does not — CMake's esengine-core — has never been built.

  • A component that describes a region of world is drawn, and a gate says so. NavAgent's routing width, ParticleForceField's reach, ShadowCaster2D's occluder box and PostProcessVolume's graded region were all authorable numbers with nothing on screen to show what they covered — the same gap the light gizmos had. All four now draw their extent, from one table rather than a gizmo path each: an extent is a ball or a box wherever it comes from, and what differs is what it MEANS, which is its colour. New gate check-gizmo-coverage: a component declaring a spatial field must be named in the viewport, because gizmo-chrome's list is written by hand and cannot notice a component nobody added to it. size counts, with the components that ARE their own picture (a sprite, a shape) listed rather than the field name dropped — dropping it to spare the sprite is what hid the volume.

  • Component data merges one level into nested objects. A builtin's fields were laid over their defaults with a shallow spread, so a value the data carried replaced the default whole — and a {x, y} written before that field grew a z arrived with no depth at all. Not an error, a silent zero: two of the engine's own particle scenes rendered nothing the moment gravity became a Vec3. The script path already merged this way through create; both now share mergeIntoDefaults, which also copies nested defaults rather than handing every entity the same array.

  • Three particle fixtures had no check running them. particle-trail, particle-collision and particle-forcefield existed as scenes that nothing loaded — the trail, floor-collision and force-field paths were unwatched, which is where a simulation rewritten in three axes most easily stops producing a frame. All three now run at PR tier, alongside a new particles-billboard that views one particle from the side: a quad fixed in the x/y plane is edge-on there and covers nothing.

  • What a scene can be navigated over can be seen in the running game. NavDebugDraw outlines every walkable face where it actually is — at the height of the ground for a mesh, in the scene's own plane for a grid — and marks in red every edge the walkable world stops at, which is the only thing that explains a route going the long way round. Until now cellSize, agentRadius and agentHeight were tuned by watching whether an agent happened to move. One drawer for both kinds of surface, off by default, and capped at a few thousand faces: an overlay that stops the game is not a diagnostic.

  • A draw overlay does not throw a frame on a core that cannot draw. Plugins register their overlays when they are built, whether or not one is ever turned on, and a core built without a Draw API has no batch to open — the render pipeline opened one anyway and lost the frame to it. Both callback passes now check first. Found by registering the navigation overlay, which broke a minimal-core test that has nothing to do with navigation.

  • A post-process volume is a volume. signedDistanceBox and signedDistanceSphere measured in x and y, so a "sphere" was a column: a camera two floors above a graded room was inside it. Both take three axes now, and PostProcessVolume.size gains an optional z half-depth whose 0 means unbounded — a box of no thickness contains nothing, so the value is free to mean what every flat scene's volume already was.

  • A navigation volume is visible while it is being placed. Nothing renders a NavVolume and nothing collides with it, so the box that decides where agents may walk was invisible in the editor — the one thing about it worth checking. It now draws its wireframe, axis-aligned as the bake samples it rather than turned by the entity's rotation, which would draw a volume nothing is sampled from. It joins gizmo-chrome, the gate that fails a gizmo which computes a shape and does not draw it.

  • A 3D scene authors where its agents may walk. NavVolume is a box on an entity; the nav plugin bakes the navmesh inside it out of the scene's own collision geometry and installs it, so navigation is authored in the scene rather than written by every game. Its fields are all facts about the agent or about how finely the world is measured — cellSize, cellHeight, agentHeight, agentRadius, stepHeight, maxSlopeDegrees, layers — never about the route, which is what the bake works out from them. Only STATIC bodies count: a crate about to be pushed is not floor. A volume that finds no walkable ground says so in the log instead of leaving agents standing still for no stated reason, and one too big to voxelise at its own cellSize says that rather than freezing. New editor check nav3d-play walks an agent round a wall in the running game and reads the two floors of a column it never walks on.

  • A 3D scene's navigation is a real navmesh. buildNavMesh voxelises the scene's collision triangles into a solid heightfield, keeps the surfaces an agent of a given size could stand on, and turns what is left into convex polygons that know their neighbours — the Recast pipeline, in TypeScript beside the grid A* rather than through a second wasm module. Every column of the world keeps all of its floors, so a bridge and the road under it are two places and an agent can be on either; a route is planned polygon to polygon and then pulled taut through the doorways it crosses, so crossing an open floor is one straight line rather than a staircase of cells. Four things can take ground away and each is asked for the one answer only it has: too steep, no headroom, on the lip of a drop, or closer to a wall than the agent is wide. agentRadius is baked in rather than applied per query — the mesh is the set of places a body that wide may stand, which is why a route over one is already clear of the walls.

    collectNavGeometry gathers the triangles from the collider components the editor gizmo and the physics overlay already read, so a mesh cannot be baked from a shape nobody can see, and a mesh collider contributes its own triangles rather than the box around them. Nothing waits for the solver any more: the geometry is in the scene from the first frame.

  • Ground can cost something. The mesh answers where an agent CAN walk; NavArea is where a scene says what it would rather walk on. A box, a cost against 1 for open ground, and routes that go out of their way for a road at half price and round a swamp at four times. It never BLOCKS — an agent with nowhere else to go wades through, which is the difference between a swamp and a fence, and the difference between this and NavObstacle.

    Both surfaces answer to it: a mesh gives every polygon the area its patch marked and multiplies each step by what that area costs, a grid prices the cells. Which patch a polygon belongs to is baked; what the patch costs is read fresh every search, so a price can change for nothing and only moving one rebuilds anything. The string-pull respects it too: a shortcut may not cross ground priced differently from the ground it starts on, because straightening a route back through the mud it had just gone round undoes the only reason it went round.

  • An agent sent somewhere it cannot reach walks to the door. findWorldPath and findPath returned nothing at all when the goal could not be reached, so an agent whose target was behind a shut door — or momentarily on the far side of one — stood exactly where it was and waited. They now answer with the route to the nearest place that CAN be reached, which is what every game wants and what the docs already promised for a goal standing in a wall. null is left meaning one thing: the agent itself is nowhere.

    Whether it got there stays visible, because the caller named the goal and the last waypoint either is at it or is not — no flag, and no second question to ask. A goal off the mesh entirely is a direction too: the walk toward it is still a walk, round the wall rather than through it.

  • A 3D AI example, and the last thing sensing could not act on. Perception has reported where a target is on all three axes since sensing became three-dimensional, and targetZ / dirZ had no reader anywhere: the chase a game writes is what reads them, and the one example that wrote one was a flat scene. examples/enemy-ai-3d is the other one — hunters that see the player through a doorway, route round the wall between them, climb a terrace by a link the ground does not provide, give way to each other on the way, and turn to look at what they saw. Every navigation part in one project, which is also what the new editor check enemy-ai-3d opens and watches: sabotaged by dropping the third axis from the chase, the hunters walk to the spot 420 units short of the player, which is exactly what the declared gap said would happen.

  • Two characters no longer walk through each other. A CharacterVirtual is swept against the WORLD, and the world does not contain characters — so nothing was ever checking one against another, and two of them met by occupying the same space. Jolt's own character-vs-character check is registered now, which is the one pair of shapes a player is sure to notice interpenetrating. Two new behaviours in the 3D physics gate: they meet rather than pass, and they stop a body apart. Found while giving NavAgents avoidance — steering kept them from aiming at each other, and nothing underneath would have stopped them arriving.

  • Agents give way to each other. A route is planned against a world that does not move; agents do, and a dozen sent to one place all planned the same route and walked it as one body. An agent whose radius is greater than zero now declares that it IS a body and steers round the other bodies on the same ground: a spread of candidate velocities around the one it wanted, scored on how soon each runs into somebody and how far it strays. Reciprocal — everyone assumes everyone else is giving way too, so each takes half and two meeting head-on part instead of both dodging the same way and meeting again. Where the arrangement is a perfect mirror, the convention that parts them is keep right.

    Sampled rather than solved, because a sample can be REFUSED: every candidate is checked against the navigable world before it is taken, so steering never walks an agent into a wall. Two bodies too wide to pass in one corridor therefore do not pass — waiting is the honest answer and going through the wall is not. NavSurface gained the question that makes it possible, isNavigable, which is not the same question as "is there a route here". An agent with radius left at 0 is routed as a point and neither gives way nor is given way to, which is what every flat game had before this. New editor check nav3d-crowd walks four agents across the same square and watches how close they ever come.

  • A scene can say there is a way where the ground has none. A mesh baked from what an agent can walk says two floors with a gap between them are two places, and it is right. NavLink is where a scene says what the floor does not: this ledge is a drop, this ladder climbs, this plank reaches the roof. Both ends are offsets in the entity's own frame, so a link travels and turns with whatever carries it, and one whose end reaches no ground joins nothing — a route ending in the air is worse than no route. Moving or switching one costs a lookup rather than a bake, because it joins polygons that already exist.

    The route BREAKS at both ends of a link: pulling a funnel taut over a ladder would plan a walk through the air beside it, so the search is run over each run of polygons and the runs are joined end to end. Which uncovered the other half — an agent crossing a link is not standing on the navigable world, so the replan it asks for there has no answer and it used to strand itself mid-air. A plan that cannot be replaced now beats no plan: a failed replan keeps the route the agent was already walking, which is also the right answer for one standing where a door has just shut. New editor check nav3d-link switches a link on in a running game and watches an agent climb it.

  • A door can shut. NavObstacle is a box that takes ground away from the navigable world without being geometry — a door, a gate, a tower just built — and enabled is what opens it again. Blocking is a BAKE input rather than a filter over the answer: the ground goes before the walkable area is eroded, so a route keeps the agent's full width clear of an obstacle instead of scraping its face. Changing one rebuilds the world, at most a few times a second, and an obstacle that never stops moving says so once rather than taking the frame rate with it. Both surfaces answer to it: a mesh is baked again, a grid has the cells under the box marked — in a mask of its own, so a door closing and opening gives back exactly the ground that was there, including the ground the map itself said was blocked. Unlike the volume it turns with its entity, because a volume IS the voxel grid and this only marks cells in one. New editor check nav3d-obstacle shuts a doorway in a running game and opens it again.

  • A NavAgent with a body is steered, not moved. The follower wrote the Transform, which is right for a marker and wrong for a character: a CharacterController3D has a solver of its own that collides, steps up and falls, and a Transform written from outside it fights that solver and loses — measured, an agent driven that way does not move at all. An entity carrying one now has its horizontal velocity written toward the next waypoint instead, and the vertical axis is left alone, because that one is the world's and writing a zero there would hold the body in the air. Distances for such an agent are measured in the ground plane: a character stands with its capsule's centre above the floor its route was planned on. New editor check nav3d-character, the one place the mesh, the character solver and the follower between them all exist at once.

  • A route over a grid is pulled taut, like a route over a mesh. A* answers in steps of one cell, so crossing open ground came back as a staircase and an agent walking it wobbled down every diagonal. shortenPath keeps only the cells where the route has to turn, and takes a shortcut only along a line the search itself could have walked: every cell it touches fits the body, and a diagonal needs both of its shared orthogonals. Both shapes of NavSurface now hand back the same shape of route, so moving a game from a tilemap to geometry does not change how its agents move.

  • A scene has one navigable world. Two NavVolumes were baked a frame apart with the last one silently winning, which made which mesh a scene got an accident of iteration order. The first is baked and any others are named in the log: a box decides where to LOOK, walkability comes from the geometry inside it, and one box big enough to hold the level costs voxels and never costs correctness.

  • Navigation plans and walks in three dimensions. Paths, NavAgent (targetZ) and the kinematic follower carry all three axes — a slope is longer than its shadow, and spending a frame's budget on the shadow walked agents uphill faster than along the flat.

    Breaking. There is now one interface, NavSurface, and two shapes behind it: NavGrid for a world that already IS cells (a tilemap, and the only one a game can flip a cell of while it runs) and NavMesh for a world made of geometry. Navigation.grid / setGrid / hasGrid are surface / setSurface / hasSurface, and the agent, the overlay and findWorldPath never learn which kind they were handed. NavGrid is a flat grid again — plane, surface, stepHeight and canStep are gone with the ray-cast heightfield they were added for, which the navmesh answers everything of and more. NavDebugDraw's showCells / showLedges are showFaces / showBorders.

  • AI sensing is three-dimensional. A Perceiver's range came from x and y, its cone from atan2 in the same plane, and its facing from the Z half of a quaternion — so a guard saw through floors, and any rotation but a flat one computed a facing out of nothing. Range and cone are now measured in all three axes (the cone as a dot product, which is the same test where both lie in a plane), and Perception reports targetZ / dirZ. Line of sight goes through the 3D solver where a scene has one; Perceiver.facingAxis picks the entity axis the cone points down (x — screen-right, what a flat scene means — or -z, where an imported model faces), and Perceiver.losLayers is the layer mask the 3D sight ray is cast against, since a ray from inside the observer's own collider hits it first.

  • Network interest is a sphere. radiusInterest measured the distance to a connection's pawn in x and y, so two floors of a building were one place and every connection streamed both — the saving the policy exists to make is the one it stopped making. The reader hook's return type is now InterestPoint, whose z is optional, so a flat game's reader keeps answering in two.

  • Spatial audio and camera follow are three-dimensional. Both measured the world in x and y only, so in a 3D scene a source across the room was as loud as one in your ear, and a camera lost its target the moment it walked in depth. spatialDistance now takes all three axes, calculatePanning projects onto the LISTENER'S own right (an unturned listener's right is world +X, so a flat scene is unchanged) and followStep damps a 3D point through a spherical dead zone. FollowTarget gains offsetZ and a followZ switch — off by default, because a flat scene's camera z is how far back it stands, and following it would walk the camera into the plane its content lives on.

  • A gate that reads a build product says when that product is stale. component-reference --check re-derives field data from sdk/dist "when a built SDK happens to be present", and never asked how old it was — two fields added to a TS component read as clean against a dist that predated them. It now compares the build against sdk/src and reports the field data as not checked rather than passing. newestSource is shared with the wasm freshness gate.

  • The engine-freshness gate answers per build variant. wasm.manifest.json carried one builtAt, stamped whenever the manifest was last written, and listed the variants merely present on disk — so building -t web vouched for a wechat binary of any age. A mini-game golden pair then failed its ABI handshake and read as a component regression (Draggable: missing addDraggable) with the freshness gate green. Each variant is now dated from its own newest artifact (manifest schema 2, written into the build dirs as well as the synced ones), staleEngineBuild takes the variant in question and names its build command, and verify-golden checks the engine behind every target a tier will package before it packages the first one.

  • A drag turns the view the way it grabs it. Dragging the editor eye moved the yaw one way and the pitch the other: a diagonal drag pulled the scene left while pulling it down, because only the vertical half followed the pointer. Both halves now grab the scene — the world turns the way the pointer moves and the eye goes the other way, which is what a turntable orbit does everywhere else. The sign convention lives in one function (orbitAfterDrag) that every drag door calls.

  • tsc-editor reported success with no editor to check. pnpm --filter prints "No projects matched the filters" and exits 0, so an uninitialised submodule left the gate type-checking nothing and passing.

  • CI's shader-twin steps would have silently narrowed. Both still globbed desktop/public/scenes, so after the fixture move they would have checked examples/ alone and stayed green.

  • The repo root and the SDK were both named esengine, so pnpm could resolve esengine: workspace:* to the repository root instead of the SDK. The root is now estella.

  • check-physics3d and verify-desktop-render were engine checks reading out of the editor's directory; the four SDK physics smokes hard-coded desktop/public/wasm rather than the engine's own build output.

  • Two C++ harnesses had stopped agreeing with the engine. Particles gained a third dimension and neither was rebuilt against it: test_particle still assigned vec2 to a vec3 gravity — a compile error, so the web and sanitizer jobs stopped there and the six jobs that need their artifact did not run for a day — and test_batch_builder asserted a 40-byte particle instance slot the engine's own static_assert already calls 44. The stride is now mirrored the way the shape stream's already was, so the next field is a compile error in one place rather than a magic number that drifts.

  • An export only the editor calls is not an export nobody calls. check-engine-exports named the roots it could not scan and then judged the exports anyway, so engine_getGpuScopes — reached from the editor's EngineHost and playHost — failed CI while every checkout with the submodule stayed green. Unscannable roots now make a verdict unverified rather than dead, as check-component-fields already did for fields, and the summary counts what it actually judged.

  • The pixel runner stopped racing a GPU process that never arrived. It launches one Electron per scene, and on the Linux runner two launches in three lost the race between the page asking for WebGL2 and the GPU service being able to answer; the retries for the rest spent the budget, so 62 of 85 scenes never ran. Linux now hosts the GPU in-process — the same SwiftShader, so the same pixels — and the tier is back to 85/85 in about two minutes.

  • A gizmo the size of the viewport is no longer judged by a box inside it. gizmo-chrome measured each gizmo's ink inside the viewport region and a 300px box around the entity. The Camera's shape is not a reach around its entity: the rect it frames is the design rect, which the editor's own framing fits to the viewport, so its edges sit at about half a viewport away at any zoom. They measure 299px; the box ended at 300. The viewport is now the only bound.

  • The editor's check runner takes its projects back. Every check writes a temp project and opens it in a real editor, which imports into it; none was ever removed, and about 700MB a run shares a disk with two checkouts, two node_modules, electron and the wasm. That disk ran out — and a runner with no disk cannot write its own log, so the failure arrived empty.

  • Four waits were written for a machine other than the one running them. The editor's pixel gates had no budget, so a bad run spent the whole job and was killed mid-step; starter-3d gave play, step and probe 180 seconds each and left the three calls between them on the 30-second default, though the same editor answers all of them with the same frame queue in front; the 45-second scene watchdog was measured on the engine's host and applied to the editor's, which spends 12 of those booting the engine through the whole editor before a scene is loaded; and fetching two optional Android oracles — deeper checks the tests skip when absent — was bounded by nothing, hung for 38 minutes, and took the ceiling of a job whose other nine were green, which is a job that writes no log.

  • One performance ratio was measuring the machine. ui-layout: editing a field vs an idle frame failed at exactly +50% against the shared 50% tolerance on a commit that changed only a workflow file. Its denominator is the idle frame, 20µs — twice the floor below which this gate already refuses to read a sample — and it does not slow down with the machine the way the edit beside it does. It carries its own tolerance now, and a regression names the one it broke.

Added

  • The navmesh is visible while a scene is being authored. The volume's wireframe said where the bake would LOOK; what it found could only be seen by entering Play and turning on a runtime overlay, which is how cellSize, agentRadius and agentHeight came to be tuned by watching whether an agent happened to move. View → Show Navigation Mesh (and a viewport toolbar button) bakes the scene's volume in the editor and draws the walkable faces where they are, with the edges they stop at picked out. It rebakes as the scene changes — at most a few times a second, since a bake is the most expensive thing an edit can ask for — so widening agentRadius pulls the mesh back from the walls in front of you. It is the same buildNavMesh the running game calls, so the picture and the routes cannot be two different answers. New editor check navmesh-preview, which asks for an AREA rather than ink (a box outline is ink) and for the area to shrink when the agent is widened.

  • Right-drag turns the editor eye. It panned, like the middle button, so the only way to look around a 3D scene was Alt-drag. Right-drag now turns a view that has somewhere to turn to — a perspective one, or one already off head-on — and keeps its pan on a flat 2D view, where turning is an accident rather than a gesture. Middle-drag (and Space + left) still pans everywhere, Alt-drag still turns anything. viewportNavFor is the whole button map, in one place.

  • Import settings are edited in batches. Selecting several assets showed the primary one's inspector, so "make every sprite in this folder nearest-filtered" was one asset at a time. The Details panel now edits the whole asset selection through the same reflection sections a multi-entity selection uses: a field the selection disagrees on reads as mixed, typing one writes it to all of them, and Save writes a PATCH — only the keys touched — so settings nobody edited are not levelled onto each other. Assets of types that share one importer schema (a sprite and a texture) batch together; a selection spanning two schemas says so instead of offering fields half of it has no answer for. ProjectStore .setImportSettingsMany is the batch door — one rescan, one re-import pass — and set_import_settings / select_asset take an array of paths, so an agent can do the same in one call. Content-browser Reimport and Copy Path follow the selection too, the rule Delete already followed. New editor check batch-import-settings.

  • Gates hold up without the editor. Nine gates whose subject IS the editor declare needs: 'editor' and are named when skipped. Gates spanning both (cycles, component-fields, import-settings, component-reference, release-gate) report exactly what they could not judge — a field whose only reader is the inspector is unverifiable here, not dead. Verified against a deinitialised submodule: 45/45 static gates and 100/100 engine pixel gates green, with every downgrade printed.

[0.55.0] - 2026-08-21

Fixed

  • No packaged game had ever loaded a mesh on a device. Three examples refused to boot on either phone with this engine build carries no mesh_createFromChannels — model-import, lighting-3d and physics-3d, which is every example with geometry in it. The binding is there, in the published host's .so and in the generated native API; what is not there is a wasm module, because a packaged game passes module: null and the engine core is native. The mesh and environment loaders were the last two reaching for app.wasmModule — which engineApi.ts's own header calls a statement about HOW the core is embedded rather than what the caller wants. They ask for the core now: the module on the web, the host's bindings on a device, both answering the same entry points and a heap to marshal through. So 3D could not ship to a phone at all.

  • A rigged model could not reach a device's registry. lighting-3d was the last example that would not boot on a phone: C++ Registry missing methods for component "MeshSkin". The native registry is assembled from PTR_ACCESSORS, and MeshSkin has no accessor because its only field is a variable-length entity list — no fixed offset, nothing to lay out. The binding generator says so inside its own output (// skip joints … needs a bespoke binding) and nothing had ever read that line, so a glTF with a rig in it has never been shippable to a device. MeshSkin joins Parent and Children, the other two with no POD layout, as a hand-presented surface — and a gate now requires every builtin to reach the registry on a device by one route or the other, because the shape of this bug is that nothing asks.

  • A compressed texture's mip chain uploaded levels the device refuses. Ten of the forty-two examples did not boot on either platform, the flagship among them, saying copySize.width (2) is not a multiple of compressed texture format block width (4). The guard that existed asked whether the IMAGE is whole blocks, and a 72×72 one is — its third mip, 18×18, is not. The rule is one function beside the block metadata it reads now, so the level count comes from the FORMAT's block rather than from the number 4: an ASTC 8×8 device stops a level earlier than a 4×4 one, which the old check never asked.

  • The fallback for a texture that is not whole blocks had never once worked. platformer did not boot on either phone: KTX2 transcode failed. The file is the 70×70 one put in the corpus on purpose so that fallback has something to fall back on. The decode counts its output in the units basis wants, and the comment beside it said block_width/height is 1 for RGBA32, so this covers both — it is not: basis reports a 4×4 block for RGBA32 as well, so a 70×70 image was offered 324 units of a buffer where the call wanted 4900 pixels, and returned false every time.

  • A re-encoded Spine or DragonBones atlas page was unloadable on a device. spine-demo and dragonbones-demo did not boot on either phone: KTX2 atlas page but no Basis transcoder in this realm. There is none and there never will be — a native host decodes KTX2 in C++, which is why TextureLoader asks the ResourceManager first and only falls to the wasm transcoder behind it. The two atlas loaders knew only the second half of that; three copies of "which form is this page in" was how two of them came to know about only one answer.

  • A module a realm was never built to carry is not a failed load. spine-demo and dragonbones-demo reported a broken boot on both phones over failed to load "basis". Nothing was broken: a native host compiles its subsystems in, so it has no basis and never will, and every caller already treats the null as "not available in this realm". SideModuleAbsent is the transport saying so — reported and answered null — while any other throw is still a load that failed and still says so.

  • A device drew no text at all. No example had ever put a glyph on a phone. rich-text captured its panels, its input box, its button and its image with not one character, and passed the smoke at 190 colours because flat panels clear a two-colour bar. Four things, each hiding the next.

    renderer_submitTextBatch takes eleven arguments and its last is cullBit; the QuickJS binding generated from that signature opens if (argc < 11) return JS_UNDEFINED. The web path passes eleven and the native seam passed ten, so every text batch a device ever submitted was dropped on the argument count, silently, in generated code nobody edits.

    With text arriving, CJK on iOS drew nothing while Latin in the same string drew. The font cache was keyed by PATH, and a collection holds many faces at one path — so whichever face was parsed first answered for every other one in the same file, on every platform whose matcher returns an index. It is keyed by the pair now, and Apple, which had left that index 0, looks it up from the descriptors of the file it names, matched by PostScript name.

    Then the diagnostic named the real one: PingFangUI.ttc face 185 "did not parse". Not a match that failed — a match the parser cannot read. stb_truetype looks for a CFF table and has no mention of CFF2 anywhere, and Apple's system CJK is CFF2 variable, so every face Core Text correctly fell back to loaded nothing. Platform grows drawGlyph, which Apple answers with Core Graphics and everyone else declines; what it hands back is coverage, not a tile, so sdfFromAlpha, the downsample and the atlas packing stay one implementation for both.

    And the CJK came through upside down, because Quartz DRAWS y-up and STORES top-down — two conventions in one API, and reading the drawing one as the storage one reversed the coverage row by row, exactly undoing an order that already matched the atlas. The colour count was 4096 either way up; this was caught by looking at the frame.

  • A shadow pass draws depth, not what the material says. lighting-3d booted on Android and drew a black screen every frame after the first, with Dawn rejecting every command buffer: the 2048² texture whose usage "includes writable usage and another usage in the same synchronization scope" is the shadow atlas, and the pass sampling it was the pass writing it. MeshPlugin suppressed lit and the normal map for a shadow pass and cleared the material where the key is built — and the material resolve ran AFTER that clear and put it straight back, so an occluder carrying a material wrote its shaded colour into the depth atlas through a variant that declares the shadow sampler. The pass has the last word now. Below it, two things that let one draw's mistake become the whole frame's: a draw that samples states its WHOLE sampler block (only the Batch layout pinned its unused units, while the shaders declare all 8 regardless), and WebGPUDevice refuses to sample the current pass's attachment. Gate mesh-shadow-material — no scene had put a material and a shadow caster in the same scene at all.

  • Every generated WGSL twin was stale, and sixteen of twenty read their uniforms at the wrong stride. A user-authored .esshader gets its WebGPU twin generated by translating the ASSEMBLED GLSL — the authored stages plus the header the engine injects — and the stamp that says whether the twin is current covered only the authored half. So when Light2D grew a fifth vec4 for the shadow atlas, every generated twin went on declaring the old four-vec4 struct and read LightConstants at a 64-byte stride where the engine writes 80, while the gate said has-twin. What that renders is not obviously broken, which is why it survived: light 0 is the one slot whose fields still line up. The 15 slots after it, the occluders, the shadow matrices and the whole environment block are read from the wrong offsets — including in the five shaders shipped in examples/effects-gallery. The stamp is over what the twin is a translation of now. Render nightly is 106/106 on WebGL2 and 105/105 on WebGPU, the first time the second backend has been whole.

  • A collider on a layer the project never named stopped colliding. collisionLayerMasks arrives from project settings at whatever length the project saved, and resolveCollisionMask read layerMasks[i] for any category bit up to 16 — so a collider on a layer past the end of that table got undefined as its filter, which reaches wasm as a mask matching nothing. No error to find. It falls back to the collider's own maskBits now, which is what "the table does not name this layer" means.

  • An upgrade a scene refuses does not replace the scene. loadCurrentScene runs the SDK's migration, which REFUSES what it cannot mean — a shape with no entities, a format newer than this engine — so the open path went from "always opens" to "may throw", and exitPrefabMode caught a throw by handing back a BLANK document. The runtime is right to refuse a file it cannot mean; a document tool is not, because that file is what the person opened the editor to fix. An upgrade that refuses opens the scene as written and says so.

  • A DragonBones scene loaded through automation drew nothing. SceneLoader.loadInto bound spine and stopped, while the PROJECT transport has bound both all along — so a scene with an armature in it loaded, reported its entities, and drew nothing, with no error anywhere. It binds both now, through one ref resolver rather than two copies. The scene that found it stays, as a pixel gate beside spine's.

  • The Windows host stopped building on a string literal. MSVC accepts 16380 bytes in one, and kLit2DHeaderWGSL had reached 18019 — the shadow work grew it a function at a time and nothing said so, because CI builds linux, macOS, Android and iOS. Split into two adjacent literals, verified byte-for-byte identical, and check-shader-literals holds the line: C2026 points at the line the literal ENDS on, nowhere near whichever function pushed it over.

  • The 3D physics example draws the world it solves. It had no renderable in it at all — eleven bodies, a character and a hinge, with only the debug overlay on screen. A physics example nobody can see except in debug mode is a poor example, and it is also why the golden interact criterion could not make its claim about it: the reducer that asks "did the picture answer the key" reads thin wireframes on black, so the declared key moved it 0.0724 where a key NOTHING reads moved it 0.0457. Every body carries the cube its collider is now, and the same measurement gives 0.2772 against 0.0241 — the 0.15 the corpus asks for with an order of magnitude on each side.

Added

  • A WebGPU run says which adapter drew it. --use-webgpu-adapter is honoured for a name Chromium knows and ignored in silence for one it does not, and nothing reported what was actually used — so a passing WebGPU run could not tell hardware from a software rasterizer, and the switch asking for one proved nothing. The headless harness could not have shown it either: its console filter spelled webgl, which does not match webgpu, so the second backend's whole boot was the one thing never forwarded. What it answers: all 85 scenes declaring the second backend pass on Electron's bundled SwiftShader, so a GPU-less runner's failures are that runner's Vulkan stack rather than Dawn's ability to drive a software rasterizer.

  • A device's boot record says what its frames drew. A capture is one flat colour whether nothing was drawn or it was drawn where the view is not, and those want opposite investigations — and the first question, did the engine submit anything, was the one nothing could answer. The periodic frame line carries the counts now (draws, triangles, sprites, meshes, text, culled) and reports on a ramp — frames 1, 2, 5, 10, 30, 60 and every 120th after — because a run judged half a second in never reaches a 120th frame, and the last line printed is how far the loop got. A stretch of skipped frames says so once, and so does coming out of it: skipping because no surface is bound looks from outside exactly like a game that hung, and which of the two it is decides where to look next.

  • A sun has a size too, and it is an angle. A light with a position carries its source as a half-extent in world units, and the penumbra follows from dividing that by the distance to what blocks it. A directional light has no such distance — its source is infinitely far away — so a length says nothing about its shadow's edge, and its cascades stayed hard while every other light's softened. Light2D::sourceAngle is what it carries instead: the full angle its source subtends, in degrees, 0.53 being the real sun's. Every engine that does this splits it the same way, and for the same reason.

    One expression still serves both, which is the point: the penumbra is the tangent of the angle the source subtends AT THE BLOCKER, times how far the receiver stands beyond it. A map with an eye divides a half-extent by the blocker's distance to get that tangent; a map without one measures its own w as 1 everywhere, so what it divides is the tangent itself. The shader picks between them on a property of the matrix — whether its w varies with position — and the same line computes the radius either way.

    What it costs to know the blocker's distance is nothing new either. The map's depth row has length A, and each kind of map inverts its own depth with it: hyperbolic where there is an eye, linear where there is not.

    Gates sun-shadow and sun-shadow-contact, both backends: one scene with the caster at two points along the SAME sunbeam, so its shadow lands in the same place and only the edge differs — 9 world units of penumbra with the caster 100 above the ground, 2.4 with it a quarter of that. Two of the four shared probes differ by 70 and 38.

    Verified against the defect and against the neighbouring field: with sourceAngle zeroed the edge collapses to one sample step (0 → 124 → 247) and both differing probes go red, and with shadowSoftness set to 200 on the same sun the frame does not move by a single value — a length is not what a sun's map reads.

  • A shadow map's edge is as soft as the light source is big. shadowSoftness — the light's half-extent in world units — reached only the 2D occluder path, which samples five points across the source and counts what each of them can see. A mesh shadow map ignored it and drew one edge, so the field's own documentation was false for maps.

    It reaches the map now, by the physics the occluder path integrates: a source of half-extent s at distance db throws a penumbra of s*(dr-db)/db across a receiver at dr. The receiver finds db by looking — eight taps in a disc as wide as the source is, and then the map's own depth inverted back into a distance. That inversion needs nothing new: the projection writes z = A - A*near/d and A is the length of its depth row, so one stored depth and this fragment's own distance give the other exactly. The filter is thirty-two taps over a disc of the width that produces, spread by the golden angle so the pattern follows the count instead of being pasted in beside it.

    What this buys over a blur is contact hardening, and that is what the gates pin. soft-shadow and soft-shadow-contact are one scene with the caster at two points along the SAME light ray: the shadow lands in the same place both times and only its edge differs — 25 world units of penumbra with the caster halfway to the light, 9 with it nearly touching the floor. The two gates read the same four probes, and two of those probes disagree by 85 and by 95.

    Where a map has no eye — a sun's cascades are orthographic — a source's size in world units says nothing about a penumbra, because there is no distance to measure it against. Those keep the one edge and the four taps, which is also what every light whose shadowSoftness is still 0 pays.

    Verified against three defects. With the softness zeroed, the soft gate's penumbra probe reads 0 where it wants 75. With the filter's radius made independent of the blocker's distance, the contact gate reads 124 where it wants 180. And with the blocker search comparing against a one-texel bias rather than its own reach, the receiver's own slope counts as the thing shadowing it — which collapses the whole feature back to a hard edge, and is how it first behaved.

  • A point light casts a shadow in every direction. A spot's map is the cone it opens. A point light opens none, and no single projection covers everywhere at once — so its map is a cube: six cones at right angles, six tiles out of the same atlas, rendered by the same pass through the same projection builder a spot hands its cone to. Only the direction and the opening differ. A receiving fragment resolves in exactly one face, and whatever stands between it and the light is inside that same face by construction, because a face's frustum IS the cone from the light through everything the face covers.

    Nothing in the pass learned a new shape to do it. A caster carries Box | Cone | Cube and the tile plan asks it how many squares it wants rather than which kind of light it came from; the atlas already handed out blocks of cells and did not care who asked. Its tile budget went 8 to 16 so a cube (six) fits beside a sun's cascades (four), and the lights that stand somewhere claim first — a crowded frame costs the sun its farthest cascade rather than costing another light its map.

    Two tests join the square's, both about a tile that has no answer for this fragment rather than a dark one: w <= 0, where the divide has no meaning (behind the light a negative w mirrors the point into the map's own square, and exactly on a face's edge plane it is 0/0), and a depth outside [0, 1], which is a place the map never saw. Each covers a case the other does not. Together they are what a cube needs: with neither, an earlier face accepts the mirrored fragment, answers "lit", and both of point-shadow's shadows disappear.

    Gate point-shadow, both backends: a lamp between a floor and two blockers, one to its left and one below it, so the two shadows land in two DIFFERENT faces of the cube. Both casters are probed too, and read the value they have with shadows off, to the digit.

    That gate also closes the hole the atlas work left open. Sabotaging ShadowAtlas::unitRect to report tile 0 for every tile used to leave all 69 scenes green, because every one of them resolved in a single tile. This one resolves in two: under that sabotage both its shadow probes come back lit — 102 where 0 is expected — and mesh-shadow-cascade, one of the scenes that could not see it before, now fails under it as well.

  • A spot light casts a real shadow map. Until now exactly one light in a scene could cast one, and it had to be the sun: everything else fell back to the world-space boxes of ShadowCaster2D, which know nothing about the meshes in front of them. A spot now claims a tile from the atlas and renders its cone through the same pass a cascade goes through — the same collect, the same vertex stage, the same depth packing — differing only in the projection it hands over.

    That projection is the cone as the frustum it is, with clip z running [0, 1] over [near, far], for the reason the orthographic one is written out by hand: a GL-convention perspective puts half its volume below zero and the second backend discards it. The near plane is a fraction of the light's reach rather than a constant, so where the depth spends its precision follows the scene's scale instead of a number.

    Who gets a tile is a decision now rather than an accident of the code: spots reserve one cell each first, and the sun takes as many cascades as still fit, so a scene with spot shadows loses its farthest directional slice rather than losing the spots.

    Gate spot-shadow, both backends: a spot above and to the left of a blocker, and the ground it throws onto. The shadow is offset from the caster — a point light projects rather than sweeps — and the probes either side of x = 162 are where its edge lands. Verified against the defect: with meshShadows off the shadowed probe reads 163 instead of 0 while the three lit probes do not move at all.

Changed

  • A field says which states of its component it belongs to, where the field is. The inspector hid the fields that are inert in a component's current state — a Spot's cone angles on a Point light, a trail's tuning with the trail off — from a switch in the editor's TypeScript: four components, seventeen rules, each written as a bare enum number (type !== 3, shape === 0 || shape === 2) in a language that cannot see the C++ enum those numbers come from. Two places knowing one thing, and the second one knowing it by ordinal.

    shown_when=<field>:<State>|<State> is authored at the C++ ES_PROPERTY site now, beside the range and the tooltip that already live there, and it names STATES: shown_when=type:Point|Spot, shown_when=trailEnabled:true. The generator resolves the names against that discriminator's own enum and ships the numbers the data stores, so reordering an enum moves every rule with it, and a state that enum has no member of is a build failure rather than a 0. The editor's switch is gone: what is left reads the rule off the field and knows no component's name.

    Twenty rules now, where there were seventeen. Light2D gained the three the switch never had — sourceAngle, shadowExtent and meshShadows are a sun's, an environment is an Ambient light's — which is what makes the component read as one kind of light at a time rather than the union of all four.

    Verified in both directions on the existing behavioural suite (inspector-conditional- fields, 14 tests that pass unchanged against the derived implementation, and 5 new ones): a rule aimed one state off turns three of them red, a state the enum does not have stops the generator with the enum named, and a discriminator that is not a field stops it before codegen.

  • A shadow's depth bias is derived where it is used, out of what the map covers there. It was computed per tile on the CPU — a constant, times the tile's coverage, over its side, times its coverage again, times how much depth a world unit is worth at the map's far plane — and stored in the tile record. That expression is quadratic in coverage where the thing it corrects for (one texel) is linear in it, and it reads the depth response at the far plane, which for a hyperbolic depth is the one place it is flattest: near a cone's near plane it is orders of magnitude too small. The per-tile depthPerWorld added earlier in this cycle made the two projections agree on the wrong number rather than the right one.

    The receiver derives it now, and in WORLD units rather than in depth: one texel of the tile it is reading, at the distance it is standing — the matrix's x scale is clip per world, w says how far away this is and is 1 where the map has no eye, and the tile's rect over one atlas texel is how many texels the square holds — times how steeply the surface stands to the light, which is the whole reason a stored depth and the depth asking about it disagree. It then asks its question one step TOWARD the light instead of shifting the answer: a step in world units is the same step whether a map's depth runs linearly with distance or hyperbolically, which is what lets one expression serve a cascade, a cone and a cube face.

    kShadowBias, ShadowProjection and the bias slot in the tile record went with it — nothing on the CPU calibrates a shadow any more, and a tile record says where a square is and nothing else. The pr tier is unmoved on both backends.

    The 2x2 taps are clamped inside their own tile in the same pass, because half a texel past a tile's edge is another light's map and, for a cube, the neighbouring face is the least related depth in the atlas. No probe in the corpus moves when that clamp is removed: the fragments it changes are the ones whose lookup lands within half a texel of a face's border, which is a curve narrower than a pixel at the sizes these scenes capture.

  • A shadow map lands where the atlas says, and a light reads its own. Two facts were spelled as literals, and between them they made "one light casts" a property of the code rather than a decision. Where a cascade sits was vec2(i % 2, i / 2) * 0.5 in one shader and its mirror image in the other — four quadrants, so four maps, so one light with four cascades and nothing else. Which light reads them was float(i) == u_shadowParams.w: a single slot number, so the other fifteen could not have a map even if the atlas had room.

    ShadowAtlas is where a square comes from now — a grid of cells handed out as aligned blocks, all-or-nothing, so a caller never gets half a cascade set and leaves the rest reading depths belonging to someone else. A tile's rect leaves it as DATA the shader indexes (shadowTile[i] = origin, side, bias) rather than an expression the shader recomputes, which is what makes tiles of different sizes cost the shader nothing: what it reads is an origin and a side either way. And a light carries its own tile range (GpuLight2D::shadowMap), so "which map is mine" is a question each light answers instead of a slot number only one can hold.

    Nothing renders differently. The allocator reproduces the old quadrant order exactly — its first four claims are the same four squares in the same order — and the whole pr tier is unmoved on both backends.

    It is pinned by a C++ test rather than a scene, because no pixel gate can see it: with unitRect sabotaged to report tile 0 for every tile, all 69 scenes still pass. A scene whose fragments resolve in one cascade draws the same picture whichever tile the other three sample, and mesh-shadow-cascade — the only multi-cascade gate there is — turns out to be such a scene. That hole predates this change: the expression it replaces was never verified either.

  • A device is asked what its clip volume is, instead of being assumed to be GL. Every projection in the engine is built for clip z in [-1, 1] and was handed to both backends unchanged. WebGPU keeps [0, 1] and discards the rest, so an orthographic camera's box was symmetric on WebGL2 and one-sided on WebGPU: anything between the camera plane and +farPlane drew on one backend and vanished on the other. RenderFrame.cpp had hand-built the shadow projection around this years-old fact, "because this matrix is the one place the choice is free" — a camera's was not, so it kept the divergence.

    Nothing caught it because no fixture had content there: the corpus stands its cameras back and the parity host puts every entity at z = 0. celestial-heights does — spire.esscene has HealthBar_Fill at world z = +1 under a camera at z = 0 — so a Dawn build drew the game without that part of its HUD.

    GfxDevice::clipDepthRange() is that fact, declared by each backend rather than read off the display name in its identity, and pure so a backend added later cannot inherit someone else's convention in silence. RenderContext::updateCameraConstants is the one place a camera's projection is converted, and it converts only what it uploads: the engine keeps [-1, 1] everywhere else, so Frustum::extractFromMatrix, the published cameraFrustumCorners, ImmediateDraw's own unprojection and every numeric assertion in mat4.test.ts are untouched, and a WebGL2 build is unchanged to the bit. No shader was edited; the eye in FrameConstants is invariant under the conversion, so nothing had to be ordered around it.

    The shadow cascades keep going through the unconverted path, and that is now stated rather than implied: their projection spans exactly the occluders it draws, so it already sits inside either clip volume, and converting it would move the depths it writes away from the copy of the matrix the receiving shader compares against — while a bias derived from the range it spans went on meaning the old one.

    Gate ortho-clip-behind-camera is that geometry. It was landed red on WebGPU on purpose one commit earlier, to hold the divergence open; it is green on both now, as is every other scene in the tier on both backends.

  • A turned sprite is culled by a box that turned with it. The same bound the mesh path just gained, for the three plane renderables that also draw a turned quad: a sprite's box now turns its pivot offset and grows its extents, and a shape's and a UI node's grow (their centres already turned). At 45 degrees the old box was 41% short of the quad, so a rotating sprite left the frame early at the edges. Text is unchanged because it never turns — its box was already exact. flatTurnZ / flatHalfExtents are the one copy of that arithmetic.

Fixed

  • Entering play answers whether the realm came up. set_play resolves both when the realm settles and when it gives up waiting for it, and the two answers were the same object — so a caller told nothing went on to probe a realm that was not there and waited out its OWN timeout instead. What CI then reported was timeout tools/call play_probe: a boot that never happened, named as whichever call drew the short straw. The door says which of the two it is now, and the driver every editor check goes through asks before it probes, so a realm that never came up fails by name.

    What it asks for is the pair, playing AND ready, which is what the door's own settle asks: a realm prewarms in an iframe once a project opens, so ready alone is answered by one that is not playing — and step sent to that advances the EDIT world, in the editor's own renderer rather than the game's.

    Four checks had each grown a poll of their own against exactly this, with a different bound each; they share the driver's now. starter-3d, the one that had none, was the one that lost the run. It also settles the character in FRAMES rather than in seconds of wall-clock — the realm's loop is throttled while the editor window is unfocused, so what a sleep buys is a fact about the machine.

    Evals into the play realm wait out a load in progress the way evals into the editor window already did. It is one helper now rather than a guard on one door and none on the door beside it.

  • The 3D starter is a complete project again. A manifest that names no scripts entry gets the defaults, and one of those is src/components.ts — the module the editor imports on its own to read a project's component schemas. The 3D starter shipped without it, because its systems declare no components and its main.ts says so. The file has to be there whether or not it declares anything: the editor opens what the manifest resolves to. templates.test.ts has been red on it since it shipped, which is what says how a bundled template is meant to be checked.

  • Waiting for a frame the GPU has not finished is bounded by the device, not by a poll count. The readback poll gave up after 240 turns of the event loop — about a second — and reported the readback as FAILED. That is the right answer for a device that died and the wrong one for a queue that has not drained, and the two are indistinguishable from the outside: what the caller gets either way is no pixels.

    Measured on the second backend, where the copy resolves on a later event-loop turn rather than at request time: point-shadow stepped 32 frames hands its frame over after 1.4 seconds, and 64 frames after 2.7 — a CPU rasterizer with six cube faces per frame behind it. Both were reported as failures. The bound is wall-clock now (15s) and is a backstop rather than a schedule: the copy is already submitted, so what keeps it from landing is a device that died, which the poll reports by itself.

    Gate point-shadow-stepped, both backends: the same scene at 64 steps. Verified against the defect — with the bound back at 1.1s it fails, by name.

  • A readback the engine refuses is a failure, not a blank frame. The pixel harness asked the engine for its own pixels and, when that came back null, read the composited PAGE instead. On the hidden window every verifier runs in, that page is blank — so a readback the engine declined produced a frame that had rendered nothing, and every probe in the scene agreed with it. It now says so, by name, and only falls back where the build cannot answer at all.

    Which is how this was found: on the second backend a scene that renders a shadow map refuses its own readback once it has stepped past about 24 frames. point-shadow at ESTELLA_VERIFY_STEPS=32 reproduces it and at 24 does not; a scene with no shadow map is fine at 200. What it is not is a rendering fault — the next readback in the same run returns the right pixels. Nothing in the corpus steps that far, so no gate moved, and the defect behind it is still open.

  • A shadow map stores the depth at the fragment, not an interpolation of its corners'. The depth written into a map was z / w, computed in the vertex stage and carried across the triangle as a varying. z / w is not affine across a triangle, so what each fragment received was an interpolation of the corners' quotients rather than the quotient at the fragment — while the receiver, multiplying the same matrix at the same point, gets the exact one. The two disagree by more the wider the depth range one triangle spans.

    An orthographic map never showed it: w is 1 throughout, the quotient is affine, and the interpolation is exact. That is why a sun's cascades were right, and why a spot aimed at what it lights was near enough — and why the first point light was not. A cube face looks ALONG a floor as often as at it, and a quad seen nearly edge-on spans 50 world units of depth in one primitive. Measured on the first point-shadow frame: every caster in the scene shadowed itself completely black, its own surface reading 0.0067 too near in stored depth — some seven world units where it stood, which no bias could have covered without detaching every shadow in the frame.

    Both stages carry the clip position now and divide per fragment, which is exact because z and w are each affine in world space. Pinned by point-shadow's caster probes: 108 with the fix, 0 without it.

  • A cone's shadow bias is derived from a cone's depth. The bias every tile got was 1/range per world unit — true of an orthographic map, whose depth is linear in distance, and wrong by orders of magnitude for a perspective one, whose depth is hyperbolic and nearly flat at the far plane. The first spot map rendered correctly and then shadowed nothing: its bias came out at 0.047 against a real depth difference of 0.004. A projection reports depthPerWorld now — 1/range for the orthographic case, near/(far*(far-near)) for the cone — so there is one bias expression and the difference between the two lives in one number. The orthographic value is unchanged to the bit.

  • A spot's aim is stored as it is. A cone with no component in the plane got the substitute (0, -1) written into its data, because the plane's half of the shading has nowhere else to read an axis from. That substitute then tilted the THREE-dimensional axis too: a spot aimed straight down had its 3D cone come out at 45 degrees. The fallback moved into the shader, where the plane's convention is applied; ES_SURFACE_3D reads the aim the light actually has.

  • A frame is given a depth buffer by what it draws, not by a setting that stopped covering it. An opaque mesh has declared its own depth test and write since it stopped waiting for a depth layer to grant them (MeshPlugin.cpp:240, "an opaque surface says so itself"). Whether the frame HAD a depth buffer to test against was still decided somewhere else entirely: the post-process capture took its depth attachment from the project's depth-layer mask alone. The two never spoke.

    So a project that declares no depth layer and engages the capture — one post effect, or the linear colour space a PBR pipeline is built for — rendered its opaque meshes into a target with no depth attachment. The test did not fail; it passed, because there was nothing to fail against. And an opaque draw sorts front-to-back for early-z, so what is painted last is what is furthest away: the picture inverted rather than degrading, and nothing said so.

    Nothing in the corpus stood there. All four 3D projects — 3d-starter, lighting-3d, model-import, physics-3d — ship gamma and ship no post stack, which is the only combination that worked.

    DrawList::needsDepth() is the one answer now: the declared layer mask OR any command that tests or writes depth, accumulated where commands ENTER the list so a render path added later cannot produce a depth draw it fails to count.

    The capture's attachments are chosen when it is BUILT, which is before the frame has collected anything — so the frame cannot be asked and the previous one is asked instead, through RenderFrame::beginFrame(). That is the frame's own opening, which begin() is not: begin()/end() bracket one CAMERA, so an answer applied there would let a 2D camera drop the buffer a 3D camera two lines later is about to test against. Three states, conservative by default: nothing has answered yet (boot) ⇒ the frame gets depth, so a 3D scene is right on the first frame it draws — the frame a thumbnail, a preview or a pixel gate takes; a frame answered and nothing in it resolved by depth ⇒ released, so a 2D project still pays for one frame's attachment and no more; anything ever resolved by depth ⇒ kept for good, a latch rather than a per-frame answer because culling makes a per-frame one flap — the lone mesh that leaves the frustum would take the buffer with it.

    What remains is one frame, stated rather than discovered: a world with no depth-resolving renderable that gains its first. It self-heals on the next frame and never returns, and it is the price of an attachment chosen before the content that needs it is known.

    Gate mesh-depth-through-capture, both backends: two opaque cubes overlapping on screen, the red one 120 units nearer, booted linear and declaring no depth layer. It was landed red on purpose one commit earlier. Measured against the two controls that differ in one thing each — gamma with no layer (capture bypassed, default surface carries depth) and linear with layer 1 (capture built with depth) both drew red; linear with no layer drew green.

  • An editor check's verdict depended on it too. The same fact one layer up: a check reads coordinates off a screenshot, which is in device pixels, and clicks in CSS ones — so at 150% scaling icon-pick clicked 1.5x away from the icon and gizmo-chrome measured everything half again too big. The check harness pins device-scale-factor to 1 for the editor it drives; a person driving their own editor over MCP is untouched, because a real window's rect is not zero and its scaling is the one they want. 33/34 with this, up from 31.

  • A pixel gate's verdict depended on the developer's monitor scaling. The headless render host never attaches its canvas to a document, so getBoundingClientRect() is all zeros and clientToScreen reduces to client * devicePixelRatio — the machine's own display scale. At Windows' 150% every ESTELLA_VERIFY_PICK therefore hit-tested a point 1.5x away from the one it named and answered null: mesh-assign and view-orbit were red on one machine and green on another, about nothing either of them is testing. The host forces device-scale-factor to 1 for the same reason it already forces the colour profile to sRGB — a gate may not read the display it happens to run on. The pr tier is 69/69 on WebGL2 and 68/68 on WebGPU with this.

  • The last gate still asserting the old work-plane rule. editor-grid-edge-on held that a head-on perspective eye works a plane it lies IN, so the grid has no picture at all. "The view works on a plane it can see" replaced that rule — a nominal plane within ~6 degrees of edge-on hands over to the plane the eye most faces, and head-on that is the 2D plane — but the gate was not moved with it, so it had been red ever since. It is editor-grid-head-on now and asserts the rule that exists: the grid covers the frame. It is sensitive both ways — under the old rule the diff was exactly zero pixels, so the new assertion fails there.

  • A skinned mesh's channels reach the inspector as numbers. meshSummary's name table stopped at Tangent, so every skinned import — the only meshes that carry the joint channels — described itself as position, uv, color, #5, #6.

  • A .esmesh channel table is checked against the vocabulary that gives it meaning. A channel's semantic IS the shader location the engine binds it to, and the per-object instance block starts at location 8; an id past the vocabulary therefore collided with that block instead of failing, which WebGPU reports as an unattributable invalid pipeline and GL does not report at all. decodeMesh rejects an unknown semantic and a table longer than the vocabulary — the one reader that sees the table as a table.

  • Two documented facts that the code contradicts. The lighting guide said a Light2D "has no third coordinate, so a point light's height comes from its radius"; the height is the light entity's own world z (RenderFrame.cpp:714), read by any surface with real geometry. The camera reference gave nearPlane no projection qualifier while qualifying its neighbours, though only a perspective camera reads it. Both locales.

Decided

  • Reversed-Z is closed, not deferred. It buys precision from a float depth exponent, and the engine has none to buy from: depth is Depth24Stencil8 on both backends, the default camera is orthographic (linear depth), and the depth test is off unless a project declares a depth layer. The [0, 1] clip a float buffer would need is EXT_clip_control on GL, which is where the web and WeChat builds live.

  • MeshChannel::Tangent stays claimed and unimplemented. Nothing writes it, nothing reads it, and no committed .esmesh carries it; normal mapping derives its tangent frame per pixel instead. Ids must stay below MESH_INSTANCE_FIRST_LOCATION, so renumbering to reclaim it would spend the last free slot to save nothing. No second UV is reserved either — there is no lightmap path to reserve it for.

  • An orthographic camera has no near plane. It renders a symmetric ±farPlane box, nearPlane is perspective-only, and honouring it would clip content authored behind z = 0 in every existing 2D scene. Documented rather than changed.

  • Mesh2D and Light2D keep their names for now. Both carry 3D work their names do not admit, but the Create picker already labels them Mesh / Light, no shipped template uses either, and the 3D path is still moving — the right end state may be a separate pair rather than a rename. Whenever it happens, upgradeComponent runs before upgradeLightAim, which finds its subject by the literal 'Light2D': renaming first would silently skip the light-aim migration on the fixtures that still need it.

Changed

  • What is nearer is measured from the viewer, not read off world z. Every renderable handed the sort key its world z as depth, and the key's own comment said why that worked: the camera looks down -Z, so a larger z is nearer. That sentence stopped being true when the eye learned to turn. A scene seen from an orbited editor view or a tilted camera still ordered its blended draws by an axis pointing somewhere else, and blended draws are exactly the ones with no depth buffer to fall back on — they do not write depth, by design, because writing is what clips translucent sprites into black edges. So the frame composited in the wrong order and nothing anywhere said so.

    CameraView::viewDepth is that measurement now, derived once per collect beside the world rect the plugins already share. An orthographic camera has no eye point, so it projects onto the direction pointing at the viewer — head-on that direction is exactly +Z and the answer is worldPos.z to the bit, which is why every 2D scene renders identically. A perspective one answers with the distance to the eye, negated to keep larger meaning nearer.

    Where the viewer is has one answer for the whole engine now. cameraFromViewProjection moved to FrameConstants.hpp, next to the field it fills, and both the shaders' view vector and the CPU's ordering read it — the two cannot disagree about where the eye is. A tilemap layer keeps its authored depth: it is flat content stacked by a number it carries, not a world point anything can measure.

    Gate sort-view-depth, both backends: two blended quads side by side in X at the same world z, the far one submitted last, seen from an eye turned -60° about Y. Equal world z ties, and the tie hands the frame to the far quad. None of the sixty-six pixel gates that already existed could fail this — head-on the old rule and the new one agree, which is precisely why it survived so long.

  • A turned model is culled by a box that turned with it. The mesh cull scaled a local AABB into world space and ignored the rotation, which a flat sprite can afford and a model cannot: the bound it produces is smaller than the geometry it is meant to contain, so a mesh rotated about anything but the view axis vanished while part of it was still on screen. Each world axis takes |R| * halfExtents now, which is exact for a box and costs nine multiplies. An unrotated entity gets the same box it got before. EntityBox became oriented last week for the hit test; this is the same fact, on the side that decides what draws.

  • The renderer has one camera, and the SDK owns it. renderFrame resolved a camera of its own in C++: it built the view from inverse(translate(position)), so it ignored the entity's rotation, read the local position rather than the world one (a parented camera pointed at the wrong place), took the first active camera it iterated past rather than the one with the priority, and knew nothing of viewport, culling mask or pixel-perfect snapping. Nothing called it — buildCameraInfo on the SDK side has been the real path throughout — but it was bound on both hosts and it was the first thing a search for the camera found. A second implementation of a thing, kept wrong and reachable, is a trap for whoever extends it next; it is gone.

  • GL states the depth function its second backend states. GLDevice::init enabled the depth test and never set the compare, matching WebGPU's Less only because that is also GL's default. The rule is written down on both sides now.

  • A light aims where its entity is turned. A light carried its own aim — direction in the plane and a directionZ bolted on beside it — and the entity's rotation meant nothing to the renderer. So rotating a light did nothing, a torch parented to a character did not swing with it, an imported light had nowhere to put its orientation, and a spot's cone axis travelled to the shader in two unrelated slots. The camera has taken its orientation from its Transform all along; the light was the one thing in the engine that did not.

    A light's aim is its entity's forward now — the rotation applied to -Z, which is where an unrotated light has always shone. Light2D.direction and Light2D.directionZ are gone; the rotate gizmo aims a light, a parent turns it, and a rotation track animates it. The GPU wire format is untouched — only where the renderer reads the aim from changed.

    Scenes and prefabs written before this are upgraded on load: the pair becomes the rotation whose forward IS that direction, so every scene is lit exactly as it was. upgradeEntityComponents is that upgrade, and it is one function now rather than the SDK's half and the editor's — the editor had its own copy of the retired-component drop and none of the rest, so a scene opened in the editor and the same scene played were two different upgrades.

    lightAimRotation / lightAimOf name the convention on the SDK side (one place; the engine's is lightForward), and q.rotationTo joins the math module — the shortest turn from one direction to another, which is what naming an aim means.

Fixed

  • The editor's view learned space; what it does in that space had not. The eye gained a focus in three dimensions and every gesture aimed through it was still spelled on z = 0. An entity's position was an x/y from the composed transform plus a z read off the LOCAL field — the same number only for an unparented entity — so every overlay projected through a mixed pair; getEntityWorldPos answers with all three from the one transform. The gizmo was drawn on the selection's shadow at z = 0 while the outline around the same entity was drawn on the entity, so under a perspective eye the handles sat where the thing was not; the drag plane passes through the point the grabbed handle is drawn at now, and a group rotate turns the whole arm from it rather than by (dx, dy, 0) — which stopped being rigid the moment the group had thickness. applyScale read none of the three axes the gizmo has drawn since the eye could turn: the Z arrow scaled x and y, and a plane handle spanning z did the same. A handle scales the axes it names now, its magnitude the drag projected ALONG the grabbed arrow over that arrow's drawn length. A parent's frame inverts in three dimensions, where the 2D inverse plus an untouched z was right only while the chain lay flat. And what you drop lands on the plane the view works on, carrying the depth that resolve returns — a mesh dragged into a 3D view used to resolve against a z = 0 wall the cursor crosses somewhere the person is not pointing, and then dropped the depth anyway.

    One rotateVec3 for the editor, where it had been transcribed three times, which is how a handle, the motion it drives and the value that lands come to disagree.

  • A handle is read on the plane it is drawn on. Every on-canvas handle — a collider point, a radius, a box corner, a sprite pivot, a cone's spread, a joint anchor or axis — is DRAWN through projectorFor, which projects on the entity's own plane, and every one of them then read the cursor back with the default canvasToWorld, which answers for z = 0. Head-on the two agree, which is why the pair went unnoticed; from a perspective eye the handle sits on the entity and the value it writes comes from somewhere else, so grabbing one makes it jump. readerFor is that projector's inverse, taken once at grab the way the projector is taken once per gizmo.

  • A world length is measured where it stands, not along one axis. A light's reach, a collider circle, a tile-collision circle and a particle spawn disk are each a LENGTH in the world, and every one turned into pixels by projecting an offset along world +X and taking how long that came out — which measures that axis's foreshortening as well as the length, so the same reach shrank as the eye turned toward X and collapsed to nothing looking down it. screenLengthAt is the one expression for it. Gated by gizmo-scale, which measures a point light's reach head-on and again from the eye the 3D toggle parks: projecting the offset again drifts it 7%, and the gate allows 3%.

  • An icon is clickable where the icon is, and align happens on the plane being worked. Two shapes of the same mistake — a quantity in a unit that matches at one zoom or from one eye. An entity that draws nothing of its own gets an icon a fixed number of CSS pixels tall, and the box a click hit was 24 WORLD units: framed on a large scene it shrinks under a pixel and the thing on screen is not clickable at all. Picking and the outline take the icon's screen size now, while the minimap and Frame keep a world size — or framing a light would zoom to a box derived from the zoom it is about to change. And align/distribute were the last gestures still spelt in world x and y: over a 3D scene "align left" moved things along world X while "align top" moved them into the air. Gated by icon-pick, on a project framed at 16000 units across; with the world size back, the click on the icon picks nothing.

  • A light's gizmo shapes had never been drawn at all. The reach circle, the aim arrow, the spot cone and the radius handle sat in an <svg width="0" height="0"> nested inside a wrapper translated to the light, so nothing outside a light's own pixel was ever painted — the bulb icon is a sibling, which is why the gizmo looked present. With them visible the aim was wrong too: it read the direction's world x and y as the screen's x and −y, right only from the head-on eye. Gated by light-aim, and verified against both defects separately.

  • A selection is outlined by its own shape. The outline was the entity's screen AABB — a box around the thing rather than the thing — which coincides with the shape only head-on and unturned: a sprite rotated 45° got a box with its corners in empty space. entityScreenHull projects the box's corners and takes their convex hull, the answer the play realm's overlay has always used, and getEntityScreenRect is the AABB OF that hull, so what hit-tests against a rect and what is drawn around an entity cannot describe two different shapes.

  • The authored screen is drawn where it is, not hidden when it is not a rect. The design frame, the device frame, the scrim and the safe-area inset are rects on the 2D plane, and a rect seen at an angle is a trapezoid; hiding the overlay from a turned eye was a workaround for drawing it wrong. They are kept in WORLD half-extents and projected corner by corner now, which makes the derived geometry world-space and better for it — "does the device contain the design" compares half-extents rather than two projections of them. Gated by design-frame.

  • An arrow key moves the way it points, on the plane being worked. The nudge added to world X and Y; looking down at the ground, ArrowUp lifted the thing into the air. screenNudgeAxes names the work plane's two axes with the signs that point right and up on screen, right resolved first so the pair is never one axis twice even from an eye looking straight down one of them.

  • The minimap is a map of the plane the scene stands on. It plotted every entity's world x/y, so a 3D scene — which stands on the ground — collapsed the whole map to a line, useless exactly where a map of a large level is worth most. It plots the work plane's two axes now, oriented so a map of the ground reads the way looking down at it does.

  • The selection readout says the pose it has. The status bar took the rotation as 2·atan2(z, w), which is the Z angle only while the quaternion's x and y are zero — so for a posed transform it reported a number that is none of its three turns, in the readout a person glances at to check what they just did.

  • A drop point falls back when the work plane is edge-on. A perspective eye held head-on looks ALONG the ground, so every ray meets it thousands of units away, or at the eye itself — and head-on perspective is exactly the state view.resetOrbit leaves. Below ~6° of facing, the point comes from the plane through the focus facing the eye, which is what a screen point unambiguously names from any angle.

  • One formula for the Z angle of a rotation. viewportMath carried two, and the play overlay used 2·atan2(z, w) to capture the angle a rotate-drag starts from — so on anything with a pose, the drag snapped its total onto a grid measured from a number that is none of the three turns.

  • The editor eye's volume reaches past what it is looking at. The far plane was a constant 100000 measured from the eye, and a perspective eye STANDS OFF what it looks at — framed on a large scene that stand-off is tens of thousands of units, all spent before the scene begins, so the back half of a scene simply vanished. editorViewClipFar adds the stand-off, so the reach PAST THE FOCUS is what the number means. Measured against a sprite 50000 units behind the plane: the orthographic eye of the same framing showed 34225 pixels of it and the perspective eye showed zero.

  • The editor eye's near plane follows how far back it stands. Depth resolution goes as distance squared over the near plane, and for this eye the stand-off IS the distance — so a near plane fixed at 0.1 spent the whole buffer on the first few units. Framed on a large scene, two opaque quads 200 units apart resolved WRONG: the further one, submitted last, covered the nearer. editorViewClipNear is a fraction of the stand-off floored at the value it has always had, so a close-up eye is unchanged. Gated by depth-precision, which asks both directions from one scene. At ordinary scales neither this nor the far plane was ever visible; it takes a project framed at 120000 units across, and both were found from the same probe.

  • The toolbar no longer states, permanently, that this is 2D. A blue chip in the display-flags group read "2D", always, and its own stylesheet said why — "the engine is 2D-only, so this reads, it doesn't toggle". That premise is gone, and the projection button five items to its left said "3D" while the chip said "2D".

Added

  • An entity's box has a third dimension, and one hit test uses it. EntityBox was {cx, cy, hw, hh, rot} with rot the Z angle of a quaternion, and the engine answered a mesh's extent with its XY bounds. So a model turned about X or Y had a box that did not turn with it, and a click was the cursor unprojected onto that entity's own z plane and tested against a rect — an answer that is right only while the eye is head-on.

    The box is an oriented box now: a centre, half-extents on its own three axes, and the rotation the renderer draws it with. A sprite and a UI node are flat (hd zero), which is what they are; an icon is a cube, so a camera or a light reads and clicks the same from wherever the view has been turned to. A click is a ray, and entityBoxRayHit is the slab test against it — where a flat box is not a degenerate case but a quad, met by a ray in its own plane, which is what a 2D editor asking "is the cursor on this sprite" has always meant.

    The editor and a running game asked that question twice, and the two had drifted: the play realm boxed a model by its transform alone, so a click anywhere on an imported mesh landed on whatever was behind it. There is one pickEntitiesByRay now; each realm passes its own camera, its own refusals, and whether it draws gizmos to aim at. The ray decides what is hit and the layer rules still decide which hit is on top, because that is what the renderer stacked them by.

    Outlines follow: every corner projects through its own depth rather than one shared plane, and a box's screen outline is the convex hull of those corners — four points while it is flat, more once it has depth to turn. q.rotate and q.conjugate join the math module, where the one copy of turning a vector by a rotation now lives.

  • The editor's view has a focus in space, and a plane it works on. The editor eye could turn, and everything else about it was still pinned to z = 0: it orbited a point on that plane, panned across it, framed on it, and drew its grid there. A 3D scene stands on the ground (y = 0), so what the grid drew was a wall you turned around, and a pan from a top-down eye slid along a plane seen edge-on.

    EditorView gains a z, so its focus is a point rather than a place on the 2D plane, and editorViewBasis reads the view's own right / up / forward off the matrix the camera is built from. Pan, zoom-about-cursor and Frame move that focus through the basis (moveEditorViewFocus) and fit against it (editorViewBoxExtent) instead of intersecting a fixed plane; head-on they are the 2D navigation to the bit.

    editorViewWorkPlane names the plane the view authors on — the ground under a perspective eye, the plane 2D content lives on under an orthographic one — and the grid draws that. The grid is a per-pixel ray against the plane now, not a quad sized to a visible rect, with fwidth of the plane coordinate deciding line width and where lines fade; so a ground plane recedes to its own horizon instead of ending at a quad edge. Its axis lines are coloured by which world axes run in the plane, which is why EditorGrid carries one colour per axis.

    Gate editor-grid-3d, both backends: the grid from straight above a perspective view has to reach all four quarters of the frame. Pinned back to the 2D plane it lights the lower half and nothing else. The headless host can enter 3D now (ESTELLA_VERIFY_PERSPECTIVE), which is what let a gate see any of this.

  • A twin written in a template literal is still a twin. check-wgsl-twin read .esshader files, and the SDK writes some of its dual-language shaders into template literals instead — the editor grid, the post-process effects, the seven builtin material templates. Forty-four shaders never reached the gate that exists because a twin missing one declaration reaches the second backend as Invalid RenderPipeline with no shader named anywhere in the log. It reads both now, and a shader's location is a file and a line either way.

  • A gate on what a WGSL twin has to declare for itself. A fragment-only twin is assembled with its domain's canonical vertex stage, and the engine injects the matching VSOut and the eight batch texture bindings with it. A twin that writes its own vertex stage gets neither — nothing can know what interface that stage produces — so it has to declare the varying struct and every texture it reaches, including the ones the injected lighting helpers sample through it.

    Miss one and nothing says so: the stage is not an error to the parser, and what reaches whoever runs the second backend is Invalid RenderPipeline with no mention of a shader anywhere in the log. That has now happened four times — a mesh twin without t3, a shadow map the same, an environment atlas nobody declared, and a sky twin naming the VSOut from its own vertex block. check-wgsl-twin follows the injected helpers a stage calls, transitively, to the textures they sample, and each of those four is red under it.

  • An environment can be seen, not only reflected. A baked .esenv gave a scene its irradiance and a prefiltered reflection, so a metal ball had a sky in it — and behind the ball was a flat clear colour. The same panorama was half visible and half not, for no reason anyone chose.

    Light2D.drawEnvironment draws it as the background: a quad on the far plane, shaded by the direction from the eye through each pixel, which is the direction the reflection already samples. Off by default, so a scene that adopts an environment for its lighting does not also acquire a sky it did not ask for; and only where there is a prefiltered reflection to look at, since the nine irradiance coefficients are that sky averaged over every direction — as a background, one flat colour.

    It is not a renderable: a sky belongs to no transform, is culled by nothing, and sorts first by being in the Background stage. Its own vertex stream, because the Batch one spends every sampler slot on a per-vertex merge and the sky has to reach the environment atlas on the unit the shaders pin it to.

Fixed

  • The 3D view head-on no longer paints the frame flat. A perspective view authors on the ground, and an editor eye at y = 0 stands IN it. Every pixel's ray then meets that plane at t = 0 — at the eye's own point — and step(0.0, t) counted the eye as a hit in front of itself. One point's grid coordinate landed on every pixel, fwidth of it was zero, every coverage and legibility term saturated, and the whole viewport came back washed in the axis colour. Two buttons reach it: 3D View, then Face Scene Head-On.

    The eye's own point is not in front of the eye. A plane through it has no picture — zero thickness, seen edge-on — so the grid draws nothing there, which is what gate editor-grid-edge-on asserts on both backends: the same view, grid on and grid off, has to come back the same frame to the pixel.

  • Whether a surface has normals no longer decides where its light is. Two facts had one switch: MESH_NORMALS said "this geometry carries a normal channel", and the injected lighting read it as "so measure the light in three dimensions". A mesh's fragment gets its real world position either way — the channel is about the surface's orientation — so geometry imported without normals was lit by a lamp hovering its own falloff radius above the plane while standing 120 units above it, and the two lit the same surface differently for a reason that had nothing to do with lighting.

    ES_SURFACE_3D is now that second fact, set by the vertex sources that give a fragment a real world position. A sprite still does not: it has no depth of its own to measure against, which is the whole compatibility story and unchanged. Flat-shaded 3D geometry near a point or spot light does change appearance — the new gate measures the difference at 74 colour levels, and the old behaviour flattened three probes that should differ to within four.

Added

  • A directional shadow spends its texels on what is near. One 1024 map covered every mesh in the scene, so its resolution was a property of the whole scene rather than of what anyone was looking at: put a piece of distant scenery in a level — behind the far plane, where the camera cannot even see it — and the shadow under a character 200 units away covered a fraction of a texel and disappeared. That is now a gate.

    A perspective view splits into four cascades laid out in one atlas (the RHI has no array textures, the same reason the environment reflection is an atlas), each covering a slice of the view on the standard practical split. The near slice is small, so its texels are small: the same 1024 that could not hold that character's shadow now holds it twenty times over. Each cascade carries its own depth bias, because the number that stops the near one shadowing itself lets a coarser one detach from what casts into it, and each is snapped to its own texel grid, or the cascade slides with the camera and every shadow edge crawls.

    An orthographic view still renders one map: its texels are already spread evenly over what it can see, so splitting it would buy nothing and cost three quarters of the atlas. A light with an explicit shadowExtent also keeps one — that number is the author saying what the map covers.

Fixed

  • The shadow map was upside down on WebGPU. A texture's v = 0 is its bottom under GL and its top under WebGPU, while a viewport rect arrives in GL's terms and is flipped inside the device — so both backends wrote the same place and one of them read the other end of it. Writing and reading a whole map cancels the two flips, which is why nothing caught it: every shadow gate was symmetric about y, and a map turned over is a map unchanged. The new cascade gates are not symmetric, and the first one to place a caster off-centre failed on the second backend.

  • A gate holds the two shader languages together. The engine's uniform blocks are written three times — the C++ struct that fills one, the GLSL declaration injected into a shader, and the WGSL twin injected into the other backend's — and the lighting helpers around them twice. Blocks are read by OFFSET, so a field added to two of the three is an error nowhere: every later field is simply read from the wrong bytes, on one backend, and the picture is merely wrong. That is how an RGBM decode lost a multiply and a mesh twin never declared its third texture; both were found by asking why a pixel was 255.

    check-shader-blocks compares what a name can carry across all three: field order, array lengths, the set of helpers, and how many arguments each definition takes — including the ones defined once per feature branch, where keeping only the last would hide a branch that drifted. It cannot prove two expressions compute the same thing; it does catch the drift that is a missing or misplaced name, which is what every one found so far has been. Two differences are declared with their reasons: u_projection names the block's viewProjection (.esshader is a format users write), and sampleNormal takes a texture and its sampler apart on WGSL, which GLSL has no way to spell.

Changed

  • The same mesh drawn again is one more instance, not one more draw call. Every resident mesh took its own draw: a hundred crates were a hundred calls, a hundred pipeline resolves and a hundred buffer rebinds, for one cube's worth of geometry. The per-object record was already an instance stream — the shape the particle emitter draws thousands from — and nothing consumed it that way, because the merge pass refused every instanced command outright.

    Draws of the same geometry now coalesce into one instanced call. They rarely sit next to each other in the frame's pool (the sort reorders them by depth long after the records were written), so merging relocates the records to the end of the stream, where the run being built is growing — cheap next to the draw call it removes, and in the same window the multi-texture merge already rewrites staged vertices in.

    Only where the order cannot matter: an opaque draw replaces what it covers and depth decides what covers what, so which of them happens first is not the result. A blended draw's order is its result, and a skinned draw carries a pose written per draw — both keep their own call. Four cubes in a scene are one call where they were four; all 60 pixel gates on both backends are unchanged.

  • The transform gizmo is built from the view's own basis. Rotate already read where the world axes point on screen and drew a ring per axis. Move and scale did not: their arrows were two written-down screen directions, +X is right and +Y is up, true only of a head-on orthographic view. Turn the eye and the arrow you grabbed was no longer the axis that moved.

    Now one basis feeds everything — the arrows, the rings, and the aim, from the same call, so what is drawn is what is hit. There is a Z axis, the vocabulary says plane where it means plane (xy/yz/zx, not an xy that meant "whatever is free"), and local space is the entity's rotation applied to the axes rather than a CSS turn of the whole gizmo — which is the only form that can express a frame turned about X or Y.

    A drag is measured on the plane its handle implies, found by intersecting the cursor's world ray with it. screenToWorld was already building that ray and throwing it away on a fixed z plane; it is now the ray's z-plane case, and CameraView.screenRay hands the ray to anyone who needs a different one. Every head-on expectation in the gizmo tests is unchanged, which is the compatibility argument: a 2D scene keeps the two arrows, one ring and one free-move square it always had, because world Z projects to nothing there.

Fixed

  • A rig too big to pose says so, instead of coming apart. A draw is posed by a uniform block of 64 bone matrices; a skin binding more joints than that had its extra ones indexing a matrix nobody uploaded, and the vertices they move went somewhere arbitrary. Nothing said a word — not the importer, which wrote the joint channel whatever the count, and not the renderer, which posed the first 64 and drew the rest wrong. A rig with fingers passes 64 easily.

    Both importers now read an over-budget skin the way they already read JOINTS_0 with no weights: imported static, and it says why and by how much. The renderer takes the same answer for a file it did not write — the bind pose, once, in the log — because a joint index answered by no uploaded matrix is the wrong-matrix read it already refuses elsewhere.

    MESH_MAX_BONES is now one number both halves read, alongside the channel vocabulary they already shared by hand: MeshChannelType is a real enum on the C++ side rather than a switch with a comment, and check-mesh-vocabulary holds the eleven values together — a .esmesh cannot be written with one meaning and drawn with another.

  • The 3D view button turns the eye. It swapped the editor camera's projection and nothing else, and swapping projection is invisible: looked at head-on, a perspective picture of the z = 0 plane is the orthographic one, pixel for pixel. So on exactly the scenes people press it on, a button labelled 3D appeared to do nothing — depth was only ever visible after finding Alt-drag, which turns the eye in either projection anyway.

    Each projection now remembers the angle it was last looked at from; the toggle parks one and restores the other, entering 3D from head-on for the first time with a three-quarter view. A turned orthographic view — the isometric one — is a working mode, and it survives the round trip unchanged.

Added

  • Geometry you can make without a modelling package. The engine drew meshes and loaded exactly one way to get one: import a glTF or an FBX. There was no cube. examples/physics-3d is the evidence — a scene of stacked crates, stairs and a swinging door with not one mesh in it, showing its own collision wireframe, because putting a box on screen meant leaving the editor to go author one.

    Seven primitives now answer to a builtin: mesh ref — cube, sphere, capsule, cylinder, cone, plane, quad — each built in code at load time. Create → Cube makes one, and the same seven head the picker on any Mesh2D.mesh field. They cost no bytes in a package and add no dependency to a scene that uses one; a capsule is the shape CapsuleCollider3D describes, and all seven are the size a new ShapeRenderer is, so one is visible where it lands.

    Closed shapes are created opaque and back-face culled, which is what lets meshes occlude each other; plane and quad stay two-sided. Create → Sun joins them: Create → Light gives a Point light at the entity's position, which lights a mesh from inside it, and nothing in the picker offered the directional key light shaded geometry actually wants.

    builtin: was already the way a material names a stock shader and a tilemap layer names the collision palette, spelled out separately in four places. It is now one predicate the ref resolver, the loaders and the cook share — a built-in ref names code, so it has to be recognized before anything tries to turn it into a path.

  • A sun can be aimed out of the plane. A directional light's aim had two components and a third the shader supplied as a constant, so every scene the engine could express was lit from in front: the sun's elevation followed from how far it was tilted within the plane, and nothing could put it low, behind, or overhead. Light2D.directionZ is that third component, and the shadow map reads the same aim, so the shadow goes where the light says rather than where the constant did.

    It defaults to -1, which is the direction a 2D scene's light has always come from — every existing scene renders the same bytes, and all 88 pixel gates agree on both backends.

  • A point or spot light has a height, where the surface has the geometry to measure it. Its depth was the falloff radius, so a lamp lit a mesh the same whether it sat on the floor or above the ceiling: radius doubled as "how far above" because a 2D light had nowhere to keep a third coordinate. On a mesh it is now the light's own world position — distance, falloff and the angle of incidence all come from where the light actually is, and a spot's cone points in three dimensions.

    A sprite keeps the plane's convention, and that is the whole compatibility story: it has no depth of its own to measure against, so a positional light goes on hovering its radius above it. The two are not a branch the frame takes — they are which definition of "where is the light" a shader compiles with, chosen by the same flag that already says whether a draw brought real normals and a real world position. One lighting model, one BRDF, and the surface saying what geometry it has.

    A light lying exactly on the surface used to be unreachable and now is not, so it is answered rather than left to produce a NaN: it lights along the surface's own normal, the limit that approaches from every side.

  • FBX import. A .fbx is a model source like a .gltf is: drop one in and it writes the same products — .esmesh per material run, the images it embeds, an .esmaterial, an .estimeline per take, and the .esprefab that assembles them. Parsing is ufbx, vendored and built to wasm, so nothing needs the Autodesk FBX SDK; binary and ASCII, every version from the 5000-series up.

    What FBX needs that glTF does not is settled before the products are written: axes and units converted to the engine's, polygons triangulated, geometry transforms turned into real entities, and Euler curves — with their pivots and pre-rotations — baked into the TRS keyframes a track can hold. Rigged models arrive rigged, bind pose and all.

    Two things it reports rather than carries: separate metalness/roughness maps (the engine samples one image packed as glTF packs it) and opacity maps.

    The import's two doors are now one reader — the editor and estella import-model (was import-gltf, still accepted) share it, along with everything downstream of a format, which is what keeps a second source format from being a second set of rules for what a model is.

  • A 3D scene the release argument can point at. examples/lighting-3d: a skinned model held at a bend, a sun that casts it onto the panel behind it, and a baked environment its metal reflects — the sky on top, the ground on its face. It carries no art at all: the glTF and the .hdr were written by a generator, so a whole 3D lighting scene is geometry and nine coefficients.

    Skinning, mesh shadows and environments were each proved by a pixel scene and carried by no packaged game, which the corpus said in the open as three declared gaps. This closes all three, and found three defects doing it — every one of them in the half nobody could see, between the editor and the package.

Fixed

  • A web package carried the SDK's source maps whatever the build asked for. "Source maps" is a build option, off by default, and it reached only the two bundles the export writes itself — the SDK tree copied in beside them brought its maps along regardless. They were most of the package: hello-world shipped 4.96 MB of them in 8.0 MB. The option now covers both halves, which is what it reads as, and a build without maps also drops the sourceMappingURL line from the scripts it copies — a package that names a map it does not carry 404s the moment anyone opens devtools on the shipped game.

    With the module scan below, hello-world goes from 8.0 MB to 3.0 MB.

  • A web package carried every optional module the engine builds. The export copied the engine's wasm directory wholesale, so a 2D game shipped the 3D solver, all five Spine runtimes, the DragonBones player, the video decoder and the Basis transcoder — about 3.9 MB of binaries nothing in it could ask for. A package now carries what its content can reach: hello-world's runtime went from 6.0 MB to 1.7 MB, physics-playground takes the 2D solver and not the 3D one, and spine-demo takes the two Spine runtimes its skeletons report rather than all five.

    The mini-game and playable exports already answered this question — a playable is size-capped, so it had to. What they answered it with was a private copy of the runtime's component tables, and the copies had drifted: neither knew about MeshCollider3D, ConvexCollider3D or any of the five 3D joints, so a scene held together by a hinge was a scene those exports believed needed no solver. One of them also had no entry for physics3d at all, which is why exporting a 3D scene as a playable failed on an artifact called undefined.js. There is one scan now, and it calls the runtime's own predicates rather than a reproduction of them.

    Two rules it gained on the way. It reads prefabs, not only scenes: the runtime expands prefabs before it asks whether a scene needs physics, so a body that arrives only through a prefab is one the package has to carry, and a project that spawned its bodies that way had been shipping without a solver everywhere the scan was load-bearing. And a module the content needs that the wasm directory does not hold now fails the export, where the web path used to ship it by accident and had no opinion.

  • An asset named only inside another asset's document was culled from the build. A baked environment names its reflection atlas as a sibling of the .esenv, and nothing else in the project mentions that file — so the dependency scan, which never read environment documents, left it unreachable. The game booted, asked for the atlas, got a 404, and lost every reflection it was lit for; the editor showed none of it, because the editor serves the whole project. An animator controller had the same hole to the clips its states play.

    Shipping the file was only half of it: staging is content-addressed, so the document no longer sits beside its sibling and has to name it by project path.

  • A skinned model imported from a glTF never deformed once it was placed. MeshSkin.joints is a list of entities, and every translation of entity-ref fields tested a single value — so the list went through untouched and its prefab-local strings reached the World's numeric entity vector. The mesh drew in its bind pose, which looks exactly like a model that does not animate. GPU skinning has worked since it shipped; it had never worked through a prefab, which is the only way an imported model reaches a scene.

  • A 3D shadow never reached a scene viewed through a perspective camera. The shadow map's coverage came from reprojecting NDC z=0 — the whole view for an orthographic camera, and a cross-section a few units wide near the near plane for a perspective one. A 3D scene got a 1024² map covering about twelve world units around the camera's centre: nothing cast onto anything, and geometry that happened to sit at the centre shadowed itself instead. Coverage now comes from the world box the meshes occupy, which is the same answer for both cameras.

  • A packaged game drew no bitmap text. A .fnt names its page image as a sibling, in text rather than JSON — so the dependency scan, which read neither the document nor its type, culled the page; and the staged font still asked for a sibling that content-addressed staging had moved away. Both halves are fixed, and the rule for "is this ref already a project path" — which existed three times privately and not at all in the font loader, which is why it joined a sibling to a directory that no longer existed — is now one shared resolver.

  • An import warned that skinning is not implemented. It has been implemented since it shipped, so a perfectly good model reported a limitation the engine does not have. The case the warning was written for is real and different: a channel aimed at a skinned mesh's own node moves nothing, because glTF requires that node's transform to be ignored. It now says that, and says to animate the joints instead.

  • A component's Chinese reference link pointed at an English heading. Five 3D physics entries carried the English slug, so the Chinese reference sent readers to headings that do not exist on a page whose headings are 刚体, 形状 and 角色. The only check that resolves those anchors needs the site built, so it runs from the docs deploy — which a release calls: v0.54.0 shipped its binaries and then failed on three dead anchors, leaving the site describing 0.53.

[0.54.0] - 2026-08-17

Added

  • 3D physics on a device. The Jolt module is compiled into the native host the way Box2D already is, so an iOS, Android or desktop build carries the 3D world instead of failing to find a side module that has no story there. Its entry points are declared once (Physics3DBindings.hpp) and both platforms bind the same file — until now the SDK's TypeScript interface was the only statement of that surface, which is exactly the drift the 2D module documented when it grew the same header.

  • A 3D physics example. examples/physics-3d: a character walks, climbs two steps, shoves crates and swings a hinged door, drawn by the debug overlay so the project ships no art. Every check until now was a synthetic fixture; this is the first project that uses the whole chain, and it found the gap above on its first run.

  • The running game can draw its own 3D shapes. Physics3DDebugDraw outlines every collider the solver built, in the game rather than in the editor — which is the only place the question "why did the player get stuck there" can be asked. The editor hides its own overlays in play, so what you see is the engine answering.

    Draw.line3D is what made it possible: the immediate-mode vertex has always carried three components, and the ribbon is now widened across the view rather than in the plane, so a line reads as a line from wherever the camera is.

  • Imported geometry that moves. A ConvexCollider3D collides against the convex hull of a mesh's vertices — a rock, a chamfered crate, a barrel that rolls. MeshCollider3D is scenery whatever its body says (Jolt cannot give a triangle soup an inertia tensor); a hull is a volume a solver pushes as readily as a box.

  • A fast 3D body stops at a thin wall. RigidBody3D.continuousCollision checks the whole path a step covers rather than only where the body ended up. At any speed that crosses more than its own thickness in a step — a bullet, a thrown object — discrete collision reports nothing, because the far side of the wall is a perfectly valid place to be.

  • A 3D character can shove what it walks into. CharacterController3D gained pushForce — the force it may spend moving a dynamic body out of its way. A character is swept rather than solved, so nothing moved for it before: mass was carried into the solver and had no effect anyone could see.

  • Joints for the 3D world. PointJoint3D, HingeJoint3D, SliderJoint3D, DistanceJoint3D and FixedJoint3D — a shared point, an axis to turn about, an axis to slide along, a distance to keep, and no freedom at all. A door, a rope bridge, a lift and a ragdoll are all two bodies and a rule, and until now the 3D world could only say "these two touch".

    Anchors and axes are written in the declaring entity's local space and resolved when the joint is made, which also sets the ZERO of every limit: a door placed closed reads angle 0. motorSpeed can be changed from gameplay at any time, and angle / translation come back each step.

    collideConnected joins the two bodies into one assembly rather than one pair, so everything a chain of joints reaches stops colliding with the rest of that chain — what a door needs against its own frame, and what a ragdoll needs against itself.

  • A 3D joint shows what it holds. The viewport draws the link from a joint's anchor to the body it names, and — for a hinge or a slider — the axis it is free about. A joint has no shape to see: which body and which axis live only in the numbers, and the axis is the half no position on screen can imply.

  • 3D colliders are visible while you author them. The viewport draws a wireframe of every 3D collider — box, sphere, capsule, character, and the bounds of a mesh collider — turned the way its entity is. A 3D shape is nothing the renderer draws, so until now the only way to learn whether a box was the right size was to press Play and watch what happened.

    A shape the running world would NOT build is drawn dimmed and dashed: the solver gives an entity one body shape, and a disabled collider, one shadowed by a higher-priority shape, or one on an entity with no rigid body would otherwise promise a collision that never happens.

  • Spatial queries with a shape, not just a line. The Physics3D resource answers sphereCast, overlapSphere and overlapBox alongside raycast, all in world units and all narrowable by layer. A ray is infinitely thin and slips through the very gaps a moving body would not fit, so "can this thing get there" was a question the world could not be asked.

    A layer mask of 0 means EVERY layer rather than none: a caller that did not ask to filter is asking for everything, and the other reading would make the commonest call return silently empty.

  • 3D collision layers. Every body is in one of sixteen layers, and a project says which layers hear from which — bullets that pass through their own team and stop on the world, which two layers could not express. Both sides must agree, so one of them refusing keeps two bodies apart and a rule only has to be written once.

    ONE layer per body rather than the 2D world's category bits: Jolt classifies a body by a single id. A body's layer is fixed when it enters the world, so the matrix is installed as the world is built.

  • Imported geometry can be collided against. A MeshCollider3D uses a mesh's own triangles — a terrain, a staircase, the inside of a room, none of which a box or a capsule can express. Always static: a triangle soup has no inertia tensor, so there is nothing for a solver to push.

    The triangles are the ones the mesh decode already produced. Geometry went to the GPU and its bytes were let go, which is right for drawing and useless for colliding, so the asset layer now keeps the positions and indices under the handle everything already references the mesh by — nothing else, since a collider does not care what colour a vertex is.

  • The 3D world says what touched what. Contacts and sensor overlaps reach the ECS through a Physics3DEvents resource, drained per fixed step: an enter carries both entities, the normal and the point; a sensor names itself first, so a listener never has to work out which of the two it subscribed to.

    An ended contact carries only the pair. At that moment the solver holds both bodies locked and one may already have been destroyed, so there is nothing left to report — and a contact ends when a body falls ASLEEP as well as when it moves away, which is what the gate had to be rewritten to see.

  • A 3D character stands, walks and climbs a step. CharacterController3D is swept against the world rather than solved in it, which is what lets it climb a 20cm step and stay glued to a slope without inheriting the momentum of whatever it stands on. Set velocity from gameplay each step and read isOnFloor, floorNormal and realVelocity back — the same shape the 2D character controller has.

    The vertical component is carried for you: a Jolt character does not fall on its own (its gravity parameter only pushes down on what it stands on, and the vertical speed belongs to the caller), so the module integrates gravity rather than leaving every caller to rediscover that velocity.y = 0 otherwise means "hang in the air".

  • A 3D physics world, beside the 2D one rather than over it. Jolt Physics ships as a second side module, so a project that never asks for a 3D world never pays the 1.2MB it weighs — and a 2D scene keeps the solver, the units and the feel it already has. RigidBody3D with a BoxCollider3D, SphereCollider3D or CapsuleCollider3D puts an entity under it, and what the solver moves is written back to its Transform.

    Sizes are authored in world units and reach the solver in metres, at the same pixelsPerUnit the 2D world uses: a solver tuned for metres behaves nothing like itself when a character is 180 units tall.

    Two things emscripten does not give for free, both of which present as something other than themselves. Jolt DECLARES that it uses SSE4.1 under wasm SIMD, so those intrinsics have to be asked for or the library will not compile at all; and its solver needs far more stack than the 64KB default, which a short stack reports as an out-of-bounds access inside the step.

  • A panorama becomes an environment, and an ambient light casts it. An equirectangular .hdr in a project now bakes into the two things a renderer asks an environment for, and an Ambient Light2D can point at the result: a surface takes its fill light from the direction it faces, and a metal reflects the sky rather than one flat colour. The light's colour and intensity scale both halves, so an environment is tinted the way the flat term was.

    The diffuse half is nine spherical-harmonic coefficients — no texture at all — and its convolution is divided by pi, which is what makes a constant environment reconstruct as that same constant. That identity is why a light with no environment is the order-zero case of one expression rather than a second lighting path, and why every existing lit scene is byte-identical. The specular half is one ordinary RGBA8 image: octahedral faces stacked by mip, RGBM-encoded, so nothing downstream learns a cube map or a float format.

    Two defects a saturated probe would have hidden turned up in the first gate. The RGBM decode did not match the encode — a whole factor of the multiplier, which read a 0.9 reflection back as 2.66 and clipped it to white. And the atlas was being loaded as a picture, so its rows arrived turned over: mip 0 sat where the last mip should be, and a head-on mirror reflected the sky behind it. Its rows are a layout, not an image.

  • A skinned model deforms. The joints an import recorded now move the vertices bound to them: each bone is the joint entity's world placement times the mesh's own bind matrix, and the result is world-space, so a skinned mesh's own transform is ignored exactly as glTF requires. The pose travels as a uniform block written immediately before the draw that reads it — a bind group's textures are visible only to the fragment stage on WebGPU while its buffers are already visible to both, which makes a block the shape that works on both backends. Geometry the engine cannot pose (a joint count that disagrees with the bind pose) draws undeformed rather than wrong.

    Three things this needed had never run. An entity LIST reaching a component was one: Children is engine-maintained, so no document had ever authored one — the scene loader remapped only scalar references, leaving a joint list pointing at whatever those ids mean at runtime, and the boundary itself could not carry a JS array to std::vector<Entity>. An un-normalized integer vertex attribute was another: the GL backend had only the float entry point, which converts, and a converted joint index is not an index. The third is below.

  • A gate for conditionals a WGSL twin cannot use. A GLSL stage is preprocessed by the driver and has a full C preprocessor; a WGSL twin is expanded by the engine, which understands #ifdef, #ifndef, #elif defined(X) and #else. A #if defined(A) && !defined(B) there is not an error — the line is emitted verbatim into the WGSL, which then fails to compile, and what reaches anyone is an invalid pipeline that does not mention a shader. The two halves of a shader file do not have the same powers, which nothing else would have said.

  • A skinned model's bind pose comes in with it. .esmesh carries a joint channel, a weight channel and the inverse bind matrices the first indexes — together, because a file whose joint indices point at matrices it does not carry is a file that cannot say what it means. A glTF's skin sits on the node rather than the primitive, so the geometry learns its bind pose from whatever draws it, and the prefab records the joints as the entities those source nodes became. Nothing draws with them yet; the renderer's half is next, and the gate below now says so out loud rather than letting the field look finished.

  • The dead-knob gate stopped taking anyone's word for it. It searched every source as one concatenated blob, so any file mentioning a common field name vouched for every component that declares one — a diagnostics counter called 'physics.joints' was standing in as the reader of a mesh's joint list. A reader now has to name the field AND the component it belongs to, which is how reaching one works. It also reads examples/ now, because some fields exist to be read by a game: Perception writes what it saw and the engine never looks again, and judging that by engine sources alone calls an output a dead knob. Nine fields were being vouched for that way and are recorded as gaps, each saying what is missing — four of them are one gap (CacheAsBitmap is declared and nothing renders a subtree to a texture), three are another (only the mesh path resolves a material into a program).

  • The model-import sample plays what it imported. Its glTF now carries a clip that lifts the banner, so the certified chain runs from the source file through the import's products to a packaged build that plays them — the capability the corpus is checked against, not a claim about it. Parity alone would not say so (a build playing nothing matches an editor playing nothing): the packaged frame with the clip stopped differs from the one playing it by 0.0527, with a cell reading 0.90.

  • A model's animations come in with it. A glTF's animations were counted and reported as skipped, so an imported model could be placed, lit and posed but never moved. Each one is written out as an .estimeline beside the meshes, and the prefab's root carries a player pointing at the first — stopped, because what to play is the scene's decision and not the importer's. A channel targets its node by the path of names the runtime resolves, so sibling nodes sharing a name are made distinct at import rather than leaving a track to drive whichever the walk reached first. Interpolation carries across as it stands: LINEAR and STEP by name, and CUBICSPLINE's [inTangent, value, outTangent] triples into the three fields a keyframe already has, tangents included, since both sides measure them per second. Quaternion keyframes are sign-aligned so a rotation takes the short way round. Morph-target weights are still reported rather than dropped, and an animation driving skinned joints now says that the mesh bound to them will not deform — the joints move, which is what node animation is.

  • A rotation can be animated on all three axes. Transform.rotation is a quaternion, but the reflection metadata offered exactly one animatable channel for it — rotation.z — and that channel was not the quaternion's z component: it was the Z euler angle, and writing it rebuilt the whole rotation, so every clip that turned something about Z flattened whatever pose it had. (The same defect the inspector's rotation control and the play realm's turn-by each needed fixing for; this was the third copy.) A quaternion now offers its four components plus rotation.angle, the Z turn a 2D scene thinks in — and that one composes, leaving the other two axes alone. Components written together are normalized once the track has landed, which traces the arc a slerp would. Documents written before this keep their meaning: rotation.z migrates to rotation.angle, asserted by sampling the clip rather than by comparing names.

  • The lighting model, in its general form. A Lit-2D shader can now call applyLightingPBR(albedo, N, worldPos, V, metallic, roughness, specular, ao) — the same lights, taken through a microfacet BRDF (GGX distribution, Smith geometry, Schlick fresnel). It is not a second lighting path beside the old one: applyLighting2D is defined as this call with metallic = 0, roughness = 1 and specular = 0, which leaves albedo * NdotL — pixel for pixel, byte for byte, what a lit sprite has always drawn. Both backends' injected headers carry it, so the two agree by construction.

    Two choices made that identity reachable rather than approximate. The pi that separates a Lambert albedo · NdotL from a physical albedo/π · NdotL is cancelled against the engine's light intensity instead of being applied to one side, so the diffuse expression is unchanged term for term. And specular is glTF's specularFactor, scaling the whole lobe rather than only F0 — at zero, Schlick's grazing-angle rim would otherwise survive and tint every existing sprite's edges.

  • A mesh casts a shadow on a mesh. A model could be imported, animated, skinned and shaded and still not throw one: the engine's only shadows were ShadowCaster2D's boxes in the XY plane, which for geometry with height is the wrong plane. A Directional light with meshShadows now renders the scene's meshes once from itself, and the lighting model reads the result as the visibility factor its loop already had a place for. Coverage follows the camera unless shadowExtent fixes it to a radius. One light per frame casts a map, and a scene where none asks pays nothing.

    Two of the four decisions behind it are about the two backends disagreeing. Depth is written and compared through the same matrix and the same expression, because GL's clip z and WebGPU's are not the same number and a shader that branched on which one it was would be wrong on one of them. And the light's projection is written out zero-to-one rather tha