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: release v0.104.1

yhhaed656a66def
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 21fe85720..7fff881c1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,12 @@ published separately; it ships inside the editor.
## [Unreleased]
+## [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.
@@ -35,7 +41,6 @@ published separately; it ships inside the editor.
- **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 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.
- **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.
@@ -15478,7 +15483,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.104.0...HEAD
+[Unreleased]: https://github.com/esengine/estella/compare/v0.104.1...HEAD
+[0.104.1]: https://github.com/esengine/estella/compare/v0.104.0...v0.104.1
[0.104.0]: https://github.com/esengine/estella/compare/v0.103.0...v0.104.0
[0.103.0]: https://github.com/esengine/estella/compare/v0.102.0...v0.103.0
[0.102.0]: https://github.com/esengine/estella/compare/v0.101.1...v0.102.0
diff --git a/desktop b/desktop
index 643ab1244..e0d70fd8a 160000
--- a/desktop
+++ b/desktop
@@ -1 +1 @@
-Subproject commit 643ab1244ad3cb00ef48be2501dd1e397d44d49c
+Subproject commit e0d70fd8a7066bdffe3babf3d157d68ea271ffc9
diff --git a/package.json b/package.json
index 32fc0bfa0..b2c181c8c 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "estella",
- "version": "0.104.0",
+ "version": "0.104.1",
"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 b188e720a..e1e315003 100644
--- a/tools/goldenProjects.mjs
+++ b/tools/goldenProjects.mjs
@@ -92,6 +92,8 @@ export const CENSUS_FLOOR = '0.60.0';
* that does not exist, and release notes are a different act. Theirs is ungated.
*/
export const SHIPPED = {
+ "Music plays as its layers.":
+ { notCertifiable: "Sound over time, which no golden frame holds. Covered by sdk/tests/audio-music-layers.test.ts (the stems of a piece begun together, each a layer of its own); nobody had judged it by ear in a packaged game when it shipped." },
"A recipe is read wherever an image is":
{ notCertifiable: "Covered by sdk/tests/texture-recipe.test.ts (a figure, a picture laid in, surface maps, text on a stand-in canvas, a ground's reader) and by an exported game of four such recipes opened twice in a browser by hand; no golden project ships an .esimage, and text follows the fonts of the device, which a golden frame cannot hold." },
"A texture recipe is drawn on a worker, once.":