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.

docs(changelog): notes for the commits since 0.96 that had none

yhh4432fc0f1bf0
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 244669500..88bd32192 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -51,15 +51,49 @@ published separately; it ships inside the editor.
- **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.
+- **Cocos scripts drive scenes as the game does.** `director.loadScene` runs a project scene through the engine's scene manager (the scenes are in the manifest, and a persistent root is `SceneOwner.persistent`), a scene's components start in one phase before the frame's updates, and `director` has a scheduler and fires its frame events. A node's scripts load and enable as it joins an active parent or is switched on, not a frame later, and a node made between frames joins the running world. `setSiblingIndex` reorders through the engine's entity order, `getComponent` finds a component by a base class it derives from or by its `cc.` name, and `Component.EventHandler`, `Node.getParent` and `Camera.screenPointToRay` exist. Sprites, labels and graphics accept the rebuild requests scripts send, and the design resolution is known to scripts before they run. A Play that follows another in the same script runtime gets the layer's systems again and none of what the last one loaded.
+- **Cocos scripts load assets by path.** `resources.load` gives images, sprite frames and audio by path, and finds an image's `spriteFrame` and `texture` by the end of the path; `Sprite` takes a `spriteFrame`. A directory load leaves out what the layer cannot load instead of failing, `loadAny` takes a uuid, a loaded asset is named for its file and counts its holders, and `assetManager` has a downloader and a factory.
+- **A converted project's scripts are components the editor knows.** The converted project declares the component classes of every script, since a game opens its views by class name, and they reach the inspector; the script entry leaves out Cocos's own editor scripts, and the scripts bundle past the gaps Cocos tolerates (missing `cc` names, a reassigned `const`, package files outside `exports`, imports used only in preview).
+- **A Cocos project's own effects are converted.** An effect becomes an Estella shader and material, so a sprite, a mesh or a particle that wore it keeps its look: its chunks are included, its vertex program is carried into the fragment, a vertex displacement becomes the material's vertex hook with a derived WebGPU twin, and each macro combination is one shader, compiled and given its WebGPU twin before it is written. The sprite texture is not made a material parameter, a blend state the material does not set is the effect's, and the import progress has a stage for checking the converted effects.
+- **Converted Cocos UI looks as it does in Cocos.** The UI layer is painted in hierarchy order, so a popup covers the text of the view under it. A root pinned to the screen is stored where the engine places it in the design box, so the document and the viewport agree, and the Cocos `Layout` runs between the engine's two anchor passes instead of keeping a second copy of the alignment. A Label with no overflow rule does not wrap and is laid out from its anchor, a Label takes a game's replaced string setter, and an EditBox becomes the engine's text field with its two labels folded in, showing its text label while it holds text. An inactive node becomes the `Disabled` tag, so its subtree goes with it instead of being stranded; enums are the engine's numbers; and a bitmap font's page ships at its full size with its meta, not halved by the default 2048 cap.
+- **A converted Cocos project is brought up to date when it is opened.** The importer records its revision in the project, and a project written by an older importer is converted again when the editor opens it.
### 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
- **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.
## [0.96.0] - 2026-10-27
diff --git a/tools/releaseNotes.mjs b/tools/releaseNotes.mjs
index c2110149c..20bd96681 100644
--- a/tools/releaseNotes.mjs
+++ b/tools/releaseNotes.mjs
@@ -43,11 +43,11 @@ export const NOTED = {
'feat(cocos): MeshRenderer, UIMeshRenderer, material properties and cc.geometry in the compatibility layer':
{"note":"Mesh renderers and materials in the Cocos layer."},
'feat(cocos): cc.js, ccenum and NodePool exist in the compatibility layer':
- {"note":"More of cc."},
+ {"note":"More of `cc`."},
'feat(bundle): the project script bundle is built again only when a file it read changed, and Cocos scripts that write the same class name each get a component of their own':
{"note":"The script bundle is not rebuilt for nothing."},
'fix(editor): opening a large project no longer spends seconds on strings that cannot be paths, a model texture the project lacks is left off instead of dangling, and an unlit mesh variant with tangents links':
- {"note":"Large projects open faster, and a model texture the project lacks is left off."},
+ {"note":"Large projects open faster."},
'feat(cocos): one script that fails to load no longer takes the others with it, a part of cc the layer lacks is a stand-in that survives use, and Director, AssetManager.Cache and the input dispatcher hook exist':
{"note":"Cocos scripts load one by one."},
'feat(cocos): a converted project links its source images instead of copying them, so conversion does not store a multi-gigabyte art folder twice':
@@ -3218,4 +3218,198 @@ export const NOTED = {
{"internal":"A type the playable size test needed; the value was already returned."},
"fix(ci): the theme ratchet banks the inspector's new virtual-instance button":
{"internal":"Moves a baseline count; no creator can observe it."},
+ "feat(cocos): director.loadScene runs a project scene through the engine's scene manager (scenes are in the manifest, persistent roots are SceneOwner.persistent); components start in one phase before the frame's updates; Camera.screenPointToRay":
+ {"note":"Cocos scripts drive scenes as the game does."},
+ "fix(cocos): getComponent finds a component by a base class it derives from, so a handler bound through the Button of a Toggle's node reaches it":
+ {"note":"Cocos scripts drive scenes as the game does."},
+ "feat(ui): TextInput stands on a world rectangle as well as a UI node, and a Cocos EditBox becomes it: the importer folds the two labels into the field and the layer's EditBox is a view on it":
+ {"note":"A text field can stand in the world."},
+ "fix(ui): a pointer lands on what is drawn last by its place in the hierarchy, not on what was made last; a Toggle belongs to the container its parent holds and assigning isChecked switches its group's others off":
+ {"note":"A pointer lands on what is drawn on top."},
+ "fix(cocos): a Label takes a game's replaced string setter (the engine's _string and friends land on the Text), and an EditBox shows its text label while it holds text":
+ {"note":"Converted Cocos UI looks as it does in Cocos."},
+ "fix(cocos): a play session that follows another in the same script runtime gets the layer's systems again and none of what the last one loaded":
+ {"note":"Cocos scripts drive scenes as the game does."},
+ "fix(cocos): a Label with no overflow rule does not wrap and is laid out from its anchor, as the node grows to the text in Cocos":
+ {"note":"Converted Cocos UI looks as it does in Cocos."},
+ "feat(render): layers painted in hierarchy order, so a panel covers the text of the panel under it; the Cocos UI layer uses it. Text takes an underline field; resources.load finds an image's spriteFrame and texture by path suffix":
+ {"note":"A layer can be painted in hierarchy order."},
+ "fix(cocos): a node's scripts load and enable as it joins an active parent or is switched, not a frame later; a converted script component's dropped fields are ignored quietly":
+ {"note":"Cocos scripts drive scenes as the game does."},
+ "feat(cocos): resources.load gives images, sprite frames and audio by path, Sprite takes a spriteFrame, Node has getParent; the script entry leaves out the editor's own scripts":
+ {"note":"Cocos scripts load assets by path."},
+ "feat(cocos): the generated script entry loads every component class of the project, since a game opens its views by class name":
+ {"note":"A converted project's scripts are components the editor knows."},
+ "fix(cocos): the session check also runs when a prefab is asked for":
+ {"note":"Cocos scripts drive scenes as the game does."},
+ "fix(cocos): the layer drops what it kept of a session when the asset loader gives everything back":
+ {"note":"Cocos scripts drive scenes as the game does."},
+ "fix(cocos): a loaded asset is named for its file, and what the layer kept of a play session is dropped when the next begins":
+ {"note":"Cocos scripts load assets by path."},
+ "fix(cocos): a directory load leaves out what the layer cannot load instead of failing, and Component.EventHandler exists":
+ {"note":"Cocos scripts load assets by path."},
+ "feat(assets): a scan reports how many documents it has read of how many":
+ {"note":"The loading screens say how far they are."},
+ "perf(assets): a scan keeps what each document refers to by what the file was, so a second scan of a large project reads nothing it has read; fix(cocos): a component is found by its cc. name and can be named by a script":
+ {"note":"A second scan of a large project reads nothing it has already read."},
+ "feat(shaders): the canonical vertex stage hands a mesh second uv set to a material, and a converted effect is one shader per macro combination, compiled and given its WGSL twin before it is written":
+ {"note":"A material can read a mesh's second uv set."},
+ "feat(shaders): a material vertex hook gets a derived WGSL twin, and an effect that displaces its vertices is converted with the displacement as that hook":
+ {"note":"A Cocos project's own effects are converted."},
+ "feat(cocos): a particle effect is converted on the engine particle stage, and a particle takes the converted material":
+ {"note":"A Cocos project's own effects are converted."},
+ "fix(cocos): the sprite texture is no parameter of a converted material, and a material blend state it does not set is the effect's":
+ {"note":"A Cocos project's own effects are converted."},
+ "feat(cocos): an effect includes its chunks and its vertex program is carried into the fragment, so the project materials convert for meshes as well as sprites":
+ {"note":"A Cocos project's own effects are converted."},
+ "feat(cocos): a project's own effect is converted to an Estella shader and material, so a sprite or mesh that wore it keeps its look":
+ {"note":"A Cocos project's own effects are converted."},
+ "feat(cocos): a sprite, a label and a graphics are UIRenderers, which accept the rebuild requests scripts send":
+ {"note":"Cocos scripts drive scenes as the game does."},
+ "feat(cocos): the importer records its revision, so a project it wrote earlier is re-imported on open":
+ {"note":"A converted Cocos project is brought up to date when it is opened."},
+ "feat(cocos): director has a scheduler and fires its frame events, setSiblingIndex reorders through the engine entity order, loadAny takes a uuid, and an asset counts its holders":
+ {"note":"Cocos scripts drive scenes as the game does."},
+ "feat(cocos): a root pinned to the screen is stored where the engine places it in the design box, so the document and the viewport agree":
+ {"note":"Converted Cocos UI looks as it does in Cocos."},
+ "refactor(ui): the engine anchors run in two ordered passes and the Cocos Layout is a system between them, so alignment has one owner instead of a second hand-called copy":
+ {"note":"Converted Cocos UI looks as it does in Cocos."},
+ "feat(cocos): the project design resolution is known to scripts before they run, assetManager has a downloader and factory, and a node made between frames joins the running world":
+ {"note":"Cocos scripts drive scenes as the game does."},
+ "feat(cocos): a converted project declares its script components for the editor and starts from the scripts, and the Cocos scripts bundle past the gaps Cocos tolerates (missing cc names, reassigned const, package files outside exports, preview-only imports)":
+ {"note":"A converted project's scripts are components the editor knows."},
+ "fix(release): escape the apostrophe in the Cocos re-import release-note key":
+ {"internal":"Repairs a key of the release-notes ledger; no creator can observe it."},
+ "feat(art): preserve Qinglan native sculpt revision and comparison":
+ {"internal":"Source art studies kept in the repository's art/ folder; no part of the engine, the editor or a build reads or ships them."},
+ "feat(gameplay): grid snapping and a placement check, and the entities nearest a point":
+ {"note":"Grid placement, and what stands nearest."},
+ "feat(art): add reversible Qinglan face candidate and review evidence":
+ {"internal":"Source art studies kept in the repository's art/ folder; no part of the engine, the editor or a build reads or ships them."},
+ "feat(engine): the device's battery and heat lower the frame cap and the quality level, by a policy the project names":
+ {"note":"Save power when the battery is low or the device is hot."},
+ "fix(text): a bitmap font's baseline comes from the font's own base over its size, not a 0.8em guess that put a 0.88 font four pixels high at 48px":
+ {"note":"Bitmap fonts."},
+ "feat(text): a glyph page is read by a mode — plain, distance field, mask, fill — so a bitmap font with its outline baked into the page draws in two passes with the ring in any colour; the Cocos import declares such fonts":
+ {"note":"Bitmap fonts."},
+ "feat(2d): a palette effect holds the whole picture to one set of colours, dithered":
+ {"note":"A palette effect."},
+ "fix(import): a Cocos bitmap font's page keeps its full size, not the 2048 default cap that halved a 4096 page and softened every glyph":
+ {"note":"Converted Cocos UI looks as it does in Cocos."},
+ "feat(2d): what walks leaves rings on water and prints on soft ground":
+ {"note":"Footprints and ripples."},
+ "feat(text): Text draws a bitmap font (.fnt) from its page texture, through the same layout as any font; widget prefabs regenerated for the Text box defaults":
+ {"note":"Bitmap fonts."},
+ "feat(text): TextOverflow.Shrink sets type smaller, a whole pixel at a time, until it fits its box; the Cocos import maps its Shrink labels to it":
+ {"note":"Text can shrink to fit its box."},
+ "feat(text): a world Text can lay out in its own box — width, height and an anchor pivot — so labels wrap, align and clip without joining a Canvas; the Cocos import uses it":
+ {"note":"World content has a rectangle: `ContentRect`."},
+ "feat(2d): plants of a sway material lean away from a body walking through them":
+ {"note":"Mist, wind in the grass, and roofs that fade over the player."},
+ "fix(import): a Cocos inactive node becomes the Disabled tag, so its subtree goes with it, instead of a dropped entity that strands its children":
+ {"note":"Converted Cocos UI looks as it does in Cocos."},
+ "feat(2d): a generated world on the screen plane, laid out by the worldgen rules and published in chunks":
+ {"note":"A generated 2D world."},
+ "fix(art): reject Qinglan face study after visual review":
+ {"internal":"Source art studies kept in the repository's art/ folder; no part of the engine, the editor or a build reads or ships them."},
+ "fix(import): Cocos enums as the engine's numbers, bitmapfont meta so the page ships, and the engine's own component validation in the test":
+ {"note":"Converted Cocos UI looks as it does in Cocos."},
+ "feat(2d): 2D shadows have eight channels and reach the tiled lights past the loop's sixteen":
+ {"note":"More 2D lights cast shadows at once."},
+ "feat(art): add editable Qinglan face cage study":
+ {"internal":"Source art studies kept in the repository's art/ folder; no part of the engine, the editor or a build reads or ships them."},
+ "feat(pipeline): import a Cocos Creator 3.x project as Estella prefabs and scenes, without touching the source":
+ {"note":"Open a Cocos Creator project from the editor."},
+ "feat(2d): a fog of war remembers what a viewer has seen, and a save can keep it":
+ {"note":"What the player can see, and what they have seen."},
+ "feat(2d): a viewer and the walls it cannot see through hide what is not lit":
+ {"note":"What the player can see, and what they have seen."},
+ "feat(mcp): a connect dialog for AI tools, with the permission decided by the editor (desktop ac014832)":
+ {"note":"Connect AI tools to the editor from one dialog."},
+ "feat(mcp): one-click add of the editor to Claude Code, Cursor and Claude Desktop (desktop b2cb78f3)":
+ {"note":"Connect AI tools to the editor from one dialog."},
+ "feat(art): add Qinglan xianxia character and human face studies":
+ {"internal":"Source art studies kept in the repository's art/ folder; no part of the engine, the editor or a build reads or ships them."},
+ "feat(2d): a cooked streamed world can be cut on x and y, so a 2D scene is a grid and not one row":
+ {"note":"A 2D world streams on x and y."},
+ "feat(2d): a streamed world is cut on x and y, and an infinite tile layer can let a chunk go":
+ {"note":"A 2D world streams on x and y."},
+ "feat(2d): a sprite that stands on the ground keeps the rain's rings and wet darkening off it":
+ {"note":"Rain for a 2D scene."},
+ "feat(2d): the samples across a soft shadow's light source are a quality setting":
+ {"note":"A soft 2D shadow's smoothness is a quality setting."},
+ "feat(2d): the rain shelter mask size is the effect's own field, and a quality level holds it lower":
+ {"note":"Rain for a 2D scene."},
+ "feat(2d): the rain's shelters are painted into a mask, so a scene has as many as it has roofs":
+ {"note":"Rain for a 2D scene."},
+ "feat(2d): lights that cannot meet share a channel of the 2D shadow mask, so a camp of torches all cast":
+ {"note":"More 2D lights cast shadows at once."},
+ "feat(2d): a light reaches a range of sprite layers, so a lamp in a hut does not light the roof over it":
+ {"note":"A 2D light can keep to a range of sprite layers."},
+ "feat(2d): rain that reads no depth, with rings and puddles on the ground and dry ground under a roof":
+ {"note":"Rain for a 2D scene."},
+ "feat(2d): mist, sprite wind and cover fade, so a top-down scene can have the weather a forest needs":
+ {"note":"Mist, wind in the grass, and roofs that fade over the player."},
+ "feat(prefab): ?expand-virtual leaves out an instance marked as another layout":
+ {"note":"Virtual prefab instances."},
+ "feat(ui): export deferredEntities and deferredRecord, for a game that keeps two layouts as virtual instances":
+ {"note":"Virtual prefab instances."},
+ "feat(prefab): ?expand-virtual makes virtual instances whole, for a harness that expects every node at boot":
+ {"note":"Virtual prefab instances."},
+ "feat(prefab): virtual instances, seen when authoring and made when they are used":
+ {"note":"Virtual prefab instances."},
+ "feat(ui): UIPages, pages of a UI that exist only while they are wanted":
+ {"note":"UI pages that exist only while they are wanted: `UIPages`."},
+ "perf(ui): GearApplySystem does not run in a frame where nothing it reads changed":
+ {"note":"UI gears cost nothing on a frame where nothing they read changed."},
+ "fix(export): a playable that is far over its cap is built at once and reports its size":
+ {"note":"A playable far over its size cap is built at once and says its size."},
+ "fix(editor): the project watch is quiet while a Cocos re-import writes, and the project is refreshed once at the end":
+ {"note":"Re-import a Cocos project without losing your edits."},
+ "feat(editor): a selection draws nothing over the running game unless Inspect is on; a new one shows where it is for a moment":
+ {"note":"A selection stays off the running game unless Inspect is on."},
+ "feat(editor): the engine step of the loading screen shows which step of the boot it is in":
+ {"note":"The loading screens say how far they are."},
+ "feat(editor): the loading screens say how far they are: one bar, a line per step with its count and time, and the time so far":
+ {"note":"The loading screens say how far they are."},
+ "feat(cocos): the import progress has a stage for checking the converted effects":
+ {"note":"A Cocos project's own effects are converted."},
+ "fix(editor): the status strip keeps each readout on one line and drops the long message and the least useful readouts when it is short of room":
+ {"note":"The status strip fits a narrow window."},
+ "feat(cocos): a project converted by an older importer is brought up to date when it is opened":
+ {"note":"A converted Cocos project is brought up to date when it is opened."},
+ "fix(test): the MCP client adapter checks run under the throwaway home, so they no longer touch the real VS Code config on Windows":
+ {"internal":"Points the MCP client adapter tests at a throwaway home directory; no creator can observe it."},
+ "refactor(editor): the edit world reads the screen fit from the one runtime config derivation instead of deriving it a second time":
+ {"internal":"The edit world reads the screen fit from the one runtime config derivation; the fit it lays out in is the next fix's, and this changes nothing on its own."},
+ "fix(editor): the edit world lays UI out in the project fit, so a root pinned to the screen takes the design box instead of the viewport pixels":
+ {"note":"The edit viewport frames and lays out the scene as the game does."},
+ "fix(viewport): 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":
+ {"note":"The edit viewport frames and lays out the scene as the game does."},
+ "fix(play): a project script bundle that throws while it loads is logged instead of looking like no bundle":
+ {"note":"A project script bundle that throws while it loads is reported."},
+ "fix(cocos): the schema extractor resolves cc, so a converted project's components reach the inspector":
+ {"note":"A converted project's scripts are components the editor knows."},
+ "fix(cocos): the conversion progress window carries the editor icon, has no scrollbar, and speaks the editor language":
+ {"note":"A Cocos conversion shows its progress."},
+ "feat(cocos): converting a Cocos project runs on a thread of its own with a progress bar, so the editor no longer looks hung":
+ {"note":"A Cocos conversion shows its progress."},
+ "feat(editor): settings rows for the power-saving policy":
+ {"note":"Save power when the battery is low or the device is hot."},
+ "fix(editor): the connect dialog and its status-bar mark use the editor's own components and tokens":
+ {"note":"Connect AI tools to the editor from one dialog."},
+ "fix(editor): the status bar's AI agent mark waits for the bridge it reads from":
+ {"note":"Connect AI tools to the editor from one dialog."},
+ "feat(editor): one dialog connects AI tools, and the editor grants what an agent may do live":
+ {"note":"Connect AI tools to the editor from one dialog."},
+ "feat(editor): the editor adds itself to the AI tools on the machine, one switch each":
+ {"note":"Connect AI tools to the editor from one dialog."},
+ "feat(editor): the streamed-world grid follows the plane a world is cut on":
+ {"note":"A 2D world streams on x and y."},
+ "feat(editor): the quality page sets how many samples a soft 2D shadow is drawn with":
+ {"note":"A soft 2D shadow's smoothness is a quality setting."},
+ "feat(editor): the quality page sets the largest 2D rain shelter mask a level allows":
+ {"note":"Rain for a 2D scene."},
+ "feat(editor): make a prefab instance virtual from the inspector or the outliner":
+ {"note":"Virtual prefab instances."},
};