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.

chore: prepare v0.98.0 release

yhh0f75f2d9b99b
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1108e4c9a..5f9888bcf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,9 +14,30 @@ published separately; it ships inside the editor.
## [Unreleased]
-### Removed
+## [0.98.0] - 2026-11-04
-- **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.
+### 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
@@ -24,6 +45,44 @@ published separately; it ships inside the editor.
- **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
@@ -15029,7 +15088,8 @@ not kept before this file was introduced — see the Git history at
`github.com/esengine/estella` for the full commit-level record since the first
commit on 2026-01-25.
-[Unreleased]: https://github.com/esengine/estella/compare/v0.97.0...HEAD
+[Unreleased]: https://github.com/esengine/estella/compare/v0.98.0...HEAD
+[0.98.0]: https://github.com/esengine/estella/compare/v0.97.0...v0.98.0
[0.97.0]: https://github.com/esengine/estella/compare/v0.96.0...v0.97.0
[0.96.0]: https://github.com/esengine/estella/compare/v0.95.0...v0.96.0
[0.95.0]: https://github.com/esengine/estella/compare/v0.94.0...v0.95.0
diff --git a/SECURITY.md b/SECURITY.md
index 4d4a0aa08..48dbbcbc3 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -7,8 +7,8 @@ upgrading to the latest release is the supported path to a fix.
| Version | Supported |
|---------|-----------|
-| 0.97.x | Yes |
-| < 0.97 | No |
+| 0.98.x | Yes |
+| < 0.98 | No |
`tools/check-release-metadata.mjs` fails the build if this table stops matching
the version being shipped, so it cannot quietly fall behind again.
diff --git a/desktop b/desktop
index 227965fda..cf2391a54 160000
--- a/desktop
+++ b/desktop
@@ -1 +1 @@
-Subproject commit 227965fda43e69863e9864a963294533bbd0d67f
+Subproject commit cf2391a54c8ecf2b2b4e85e2b7866bf55d2f535b
diff --git a/package.json b/package.json
index b954f771a..a57d932ac 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "estella",
- "version": "0.97.0",
+ "version": "0.98.0",
"private": true,
"type": "module",
"description": "Estella - A fast 2D/3D game engine powered by WebAssembly and ECS",
diff --git a/tools/goldenProjects.mjs b/tools/goldenProjects.mjs
index 579bee3f7..d1ecdec25 100644
--- a/tools/goldenProjects.mjs
+++ b/tools/goldenProjects.mjs
@@ -1022,6 +1022,46 @@ export const SHIPPED = {
{ notCertifiable: "A rendering feature, covered by its unit tests and the Texture Canvas example run in the editor; no golden project pastes textures, and one packaged frame cannot decide a result that depends on the device." },
"Pack several textures onto one canvas at run time: `TextureAtlas.pack`.":
{ notCertifiable: "A rendering feature, covered by its unit tests and by the Render Texture example run in the editor; no golden project packs textures, and one packaged frame cannot decide a result that depends on the device." },
+ "PhysX as a second 3D solver.":
+ { notCertifiable: "The solver is a project setting no golden project chooses; check-physics3d-physx runs the 98-behaviour 3D smoke against the PhysX module in CI, and verify-native-physx exports the 3D example on each solver and holds that the chosen one answered." },
+ "A web game can run in a browser without WebAssembly.":
+ { notCertifiable: "An opt-in packaging setting that no golden project turns on; the SDK suite runs against the JavaScript engine (ESENGINE_ENGINE=asmjs), and one packaged frame from a browser that has WebAssembly cannot decide the fallback." },
+ "The Windows and Android hosts run the game":
+ { notCertifiable: "A property of the native hosts, not of a game act; the native verifiers boot the hosts, and the speed is the bench/aot-native measurement, which no packaged frame decides." },
+ "An Android package runs its `@compiled` systems as machine code.":
+ { notCertifiable: "Needs an Android device to decide, which the golden runner does not drive; measured on a phone with the AOT bench." },
+ "Mesh textures stream to the size their views need.":
+ { notCertifiable: "A memory and bandwidth result, held by the texture-streaming and mip-need editor checks on the 3D examples; a packaged frame looks the same whether the texture streamed or not." },
+ "Impostors.":
+ { notCertifiable: "A rendering feature covered by impostor.test.ts and the impostor editor check; no golden project uses impostors." },
+ "Billboards.":
+ { notCertifiable: "A rendering feature covered by test_billboard_facing and the billboard editor check; no golden project uses billboards." },
+ "A draw call budget per quality level.":
+ { notCertifiable: "A counter and a profiler readout, covered by draw-budget.test.ts and the draw-budget editor check; no game act decides it." },
+ "A first-person controller.":
+ { notCertifiable: "A gameplay component covered by first-person.test.ts on the 3D physics module; no golden project is first-person." },
+ "Ragdolls.":
+ { notCertifiable: "A physics feature covered by ragdoll.test.ts and the ragdoll smokes on both 3D solvers (20 of 20); no golden project carries a ragdoll." },
+ "Move along a spline, and a 2D ground along one.":
+ { notCertifiable: "Covered by spline.test.ts and the editor's spline handles; no golden project lays a path or a band." },
+ "Terrain brushes.":
+ { notCertifiable: "An editor authoring tool and its engine edit, covered by terrain-sculpt.test.ts and the editor's terrain-sculpt-tools test; a packaged game does not paint terrain." },
+ "`MouseButton.Left`, `Middle` and `Right`.":
+ { notCertifiable: "An API name for values that already existed, covered by input-map.test.ts and the API baseline." },
+ "`SceneManager.getLoading` and `whenLoadsSettle`.":
+ { notCertifiable: "An API covered by scene-loads-settle.test.ts; no game act depends on asking what is loading." },
+ "`App.setRunInBackground`.":
+ { notCertifiable: "Behaviour of a hidden page, which a golden run (a visible frame) cannot reach; covered by app-run-in-background.test.ts." },
+ "`CameraView.pointerToWorld` and `pointerRay`.":
+ { notCertifiable: "An API of the camera view with no test of its own; no golden project turns a pointer into a ray, and a frame cannot show the conversion." },
+ "`uvRectFromPixels`.":
+ { notCertifiable: "A pure conversion from pixels to UV space with no test of its own; no golden project asks for it, and a frame cannot tell which helper made a rectangle." },
+ "`pointerEvents: Receive` under a `None` ancestor.":
+ { notCertifiable: "A hit-test rule covered by pointer-blocked-in-tree.test.ts; no golden project nests a Receive node under a None one." },
+ "An asset path written into a component while the game runs is loaded.":
+ { notCertifiable: "Covered by the asset field path tests on every core and by the export asset scan; no golden project writes an asset path at run time." },
+ "`sceneOutOfBandFields`.":
+ { notCertifiable: "A tooling query a game never calls; the MCP field edit uses it to name what to use instead, and it has no test of its own." },
};
/** Numeric compare of two `x.y.z` strings. */
diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjs
index c63f731d6..e637dfcdd 100644
--- a/tools/releaseNotes.mjs
+++ b/tools/releaseNotes.mjs
@@ -3528,4 +3528,276 @@ export const NOTED = {
{"note":"A drop on an Outliner row lands."},
"fix(editor): a play that cannot start prints every compile error to the output log, and the status line carries the reason, not only that it failed":
{"note":"A play that cannot start says why."},
+ "fix(api): a released const that gained readonly properties keeps its promise":
+ {"internal":"the API baseline check reads an additive const as additive; nothing a creator uses changed"},
+ "fix(assets): a core with no resource manager does not load authored asset paths":
+ {"internal":"a headless core used by the engine tests; a game always has a resource manager"},
+ "fix(ci): the API snapshots carry PhysX and the JS engine; Linux fetches no Windows V8":
+ {"internal":"CI snapshots and the Linux build fetch; nothing that ships changed"},
+ "fix(ecs): world.set reads a vector written before it grew an axis":
+ {"note":"Commands inside a query."},
+ "feat(android): PhysX is its own library, packed only for a PhysX project":
+ {"note":"PhysX as a second 3D solver."},
+ "feat(native): PhysX runs on Windows, Linux and Android hosts, beside Jolt":
+ {"note":"PhysX as a second 3D solver."},
+ "feat(physics3d): PhysX as a second 3D backend, chosen per project, set up like Unity":
+ {"note":"PhysX as a second 3D solver."},
+ "feat(web): the JavaScript engine is opt-in — Project Settings → Web → Run without WebAssembly":
+ {"note":"A web game can run in a browser without WebAssembly."},
+ "feat(web): a browser without WebAssembly runs the game — the engine also ships as JavaScript":
+ {"note":"A web game can run in a browser without WebAssembly."},
+ "fix(export): an exported web game's long music plays — its CSP allows blob: media":
+ {"note":"Long music plays in an exported web game and in Play."},
+ "feat(android): an APK deflates its native libraries — an empty project is 20 MB, not 54":
+ {"note":"An Android APK is less than half the size."},
+ "fix(native): a phone runs the scripts a browser runs — V8 with Intl, and TextEncoder":
+ {"note":"The Windows and Android hosts run the game"},
+ "fix(android): the 60 fps frame-rate hint reaches the system on current Android":
+ {"note":"A native game runs at the frame rate it asks for."},
+ "fix(android): the V8 host boots on a phone, and compiled systems install there":
+ {"note":"The Windows and Android hosts run the game"},
+ "fix(text): a bitmap glyph's outline is the glyph grown, not eight stamped copies of it":
+ {"note":"A bitmap glyph's outline is the glyph grown,"},
+ "feat(native): the Windows and Android hosts run the game's JS on V8, with its JIT":
+ {"note":"The Windows and Android hosts run the game"},
+ "fix(native): an embedded shader is cut into literals MSVC can hold, and the check sees delimited ones":
+ {"internal":"lets the Windows host compile; a shipped host behaves the same"},
+ "feat(ui): pointerEvents Receive takes the pointer back under a None ancestor":
+ {"note":"`pointerEvents: Receive` under a `None` ancestor."},
+ "perf(app): a single system can sit out the frames it has nothing to do in":
+ {"note":"Systems and plugins with nothing to do cost nothing."},
+ "feat(aot): an Android package runs its @compiled systems as machine code":
+ {"note":"An Android package runs its `@compiled` systems as machine code."},
+ "feat(history): Undo run takes back a whole agent run in one click":
+ {"note":"History shows where an agent run began"},
+ "feat(history): agent runs are marked in History, file undo is kept by space, captures stop at 1568 px":
+ {"note":"History shows where an agent run began"},
+ "perf(app): seven more subsystems sit out the frames a scene gives them nothing to do":
+ {"note":"Systems and plugins with nothing to do cost nothing."},
+ "fix(mcp): the connection survives an editor that fails to start, and tells the agent how to work":
+ {"note":"The MCP connection survives an editor that fails to start"},
+ "feat(app): Plugin.activeWhen — a plugin whose components no entity has costs nothing per frame":
+ {"note":"Systems and plugins with nothing to do cost nothing."},
+ "feat(mcp): a local log of which tools fail; the guide says how undo, permissions and progress work":
+ {"note":"An agent call over MCP is one undo step, files included."},
+ "feat(mcp): agent calls are undo steps with their files, tools carry annotations, long calls send progress":
+ {"note":"An agent call over MCP is one undo step, files included."},
+ "feat(shaders): the cook derives every shader's WGSL twin where the host ships the converters":
+ {"note":"Every shader's WGSL twin is derived as it is read."},
+ "feat(scene): sceneOutOfBandFields names what a component carries beside its fields":
+ {"note":"`sceneOutOfBandFields`."},
+ "fix(textures): atlas pages fill their clear texels too, and solid art is not taken for premultiplied":
+ {"note":"A transparent edge shows no dark fringe."},
+ "fix(textures): a transparent edge no longer shows a dark fringe":
+ {"note":"A transparent edge shows no dark fringe."},
+ "feat(assets): a package carries the assets its scripts name, and says which file it lacks":
+ {"note":"An asset path written into a component while the game runs is loaded."},
+ "feat(editor)!: remove the built-in agent; plugin agent tools reach MCP clients":
+ {"note":"The editor no longer has an agent of its own."},
+ "feat(camera): orthoSize stays the zoom under a design-resolution fit":
+ {"note":"`orthoSize` stays the zoom under a design-resolution fit."},
+ "feat(input): MouseButton.Left / Middle / Right":
+ {"note":"`MouseButton.Left`, `Middle` and `Right`."},
+ "fix(sdk): the shipped .d.ts files keep real names between their chunks":
+ {"note":"The shipped `.d.ts` files keep real names between their chunks."},
+ "feat(scene): SceneManager.getLoading and whenLoadsSettle":
+ {"note":"`SceneManager.getLoading` and `whenLoadsSettle`."},
+ "fix(text): a label's shadow and outline fade with its own colour alpha":
+ {"note":"A bitmap glyph's outline is the glyph grown,"},
+ "fix(ui): every Interactable carries its UIInteraction from the frame it appears; one exported game hit test":
+ {"note":"A UI press lands on the frame a control appears."},
+ "feat(assets): an asset path written into an engine component at run time is loaded into its handle":
+ {"note":"An asset path written into a component while the game runs is loaded."},
+ "fix(ecs): a Mut row kept past the loop stays live until the system returns":
+ {"note":"Commands inside a query."},
+ "fix(ecs): cmds.spawn(...).id() inside a query reserves the id instead of throwing":
+ {"note":"Commands inside a query."},
+ "fix(shader): a reserved #pragma param says how to read the uniform it shadows":
+ {"note":"A reserved `#pragma param` says how to read the uniform it shadows."},
+ "feat(mcp): frame stats carry what texture streaming holds; the MCP docs say when the editor starts":
+ {"note":"Mesh textures stream to the size their views need."},
+ "feat(app): App.setRunInBackground keeps the loop going while the page is hidden":
+ {"note":"`App.setRunInBackground`."},
+ "fix(debug): device_screenshot reads a native build's frame back":
+ {"note":"More of the editor answers over MCP."},
+ "feat(export): a web build ships a small copy of each texture a mesh draws, and streaming fetches the file only once a view needs more":
+ {"note":"Mesh textures stream to the size their views need."},
+ "fix(assets): a cooked MP3 starts with its first frame, not the encoder's flush bytes":
+ {"note":"A cooked MP3 starts with its first frame,"},
+ "feat(render): uvRectFromPixels, the one pixel-rect to UV conversion, and docs for y-up UV space":
+ {"note":"`uvRectFromPixels`."},
+ "fix(render): a material's sprites no longer merge across textures":
+ {"note":"A material's sprites no longer merge across textures."},
+ "fix(ui): nine-slice borders reach the native core, and a short box keeps its corners round":
+ {"note":"Nine-slice borders reach the native core,"},
+ "feat(camera): CameraView.pointerToWorld / pointerRay take the pointer as Input reports it":
+ {"note":"`CameraView.pointerToWorld` and `pointerRay`."},
+ "fix(camera): CameraView and PresentedCameraView are published on the native core too":
+ {"note":"`CameraView.pointerToWorld` and `pointerRay`."},
+ "feat(assets): a texture a mesh draws starts small while texture streaming is on, and grows to what its views need":
+ {"note":"Mesh textures stream to the size their views need."},
+ "feat(render): texture streaming holds each mesh texture at the size its views need, measured per draw from the mesh's UV density, and moves it behind the same handle":
+ {"note":"Mesh textures stream to the size their views need."},
+ "feat(render): an Impostor stands a picture of its mesh in once it is small, taken from many directions by the engine's own cameras and drawn as one batched card per view":
+ {"note":"Impostors."},
+ "feat(render): Billboard turns a mesh to each view that draws it, flat in the view plane or upright about world up, without writing its Transform":
+ {"note":"Billboards."},
+ "feat(render): the device counts every draw a frame asks of the GPU, every pass included, and a quality level holds a draw call budget against it":
+ {"note":"A draw call budget per quality level."},
+ "feat(gameplay): FirstPersonController looks, walks, jumps and crouches in a CharacterController3D; FirstPersonViewModel draws a held thing with a second camera so it does not go through walls":
+ {"note":"A first-person controller."},
+ "feat(physics3d): RagdollJoint gives a bone no body or limits of its own; the ragdoll plan is shared with the editor, which draws it":
+ {"note":"Ragdolls."},
+ "feat(spline): a terrain band's lip can be drawn with an image repeating along the surface; PathFollower is shown to answer a timeline track or graph node by property path":
+ {"note":"Move along a spline, and a 2D ground along one."},
+ "feat(physics3d): a ragdoll's knees and elbows are one-way hinges, folding back and forward from the pose they start in":
+ {"note":"Ragdolls."},
+ "feat(physics3d): a ragdoll's joints are limited by their part of the body (spine stiff, shoulder loose, shin almost a hinge), read from bone names":
+ {"note":"Ragdolls."},
+ "feat(import): far LOD levels may collapse across borders and seams and shed specks, so they reach their budget":
+ {"note":"Far LOD levels reach their budget."},
+ "fix(physics3d): a ragdoll keeps the animation running and puts the bodies' pose over it, finds a skin below its entity, and defaults to looser limits":
+ {"note":"Ragdolls."},
+ "feat(physics3d): Ragdoll turns a skinned character's bones into jointed bodies and blends back to the animation":
+ {"note":"Ragdolls."},
+ "fix(spline): TerrainBand2D and PathFollower pull the spline module into a build; a band rebuilds a mesh the editor cleared":
+ {"note":"Move along a spline, and a 2D ground along one."},
+ "feat(spline): TerrainBand2D draws a 2D ground along a Spline, with a surface lip and an optional chain collider":
+ {"note":"Move along a spline, and a 2D ground along one."},
+ "feat(spline): PathFollower moves an entity along a Spline at a steady speed (once, loop, ping-pong)":
+ {"note":"Move along a spline, and a 2D ground along one."},
+ "feat(native): the target frame rate reaches the host, which paces its display-driven loop to it":
+ {"note":"A native game runs at the frame rate it asks for."},
+ "fix(android): ask the system for 60 fps and clock frames by the vsync timestamp":
+ {"note":"A native game runs at the frame rate it asks for."},
+ "feat(terrain): brushes change an area's ground in place, with the pages made again only where a stroke reached":
+ {"note":"Terrain brushes."},
+ "fix(desktop): graph wires take Unreal's spline, a pinned tilemap mode has a way out, and dev keeps the main-process externals":
+ {"note":"Tilemap mode has a way out."},
+ "fix(viewport): a camera move wakes the paint that carries it":
+ {"note":"A camera move in the viewport always repaints."},
+ "fix(material): a live texture edit keeps drawing once the texture's cooked form lands":
+ {"note":"A live texture edit keeps drawing once the texture's cooked form lands,"},
+ "fix(checks): the editor checks run a fresh English profile and wake the lazy editor":
+ {"internal":"an editor or engine check, which a creator does not run"},
+ "fix(checks): collider3d-gizmo measures the dimmed wire by its ink, not by bright pixels":
+ {"internal":"an editor or engine check, which a creator does not run"},
+ "fix(checks): gizmo checks follow the orthoSize rule and the plane handles' new place":
+ {"internal":"an editor or engine check, which a creator does not run"},
+ "fix(scripts): a shipped editor type-checks with the TS standard library":
+ {"note":"A packaged editor type-checks scripts with TypeScript's standard library,"},
+ "fix(settings): an Android package carries PhysX only when it is chosen":
+ {"note":"PhysX as a second 3D solver."},
+ "fix(settings): the 3D solver note says native apps run the chosen solver":
+ {"note":"PhysX as a second 3D solver."},
+ "feat(settings): Project Settings → Physics → 3D solver picks Jolt or PhysX, and Play runs the one chosen":
+ {"note":"PhysX as a second 3D solver."},
+ "feat(settings): Web packaging can carry the JavaScript engine — off by default":
+ {"note":"A web game can run in a browser without WebAssembly."},
+ "fix(play): a streamed clip plays in Play — the realm's CSP allows blob: media":
+ {"note":"Long music plays in an exported web game and in Play."},
+ "feat(packaging): Android setting to compress the APK's native libraries (on by default)":
+ {"note":"An Android APK is less than half the size."},
+ "fix(ui-inspect): the pointer verdict asks the nearest decided node, so Receive under None reads as hit":
+ {"note":"`pointerEvents: Receive` under a `None` ancestor."},
+ "feat(build): the Package dialog says when an Android export needs the NDK for compiled systems":
+ {"note":"An Android package runs its `@compiled` systems as machine code."},
+ "feat(history): Undo run takes back a whole agent run in one click":
+ {"note":"History shows where an agent run began"},
+ "feat(history): an agent's undo reaches as far back as space allows, and History shows where its run began":
+ {"note":"History shows where an agent run began"},
+ "fix(mcp): an editor that fails to start is a tool error; the server tells a session how to work":
+ {"note":"The MCP connection survives an editor that fails to start"},
+ "feat(mcp): capture_viewport realm play reads the running game's own frame back":
+ {"note":"More of the editor answers over MCP."},
+ "feat(mcp): a local log of which tools fail, and a summary of it":
+ {"note":"An agent call over MCP is one undo step, files included."},
+ "feat(mcp): edit_controller and set_gear_binding author UI controllers and gears":
+ {"note":"More of the editor answers over MCP."},
+ "fix(mcp): take back two tools another session's work-in-progress lent my last commit":
+ {"internal":"reverted tools that a previous commit lent by mistake; no release carried them"},
+ "feat(mcp): arguments are checked all the way down, and the error names where":
+ {"note":"An agent call over MCP is one undo step, files included."},
+ "feat(shaders): a project shader's WGSL twin is derived as it is read, in a packaged editor too":
+ {"note":"Every shader's WGSL twin is derived as it is read."},
+ "feat(mcp): a long call tells the client it is still running":
+ {"note":"An agent call over MCP is one undo step, files included."},
+ "feat(mcp): every tool carries MCP annotations from its effect":
+ {"note":"An agent call over MCP is one undo step, files included."},
+ "feat(mcp): one agent call is one undo step, and its files go back with it":
+ {"note":"An agent call over MCP is one undo step, files included."},
+ "fix(mcp): set_field on a MeshRenderer's inline geometry says what to use instead":
+ {"note":"An agent call over MCP is one undo step, files included."},
+ "fix(editor): the editor shows a texture's shipped image, not only its KTX2":
+ {"note":"A live texture edit keeps drawing once the texture's cooked form lands,"},
+ "feat(build): the size report names assets that ship because the scripts name them":
+ {"note":"An asset path written into a component while the game runs is loaded."},
+ "feat(editor)!: remove the built-in agent; plugin agent tools are served over MCP":
+ {"note":"The editor no longer has an agent of its own."},
+ "fix(mcp): step waits for scene loads in flight and names them":
+ {"note":"More of the editor answers over MCP."},
+ "fix(mcp): a play_input click presses on the first frame it is given":
+ {"note":"More of the editor answers over MCP."},
+ "fix(mcp): click_ui confirms its target with the game's hit test":
+ {"note":"More of the editor answers over MCP."},
+ "feat(mcp): the everyday tools are listed from the start and the rest in groups enable_tools turns on; every tool stays callable by name":
+ {"note":"More of the editor answers over MCP."},
+ "refactor(mcp): the fourteen longest tool descriptions say the same in about half the words":
+ {"internal":"tool descriptions read shorter; what each tool does is unchanged"},
+ "feat(mcp): the editor starts on the first tool call, not before the handshake; get_stats answers for the running game; a probe has the SDK as sdk":
+ {"note":"More of the editor answers over MCP."},
+ "fix(play): Play keeps running in a hidden or background editor window":
+ {"note":"Play keeps running in a hidden or background editor window,"},
+ "fix(scripts): the shipped editor carries TypeScript's standard library, so check_scripts stops reporting 'Cannot find name Math'":
+ {"note":"A packaged editor type-checks scripts with TypeScript's standard library,"},
+ "fix(project): text writes publish whole files, so a reader never sees a half-written manifest":
+ {"note":"A project manifest is never seen half-written."},
+ "fix(export): an export that does not name an option takes what the Package dialog saved":
+ {"note":"An export that does not name an option takes what the Package dialog saved."},
+ "fix(editor): fitting a sprite to its texture never overwrites a size written after the texture":
+ {"note":"Fitting a sprite to its texture never overwrites a size written after the texture."},
+ "fix(play): a new Play reads textures as they are on disk now":
+ {"note":"Play keeps running in a hidden or background editor window,"},
+ "feat(checks): texture-streaming says what a build with small copies would fetch once settled; the streaming setting names the download it saves":
+ {"internal":"an editor or engine check, which a creator does not run"},
+ "feat(history): an edit made through an MCP tool is recorded as automation's, and an on-disk change reloads the scene without asking when those are the only unsaved steps":
+ {"note":"More of the editor answers over MCP."},
+ "feat(checks): texture-streaming reads the memory a scene first comes up in":
+ {"internal":"an editor or engine check, which a creator does not run"},
+ "feat(settings): a quality level streams its mesh textures within a budget, checked on dusk-fort and bistro; the mip-need library is typed":
+ {"note":"Mesh textures stream to the size their views need."},
+ "feat(checks): mip-need measures how much texture a 3D example holds that its first view does not need":
+ {"internal":"an editor or engine check, which a creator does not run"},
+ "feat(viewport): impostors are checked: every kind's pictures are taken, each card covers its mesh in its colour, and the cards are one draw":
+ {"internal":"an editor or engine check, which a creator does not run"},
+ "fix(overlays): a viewport dropdown closes on its own button and on a press of the scene, which cancels pointerdown and so never sent the mousedown the dismissal waited for":
+ {"note":"A viewport dropdown closes"},
+ "feat(content-browser): in a dock group 800px or wider the toolbar rides in the tab strip, so the grid starts right under the tabs":
+ {"note":"The content browser has one toolbar."},
+ "feat(viewport): a billboard is checked turning its quad to the camera in both modes; static batching names a billboard it leaves out":
+ {"internal":"an editor or engine check, which a creator does not run"},
+ "feat(content-browser): path, search and filter share one 26px toolbar; New and Import move to the empty-space menu; a bottom slider switches list and grid; a narrow dock gets the folder tree as a drawer":
+ {"note":"The content browser has one toolbar."},
+ "feat(profiler): the Render module shows the frame's GPU draws against the quality level's draw call budget, split by pass; a level's budget is a Quality setting":
+ {"note":"A draw call budget per quality level."},
+ "feat(viewport): a selected ragdoll shows the limbs and joint limits it would be made of":
+ {"note":"Ragdolls."},
+ "feat(viewport): a Spline on its own gets drag, insert and delete handles, on the screen's plane in 2D and the ground's in 3D":
+ {"note":"Move along a spline, and a 2D ground along one."},
+ "feat(gizmo): shafts brighten toward the tip, scale centre is a dotted disc, as in Unreal":
+ {"note":"The editor looks and handles like Unreal."},
+ "fix(viewport): empties, lights and cameras get no selection box, as in Unreal":
+ {"note":"The editor looks and handles like Unreal."},
+ "fix(gizmo): all three plane handles are always drawn, edge-on ones as slivers, as in Unreal":
+ {"note":"The editor looks and handles like Unreal."},
+ "fix(gizmo): a plane handle seen edge-on is hidden instead of drawn as a sliver over an axis":
+ {"note":"The editor looks and handles like Unreal."},
+ "feat(viewport): Alt + right drag dollies the eye, as in Unity and Unreal":
+ {"note":"The editor looks and handles like Unreal."},
+ "feat(terrain): a terrain brush raises, lowers, smooths and flattens an area's ground and paints its layers":
+ {"note":"Terrain brushes."},
+ "feat(viewport): the transform handles default to 1.2x, arrows 96px instead of 80 — they were small in a viewport that has the whole panel; the Handle size setting still runs 0.5 to 2":
+ {"note":"The editor looks and handles like Unreal."},
+ "fix(viewport): a selected camera in a 3D view draws its whole frustum, strongly, instead of only the flat frame where it meets z = 0; an unselected one stays a quiet outline and Show Frustum still forces the volume":
+ {"note":"The editor looks and handles like Unreal."},
};