what we're building

One Place: engine v6.0.0

Released September 5, 2026

Spawn 6 is a new engine under every new world. Here is what you can make now.

• Worlds have no size limit. A player's machine loads the part around them and streams the rest in as they move, so a city of a million things opens on a phone about a second after the link.
• Portals. A door in your world opens onto another place or another world, yours or anyone's. You see the far place in the glass, walk through with no loading screen, and what you carry, throw or shoot crosses with you.
• Any number of people in one world. Your own moves land the instant you make them. A friend whose connection drops is gone, not a statue, and a refresh puts you back where you stood, holding what you held.
• Savi builds in your room while your players stand in it. She changes the one piece you named, and it lands under their feet in about a second. Say "play it yourself" and she joins your game as a player and tells you what it felt like. Wisps build pieces in parallel or play with you.
• Every version of your world is kept. Open the history panel, read what changed and why, go back to any row, or undo one change from a while ago without losing what came after.
• Saving just works. A player's coins, inventory and claimed land return on every rejoin, a hole dug today is there tomorrow for everyone, and the world's state outlives every empty room. No save script to invent.
• The ground reads as a place: hills at four scales, coasts you wade into, block worlds you dig through. A dig lands for every player at once and one player's digging can be undone by name. A sea at a level, a lake that fills its basin, a river that runs downhill. One time of day relights the whole world, and a day-night cycle runs with no script.
• Spawn's own physics engine. A car arrives complete on the first ask: seat, chase camera, engine sound, brake lights and a road. Doors on hinges, lifts that carry riders, belts that move what stands on them, ragdoll on death, and swimming with nothing to build.
• Touch controls on every phone for free, built from your game's own actions. A wheel appears under the thumb the moment a player boards a car.
• Effects live in the world: particles lit by the scene, dying on the ground or bouncing, blown by the one wind that bends the grass. Words and buttons painted on objects are sharp at any distance and wired to the game. One soundtrack everyone hears in sync.
• "Publish it" is one act and the link comes back. Players on the link keep their version while you keep editing, and you decide when they take the update. A link can open a world at a version and at a place.
• Savi finishes more of what you ask, in less time. She moves instead of asking, talks while she works, and remembers you and your world between sessions.

Your existing games. Every game keeps running on the version it was built on. Nothing changes until you ask Savi to move it. New worlds start on Spawn 6. To move a game, ask Savi: "Move this game to Spawn 6." She does the move, leaves a short report in your history, and you walk your game the way a player would. If anything looks wrong, "move it back" is the same sentence the other way; your world's content is kept, and the versions from before the move are folded into one starting point rather than kept as a browsable list. A game that cannot move cleanly is refused with the reason and what to fix, never half-moved.

For script writers: flat shapes (rings, circles, planes, discs) now stand upright by default. Your existing worlds keep their exact look. Ask for a new flat shape lying on the ground when that is what you want.

Known rough edges, being polished in the open:

• Cars can jitter at speed on some machines. Driving works; the smoothness is being tuned.
• Leaf shadows cost more than they should on lower machines. Your world still draws; the cheaper shadow is on the list.
• Moving an older game up is the newest path and the one being watched closest. If your game looks wrong right after the move, say so in #bug-reports and leave the version buttons alone until someone has read it.
• Right now Savi can only change a world someone has open, so keep your game tab open while she works.
• Some phones pick a higher quality than they can hold and take a few seconds to draw the first frame; the pick is being tuned.

If something feels off, press Tab in your game, hit the beetle, and paste what it copies into #bug-reports with one line on what you saw and what you expected.

Engine v5.2.41

Released September 11, 2026

• When a script writes a very large value to another player's object and then a small one in the same step, only the large write now fails, and the message names that write. Before, the small write failed too and the message said it was the one that was too big.
• A player or NPC character now reports its collisions properly: walking into a wall fires the collision once, with the contact point and the wall's facing; landing on the floor fires once when you land; touching the same thing again fires again. Before, wall hits arrived late and empty or not at all, and standing still on the floor fired at random moments.
• In god mode, clicking on a shape no longer changes its size. Before, a click near the edge of a cube's face could squash or stretch the cube, and two clicks could flatten it to a slab. A click now only selects; you have to drag to resize.
• When the game gives up on a bad connection mid-stream, it now drops the rest of that stream at once instead of logging a burst of extra reconnect errors first.
• Switching tabs while a game loads no longer makes its saved data come up empty when you come back. Before, a tab left in the background could return to a game whose scores and saves had not loaded.
• On a computer that struggles to keep up, the game's color grade no longer flickers on and off. Before, the engine would switch the grade off to lighten the load on that machine and then switch it back on a moment later — sometimes because it had decided the grade was not the cause, and sometimes by mistake, right after the switch-off had actually helped — and then repeat the cycle, so the whole screen kept changing color while you stood still. Now, when switching the grade off helps, it stays off on that machine until you or Savi change the look; when it does not help, the engine switches it back on once and leaves it alone.
• Switching tabs for a while no longer makes a game's AI-powered characters fail to answer when you come back. Before, a character that asked for its next line while you were away could come back with a "timed out" error even though the answer had arrived.
• A vehicle you are driving (or any object a script has moved) no longer jumps back to where it was placed in the editor when a change to the ground is saved — a new road, a flattened pad, a terrain script edit. Before, saving any of those put every moved object back on its original spot, with the driver still inside.
• When a texture is downloading unusually slowly, or is waiting its turn behind many other texture downloads for a long time, the engine now says so once in the game's logs instead of staying silent — nothing in the game needs changing when you see it. A texture that nothing in the world is asking for any more no longer takes a download turn ahead of one that is.
• On a slow connection, big worlds now finish loading their textures instead of getting stuck. Before, a texture that was still downloading after 30 seconds was thrown away and requested again from scratch, over and over, so on a busy line some floors, walls and effects never got their real look — walls whose texture never arrived did not appear at all. Now a download that is still moving is left alone until it finishes, textures are requested a few at a time in the order the world asked for them, and they go ahead of the much larger 3D model downloads on the line, so surfaces get their real look early in the load instead of at the end.
• When your game's image generation hits its rate limit, Savi now hears that it is a limit — not a broken texture — and when it lifts, textures load without an extra stalled retry.
• Resizing or adding a rectangular flattened pad and then saving no longer makes every scattered tree and bush in the world blink out and grow back. Before, a saved pad could re-plant the whole world for a moment.
• Saving a script no longer makes the trees and bushes in your world blink out and grow back for everyone connected. Before, some saves made the engine rebuild the whole ground and re-plant every scattered tree even though nothing about the terrain had changed.
• Fading the stars or the moon over time — brighter stars as dusk deepens, a milky way that comes up slowly, a moon that dims toward dawn — no longer stutters. Before, a slow fade could hitch every couple of seconds. The night looks the same at every step; it only gets there smoothly.
• A fast object no longer reports hitting the ground while still in the air at a terrain edge. Before, a plane or a thrown ball crossing between stretches of ground could get a "hit the ground" event metres up, with no contact point, and scripts that crashed or exploded on it fired for nothing. Real landings still report where and how hard.
• When you delete the last thing that used an animation clip, the clip leaves your game's saved data too; if you use it again later, it comes back. Before, clips from a deleted cinematic stayed in the game forever.
• A script that runs away in a multiplayer room is now paused for 10 seconds and then resumes on its own, the same as in a singleplayer game, so the room stays smooth for everyone.
• When Savi looks at your game, she now sees the images in your game's HTML — icons, portraits, fighter cards, background plates — the same way players do. Before, an image loaded from your uploads showed on screen but was blank in her view, so she could send you hunting for a bug that was never there.
• A comment's automatic screenshot now shows the images in a menu, shop or dialogue that was open when the comment was left, instead of empty boxes where they stood.
• While you are building, clicking a creator tab's panel — its title, a label, the space between controls — no longer also clicks the world behind the panel. Before, that click could select, place or paint something you never aimed at.
• A creator tab that builds its own panel (a drag-and-drop editor, a floating window) now looks right the first time you open it in a session. Before, the first open of such a tab in a fresh session showed plain unstyled text in the top-left corner until you opened any other tab once.
• When a shape you generated is invisible for one player because their copy came out different from the saved one, Savi can now read the reason from the game's own log and tell you what differs, instead of only being able to say it didn't match.
• When Savi rebuilds a room's shell in one edit — replacing a floor made of simple blocks with a 3D model that carries its own collision shape — the old floor now stays solid under anyone standing on it until the model's collision shape is ready, then hands over. Before, the floor vanished the instant the edit landed and players standing there fell through the world while the model was still loading. If a model's collision shape never arrives, the old floor lets go after fifteen seconds.
• When you remove a behavior from an object, or edit its script, the old script's event handlers now stop everywhere, for every player in the room. Before, an object whose behavior you had removed could still react to events after another player left the room, and an edited object could react twice to each event until you saved again.
• If you edit a script while other players are in the room, an object's event handlers from that script can go quiet after players come and go, until you save the script once more. Savi now sees exactly that in the logs and can tell you to save again, instead of telling you to restructure a script that was already right.
• Objects a place creates in your first moment inside it now appear — for you and for everyone else in the room. Before, when you arrived in a freshly made place, those first objects could be dropped, or exist only on your own screen.
• A campfire's smoke column no longer makes the whole game's particles shrink. Effects are now measured by how much of the screen they really cover, from the particles actually drawn, instead of assuming every puff is at its largest size.
• Custom-shaped objects that a busy scene left solid but invisible for a player — you could bump into a bench you could not see — now come back on their own once the scene gets lighter, and keep retrying on a slow schedule until they do, instead of staying invisible until the page is reloaded.
• A model whose download is cut by the network partway through is now retried instead of being reported as a file that cannot be read.
• When a model's size can't be read, Savi no longer calls the file broken or asks you to re-add it. She says what happened and what comes next: the size is read again when the game next loads, or when the model is replaced. A file over the platform's size limit is told so, without a guessed number.
• When a model file cannot be read, the message now tells the true case apart: a file that is really over the platform's size limit says so and how far over it is; a file whose header does not describe its contents says that instead of asking for a smaller export; a file that ends early says it ends early. Each message ends with the one thing to do next — a smaller export for a file over the limit, a re-export and a replaced model ref for the others.
• A character you export from Blender with many animations baked in now loads with its size known; before, a file with a large set of animations could be reported as "malformed" even though it was fine, and physics and decoration around it used default sizes for the rest of the session. A model's size is read from the file the platform actually serves: a file over the platform's model limit is told so, and a file whose header does not match its bytes is told to re-export.
• An object whose shape follows the ground, if it is created a moment before its place's terrain is ready, now waits and builds against the real ground once the terrain is there, instead of building flat. While it waits it is not drawn, and the logs Savi reads say which object is waiting on which place's terrain.
• If your game tab was in the background for a long while in a busy room, it now first catches up on everything it missed when it comes back, so nobody's world gets reset to what your tab last saw.
• Savi no longer reports an object missing just because the screen she asked was behind the room — her eye now knows when the tab it asked has not caught up yet.
• Weak laptops no longer get extra shadow work they were not asked for.
• When a script writes a very large or very deeply nested value to another player's object, the write now fails at once with a message in your logs that says how big the value was, what the limit is, and what to do next. Before, the value looked like it landed and then quietly vanished about five seconds later with no message.
• When Savi looks for an object the screen she asked has not caught up to yet, she now learns that in the same look instead of asking twice.
• A material script can now set material.color = new Color(...) (or a hex like 0xff8800, or "#ff8800") the way it works in three.js. Before, that line quietly broke the material.
• A shape given a number it cannot draw — a size that came out as NaN, a million segments, a curve with one point — now draws with that value fixed up and tells Savi what was wrong, instead of vanishing or stalling the frame.
• Ground decorations with an impossible size in one item keep rendering; only that value falls back to its default.
• When a change to another player's object never gets an answer because that player's tab is in the background, Savi's log now says exactly that instead of a bare timeout.
• When frames get slow and the engine has to switch off a custom see-through material — a glow, a haze, an atmosphere around a planet — the object no longer turns into a solid gray shape that hides everything inside it. A see-through material now simply stops drawing until frames recover (a plain translucent one shows as a translucent shape instead), so the world behind it stays visible.
• When another player removes an object, your game no longer repeats that removal back to the room. Nothing changes on screen; the room just keeps one record of the removal instead of two.
• Pressing the bug-report button no longer freezes your game. On slower computers with a lot of art in the game, packaging the report used to stop the game for a minute or more, and the screen then said the game had crashed when it had not. The packaging now happens on the side while you keep playing.
• In multiplayer games, empty areas no longer cost physics time, and characters standing in an area nobody has visited no longer fall through ground that was never built. Singleplayer games keep every area running, as before, so moving platforms, spawners, and patrols in areas you are not in keep working while you are away.
• When physics is slow, the performance note Savi receives now says what was actually being simulated — how many moving objects, scenery pieces, and characters, across how many areas — instead of always blaming falling props, so the advice matches your world.
• A pond's bank is now complete all the way around. Before, at some angles the bank stopped short, and on a slope the downhill ledge ended in a straight cut — both now follow the pond's curve.
• When Savi previews a sign on its own, the preview now shows the sign's board instead of answering that there is nothing to preview. The lettering still only appears in the game scene, and the preview says so.
• When Savi looks at a piece of scripted geometry whose script has a loop that never ends, your game no longer freezes and the tab no longer dies. The look comes back after five seconds and tells Savi which script did not finish, so she can fix it, and everything else in the picture still renders.
• If the game server hits an error while a player is connecting, the player's game now reconnects and joins again on its own, instead of ending up in a world where nothing ever moves.
• When the picture has to rebuild itself after a hiccup in the connection between the game and the screen, custom-shaped objects that had settled in place — terrain pieces, decorations, meshes a script built — now come back instantly instead of vanishing for a couple of seconds and being rebuilt one by one.
• Long rivers no longer make the terrain take many seconds to appear: a world with dozens of rivers now finishes its ground in well under a second, with every river and pond at the same water level as before.
• A camera moved by a script now moves as smoothly as the rest of the scene. Everything timed in seconds — screen shake, camera punch, zoom, hit-stop, music and light fades, highlight pulses, sprite frame rates — now lasts the time you wrote. Before, all of these ran about one and a half times too fast for every player on every screen, up to 1.75×. A camera follow you tuned by feel may now feel a touch slower; nudge its rate up if so.
• While Savi is building in your world and you are not in it, scripts that save game data into the world itself (with withPersistence) still change the running world, but those particular saves are not written down and will not be later. The running world keeps those changes only until it restarts or is reset from its saved version. Saves the game makes while you have it open in your own tab are written down. The engine now says exactly that in the logs Savi reads, so she can tell you plainly instead of hunting for a permission problem that does not exist.
• When Savi swaps your game to a different starter while you are in it, the old world now clears out of your tab and the new one appears, instead of the old scene staying on screen until you reload.
• Ground that was still being built when your connection hiccuped no longer gets thrown away and rebuilt from scratch: the engine now measures a build's waiting time by the ticks your game actually ran, so a reconnect cannot make every in-progress piece of terrain look overdue at once.
• Top-down games that took the previous update while a room was open could keep an old wall shape in that room: walls Savi drew still let players walk through them even though the update fixed walls. Walls now take the fixed shape in every open room the moment the game runs on this version, and a wall with its own drawn outline keeps that outline. If you are on the previous update and a wall is still walk-through, ask Savi to restart the room — the room rebuilds from your last save with the fix in place.
• Textures on primitives that used to draw upside down — small ones on desktop, all of them on phones — now draw the right way up. Textures on custom-built (scripted) shapes now draw the right way up too, on every device and at every size. If you flipped an image or a drawn texture to work around either, flip it back.
• When a script's write to another player's object is too large or too deeply nested, the message now says that write changed nothing, instead of saying nothing changed on the object — other writes in the same step can still land.
• When your game tab is hidden and Savi looks at your screen, she now hears that the tab is hidden and that the look works again once you bring it back — instead of a message that made it sound like the renderer was broken.
• In a voxel world, when two flattened pads — or a pad and a road — overlap, everyone in the room now sees the same ground after a save. Before, a player who joined after the save could stand at a different height than the players who were already there.
• When part of your voxel world sits too far above or below a player to be drawn for them — a tall planet, a very deep canyon — the game now leaves Savi a note saying exactly which ground did not draw and that nothing in the world changed, so she can tell you what you are seeing instead of hunting for a bug.
• When a player reconnects to a busy room, another player who is still in the room can no longer vanish from their screen. Leftover objects that were removed while nobody was around now stay gone for everyone who joins later, instead of coming back each time.

Engine v5.2.40

Released September 3, 2026

• Walls and other flat sprites in top-down games block the player along their whole height again.
• Collision shapes you drew for a sprite stay in place when a script or Savi updates that object's physics — a foot-high wall no longer turns into a full-height one after a save.
• When the game's own default cloud texture has not loaded yet, Savi's look at your game now says exactly that, instead of telling you a texture failed to generate and sending her to search your game for something you never made.
• Savi's picture only says "those are your editing handles" when the handles are actually in the shot — select something, fly off to look at another part of your world, and she reads that view as the game it is.
• When you ask Savi to look while you have something selected in god mode, her picture now tells her that the editing handles in it are the editor's, not part of your game — so she stops hunting for "floating diamonds" that are not there.
• Props keep their real collision shapes across edits and updates instead of reloading them all.
• For creature models made from now on, Savi's look says when the model has no skeleton by design, instead of waiting for animations that were never coming.
• No change to how any game sounds: the reverb plumbing this removes was muted and unreachable from scripts.
• Clearing out almost everything solid in a level at once — tearing down a whole floor before building the next one — no longer freezes physics for a moment and drops the ground checks that follow it.
• Games that create a fresh arena or level for each match no longer slow down over time: when a match's place ends, everything in it is cleaned out of the room's memory, so joining later stays fast instead of loading every arena that ever existed.
• Savi's scene report no longer counts decals behind the camera as covering the screen.
• An effect asking for more particles than the CPU fallback runs now says so in the log.
• Big worlds with generated terrain load their places many times faster — the ground is measured once per load, not once per object.
• Savi can read a model's bones and shape on the server, not only in a browser.
• Savi's builder body no longer shows up in your tags: ['player'] queries when your player template lists the player tag itself — the game-side filters that skipped her by id are no longer needed.
• Deleting or undoing something you painted with the scatter brush now removes everything it placed for good, even if players came and went in between — the pieces no longer come back when you reload.
• Game UI built from your ui.js no longer keeps ghost copies of an element around: when your rendered HTML stops containing a node, it is gone from the screen on that render, even if the same id appears elsewhere in your UI.
• When something is in your world but not on screen, Savi's look and her object check now say so — "in the world, not in the draw" — and when a texture is there but the texture budget left the object flat, they say that instead of reading it as fine.
• Shared objects and new spawns now keep script changes when players reconnect.
• Joining a game whose starting place is not called "main" no longer builds the "main" place first and throws it away — players land in the starting place directly, without the extra load time.
• Pressing a keyboard or headset Play/Pause key no longer silences your game's music while the game keeps running. Game audio ignores the key the same way on every track.
• onPlaceStart runs again when Savi's builder is the first to enter a brand-new room — saved terrain and state your game restores there come back.
• In a busy multiplayer room, walking into another area, leaving, or coming back from a hidden tab now takes effect on your own screen the same way it does for everyone else — before, your own game could keep treating you as still in the old area or still away, so the area you stood in could freeze on your screen.
• Fences and paths attached to a raised building now sit on the ground instead of floating at the building's height.
• When Savi reads your game's state from your browser, she can now see the last few times the tab was in the background — so what changed in the room while you were on another tab reads as "you were away", not as a problem with the game.
• The parts a player's body script builds at spawn now show for everyone who joins. Before, each player could see their own rig, weapons, or pets, but everyone else saw a bare player.
• After a connection hiccup, the dead connection's leftover traffic no longer trips a burst of extra reconnect errors on the way back — it is dropped cleanly and the reconnect picks up where it left off.
• Savi's raycasts can filter by tag again when she runs code in your world from the chat — asking for "only hit the walls" or "skip the players" now works the same there as it does inside your game's scripts.
• Saving a helper file no longer wipes the things a builder script spawned with fixed names. A script that clears its own pieces and rebuilds them under the same ids keeps every rebuilt piece after the save.
• After a connection hiccup, a world with many moving creatures no longer grows heavier in the background each time it reconnects — rejoins and late arrivals load the same world, not a swelling copy of it.
• A sky or lighting change your game's script makes with patchAtmosphere now reaches every player, late joiners included. The day/night cycle's hour agrees across players after such a change.
• One bad packet from another player no longer drops the good ones with it: when something in a player's update is malformed, only that piece is set aside — everything else in the same update still arrives, and other players' characters and the game's creatures keep moving.
• When your connection drops for a moment and comes back, other players see you again — before, they could be left looking at an empty spot where you stood until they reloaded.
• Empty per-party areas that a game creates on the fly (the "session" kind) now close about ten minutes after the last player leaves, even when the player who opened them has left the game — they used to stay open until the room restarted, and a player who came back within those ten minutes still lands in the same area.
• Music, ambient loops and sky settings set while the host was briefly away no longer snap back to the older setting when the host returns.
• A world with terrain switched off no longer shows a mountain skyline it does not have.
• When a script removes and re-adds a terrain mark in quick succession (a builder re-carving a cellar), other players no longer get a flash of un-dug ground under their feet.
• Drawn textures that were cheap to describe but heavy to paint no longer sneak past the 50 ms bake budget or load the GPU; a texture that is too heavy to paint now parks with the same "over the bake budget" note as a slow draw loop, and everything else bakes as before.
• When the renderer trips over its own drawing setup, Savi's report says so instead of blaming the graphics card.
• When you join a friend's game, one badly-named object in their world no longer hides everything else from you — including their character. And if one of your objects has a name too long for the network to carry, your game now tells you which one, so other players can see it once you shorten it.
• A reconnect after a dropped acknowledgement no longer trips over the old connection's leftover data and reconnects a second time — the loop that could keep a player in a busy room reconnecting every minute is closed.
• Deleting a fence or path removes all of it for every player and after every reload — its posts and rails no longer stay behind on other players' screens.
• After a room restart, a player who reloads while Savi's builder is in the room no longer leaves spells and other moving objects frozen in place on other players' screens.
• Particle effects that use curl noise cost about half what they did per frame, and no longer make the game's memory grow while they play.
• Savi's answers about SpawnJam judging, rules and deadlines now point you to the jam page instead of guessing.
• Joining a world that holds thousands of tiny objects no longer loses a whole batch of them on the way in.
• Worlds whose custom geometry keeps regenerating — living terrain, animated cloth, meshes rebuilt by a script — no longer fill the browser's memory over a long session until the game freezes or the tab dies; the old versions of each mesh are released as the new one arrives.
• A texture added after your world is already full of textures no longer comes out the wrong size or cut off when its repeat is not a whole number.
• When Savi works in an area of your game that nobody is standing in, her scripts there now run right away — before, if you were already in the game when her builder joined, every script she aimed at an empty area could fail with "wait for the room" for as long as the session lasted.
• When your game's on-screen UI fails to load, Savi now sees which file never answered and whether it was the network or the page — and a UI that grows past half a million characters per frame gets one plain warning instead of silently loading fifteen times.

Engine v5.2.39

Released September 2, 2026

• When Savi previews a custom material and a setting was spelled in a way the material never reads, the preview now says so instead of quietly showing the default look.
• Objects your scripts spawned at runtime — village props, walls, cove pieces — come back visible when you are the first to rejoin a room everyone had left. Before, they stayed solid but invisible until a script touched them.
• In god mode, clicking into the toolbar's search box while holding a movement key no longer leaves the camera flying on its own.
• If your own character was removed from the world by a script and you press the god-mode key, the message now says what happened and that a reload brings you back — instead of wrongly saying you lack permission.
• If your world's water uses the low-level liquid.overrides settings — depth tint distance, wave frequency, foam coverage, caustics strength — a change to only those settings now shows up right away. Before, the water kept its old look until some other water setting changed too.
• When the player hosting an area of your world walks out of it, the things you built there no longer vanish for someone who joins right after. Before, a new player could arrive to an empty area for a few seconds.
• A change Savi makes to your player shows up in your own game right away, not just in other players' games.
• Sound now starts on your first tap in games with their own on-screen UI, on phones too.
• When something your script spawned vanishes a few seconds later because a write to another player's character was refused or never answered, Savi's logs now say so — which write, why, and how many things it took with it — instead of nothing.
• When the game drops an effect because the thing that sent it had already left the room, Savi's log reads now say that. Before, the same line read like a rule about who may do what.
• Reloading while inside one of your game's places no longer drops you at another place's start spot, falling through the dark. You come back the way a reload has always been meant to work: at your game's spawn, unless your game saves and restores position itself.
• When the same account opens a game in a second tab or on a second device, the first one now says so right away ("This game was opened in another tab or window…") and stays put, instead of going quietly stale and cutting back in every time you switch to it.
• Worlds with many rivers and ponds build their ground faster. Each piece of ground no longer redoes the river and pond water math that an earlier piece already did.
• When Savi saves a script from inside the game, the objects running it pick up the new version right away — including in the world that ran the save.
• When the server turns down one of a sprite's animation clips, Savi's logs now name that clip and show the server's reason and when the engine will ask again. Before, the log said the clip was "still generating" and left out the reason.
• When a sprite setting such as its named animation is removed from a game's spec, sprites already in the world drop the old value when that edit is applied, instead of keeping it until a reload.
• After you leave and come back to a part of your world, the things your scripts hid stay hidden and the things they spawned stay.
• In worlds on the Mantle physics engine, walls and floors your scripts shaped with their own collider are now solid for players who join after they were built. Before, only the player whose game built them could stand on them.
• When things your script spawned vanish a few seconds after it wrote to a player whose tab was in the background, Savi's logs now say that the background tab is the cause instead of only "no answer in time".
• An arena your game creates on the fly keeps running when the player who opened it tabs away.

Engine v5.2.38

Released September 1, 2026

• When a script moves many objects at once and one of the entries is shaped wrong (for example the position sits next to the id instead of inside properties), the log now says which entry was skipped and why, instead of the call silently doing nothing.
• Object previews now say when a custom material's texture lookups show as flat white because the preview booth doesn't sample textures — so a white preview reads as booth policy, not a broken texture.
• Savi's isolated object previews now say when an object's texture was not part of the render, so a preview that looks blank or white no longer reads as a broken texture.
• When a camera script moves its own eye (a crouch, a lean, a lower stance) and the engine's mouse-look camera does not follow, the game's logs now say so and name the knob for eye height. Before, the picture stayed put with no message anywhere saying why.
• A prop whose collider file can't be fetched now falls back to its own model's shape at once instead of retrying forever. If the model itself can't be fetched either, the retry stops after one honest log line instead of looping every few seconds.
• Games that send players to different rooms (a routing script, or "first open room") do that on the published game again — before, every player landed in the same room.
• Swapping a model onto a placeholder shape now removes the placeholder. Before, an object built as a generated shape and later given a model could keep drawing the old shape inside the new model until primitive: null was written as well.
• Scripted shapes attached to a parent and shaped to the ground now land where they actually stand. Before, a child object created together with its parent could sample the terrain at the wrong spot and float or sink by the terrain's height — and stay that way until the game was rebuilt.
• A player who drops and comes back is visible to everyone already in the room again, not just a name tag. Before, if your connection blipped mid-game and you came back, the other players could see your name floating over nothing — your character's body was missing on their screens until they reloaded. Now your whole character comes back for everyone the moment you do.
• Savi's log reads now say how old each line is — "14m ago", "since 3h ago · last 2s ago · ×6", or "before your last 6 saves" — so an old warning is no longer mistaken for a live one, and a warning that is still firing shows up when she asks for recent logs.
• Reading a player's client logs works in every kind of room again, including local dev rooms.
• Script-budget warnings now say how long a tick is in your game, so a 30Hz game is not misread as running twice over budget.
• Fixed a rare wedge where a saved library file looked updated in Savi's file tools but the running game kept using the old numbers until the room restarted. A saved script now has exactly one home in the game, so an edit that saves is the edit that runs.
• Texture scripts passed to a custom material as a parameter (for example params: { map: 'scripts/tex-banner.js?rev=6' }) now bake. Before, the engine reported the texture script as "not found" even though it existed in the game's scripts.
• Objects built from a geometry script (or custom geometry) now respect castShadow: false and receiveShadow: false the same way plain boxes and spheres do. Before, a scripted object with shadows turned off still threw a full sun shadow.
• Savi's builder now stays in your room for the whole session instead of re-joining every time she starts a piece of work — and your game keeps running while you are away. Before, if your tab went to sleep in the background, Savi's scripts could fail for many minutes, and her builder kept popping in and out while you played. Now the parts of your world you are not playing in keep running while she works, and background builds in empty areas keep a live world under them from start to finish.
• Skyboxes made from a big uploaded image now use a 4K version cooked from your original upload. Before, a sky made from an uploaded photo or panorama could look soft even when the file you uploaded was sharp.
• Digging, blasting, or filling the same spot over and over no longer slows the game down as the session goes on.
• The engine no longer reports a texture script as "not found" from one screen's stale view. When a texture is waiting on its script, the game re-fetches the script library automatically, and only the game itself — which can actually see your scripts — decides whether a script is genuinely missing.
• A first-person camera you move up or down now renders where you put it. Crouch by lowering the camera's eye height and the view drops with it, instead of the camera pulling back and tilting down.
• A look script may now spell its export as export { look } or keep export-looking text inside a string — the same rule material and texture scripts already followed. The .json require() in material, texture, and look scripts shipped in 5.2.37; this version keeps that rule in one place so the script kinds cannot fall out of step again.

Engine v5.2.37

Released September 1, 2026

• Sliders and draggable controls work in creator-tab panels. A native slider (input type=range) in a creator tab built with onMount never responded to dragging — buttons worked but thumbs stayed put. Panels in creator tabs now treat every press as panel input, so sliders, drag handles, and text selection inside them behave like normal UI, and presses inside an open panel no longer leak into the world as camera or selection input.
• Savi is now told when a model's collider does not match what she asked for. Declared collider sizes that get replaced by an auto-fit shape, and model colliders that never materialize, produce a clear message instead of silent surprise — so Savi stops guessing why rays pass through a body and tells you what actually happened.
• Changing a world's gravity takes effect immediately on all physics engines. Asking Savi to change a place's gravity mid-session (updatePlace with a gravity value) now applies to falling and resting objects on the very next physics step, whichever physics engine the place runs — including objects that had settled to sleep, which wake into the new gravity. Before, places on the default engine kept the old gravity until the place fully reloaded.
• Purchases that award a spin now work. A purchase whose fulfillment applies angular velocity or an angular impulse (making something spin as the reward) was refused with a generic error; those verbs are accepted now.
• Objects no longer freeze after your tab stalls for a few seconds (a debug dump, a heavy save) while Savi's builder is in the room. Physics objects move again the moment your tab comes back, with no room reset.
• Rapid Savi edits stop hitching big games. In games with a lot of scripts, every script save caused a visible stutter while the whole script record was re-scanned; now only what actually changed is re-processed, so back-to-back edits feel smooth.
• Repairing a mined area by re-running the same fill works again. Re-running fillVoxels with identical arguments over a spot where blocks were mined or broken one at a time silently did nothing — the holes stayed. Now the repair fill lands; existing worlds heal on the first repair.
• Rebuilding with the same block type after clearing an area works again. Placing a block back in a spot it held before a multi-block clear (an explosion, breakVoxels, a fill) silently did nothing for that one material — other materials worked, which made craters feel cursed. Existing worlds heal on the first rebuild; no workaround needed anymore.
• Savi's camera shots now show lamp, torch, and other local lighting the way players see it — before, a posed shot could show pitch-black rooms that glow correctly in the game, and Savi would try to fix lighting that was never broken.
• Savi's camera shots also now show characters and animated models the player wasn't looking at — before, a shot aimed away from the player's view could silently drop them, and Savi read your models as missing when they were standing in the world.
• A script that accidentally re-attaches an object under itself every tick can no longer crash the whole game world — the engine now refuses the bad attach immediately and tells the script exactly what went wrong and how to fix it.
• Uploaded models whose source file carries a large built-in offset no longer vanish from the game while every measurement says they are standing right there — they draw, animate, and cast shadows at the spot you placed them.
• Leftover copies of departed characters (like Savi's builder popping in and out while she works) no longer pile up on screen on slower devices — the cleanup that removes them now runs even when your device is busy.
• Sharing a game whose whole presentation is HTML UI (menus, cards, text screens) now posts a screenshot of what players actually see — before, the shared image was solid black.
• Players in games without gravity no longer drift away endlessly after leaving a moving platform — the platform's momentum now stops after a few seconds instead of carrying them forever.
• Texture scripts, material scripts, look scripts, and voxel builders can now read data from .json files with require(), the same way behavior scripts always could — a texture that pulls its palette or lore from a JSON data file now bakes instead of failing to compile.
• Savi no longer piles up copies of her body in your game. Each time she started a piece of work, a fresh copy of her builder joined your room and bowed out a minute later — and on loaded devices the departed bodies could stick to your screen until reload, dragging the whole game. Her builder now keeps one identity per room, so there is only ever one of her body, however busy she is and however loaded your device gets.

Engine v5.2.36

Released August 29, 2026

• Clicking a button in your game's UI no longer steals the keyboard: WASD keeps working through the click, a key you were holding is not dropped, and Space or Enter after clicking "buy" jumps or interacts instead of buying again. Tab opens chat even right after you clicked a game button.
• Click-to-copy fields (invite codes, share links) no longer eat the arrow keys for the rest of the session. Real text boxes still take the keyboard while you type in them, and a click on the world hands it back.
• Savi now gets a warning at write time when a game binds "hold Cmd" or "hold Ctrl" next to keys the browser owns (W, T, N, Q), and when a mouse-look game binds Escape — the browser takes the first Esc to release the pointer, so she is pointed at the engine's pointerLockLost signal instead.
• Savi no longer reports a browser extension's chatter as a fault in your game. If a player has an extension that talks to every page, the game used to count those messages against itself and Savi could tell you your UI code was misbehaving. Those messages were never yours; they are now ignored.
• Faces move now: models with shape keys (Blender's blend shapes — blinks, smiles, mouth shapes) play them. An animation that drives them in the file just works, and you can set them from a script — properties.morph = { Blink: 1 } closes the eyes, getMorphTargetNames() tells you what a model has. Uploaded a face and got a frozen stare before? Try it again.
• Objects no longer flicker back to an old state when two things edit them at once. When another player or Savi changed an object in the middle of someone else's change, the first player's game could quietly re-save its last value on top of the newer one a moment later — furnaces and conveyors would strobe, the room's traffic would climb, and a tab could run out of memory. The old value is now dropped the moment the newer one arrives.
• Very busy multiplayer rooms no longer crash the game tab. When a room sends changes faster than a player's device can process them, the engine now keeps only the newest movement update for each mover instead of queueing every stale one — movement stays current, nothing that matters for the world's saved state is dropped, and the browser stops running out of memory and killing the game mid-session.
• Games that paint lots of objects or particles with script-drawn textures run at full speed again. Animating those objects used to make the engine re-read the whole texture script on every change, every tick — busy scenes stuttered, and the engine's performance governor could switch the game's own effects off right in the middle of the action. The re-reading is gone; the effects stay on.
• Uploaded and generated models are solid in multiplayer rooms now. A model with a mesh collider used to collide only in singleplayer — in a shared room, players and raycasts passed straight through it however solid it looked. Models now collide by their real shape everywhere.
• A multiplayer room can no longer be frozen by one player's out-of-date connection. NPCs and machines keep moving, buttons keep answering, and a game's start flow works for joining players.
• When you ask Savi whether something is solid, the answer now comes from the collision the engine actually built, not from the object's settings. A model whose collision never loaded used to read as solid while players fell straight through it; it now honestly answers that nothing is there yet, and the collider view draws markers only where collision really exists.

Engine v5.2.35

Released August 29, 2026

Characters walking across scaled vehicles and platforms animate at their real speed — no more foot-sliding on giant carriers or sprint animations on miniature props.

• Phones that can't run Spawn now say so honestly instead of reload-looping. When a phone's graphics driver permanently refuses the engine's texture uploads (a hardware/browser limit, not a glitch), players used to get "Something hiccuped — reloading brings it back" — advice that could never come true. They now get the same honest can't-run guidance the unsupported-device screen already gives, including the Desktop-site tip on Android, and the automatic boot retries stand down instead of looping.
• Games run much smoother on MacBook Airs and other everyday Macs. The engine used to treat every Mac like a top-end studio machine and max out the graphics; now it starts sensibly and raises quality only where the hardware proves it can afford it — powerful Macs still climb back to full quality within the first minute, automatically.
• Savi's camera snapshots of your world now show your sprites. Before this, when she looked at a 2D world from her own camera angle, every sprite outside your current view was missing from her picture — she'd see the ground but report your NPCs and objects as not rendering, and could spend a whole session chasing a bug that wasn't there. Her snapshots now show what a player standing at that spot would actually see.
• Big NPC worlds stop paying collision costs for the ones standing still — now on multiplayer too. Every NPC carries an invisible touch-sensor bubble, and multiplayer clients used to re-check every bubble against the whole world every tick even for NPCs parked far away. Parked NPCs are now nearly free on every player's machine until something actually moves near them, and enters/exits still fire the exact tick a player walks in or out.
• Slowness reports now name the engine systems and the scripts that used the time wherever your game ran them, not only on players' machines.
• When Savi reports a performance problem to the team ("this world runs slow"), the report now includes exactly where the game's simulation spent its time — which engine systems and which of your scripts — measured in your live session. Slowness reports name their culprit instead of needing a follow-up debugging session.
• Effect scripts can read ctx.device — author cheaper phone variants. effect(ctx) now gets the same { class, coarse } device facts your material and look scripts already use, so one explosion can throw 100 sprites on desktop and 40 smaller ones on a phone, full fidelity where the hardware affords it. It's per-viewer and render-only: counts and sizes may branch, but keep lifetimes and timing windows the same on every device, so the effect ends at the same moment for every player.
• Config panels in creating mode whose images finish loading after the panel draws now scroll immediately — previously the newly-too-tall panel could stay stuck unscrollable until it re-rendered.
• Tab panels in creating mode (your authored config UIs — armories, shops, settings) now scroll when their content is taller or wider than the panel, instead of cutting off everything below the fold. Every field is reachable on any screen size.
• Quality settings now come from measuring your graphics chip instead of guessing from its name. Thin fanless laptops that share a name with much bigger machines used to open at max settings and stutter; now every device runs a fraction-of-a-second graphics test once, remembers the answer, and opens at settings it can actually hold.
• Heightmap terrain obeys your lodRanges and verticalRange — deep worlds and pulled-in horizons are authorable. Dig a gorge past −32 by lowering verticalRange.min (the out-of-bounds net follows your floor down), pull the streaming bands in so a compact world spends its budget on the dense middle, or push them out for vista and observer worlds. Perfectly flat worlds are legal too: verticalRange: { min: 0, max: 0 } is a flat sheet, not an error.
• Savi now knows when the 2d tile layer is covering a 3d object instead of hunting a render bug. In top-down 2d worlds, painted tiles draw over blocks and models that sit below the camera's eye level — that is how 2d layering works, not a glitch — and when you ask her about such an object she is told "drawn but covered by the tile layer" instead of "rendered", so she can say what is actually happening and how to see it (lower the camera, or build 2d scenery from sprites).
• Your game can now read the link it was opened with: api.launchParams gives you the URL's query parameters (like ?code=1234 from a QR code or invite link) right from the player's spawn — great for party codes, invite flows, and deep links into a specific mode.
• api.enterRoom(roomId) sends a player to a specific room — build lobbies, party-up flows, and "join my friend" buttons. It's a request to travel, not a teleport receipt: the platform still picks the door, and your code gets an acknowledgment that the move was dispatched.
• Fixed a bug where re-running a patch after a failed save could silently lose it. If a save died halfway (a flaky room, a rejected batch), re-applying the same terrain/player/camera/inputs patch used to report "changed nothing" and never reach the saved game — your world could revert to starter terrain after a restart. Re-runs now always reach the save, and truly redundant patches still don't clutter your version history.
• Worlds full of NPCs stop paying physics for the ones standing still far away. Every NPC carries an invisible touch-sensor bubble, and the engine used to re-check every bubble against the whole world every tick — even for NPCs parked at the far end of the map. Parked NPCs are now nearly free until something actually comes near them, and everything still fires exactly when a player walks in.
• Fixed falling through the world when spawning or teleporting into a place whose terrain is still loading. Players now land on the terrain's true ground height immediately — the engine stands them on the height model's own answer while the real terrain streams in underneath, instead of letting them fall and flicker until it catches up. A player template with visible: false stays invisible — builder bodies stop appearing in observation games. The engine no longer dresses the default profile avatar on any body whose template declares it invisible, including Savi's own builder body when she joins to work in the background.
• Fixed a serious multiplayer bug that could permanently delete parts of a world. Rejoining a large game that had been sitting idle could lose the most recently built things; rejoining now keeps everything in the world. Switching rooms quickly no longer risks losing the last save from the room you left — the game finishes writing your departure data before it connects to the next room, and a room switch still always completes within a few seconds even if that write gets stuck.
• Scripts that do a lot of math got faster. Math.max, Math.min, and Math.hypot in your behavior scripts and terrain generators used to pay a hidden tax on every call — up to 19x slower than they should be. Hot loops like distance-to-track checks, clamps, and steering math now run at close to full engine speed, with results bit-for-bit identical to before.
• Moving around in god mode stays smooth while background builders are working. When wisps were writing heavily, the engine's own bookkeeping could bury the simulation step that moves your body — movement visibly chopped while looking around stayed smooth. Both bookkeeping passes are now capped per tick, so your movement never waits on them.
• Point at any part of a generated build — Savi now sees exactly which block you mean. "Remove these bars" used to send her probing a whole procedural tower by hand; now the exact piece under your cursor answers with its own name and measurements.
• Your game can now tell a fresh arrival from a reconnect: api.resumed is true when a player's session picked back up where it left off (their connection blipped, or they tabbed away and came back) and false on a genuinely fresh start — so you can skip the intro cinematic for someone who was just here, or say "welcome back" only when it's true.
• Fixed a false alarm that blamed your scripts for "oscillating" touch controls. In busy multiplayer rooms the engine could mistake its own internal refreshes for your game switching touch surfaces rapidly, then point at an innocent script file — even in games with no touch-surface selector at all. The warning now fires only when a selector you wrote actually flips between surfaces faster than players can follow, and it names the actual selector script.
• Touch sticks: place them, keep them level, keep them visible. A fixed stick now takes position: { x, y } (0..1 within its thumb zone) so you can pull it in from a tablet's edge or line two sticks up — the engine still keeps it out of notches and platform chrome. symmetric: true on a touch surface keeps the left and right analog zones the same size even where platform chrome trims one side. And visibility: "always" on a stick keeps its resting pad on screen instead of fading when untouched. Games that hide the player template (visible: false) and dress bodies from scripts now work end to end: your script's model writes always land (including dressing players in their own account avatar), and script-driven characters animate under your animations instead of the engine's. If a script reveals a player that nothing has dressed yet, the runtime log now says so once and names the fix, instead of showing an invisible body with no diagnostic.
• Resizing the game window is smooth now. Dragging the window edge used to make the engine rebuild its render surface dozens of times a second — on some machines that could freeze or crash the graphics process mid-drag. The view now scales fluidly while you drag and snaps sharp the moment you let go.
• Adding a behavior script to something that already exists now actually starts the script — no more "Savi attached it, the save looked fine, and nothing happened."
• When spawns can't land yet in an area of the room, you and Savi now get a clear one-line explanation instead of things silently never appearing.
• When Savi looks at your game and something isn't drawn, her tools now say why it isn't drawn instead of reporting it as rendered — fewer wild-goose chases after "invisible" objects.
• Gravity now does what it says: falling and thrown objects accelerate at exactly the strength you set for the world, instead of a bit more than half of it. If you tuned gravity extra strong to make things fall right, ease it back to the number you actually wanted.
• Scripts that ask for the player list now find everyone, in every kind of room — players who joined before your script's connection no longer come back as an empty list.
• When a script inside one of your lib/ files crashes, the error now points at that file and line (lib/boom.js:3) instead of blaming the engine — including crashes after an await inside the lib.
• depthTest: false now draws over things instead of disappearing — a material with depth testing off composites on top of the world, and Savi's eye finally sees it exactly like your players do.
• Materials gained renderOrder (default 0, higher draws later) for explicit draw order among always-on-top and transparent surfaces — eyes through hair is two properties: hair stays normal, the eye patch wears { depthTest: false, renderOrder: 1 }. Also the recipe for UI-over-world quads, x-ray outlines, and decals that must win. renderOrder is an integer in ±1000 — fractional values truncate.
• Editing one player script — or adding or removing one — no longer resets the others: summons, equipment, and timers survive saves that didn't touch them.
• If a script stores a function in a spawned object's state, the object no longer becomes impossible to clean up with run_script — and when a save still can't be applied, the error names the exact object and component carrying the bad value.
• Multiplayer rooms hold together better: players who stand still stay in sync, page reloads leave others' games intact, and joining mid-game no longer makes part of the world vanish.
• Saves stop un-saving themselves: a script save that landed while your connection was mid-shuffle can no longer be silently rewritten back to its old bytes over and over. If a save genuinely loses to someone else's newer edit, the loss is recorded instead of hidden.
• Deleted things stay deleted for everyone: a monster or object killed while one player's connection was catching up no longer lives forever on that player's screen.
• Spinning and moving arenas built from static parts no longer risk killing physics. Rotating a parent full of static walls, floors, and cover no longer rebuilds every part's collider each tick — the parts just move. Big rotating rings, carousels, and script-driven set pieces run much cheaper and no longer degrade into the "physics died, reload the page" state.
• Standing on a moving platform no longer flips your position readings. When the game auto-attaches a player to a platform they're riding, scripts that read the player's feetPosition keep getting world coordinates — camera rigs, aim code, and referees keep working mid-ride.
• Script errors from run_script now point at your own line (run_script:2) instead of dumping engine file paths, and engine hiccups during run_script say what happened in one line — "your code didn't cause this" — instead of dumping engine internals.
• Script-built pieces (fences, pickaxes, generated props) made on an older engine version no longer silently stop being drawn after the room moves to a newer one — they rebuild themselves automatically.
• Multiplayer trigger zones now count every player's enters and exits — visitors' crossings no longer vanish, and zone counters stay the same on every screen instead of silently forking per viewer. Attached models can now wear their parent's animations: attachment: { skin: true } makes a child model deform with the parent's rig — a jacket that bends with the body, armor that rides the run cycle — with bones matched by name (case-insensitive, mixamorig prefix tolerated). Joints that match no parent bone hold their rest pose and Savi gets a diagnostic naming them, with a skin: { map: { ... } } escape hatch for rigs whose bones are named differently.
• Skinned characters can read your baked vertex data: per-vertex masks work on rigged bodies. vertexColor() delivers baked COLOR_0 on skinned draws, uv(1) delivers a second UV set (and refuses loudly when the model doesn't carry one — never silently serving uv(0)), and the new attribute('normal') / attribute('position') read the raw rest-pose streams the pose can't bend — the clean channel for masked anime outlines.
• A material that can't run now says why: the fallback to plain Std/PBR lands a one-line verdict in getLogs naming exactly what this model's geometry doesn't deliver, and the park stays visible in debug dumps for as long as it holds.
• Very large worlds with thousands of scripted meshes no longer black-screen when moving between places — the world streams in steadily instead of the game running out of memory and freezing until a reload.
• Worlds that reuse the same generated mesh across many objects (module-built forests, repeated props) load noticeably faster — the mesh crosses to the renderer once instead of once per object.
• Spot light cone angles are now plain degrees like every other angle — ask for a 62° cone and you get a 62° cone.
• Scripts that contain escaped backticks inside strings or comments (markdown docs, code samples) no longer get silently corrupted at load time — legal code compiles exactly as written.
• Debug reports now capture what your screen was actually drawing, not just what the game world contained — "my friend is invisible" bugs get found much faster.
• Bug reports you send us now show whether your character actually entered the world and whether your controls were reaching the game — so we can find the real problem much faster.
• Games download and boot faster: the engine's client code shed about a fifth of its total size.
• There's now an "Exit god mode" button on screen, next to "Hide controls" — no more being stuck flying because nobody told you about Tab+G.
• If your game binds "hold Ctrl" (a crouch, a sprint) in a WASD game, Savi now gets a warning that pressing W while holding Ctrl closes the player's browser tab — so the binding gets fixed before a player hits it.
• Scheduled game logic — crons for day/night cycles, waves, restocks — now actually runs in your published game while players are in it. It used to run only in the dev room while you were building.
• Updating one terrain material with a partial update no longer silently wipes the others from the save — the world that reloads is the world you saw.
• Models and images that finish generating while Savi builds without an open game tab now appear in the world as soon as they are ready, instead of staying invisible to that session until a reload.
• 2D characters with many animations load in more reliably when the art kitchen is busy: the game now waits exactly as long as the server asks before re-requesting sprites, so stuck animations heal sooner instead of hammering the queue.
• Fixed a rare freeze where a game tab kept its connection but silently stopped taking in edits and saves — and screenshots still claimed everything was current. The freeze class is gone, and Savi's tools now report exactly which version of the world the screen is really showing.
• Digging or placing single blocks in big voxel worlds is much lighter on physics — one block edit no longer rebuilds the whole chunk's collision.
• Mining and building in really big voxel worlds feels immediate now — block edits show up in roughly a third of the time, with no hitch as the world grows.
• Voxel blocks with custom shapes — stairs, slabs, anything a material's shape hook builds — are solid now. Players used to walk or fall straight through them whenever the chunk also held plain blocks.

Engine v5.2.34

Released August 22, 2026

• Tweaking one knob on a custom material no longer breaks the whole material. Changing a single parameter on a script-built material (a glow's gain, a beam's density) used to silently throw away the script and every other parameter — the object snapped back to a plain solid-colored default, and it looked like your material was never there. Now a single-parameter tweak changes exactly that parameter and leaves the rest of the material alone.
• Group objects that are already placed without anything moving: attachTo(rootId, { keepWorld: true }) adopts a piece under a parent while keeping it exactly where it stands — build a brazier or chandelier from placed pieces, parent them to one root, and move the whole thing as one object.
• Savi's builder can join every game again. In some games on newer engine versions, she could not get in at all.
• Saves and other database calls made by players' own behaviors were silently failing in some rooms — on some games, all of them. Fixed: those calls now go through and wait out reconnection blips instead of being dropped.
• Roads can vary their width along the route. Give a road's width a list — one number per point, like [2, 8, 2] — and it narrows and widens smoothly between them: straights that open up, corners that pinch, a plaza that necks down into an alley, all on one spline. Edge lines, sidewalks, hedges, and lamp posts follow the changing edge, and driving/collision matches what you see. A single number still means one width for the whole road.
• Deleted something and watched it pop back a few seconds later? Fixed. Your delete always saved — a laggy connection could briefly re-load the world from just before it and bring the object back. The engine now remembers what your last save contains and never rolls behind it.

Engine v5.2.33

Released August 22, 2026

• A one-off network hiccup while the engine downloads no longer kills a player's first open. If one piece of the engine fails to arrive, the game now quietly re-requests it once before showing an error — the class of "it just showed 'something went wrong' the first time I opened it" caused by a single flaky fetch heals itself.
• Vehicles and other built objects no longer come back scrambled after a reload — wheels, seats, and parts stay exactly where you put them, every session.
• Dragging an object no longer teleports it back to where it last saved. After a stretch of continuous dragging, grabbing an object could snap it to a stale position (roughly where the last autosave put it) and every drag after that kept teleporting. The drag now always starts from where the object actually is in your hand.
• Things stay the right size when you walk into a new area. In multiplayer rooms, objects with a size limit (layout) could show up giant — a 10m watchtower rendering at 45m — and stay giant until the room restarted. They now always appear at their correct fitted size.
• Scripted edits to painted terrain and scatter no longer make the rest of the paint vanish in the running game.
• Middle-click is now reliable. Binding the middle mouse button no longer fights the browser — bound middle-clicks can't trigger page autoscroll or other browser defaults — and a middle button held when pointer lock drops (Esc, opening chat) no longer sticks "down" until something else resets input. Actions bound to middle fire on press and release exactly like any key, every time.
• Falling out of the world while seated no longer welds you under the vehicle. When the engine's fall-catcher or terrain rescue moves a body back to safety, a rider still parented into a seat is unseated first and lands at the rescue point as a free body — before, the rescue position could be re-read as a seat offset and leave the player stuck under the cart until a script intervened. The unseat-before-rescue guard scripts wrote by hand is now the engine's own behavior.
• Custom crosshairs are yours now — the platform's white pointer dot no longer sits over your game's own crosshair. It stays hidden until a player actually moves the mouse in the overlay, which is the only time anyone needs it.
• Old open tabs can no longer cross your live game's players into your editing room. A tab left open from before a recent fix could reconnect players into the room you edit in — reading half-built work and manufacturing wipes. The server now refuses those stale connections at the door and the page reloads itself into the right room.
• Ctrl-Z now survives a reload in multiplayer worlds. Before, undoing a delete brought the object back on your screen but never re-saved it — it silently vanished the next time the world loaded (and if it lived in a side map, even a saved restore could teleport to the main map). Now an undone delete is really back: full object, behaviors and all, in the place it belonged.
• Ghost copies of players no longer appear while the builder reconnects. Reconnecting leaves everyone on the current game and keeps their progress intact.
• "Which script is eating the tick?" is now one question, not days of ablation. In multiplayer rooms, api.getPerformanceSnapshot() (Savi's perf read) now answers with the real per-script cost — cumulative ms per script file over the measured window — plus how many scripted entities ran vs. were schedule-skipped each tick. Before, the read came back empty in multiplayer rooms.
• On slow or busy computers, the game no longer tears itself down to "recover" from its own lag — the surprise "Connection lost. Reconnecting…" after a long freeze, and waves of textures failing and retrying, both came from the engine misreading its own slowness as failure. It now tells the difference and rides the lag out.
• Grass is no longer black from the far side. Grass blades and plant sprites used to render as black shapes when you looked at them from the side facing away from the sun's shading — fields showed dark patches that moved as the camera turned. Every blade now reads the same green from both sides, the way ground cover should.
• Your game UI can now save files to the player's device. Export buttons built the normal web way — make a Blob, point a download link at it, click it — now actually download: story text, save files, level exports, screenshots. Before this, the export button did nothing at all, with no error anywhere.

Engine v5.2.32

Released August 20, 2026

• Meshes reworked while your tab was hidden now reappear when you come back — big generated meshes edited behind a hidden tab could return solid but invisible until each one was nudged by hand; the engine now spends no retry budget while nothing is being drawn, re-requests everything parked the moment the tab returns, and tells Savi how many meshes are undelivered on a player's screen if any stay stuck.
• Objects created through a save show up for everyone, every time. Before, an object created through certain save paths could land in the game's saved data but never appear in the live room — invisible to you and every joiner until someone else happened to edit the world. Now the room builds it within a fraction of a second, no outside edit needed.
• Fixed: custom cursor sprites no longer swallow mouse clicks. Games that replace the native cursor with an image (draggable=false, pointer-events:none) work again on desktop — clicks pass through to your buttons and your world exactly like they did on 5.2.21.
• A model that hits a momentary server hiccup no longer reads as dead. The placeholder used to flip to "Couldn't spawn" — and Savi's eye to "a receipted death" — off one failed read, even when the asset was fully imported and serving; creators were told to regenerate or rename assets that were fine. Now the engine keeps probing through transient trouble, tells you exactly what it measured ("N reads have failed so far") and only declares an asset dead when the server itself confirmed it.
• Shadows from static models come back on iPhone and iPad. On some Apple devices, props and buildings imported as unskinned 3D models silently stopped casting shadows (characters still did). They cast again.
• Multi-area games stop losing areas: walking back into an area that had emptied out (a prologue street, a lobby, an arena) now reliably brings back everything you built there. Before, a busy room could bring the area back as an empty box until the room restarted.
• Cap your game's frame rate — engine.graphics.maxFps caps how fast the renderer draws (great for heat, battery, and steady pacing on phones), and players can set their own lower cap in settings. Your game logic runs exactly the same; only the drawing rate changes.
• Big worlds load in smoother. While a large game streams in, the renderer used to spend a chunk of every frame re-sorting the scene; that cost is ~10× smaller now, so the first seconds of a heavy world hitch less.
• Editing a shared library file your game's UI uses now reliably updates the screen: before, if the room's updates hiccuped, a lib-file edit could leave the old UI showing forever — while the diagnostics insisted everything was fine — until the tab reloaded.

Engine v5.2.31

Released August 20, 2026

• Characters stay seated — riding a vehicle no longer forces the walk animation. A character parented to a moving vehicle or platform no longer plays walk/run at the vehicle's speed, and npc: { locomotion: false } now releases the player avatar's engine gait too, so a seat clip plays alone.
• Your character appears even where animations can't bake — static beats invisible. Where animations can't bake (such as in local development), characters load as their unanimated base model instead of holding the placeholder orb forever.
• Savi can no longer mistake a frozen view for your live screen — she says when her eyes are stale instead of guessing from old pixels. When she captures a player's screen and that player's tab has silently stopped receiving updates, she now gets told the frame is stale instead of treating old pixels as the live game.
• Buttons and clickables work with the mouse again on desktop. 5.2.30's touch-tap fix was classifying desktop clicks as UI wherever any script-wired or cursor-styled element sat — in click-driven games, every mouse press could read as a UI hit and world clicks went dead. Desktop clicks now classify exactly as they did in 5.2.21, while phones keep all of 5.2.30's touch fixes (script-wired buttons and pads still take the tap over the engine stick).
• Objects keep their rotation while you move them. Rotating an object and then dragging it somewhere no longer snaps the rotation back mid-drag — a background save arriving while your hand is on the object can't undo what you just did.
• Rapid spawn-and-despawn effects now cost the connection nothing while it is catching up. Things that appear and vanish before the room ever hears about them are simply never sent, so real updates (movement, commands) keep flowing at full rate under any spawner load.
• Your game can react when the mouse cursor is freed — pause menus on first Esc now work. The browser eats the Esc that exits mouse capture, so scripts could never see it; now input.actions.pointerLockLost fires the frame the lock releases and input.axes.pointerLocked reads 1 while the crosshair owns the aim — no declarations needed.
• Your edits always land in YOUR room — never an invisible copy — even right after joining. Before, Savi's builds could land in a copy of the world you couldn't see (especially during busy building sessions or right after you joined). Now what Savi builds is what you watch appear.
• Long music tracks in multiplayer rooms no longer cut out after a second — the song keeps playing through world syncs and rematches.
• Worlds with rapid spawn-and-despawn effects no longer flood the connection — everyone's movement stays smooth. Spawners that mint and destroy entities continuously used to flood the room with bookkeeping and could starve real updates (frozen movers, "like I disconnected without disconnecting"); their churn now travels light and dead spawns fold away under pressure.
• 2D characters no longer flash white when switching animations — they hold their pose while the next animation loads. The spinning loading rings now appear only the very first time a sprite paints, when there is nothing else to show.
• Texture scripts no longer break image loading — script-driven textures and image uploads work together. A game whose art is drawn by texture scripts (scripts/tex-*.js) no longer collects false "FAILED to generate — rename it" verdicts against healthy scripts, and animated script textures stop getting fake frame grids guessed at them.
• State handles never go stale — edits after a state change always land. A script can grab its state once and keep using it: reads see every later patch the moment it happens, and writes always reach the world, even right after a respawn-style state reset.
• Big built-out worlds run much smoother while you build. A background cleanup check used to re-scan every object in the world every tick — in decorated worlds that alone could eat most of the frame budget. It now only wakes up when something actually changes.
• Scripted movers keep moving in long-running multiplayer worlds. Anything animated with Math.sin/Math.cos of game time — patrolling animals, bobbing platforms, spinners — used to freeze in place in multiplayer rooms (moving only once every few minutes) once the room clock got large. They move continuously now.

Engine v5.2.30

Released August 19, 2026

• Saving no longer freezes or respawns objects in multi-area singleplayer games. In a singleplayer game with multiple places, every save was silently destroying and respawning every object outside the player's current place — re-running spawn effects, resetting runtime state, and freezing the game for a moment while materials and geometry rebuilt. Saves are now quiet: nothing that didn't change is touched.
• Script-wired buttons and touch pads now work on touch — no bridge or workaround needed, even with engine touch controls on. Controls you wire from a script (element.onclick = ..., pointer handlers, cursor:pointer styling) now take the touch everywhere they're visible — the engine's movement stick and camera no longer steal taps from them, and iOS taps that Safari tried to cancel still land. Empty screen space still belongs to the engine stick and camera.
• No more "Connection lost. Reconnecting…" flashes when you tab back into your dev room. A hidden tab's queued background traffic now just drains on return instead of forcing a fresh reconnect and a full world reload — tabbing away and back is seamless again.
• Place travel works reliably on busy rooms. On rooms with lots of join/leave churn, a player's enterPlace could silently do nothing — the call returned the destination but nobody moved — until the next clean rejoin. Travel now lands on the first try regardless of how churny the room was when you joined.
• Safari no longer eats all your memory while a game sits waiting for its first click — the bug that could freeze a whole laptop on a quiet world is gone.
• Savi gets interrupted less while you build. Routine engine notices — a texture that didn't load, a clip name that doesn't exist, a placeholder holding while art generates — now go quietly into her logs instead of pinging her mid-conversation. She still hears immediately about real breakage (broken scripts, crashes, things that stop rendering), and about any problem that suddenly happens dozens of times at once.
• Games with lots of moving objects spend less engine time per frame on internal bookkeeping — positions, rotations, and scales are read without generating garbage-collector pressure, leaving more headroom for game logic at the same object count.
• The stray scrollbar that could pop over your game's right edge (and make your game UI look broken) while art was spawning is gone.
• Editing your game's UI no longer gets stuck showing the old version until a restart. If the room's updates ever stall, the engine now notices within a few seconds that your HUD script changed, recompiles it from the live copy, and repaints — and tells Savi it happened instead of silently serving the old screen.
• Savi working in the background no longer breaks the area you're playing in. While she worked, the exact arena you were standing in could stop running physics — bots froze, pickups never appeared, and "nothing works" until a restart. Now the place you are playing in keeps running normally while she works.
• Terrain works everywhere in multiplayer worlds — no more falling through far areas. Ground far from the players — under a driverless car, a wandering NPC, anything physics moves — is now guaranteed solid in multiplayer rooms, exactly like singleplayer. Before, objects in far regions of a shared world could fall through or let players walk through terrain that never got its collision built.
• Placeholder images keep their shape while models generate — a tall character concept no longer renders squashed and stretched on its loading card.
• Savi can rename something across your whole game in one step — and show you every change before making it. Renaming a town, an item, a character used to mean editing every script that mentions it, one file at a time. Now one call previews every affected line across every script, and the same call applies it.
• Games with lots of moving objects spend less time in memory cleanup — motion updates now recycle their bookkeeping instead of generating garbage every tick.
• Games with several AI-generated or uploaded 3D models hold dramatically less memory on phones — the engine now frees each model file's raw bytes once its textures reach the GPU instead of keeping whole files around, which is a big step against the "game reloads on iPhone" class of crash. Busy building sessions also idle lighter: landing model metadata no longer re-scans all your scripts, and big boot bursts no longer leave permanently enlarged buffers behind.
• Long sessions in sound- and media-heavy games use much less memory: decoded sound effects, warmed video clips, and edited-away material shaders are now released when nothing is using them (they reload on demand), which especially helps phones stay alive in big games.
• Games with lots of timers — every() loops, staged builds, scheduled waves — no longer pay a per-tick sweep over every armed timer, and the engine's own tick loop allocates far less, so long sessions hitch less from garbage-collection pauses.
• Your character no longer keeps running on its own after opening menus mid-stride. If you were holding a movement key when the chat or an overlay opened, the release landed on the menu and the game never saw it — the character kept walking with no key down until a god-mode round trip cured it. Held keys now release the moment the game surface stops receiving your keys.
• Mouse aim no longer goes dead after quickly closing chat — the game re-grabs the mouse itself. Before, flipping the chat overlay open and shut at the wrong instant could leave a first-person game with working keys but a dead mouse until you opened and closed chat again.
• Your mouse's side buttons can now be bound — quick-melee, ping, whatever your game wants. Ask for mouse4 / mouse5 binds; the browser's back/forward navigation stays out of the way while a side button is bound.

Engine v5.2.29

Released August 17, 2026

• Big long-lived worlds no longer melt down in multiplayer. When a world grew past an internal size ceiling, joins behind the scenes failed over and over — each attempt paying a huge download — and all that churn kept disconnecting the actual players, resetting them to spawn and timing out saves. Those joins are now as cheap as a player's, and when something does fail to join, it retries politely instead of hammering the room.
• Savi's helpers now enter big worlds the cheap way players do. Instead of downloading the entire world just to get in the door, they join instantly with the essentials and stream the rest in behind the scenes — so a large world's helper shows up in seconds instead of paying a giant download at the doorstep.
• A player whose game freezes for a while (heavy tab, background throttle, giant world load) now snaps to the room's CURRENT state when it thaws, instead of replaying minutes of stale multiplayer history — a window during which their client silently dropped other players' actions.
• Remote players and NPCs recover to their live positions faster when a busy room backs up. When chat and world updates interleave with movement, a slow device now skips straight to each mover's latest pose instead of replaying a backlog of stale ones.
• Bots and props no longer freeze or snap backwards for some players when players come and go. Players whose view of the room was a beat behind used to lose the latest bot and prop updates at that moment — now those updates are kept and applied, so everyone sees the same world through the change.
• Saves and loads that run when a player joins no longer fail during the room's first moments. Every boot had a short window where the room was still connecting; a script reading its saved data there got errors and fell back to defaults, and saved terrain edits waited on a retry instead of loading cleanly. The engine now holds those reads until the connection is ready and runs them immediately — and if the room genuinely can't connect within 30 seconds, the script gets one honest error saying the call was never sent, so retrying it is safe.
• When the engine slows something down on purpose, Savi can now see exactly what and why. If the engine parks heavy shader work to keep a session playable, that shows up as a named fact — which safeguard engaged, how much it's holding, since when, and whether it will come back on its own — so "why does my game look different on that phone" gets a straight answer instead of a mystery hunt.
• Five more engine safeguards now explain themselves instead of looking like bugs. When a game runs slow because the device can't keep up (dropped sim ticks), when multiplayer movement snaps to the latest position under backlog, when terrain is slow to build on an overloaded device, when a run_script times out, or when textures unload under memory pressure — each now shows up in Savi's health check as a named fact with the real cause. The run_script one matters most: a timeout on an overloaded machine now says the machine was overloaded and your script is not proven at fault, instead of wrongly blaming your code for a busy loop.
• A UI whose script library outgrows the mount budget now tells you, instead of silently keeping the old UI alive. If your ui.js and the modules it requires grow past the UI size cap, you get one loud fault naming the measured size and the budget, the receipts read "mount dropped over cap" instead of "sent", and trimming or merging lib modules re-mounts immediately — no dummy edit needed. The module-count ceiling also rose 256 → 4096, so the byte budget is what governs.
• Clearer answer when a script destroys a generated piece of a wall or road. Fences, walls, and roads generate their segments automatically; those segments disappear (and come back) with their parent. When a script tries to destroy one that's already gone, the engine now explains that instead of guessing the script used a wrong id format.
• Scripts that touch an object living in another area now get told exactly that. Writing to an entity that lives in a different place used to fail with a generic "not found" that read like a typo; now the error names the entity's real place and states the rule — writes only apply within the calling place — so you stop hunting for id typos that aren't there.
• Animation channels playing your authored clips now report how long they run. getChannel().duration used to read null forever for authored clips — finished never fired and progress sat at 0 — so scripts couldn't sequence off a clip's end. All three now answer from the clip's own minted timing; a duration you set by hand still wins.
• Model references pasted as bare upload filenames now just load. A ref like public.aHR0….glb (the canonical import filename without the /cdn/ prefix) used to sit as a permanent placeholder while the scene note claimed the model had been declared dead. It now loads the model it names — and references that genuinely can't resolve say so honestly: "no request was ever made", never a fabricated death verdict.
• Savi can see broken shaders, looks, and script errors in multiplayer worlds again. When a look, material, or texture script fails on someone's screen in a multiplayer room, Savi now gets the actual error (in her logs and as a heads-up message) instead of nothing — so she fixes your one-line bug instead of chasing a phantom engine problem.
• Savi can no longer mistake a silently frozen game tab for the live world. When a tab's connection looks alive but has stopped receiving updates, her scene captures now carry the world version they were rendered from, so she says "your tab is showing an old version — reload to catch up" instead of describing the stale frame as current and rebuilding things that already exist.
• A silently frozen game tab now heals itself instead of gaslighting the session. When a tab's world stops updating while its connection looks alive (the "everything I ask Savi to build never shows up" freeze), Savi's tools now detect the frozen version, save a diagnostic snapshot of the tab, and quietly direct it to re-sync — or, if that fails, to rebuild its game session in place — instead of describing a stale world as current and rebuilding things that already exist.
• Objects stop silently going missing — and destroyed ones stop haunting the screen. When a create, destroy, look change, or effect got lost on the way to a player's screen, that player used to see a permanently stale world until they reloaded: new buildings invisible, destroyed enemies still drawn, finished effects fogging the screen forever. The engine now compares what the screen holds against what the game says exists, every second, and repairs exactly the difference within a few seconds — both directions, without touching anything that's healthy.
• Edits and heals now stick in empty rooms: when Savi (or you) fixes an object and saves, the fix survives everyone leaving and coming back — the room no longer resurrects the object's old position or state from stale multiplayer history at the next join.
• api.getPlayers() can no longer be broken by tag writes. A script that overwrites or wipes a player's tags used to make that player vanish from getPlayers() (while they kept playing, visibly in the world) — and a non-player session body mis-tagged "player" could show up in rosters and counts. Player enumeration now reads the platform's own record of who each session is, so getPlayers() always returns exactly the connected players — whatever your scripts do to tags. tags: ["player"] queries still work exactly as before for your own gameplay logic.
• Long play sessions on phones stop eating memory until the game dies. Every shot, hit, and pickup sound used to leave a little audio machinery behind forever, and long iPhone sessions grew until iOS killed the tab. Finished sounds now clean up after themselves, and several behind-the-scenes buffers that were sized for desktops now use phone-sized versions on phones.
• Long music tracks stream instead of sitting fully decoded in memory. A track past ~43 seconds — or a looping one past ~22 — now plays as a stream with a tiny memory cost, at worst a small seam when a very long loop wraps. Short loops and stems still loop seamlessly, exactly as before.
• Less wasted work every frame. The engine stopped re-sending unchanged particle, terrain, decal, and lighting data to the GPU every frame — particle-heavy and effect-heavy scenes get that budget back.
• Voxel worlds with heavy terrain generators no longer grow holes and see-through ground around the player. Chunk builds that used to be silently thrown away after 10 seconds — because the engine bundled far-apart chunks into one oversized job — now build one chunk at a time and land.
• Walking across a voxel world stays smooth. A slowdown we found in testing before this release, where streaming in new ground could grind the whole game, is fixed.
• Math.floor and friends are exact again in scripts and behaviors. Math.floor, Math.ceil, Math.round, and Math.trunc now return exactly the number you'd expect on big values — Math.floor(334350000) is 334350000 again, not 334350016. Integer math, indexing, and anything built on flooring big numbers works the same in your script files as it does everywhere else.
• Numeric constants in your scripts are exact now — physics constants survive to the last digit. 6.674e-11 is exactly 6.674e-11 in behaviors and required modules, 0.1 + 0.2 is 0.30000000000000004 like everywhere else in JavaScript, and a constant compared against the same constant from another file is byte-identical. Your source numbers are never rounded behind your back anymore.
• First-person and aim-over-shoulder games shoot down the crosshair on phones. Tapping the fire button used to send the shot toward your thumb instead of where you were looking; the crosshair is now the aim on touch exactly as it is under the desktop pointer lock. Cursor cameras (pointerLock: false) still aim at the finger.
• Your character stops walking when a chat box grabs the keyboard. Before: holding a movement key at the exact moment any text field in your game took focus (a chat composer opening on Enter, for example) left the character walking in that direction forever — the release landed in the text field and the game never heard it. Now the engine clears held keys the moment a text field takes focus, the same way it already did for the platform's own text fields. Any script watchdogs you built to zero stuck movement when your chat opens are no longer needed.
• Savi's builder body no longer materializes inside your face. In first-person games her body used to appear exactly at the spawn point — inside your camera — every time she came to work, until a correction kicked in seconds later. She now arrives a polite conversational step away, already facing you.
• Asking Savi to replace the world now works in multiplayer rooms. "Start over from the 2D platformer starter", "wipe this and make it a UI game" — these used to fail in multiplayer while working fine solo. Now they work everywhere; other players in the room still can't trigger a world wipe from their side.
• Shader materials the engine parked for performance now always find their way back when the scene calms. Before, if frames dipped right after the engine re-enabled a parked material, that material stayed on its plain fallback until a full page reload. Now the engine just waits longer between retries (doubling up to about a minute of steady frames), so a scene that calms down gets its look back on its own. And lag from game logic — lots of moving objects, heavy scripts — no longer counts against a material being probed back; only real GPU cost does.
• Players whose device genuinely can't run Spawn now hear the truth instead of "Update your browser". Phones and computers whose graphics are below Spawn's floor used to be told to update a browser that was already current — forever. Now they get an honest answer: this device can't run Spawn, here's what's worth trying. Machines where a browser setting is the real fix get the setting steps instead.
• Phones and browsers that can't start 3D now get an honest answer instead of an endless reload loop. When a device's graphics can't run a game, the loading screen now explains what's going on and what to try — before, it said "reloading usually fixes it" forever on a device where reloading never would.

Engine v5.2.26

Released August 16, 2026

• Terrain edits now sync reliably in always-on worlds. Players who rejoin get the terrain exactly as it was edited — edits made by scripts or by players who have since left no longer silently vanish on rejoin. And freshly edited chunks rebuild ahead of background work, so digs and builds turn solid and visible faster even while the world is busy streaming.
• Drawn textures (lava, water, animated art made by texture scripts) no longer vanish for a minute and a half when a crowd of players joins at once. The engine now recognizes that the stall was the join rush, not your texture script, and keeps retrying quickly instead of putting the script in time-out.
• Destroying something now cleans up everything it generated. Roads, rails, fences and other spline-built objects leave no debris: destroying the root also removes the segments, posts, and collision pieces it spawned — including ones orphaned by an old destroy. If your world already has stranded leftovers, one destroy of the old root id (or one destroyObjects sweep) clears hundreds of them; no room restart needed.
• Every light in your world now shows its marker in god mode — including lights nested inside other objects and lights buried in walls. Markers draw through geometry and you can click them through walls to select and edit the light. No more invisible, uneditable lights.
• Performance health readouts now tell the whole truth on small screens: when the engine holds your game at native resolution because a lower render scale wouldn't actually help, the report says so in plain words — and the auto-quality tuner stops wasting time on resolution cuts that change nothing, reaching the settings that DO help faster.
• Always-on worlds stop restarting under load. A busy world working hard no longer gets mistaken for a dead one and restarted — the multi-minute freezes that hit heavy worlds over and over are gone. And when a world genuinely IS overloaded, Savi's tools now say so plainly instead of failing with mystery errors.
• Textures that get stuck as flat placeholder colors (the pink-blocks look) now heal themselves: the engine quietly retries every few minutes until the real texture arrives, and flipping to another tab and back still kicks an immediate retry. No more refreshing the page to get your textures back after a flaky connection at load.
• Games can take photos now! window.spawn.view.captureFrame() in your game UI hands your script a snapshot of that player's own view — build safari cameras, photo quests, postcard booths. Each player can only photograph their own screen, the shot is pure game world (no menus or chat in the frame), and nothing is saved or shared unless your script chooses to upload it.
• Uploading a model with shape keys (morph targets — blinking faces, facial expressions) now tells you plainly what happened: one clear warning says the engine doesn't support shape keys yet and skipped them, and the rest of the model loaded fine. No more models silently arriving with frozen faces — and no more parser jargon drowning out the warnings that matter.
• Multiplayer worlds get their animations back. Since 5.2.18, animations authored in a multiplayer world were never actually saved to the world's animation library — other players saw characters frozen in place (one world had 129 rigged characters stuck like statues). Authored animation clips now save and reach every player, and existing worlds heal on their own: the next time an animation plays, the library mints and everyone sees the motion.
• Leftover Savi todo-marker debris cleans itself up. Worlds that collected stray marker cubes from long-gone todo notes (one world was carrying over 2,000) get swept automatically — and the sweep sticks in always-on worlds instead of the shards creeping back on your next visit.
• Invisible-wall checks now match where walls are actually drawn. Occupancy probes against uploaded and conjured meshes (cave shells, sculpted walls) used to test a ghost box at the object's origin instead of where the geometry really sits — the drawn wall read empty while the empty ground at its feet read blocked. Cave and mesh interiors now answer occupancy correctly, so scripted barriers and "is this spot solid?" logic agree with what players actually see.
• Looping sounds now register in always-on worlds — Savi's audio tools can see and stop them again. In multiplayer rooms, started loops were never recorded: "what's playing?" answered nothing, stray loops couldn't be hunted down and stopped, and players who joined late had no record of the ambience already running. Loops now register for everyone in the room, late joiners included.
• Discord links in game UI now work in every spelling. A plain HTML link (<a href="https://discord.gg/…">) now asks the player to confirm and opens Discord in a new tab, exactly like openLink(...) and window.open(...) — and a link to a non-partner site tells you why it can't open (in your logs) instead of doing nothing.
• Steep-slope climbing, sliding, and ground-snap are now yours to tune — skate parks and parkour walls just became authorable. On any physics: { body: "character" } object: maxSlopeClimbAngle: 70 (degrees) walks up steep quarter-pipes, snapToGroundDistance: 1.2 hugs snowboard downhills (or false to launch off ramp lips), minSlopeSlideAngle makes too-steep ground slide you downhill, and characterMass sets how hard you shove crates.
• Rejoining an edited world can't serve you stale terrain anymore. A rejoin (always-on worlds, long-lived sessions) now rebuilds exactly the chunks that really changed — no more terrain that looks like it forgot the last session's edits until something else forces a rebuild.
• Passengers and vehicle parts no longer drift apart for other players. Parts spawned by a vehicle (lights, turrets, seats) used to slide away from it — unboundedly, and the drift stuck — on everyone else's screen when some players drove. Now the whole vehicle stays together on every screen, whoever drives it.
• A graphics-driver crash can't blind Savi for an hour anymore. When the GPU device dies, her screenshots and view tools now answer plainly — "the renderer is restarting; your content didn't cause this" — instead of surfacing raw driver errors, and her capture eye reboots itself on the very next look.
• Debug dumps stop crying wolf about audio. The engine's planned network probes and cross-site audio fetches always LOOKED like failed requests in a dump ("[error] 0B" walls) even when your audio was working perfectly — Savi would investigate healthy sound as if it were broken. Those rows now say what they are ([probe], [opaque]) so real network errors stand out — and they never crowd real failures out of the dump.
• Savi can now SEE which objects are solid when she looks — no more guessing why players fall through. When she identifies an object or frames it in a look, the answer says whether it actually collides right now (solid: static-mesh, solid: none, …), so a wall that only looks like a wall gets caught the moment anyone checks it instead of the moment a player falls through it.
• Textures no longer flicker or swap after heavy editing sessions — a texture-cache cleanup racing the renderer could previously freeze the whole session with a "graphics driver hiccuped" error until reload.
• Tile maps stop going blank mid-edit. If your tile world's generator script briefly breaks while you're editing (or hasn't finished loading), painted chunks now hold their last good art instead of flashing to flat empty slabs — and the engine tells you the generator is unavailable instead of staying silent. The moment the script heals, your pending edits fold right in.
• Timers scheduled while a world is still starting up (runInTicks, runInSeconds, runSchedule) now fire once the world is running instead of silently disappearing — staged builds queued at startup no longer stall.
• Voxel block textures stop getting stuck as flat white/pink. Rebuilt chunks no longer forget they're waiting on a texture (the "first block pink, second correct" bug), worlds with more than 64 block materials get all their textures instead of flat tint from material 65 on, and when a texture genuinely can't apply the engine now says why instead of silently painting white.
• Voxel worlds stop going black when their generator script breaks. The same cure as for tile maps: if a voxel world's generator script briefly fails to compile, built terrain now HOLDS its last-good look (and hand-placed voxels keep rendering) instead of whole regions silently turning to permanent black nothing — the engine says the generator is unavailable, retries, and heals the moment the script recovers.
• Recoloring voxel terrain is instant now. Changing a voxel material's color, texture, roughness, metalness, or emissive updates the world as a palette swap — no more full-world remesh (with its multi-second hitch and physics churn) for a cosmetic edit. Structural edits (solidity, collision, block shape) still rebuild what they must.
• Joining an always-on world with terrain edits stops paying a growing tax. Every join used to quietly grow the world's edit history and force edited terrain to rebuild even when nothing changed — long-lived edited worlds got slower to join with every visit. Syncs are now a clean no-op when nothing changed, so joins stay fast no matter how many times the world has been synced.
• Game photos come out the way you ask. window.spawn.view.captureFrame() still hands back a JPEG by default, but now captureFrame({ type: 'image/png' }) gives crisp pixel art with no compression, { maxSize: 4096 } keeps the full resolution, and { type: 'image/webp', quality: 0.6 } makes a small share-sized shot. Rapid double-clicks take two photos instead of dropping the second.
• Savi stops learning object paths that only half-work. Reading an object by its list position used to succeed, so she'd keep using that number as a name — and then every edit or destroy aimed at it silently did nothing. Now the read itself tells her the object's real name the first time, so she talks about your objects the same way she changes them.
• 2d worlds stop developing permanent invisible holes — the picture always catches up to the world. A tile chunk that got lost on the way to your screen (or kept showing old art after a re-save) used to stay wrong until a reload; now the engine notices within seconds and repaints exactly the chunks that diverged. First loads that raced the terrain script no longer come up empty with no ground to stand on — the map fills in the moment the script is ready.
• A model that failed to load because of a hiccup now says it will retry — renaming is never needed. When the server answers a failed download with its own retry window, Savi's scene view now reads "temporarily failed — retries on its own" instead of declaring the asset dead and regenerating it under a new name.
• Falling through the world now puts you back instead of dropping forever — and your script can choose where. Heightmap worlds get an automatic floor far below the deepest terrain: anything that falls past it comes back at the spawn point. Tune it per place with worldBounds: { bottom: -140 } (any world kind, null for no floor at all), and take over the response by exporting onOutOfBounds(event, api) from the body's behavior — return false and the respawn is yours: last checkpoint, a damage penalty, a game over. Underground builds (terrain.underground: true) keep working exactly as deep as you build them; the net sits 64 m below the lowest terrain.

Engine v5.2.25

Released August 14, 2026

• Big worlds with lots of detailed scenery run noticeably smoother while you walk around — the engine now remembers collision shapes it has already built instead of rebuilding them from scratch every time objects stream in or toggle their physics.
• Behind-the-scenes: when something goes wrong in a game, the team can now see exactly which engine version it happened on — fixes land faster.
• Fixed a bug where things your scripts built could come back invisible after a server hiccup — and stay invisible no matter what. The world now heals them on its own, and re-running the script that built them fixes them too.
• Savi now hears loudly when a script's changes applied live but nothing reached the saved game — instead of discovering it after a reload wipes the work.

Engine v5.2.24

Released August 14, 2026

• Players in other places can now receive state. The classic pattern — queue the party in the lobby, warp to the arena, then tell everyone their match — just works: patchObjectState(playerId, {...}) reaches a player anywhere in the room, and the new getPlayerPlace(playerId) tells you whether someone left the game (null) or is just in another place. No more heartbeats, shepherds, or ticket systems to work around invisible teammates.
• Turning on pixelate (or chromatic aberration, depth of field, blur) for the first time in a session no longer flashes the screen black while the effect's shaders compile — the game keeps rendering un-graded for those frames and the effect lands as one clean switch.
• Hitting big things no longer floods the screen with light: the built-in damage flash is calmer by default, sized so a red hit-pulse on a huge tree or wall stays a pulse instead of a full-screen flash. Combat on normal-size enemies still reads exactly like a hit.
• flash() now takes intensity (0–1), so you can dial an object's hit flash from a subtle glow to the full white-out yourself.
• Scattered decoration works in multiplayer again. Scatter beds authored into your game's spec (grass, rocks, forests — anything painted or declared with scatter) now appear in multiplayer rooms exactly like they do in solo play. They'd been silently empty in shared rooms; no change needed on your side.
• Timestamps and big numbers in state are now exact. Storing api.seconds() (or any large number) in state via patchState/setState/direct assignment used to round it by up to ±64 seconds at today's clock scale — enough to break "how long since X" checks in ways that looked like a haunted clock. Stored numbers now come back exactly as written, everywhere, for every player.
• Game UI that uses drawn art (scripts/tex-*.js images) no longer flashes a big translucent blue square while the art loads. The loading window now paints nothing at all — the art appears when it's ready, and that's the first thing you see.
• Heightmap worlds can now have real underground. Set underground: true on your terrain (ask Savi, or api.patchTerrain({ underground: true })) and the engine stops treating players below the surface as having fallen through the world — no more being teleported back up out of your basement, tunnel, or subway line. The ground above stays exactly as solid to walk on; players still need a way down that you build (a pit, a shaft, a portal). Below the surface, floors are yours to author — the engine no longer provides a safety net there.

Engine v5.2.23

Released August 12, 2026

• Savi now files the features you keep wishing for with the Spawn team — a dream that comes back session after session gets written down once, in your words, instead of staying her private workaround.
• If a script's event listeners ever get marked dead (after an error storm), registering a new listener now just works — the old "dead ears" verdict can't silence fresh code anymore.
• Fixed the bug where every world could render as a blank white screen (the August 8 incident) — the change that caused it never shipped to live games and is now fully removed.
• "I reported this to the team" is now true in every kind of room — bug reports from every multiplayer room now reach the team.
• When you summon Savi's builder body into a multiplayer room, she now arrives a polite conversational step away, facing you — never inside your face.
• While a custom sky image is still generating or loading, the sky shows a pleasant placeholder color instead of going pitch black.
• When a script sets a material property the engine doesn't understand (like three.js's map), the engine now says so once and suggests the right name — instead of silently ignoring it.
• Scripts that import each other in a circle now get told exactly which files form the circle, instead of a generic compile error.
• When Savi deletes objects that a behavior script spawns (minions, lamps, pickups), she now learns on the spot that the script will bring them back on the next room restart — so she edits the spawner script instead of leaving you a delete that silently undoes itself overnight.
• Entering god mode (or hopping into a vehicle) while holding a movement key no longer leaves your character auto-running in that direction. Your game's own input handler gets one final "all keys released" frame when control moves away, so held-key state settles exactly like a real key release.
• Shrinking an object with the built-in scale grip no longer flips into growing when you drag past its minimum — it holds at the minimum size until you drag back out. Growing feels exactly the same as before.
• Going back to a place you'd left — lobby after a match, hub after a dungeon — now brings its scripts back listening. Menu buttons, referees, and anything else wired with api.on respond after the round trip instead of going silent until a page reload.
• Swapping which script an object runs while nobody is in its place now takes full effect on the next visit — the old script's event handlers no longer linger on the object.
• Objects parented to scaled objects (like pickup items on a scaled pile) no longer randomly grow — or jump position — when players move between places or the room re-syncs. They keep the exact size and offset you authored, every time.
• You can freeze a character at an exact frame of an animation: mixer: { pose: { clip: 'Sit', speed: 0, time: 0.4 } } holds the 0.4-second pose instead of snapping to the clip's first frame — posed statues, card art, seated NPCs that sit HOW you posed them. Change time to re-pose; use it with normal speed to start a clip partway through.
• Things you delete now STAY deleted after restarts. In multiplayer rooms, deleting an object from a script (or having Savi delete it) used to quietly un-happen the next time the room came back — the room's memory resurrected the ghost. Deletes are recorded for real now, no matter who or what does the deleting.
• Editing your game from a phone in a multiplayer room now actually saves — before, those edits could silently vanish on reload.
• The engine's helpful heads-ups (notifyDm messages and built-in warnings) now reach Savi from multiplayer rooms too — and if one fails to send, it says so in the logs instead of pretending it went through.

Engine v5.2.21

Released August 7, 2026

• When a database operation takes a moment longer than a script run allows, Savi now gets a plain explanation — the database is answering, nothing hung, just re-run — instead of a scary "hung await" error that used to send her hunting for a bug that wasn't there.
• Physics (mantle worlds): characters and objects no longer catch on invisible snags while moving across smooth terrain and mesh seams, and worlds full of settled objects now truly go to sleep — an idle pile costs almost nothing, so big physics scenes stay fast.
• Fixed a case where "I've reported this to the team" was wrong: in some multiplayer rooms, engine bug reports Savi filed looked sent but quietly went nowhere. Now she's told straight away when a report can't leave that room, so she can tell you the truth — and reports that CAN be sent still go through exactly as before.

Engine v5.2.20

Released August 7, 2026

• Cleaned up engine diagnostic noise that every game session was quietly emitting — no visible change in your game, slightly less background chatter from the engine.
• While a model is still being made, its in-world stand-in now says so: "Making cat hero… takes a few minutes" instead of an endless "Loading…" — players watching a long cook know something real is coming and roughly how long, instead of reading the world as broken.
• Fixed frame pacing on some machines (many Macs included) where the engine misread the screen's refresh rate as faster than it really is and paced the game against a budget the display never had — those machines now run at their display's honest rhythm.
• When a save partially fails, Savi now gets told exactly which pieces failed and why — so she fixes the real problem instead of re-running things to figure out what broke.
• A typo'd shape name in a spawn now fails immediately with the list of real shapes (and a "did you mean"), instead of silently spawning nothing and breaking the next save.
• Notes and archived files in your scripts folder no longer break saving: a README or a .bak backup sitting in scripts/ used to make the game refuse every save read after an update — it looked like your character got completely reset. Those files are ignored now and your real scripts run exactly as before.
• Box-bodied cars and characters no longer catch on invisible seams in flat terrain — no more phantom stops at low speed or bumpy hops at high speed on ground that looks perfectly smooth.
• Reading a nested property path now just works: getProperty("primitive.width") answers what you wrote there. And bad values tell you what they wanted (a scale of "big" explains itself) instead of quietly shrinking your object to normal size.
• Spline verbs are honest now: a wrong option (like a misspelled space or a bad offset) tells you exactly what it wanted instead of quietly doing something else. And offsets written as [x, y, z] arrays just work.
• Fixed a bug where accidentally putting a function inside your saved state (even deep inside an object) could silently undo everything else your script just did. Now the function is simply skipped, everything else saves, and the log tells you exactly which key was skipped.
• Deleting a state key that has a dot in its name now works: deleteState([["dotted.key"]]) reaches exactly the key you wrote, and if you spell it the old way the log tells you the working spelling. And handing the state verbs something that isn't a state object gets a clear "call ignored" instead of quietly wiping your state.
• Coming back to your world after a disconnect no longer bounces you or your friends with "room full": a player who just dropped doesn't count as still occupying their seat while the game waits for them, so one-seat worlds stop turning away the very player they were made for.
• Terrain reads stopped inventing answers: asking for the ground at a broken coordinate (NaN from a divide-by-zero, say) now tells you exactly that in getLogs instead of quietly answering "the ground is at 0".
• When a bounds read comes back empty, the log now tells you why — a typo'd id, an object with nothing visible to measure, or a model that hasn't finished loading — instead of leaving you to guess which one you hit.

Engine v5.2.19

Released August 6, 2026

• Small windows render sharp: shrinking the game window no longer melts distant detail into mush — thin lines, far-off structures, and in-world text stay readable at small window sizes, because the engine now refuses to drop its internal rendering resolution below a legibility floor on ordinary screens.
• Places stop coming back empty: after a server crash or reconnect, a place players were standing in could lose all its objects until the room recycled — the world's cleanup sweep now notices an occupied place with no live copy and brings its objects back within moments.
• Fixed an issue where Savi wasn't able to manage your game's database properly — database setup and reads/writes she does on your behalf now land reliably in multiplayer rooms.
• Fixed an issue where crons weren't running properly — scheduled game work (timed events, recurring jobs) now fires the way your scripts scheduled it.
• Savi finishes her own checklist: when Savi completes something from your world notes (tab+f), she checks it off herself instead of leaving every done item hanging as "attempted" for you to sweep up — taste calls and anything you sent back for a redo still wait for your verdict.

Engine v5.2.18

Released August 5, 2026

• Sounds can now stick to the thing that made them: playSound(clip, { position, follow: true }) keeps a sound on a moving object instead of leaving it behind at the spot it started — your own footsteps, engine hums, and whooshes stay with you instead of trailing behind as you run.
• Spatial audio now always hears from the camera you actually see. Games with custom mouse-orbit camera scripts could previously get subtly wrong or mirrored panning while everything looked perfect — that seam is closed.
• Changes your game's scripts make to the game's own setup — input bindings, UI, camera, terrain settings, and more — now survive saves: a script could change these live and see the change silently erased the next time anything else saved the game. Now they stick.
• Games with lots of moving objects spend less engine time per frame on internal bookkeeping — positions, rotations, and scales are read without generating garbage-collector pressure, leaving more headroom for game logic at the same object count.
• Particle effects can finally layer in front of 2D backgrounds — spells, explosions, and sparkles in a 2D game draw in front of backdrop art instead of always hiding behind it. Effects and sprites now sort together by world position, so an effect between two scenery layers lands between them.
• Heat-haze and shockwave-style distortion effects no longer flash a ghostly rectangle that erases the effects behind them when their ripple settles to zero — an idle distortion is now invisible, exactly like it should be.
• Game databases work in multiplayer: scores, inventories, and anything your game saves with SQL now actually persists — including schema setup, which happens automatically.
• Performance readings got honest on iPhone: a GPU timing quirk could report absurd frame costs (literally the phone's uptime) — those readings are now filtered out at the source, so performance snapshots tell the truth.
• Games sit lighter in phone memory: an idle world no longer keeps ~24 MB of background job machinery resident, which means fewer iOS tab reloads on long sessions.
• One over-sized background job can no longer silently break all terrain and asset loading for the rest of a session — it now fails alone, loudly, naming what got too big. And the "server physics is paused" notice stops promising a wait will fix itself when it provably won't — past the warm-up window it reports the measured pause and routes to a bug report.
• Timed entities actually expire now, even when a player's device wedges: projectiles, pickups, and effects spawned with a lifetime no longer pile up frozen in the world — they end at their deadline.
• Changing another object's state now just works everywhere you can see it: edit .state on anything a query or a collision hands you and the change is real — no more edits that silently vanish because they touched a copy.
• Bot-heavy and query-heavy games get faster: reading state off query results no longer copies the whole state bag per object per tick, state writes do half the work they used to, and Savi's live edits over big worlds respond quicker.
• Editing scripts on big worlds feels snappier: each save no longer recompiles every unchanged library module from scratch, so the little freeze after an edit on script-heavy games shrinks to just the code that actually changed.
• Pinch zooms the game, not the page: every game gets two-finger pinch (and mouse-wheel) zoom by default — camera scripts that read the zoom channel keep full control of what zooming means, and games whose cameras ignore it get a sensible built-in zoom on phones and tablets.
• Big multiplayer worlds got faster to join and lighter to run: players now download and stream just the area they're in instead of the whole room, so joining a large world is quicker and crowded rooms waste far less bandwidth on movement nobody can see.
• Multiplayer rooms open faster: the world download now starts the moment the connection begins instead of waiting for the handshake — worth up to nearly a second on mobile connections.
• Multiplayer movement smoothed out: other players no longer freeze and teleport when they start moving, stop, or change direction — walking in any pattern now streams as smoothly as walking in a straight line always did.
• Music works in multiplayer rooms: jukebox tracks, stems, and fades now play for everyone — including players who join mid-track, who come in at the right point in the song instead of silence.
• Script-created things stop vanishing in multiplayer: cars, pickups, and anything a script spawns when a place starts now come back correctly when players travel between places — leaving and returning no longer leaves the world permanently emptier.
• Multiplayer ghosts are gone: a player who walks into your area now reliably appears, and one who leaves reliably disappears — no more invisible neighbors or lingering copies standing where someone used to be.
• Multiplayer uses much less data — player movement and world state now take 3–5× less, and catching up after joining downloads less — so rooms feel smoother on weaker connections and mobile data.
• Big terrain rebuilds can't knock a room over anymore: when a whole world's ground rebuilds at once, the server paces the work instead of freezing — no more "the room restarted and everything spawned in it is gone" after a heavy terrain edit.
• Games with lots of moving objects spend less time in memory cleanup — motion updates now recycle their bookkeeping instead of generating garbage every tick.
• Things spawned right after a save now come alive immediately — on script-heavy worlds, entities created during the few seconds after an edit no longer stand frozen (visible but running no scripts) until the engine finishes recompiling.
• 2D sprite edges are clean again — characters and props no longer wear a thin halo of sky color around their silhouettes when standing in front of tilemap ground.
• Editing large worlds is faster: applying a change to a world full of roads, power lines, fences, and rooms no longer re-derives every generated piece on every edit — an edit now costs work proportional to what actually changed (~4x faster applies on worlds full of generated pieces, and burst edits like big builder-script runs spend far less time in bookkeeping between steps).
• Heavy particle effects and layered music run smoother — ribbons, trails, and audio-rich scenes shed a large share of their per-frame CPU cost, with identical visuals and sound.
• Games with several AI-generated or uploaded 3D models hold dramatically less memory on phones — the engine now frees each model file's raw bytes once its textures reach the GPU instead of keeping whole files around, which is a big step against the "game reloads on iPhone" class of crash. Busy building sessions also idle lighter: landing model metadata no longer re-scans all your scripts, and big boot bursts no longer leave permanently enlarged buffers behind.
• Long sessions in sound- and media-heavy games use much less memory: decoded sound effects, warmed video clips, and edited-away material shaders are now released when nothing is using them (they reload on demand), which especially helps phones stay alive in big games.
• Games with lots of timers — every() loops, staged builds, scheduled waves — no longer pay a per-tick sweep over every armed timer, and the engine's own tick loop allocates far less, so long sessions hitch less from garbage-collection pauses.
• Invisible rotated walls: static boxes spawned with a yaw could, around busy spawn bursts and reconnects, collide as if unrotated — cars slamming into walls that measurably weren't there. Static colliders now always take their authored rotation.
• Switching a world's terrain type live actually works now — going from tile-based ground to heightmap hills (or voxels) no longer silently keeps the old ground stuck in place until the room restarts. And if a terrain setup ever fails to install, the log now says which place and what that means, instead of failing quietly.

Engine v5.2.15

Released August 4, 2026

• You can now put the game's "ear" anywhere — pin it to a ring-side mic, a security camera, or a moving NPC, and all spatial sound pans and fades from there instead of your camera. One place setting, and clearing it puts the ear right back.
• Statue false alarms gone: 3D models whose textures already ride our optimized format no longer trigger the false "content may be missing or wrong" warning. (Models with webp-only textures still render untextured by design — re-generating the texture is the road.)
• Savi can now see your game's HTML UI the way she sees your 3D scene: ask "what's on the screen UI right now?" and she gets the real list — every named element and button with its position, size, and whether it's actually visible — and "what UI is at that spot?" answers with the exact element stack, including an invisible overlay eating your clicks. No more guessing whether your menu rendered.
• AI characters walk properly. NPCs now truthfully report standing-on-ground and their real speed, so animation logic that checks those no longer traps a walking character in a looping fall pose — and scripts can read an NPC's actual velocity instead of guessing from position changes.
• Games boot a little lighter — the engine dropped nearly half a megabyte of code it never ran.
• Terrain textures now tile cleanly by default — the faint ghosted seams that could trace the texture grid are gone. If a big natural surface reads as an obvious repeating stamp from a distance, ask Savi to turn on anti-tiling for that one material (antiTiling: "stochastic") and the repeats decorrelate.
• Terrain edits during busy builds no longer stutter the room. When terrain changes land in a burst — like Savi reshaping a world while you play — the engine stops rebuilding soon-to-be-replaced ground over and over. A single terrain edit applies just as fast as before.
• Paintings keep their colour! Putting a soft or near-white color on a textured object no longer turns the art black-and-white — the texture shows its own palette. Strong colored tints still repaint the hue like always. One trade: a muted mid-tone color on a textured object now darkens the art instead of repainting it — if textured surfaces look darker after this update, brighten their colors or ask Savi to re-tint them.
• Landing on a platform's corner no longer locks your jump — corners that hold your weight count as ground.
• Editing a script no longer counts its creations as casualties — death effects only fire for real deaths.

Engine v5.2.14

Released August 3, 2026

• Safari no longer eats all your memory while a game sits waiting for its first click — the bug that could freeze a whole laptop on a quiet world is gone.
• The erase brush now erases every painted ground material at once — one pass returns the ground to its natural look instead of only removing the material you happen to have selected (paths and roads stay).
• Material brushes have a new Replace mode next to Paint and Erase: painting in Replace makes your material win by pushing the other painted materials out from under the stroke, instead of blending in on top. Plain painting is unchanged — it still layers additively, and brush strength still decides how strongly you cover the world's natural ground.
• Savi gets interrupted less while you build. Routine engine notices — a texture that didn't load, a clip name that doesn't exist, a placeholder holding while art generates — now go quietly into her logs instead of pinging her mid-conversation. She still hears immediately about real breakage (broken scripts, crashes, things that stop rendering), and about any problem that suddenly happens dozens of times at once.
• The stray scrollbar that could pop over your game's right edge (and make your game UI look broken) while art was spawning is gone.
• Savi stops getting blamed for axes the starter template ships. Every input change in a 3D game used to print five warnings telling her to remove lookX/aimYawSin-family entries that the platform itself put in the game — noise that could bury the real error when something was actually wrong. Those entries are now recognized as the platform's own, new games no longer include them, and the warning only fires for something that can genuinely break: binding a key or stick to an axis the engine computes from the camera.
• Placeholder images keep their shape while models generate — a tall character concept no longer renders squashed and stretched on its loading card.
• The touch stick on phones no longer freezes and vanishes when you move your thumb slightly. In games with on-screen UI, the browser could steal a touch a few pixels into a drag (it read the drag as a page-scroll attempt), which killed the movement stick, camera drags, and hand-rolled touch pads mid-gesture. Touches on your game now belong to your game from press to release — and your scrollable panels and lists still scroll exactly as before.
• Replace mode now does what its name says: painting in Replace pushes out the world's natural ground as well as other painted materials — a full-strength stroke leaves pure paint instead of a half-and-half blend. Erase still returns everything to natural, undo still takes the whole stroke back.
• Ground material transitions render crisper everywhere: where two materials meet you see the dominant one with organic speckle instead of a translucent wash.
• Terrain texture tiling now uses the same textureScale meaning as objects: meters each texture tile covers. If your world's ground suddenly looks ultra-dense, ask Savi to convert the old values (new = 2.5 / old).
• Games with multiple areas now work in every kind of room — walk between places with friends
• Savi can make heavy visual effects phone-friendly automatically — ask her to tune your look for mobile
• Characters with a single animation now play it instead of freezing in a pose
• Firefox players: sessions no longer die after tab-switching
• Faster texture loading on big worlds
• Multiplayer worlds with lots of places run smoothly again — the whole room no longer slows down as places fill.

Engine v5.2.13

Released August 1, 2026

• Cameras are yours now, all the way down. Savi writes your camera as a script she can read and edit — every zoom, follow, and framing choice is a line she can change — instead of flipping switches on fixed camera presets. Existing games keep playing exactly as they are; when a world upgrades to this version, Savi rewrites its camera as a script with the same feel.
• Crouch and prone finally have a real hitbox. Savi can now resize a character's collision capsule live — physics.capsule = { height, radius } — with the feet staying planted and the visible body untouched (animations own the pose). Standing up under a low ceiling politely waits until there's room instead of launching you through the roof, and shrinking always works. No more scaling the whole player down to a miniature to fake a prone hitbox.
• Game UI now boots on slow phones. Before, a phone that needed more than 4 seconds to fetch the UI shell was cut off at exactly 4 seconds, every retry started over from nothing, and the game's menus and HUD never appeared — no matter how many times you reloaded. Now the engine tells "slow" apart from "broken": as long as the UI shell is still arriving it keeps loading, retries wait longer instead of giving up on the same schedule, and only a truly dead connection gets a failure report (a clearer one, saying whether nothing ever arrived or it started and stalled).
• Reconnecting no longer looks like teleporting to your game's scripts. Rejoining, reloading, or coming back from a suspended tab used to make portal effects and travel triggers fire — the world-state snap read as a huge jump. Now scripts sleep through the join and wake to the settled world, and for mid-game re-syncs Savi can ask the engine "is this a real move or a sync?" (api.isSettling()).
• Ground-hugging objects that MOVE stopped eating your frame rate. Anything scripted to sit on the terrain used to rebuild its whole shape every beat it moved — even across perfectly flat ground — and with lots of movers that destroyed performance. Now the engine first checks whether the ground actually changed under it, and skips the rebuild when it didn't. Slopes, cliff edges, and terrain edits still re-drape instantly.
• Objects that couldn't fit on the GPU now appear as soon as room frees up. In long busy sessions, a newly spawned object could hit a full geometry table and just never render for the rest of the session — despawning things didn't bring it back. Now the engine retries the moment space opens. And when a rendering bug does get reported, the report finally carries the renderer's side of the story.
• Uploaded skies are finally sharp. A high-res panorama used as a skybox used to get squeezed through the same 1568-pixel pipe as every other image and come out smeared. Skyboxes now load a 4K version cooked from your original upload — horizon seams, planets, and cloud edges stay crisp.
• Savi can now ask the engine "can a player actually WALK from here to there?" and get a straight answer with the reason — "this step is 0.37m tall; characters can step 0.3m." Before, she could only check that floors and walls exist, so an unwalkable staircase looked identical to a walkable one until somebody played it and got stuck.
• Savi can now weld a pile of building blocks into one clean solid. Walls, walkways, and towers built from many boxes used to shimmer where pieces overlapped — now she merges them into a single seamless piece (one object, one collider), and the flicker class disappears instead of being nudged one seam at a time.
• Big worlds can fade things by distance now, without tricks. Savi sets a visible range on any object — "draw this within 700m", "draw the cheap far version beyond 700m" — and the engine handles the swap with no flash, no gap, and no flicker when you hover right at the boundary. City-scale builds stop strobing as you fly across them.
• 2D cameras can now be fenced at the TOP of the world, not just the sides and bottom — no more camera drifting up past the painted level into grey void during fast action. And if a camera-fence field the engine doesn't understand ever gets written, the engine says so by name instead of silently ignoring it.
• Traveling between zones can no longer bury you in the ground or a wall. Arrivals land on the destination's real, current ground — even when the spawn point went stale because terrain was dug, sculpted, or regenerated under it — and the crossing itself can no longer carry your old zone's coordinates into the new one. When the engine does have to lift an arrival out of the ground, Savi gets a log naming exactly which stored spawn was stale.
• Held items stop fighting the game over their size. In busy multiplayer rooms, a weapon or tool attached to a player could visibly snap between two sizes forever — the server and the player's machine each kept "correcting" the other. Now they agree on one size, the snapping class is gone, and if anything ever does fight over a value again, the bug report names the exact system doing it instead of blaming your scripts.
• Objects that sit on the ground now stay pinned to the ground when you edit them in god mode. Before, grabbing and sliding a terrain-pinned object (or just touching it with an editing gesture at the wrong moment) could quietly replace its "sit on the terrain" rule with a frozen height — and if the object happened to be mid-settle when you touched it, that wrong height stuck: things looked fine while you played, then reloaded half-buried. Now the pin itself is what saves: slide a tree and it's still a tree-on-the-ground at the new spot, lift it deliberately and it becomes a tree-floating-that-much-above-the-ground, and a touch that didn't move it changes nothing at all.
• Terrain stops going flat when texture generation is busy. New terrain materials get generated PBR detail (height and normal maps) from their texture, and while that generation was pending — or refused, e.g. for a too-small source image — the ground rendered as flat colored tint with no texture at all, sometimes for a whole day. Now the ground renders your actual texture immediately and the PBR detail upgrades in place when generation finishes. If generation refuses your texture, Savi now gets a report naming which texture and both ways out (upscale it, or turn pbr off) instead of a misleading "fix the texture reference".

Engine v5.2.12

Released July 31, 2026

• Buttons work on phones now. Action buttons Savi builds — especially in scrollable lists — used to die in mobile touch handling: you'd tap and nothing happened. The engine owns the tap now: a tap fires exactly once, a real scroll stays a scroll, and every existing game heals with no edits.
• One typo can't freeze a character anymore. A script error used to shut down the whole script after a few strikes — jump broken meant walk broken until the next edit. Now an error skips just that one call: everything else in the script keeps running, the broken path keeps being retried, and the fault report names exactly which hook failed and says the rest of your script is fine.
• Rejoining a busy room brings back the whole game now. A reconnect used to rebuild only the authored level — anything spawned during play (NPCs, dropped loot, bots) could silently vanish. Now the running world itself is reconstructable: refresh mid-game, or come back to a room everyone left, and everything that was alive is still there with its last state.
• Leaderboards are game data now. The separate window.spawn.leaderboard service is gone — Savi builds leaderboards with api.sql in your game's own database, where they can be shaped however your game needs (per-mode boards, weekly resets, friend filters). Games still calling the old API get a clear message telling Savi the one-line migration instead of failing silently.
• Savi can keep editing while players move between places. Starting a match no longer makes her edits time out.
• Characters can finally SIT — reliably. Savi has one explicit switch that stops the engine from fighting a seated pose (no more captains hovering over their chairs or drifting into the air), and she knows how to make a seat survive server reloads, so your bridge crew is still seated when you come back.
• Multiplayer rooms spend a lot less bandwidth per player. Solo play sees no difference, and the numbers your game reads are exactly the same as before. Full rooms just get cheaper and smoother.
• Terrain works fully in busy rooms now. Sculpts and terrain edits reach every player, and the ground loads from its saved baseline even when nobody's been in the room — no more flat or missing terrain that only appears after someone edits something.
• (Already live since the previous update — the notes just never said so.) Hold-to-interact, cooldowns, and any "stamp the time now, check it later" logic now work for every player, not just one. A crate that only one player could pry open, a pickup only one player could claim, a cooldown that never expired for visitors — all the same bug, fixed under the game.

Engine v5.2.11

Released July 30, 2026

• Savi can now measure your world instead of eyeballing it: asking for an object's bounds answers the real loaded size of models (stacking, fitting, and aligning become arithmetic), and while a model is still downloading she gets an honestly-flagged placeholder or a clear "still loading" note instead of a silent nothing — so things land ON tables, not 0.18m into them.
• Savi can now see your colliders. Ask her to check a collision problem and she can capture the world with the actual physics shapes drawn over it — including invisible walls and floors — instead of doing blind geometry math. The same look tells her whether the live world still matches what was built (a recycled room once silently un-solidified 143 islands; that class is now a one-glance read instead of a 20-minute hand-rolled sweep), and she can frame a shot on an invisible collider directly. If you use the debug inspector (?debug), its Physics tab now shows the same live-vs-spec verdict. Nothing changes in your game: the wireframes never appear on players' screens unless you toggled them on yourself.
• If the room restarts while you're in god mode, you come back cleanly in play mode — no more being stuck half-in/half-out where you move way too fast, look choppy, or the God Mode button does the opposite of what it says.
• Savi can no longer accidentally break your controls by deleting god-mode's internal camera entity while cleaning up — the engine refuses and tells her why.
• Your game's own buttons keep working while you're in god mode. Before, clicking a menu or HUD button you built did nothing until you left god mode — now the click reaches your game's code either way. God-mode flying and editing controls are untouched.
• A script that probes for an API member that doesn't exist (world.screen && world.screen.width) no longer crashes — the check just comes back false, and a one-time note in the logs names the near-misses. Calling a method that doesn't exist still fails loudly with the full list of what does.
• Savi can now ask the running game "what object is that?" — by a spot on the screen, a point in the world, or a half-remembered name — and get the exact object ids with their size and place, instead of guessing from her code map. Fewer wrong-object edits when you point at a thing and say "fix that".
• Characters can now hold a gaze: ik: { head: { target: { yaw: 180 } } } turns a head to face straight behind the body (any angle, any chain — degrees relative to where the body faces) with no bone math and no world point to keep updated. It sticks through world saves, follows the body when it turns, and a pose set before a model finishes loading simply takes effect the moment it lands — no more re-kicking scripts after restarts to straighten tilted heads.
• Friends joining a multiplayer game no longer break scripted objects for a moment (or for good): a car built by an onSpawn script could arrive "in pieces" — duplicated parts, physics jitter. Joiners now see the car exactly as it was built.
• Games left running on old engine versions could get "stuck": the room played fine for whoever was already inside, but every new join spun at "Starting game…" forever, and reloading just landed on the same stuck server. The platform now notices a room that keeps refusing to let anyone in, restarts it on the spot, and tells the waiting player honestly that it's retrying — so the next attempt actually gets in.
• Camera scripts that read a held key (a lean axis, a zoom axis, any inputs.axes entry bound to keys) no longer jitter on high-refresh displays. Holding the key now reads steady at full value every frame; releasing it still reads 0 the moment you let go. Mouse-look feel is untouched.
• Editing a generator script now updates every object built from it — including objects your scripts spawned at runtime and objects in rooms that restart later. Before, some of those kept geometry from the old version of the script forever, and players who joined after the edit saw nothing at all where they stood.
• Visual effects left behind by players who disconnected no longer pile up invisibly and slow your game down. One-shot effects (impacts, muzzle flashes, explosions) minted in the last moments before someone leaves used to be stuck forever — eating effect slots and CPU every frame for everyone still playing. The engine now cleans them up automatically, on the same schedule they would have cleaned themselves up. If you wrote a janitor script to sweep these, you can delete it.
• Sounds that fire on every click or hit — a creature's cry, a UI confirm — used to pile on top of themselves, getting louder and louder until they broke up. You can now say mode: "restart" on playSound and rapid retriggers replace the playing copy instead: one voice, steady loudness, no click. Sounds you don't mark keep layering exactly like before (gunshots still stack — that's their texture).
• playSound now always hands back a sound id, and stopSound(id) actually stops one-shot sounds too — cutting a long sound short finally works.
• Occasionally a save would report success but a busy game room kept serving the previous version until the next save happened to land — players saw old content, telemetry reported the old version, and nothing anywhere looked wrong. Rooms now detect that their copy of the game is provably behind a save they were told about and re-fetch until they catch up.
• Fixed another way a player in a multiplayer room could silently miss your latest save: if the one "new version!" message got lost, that player kept playing the old world until your NEXT save — with a lone player in the room, nothing would ever correct it. Now a player who missed the memo catches up within a couple of seconds, automatically.
• Live edits now always reach everyone in a multiplayer room, even through a brief network or storage hiccup. Before, if a player's client missed the ~3-second window to download your latest save, that player silently stayed on the old version of the game until your NEXT save — you'd see "saved", they'd see the old world, and nothing looked wrong on either side. Now the client keeps trying (backing off politely) until the save actually arrives.
• Roads are one mark now: give a road a spline of [x, y, z] points and the terrain flattens to your curve, the surface paints along it, and grass and trees keep off it — one source of truth instead of hand-syncing a flatten strip, a paint stripe, and clear-scatter patches that drift apart. Corners round like a real road instead of kinking at every point.
• When a player's game tab is running an older build than the server (usually right after we ship an update), their view could silently miss or mangle objects with no error anywhere. Now both sides say exactly what happened — and Savi can see it too — with the fix spelled out: that player reloads the page.
• Fixed the last known way a solo player could silently miss your latest save: in singleplayer, if the one "here's the new version" message from the server got lost, the player kept the old world until your NEXT edit. Now a game that provably missed a saved version quietly re-fetches it within seconds — while normal autosaves of the player's own progress stay exactly as quiet as before.
• Repeating textures on world sprites now behave like you'd expect: set uvRect: { x: 0, y: 0, width: 4, height: 1 } and the art tiles 4× across the sprite — it stays lit under your lights, batches like any other sprite, and clicks/raycasts hit it. Previously asking for a repeat silently turned the sprite into an unlit background plate that followed the camera.
• Scrolling parallax backgrounds (the camera-attached strip recipe) are unchanged.
• Multi-part actors (bodies built from parented objects) no longer stay dismembered. If a part ever comes unstuck from its body — the bug where heads and limbs froze in the air while the body walked away — the engine now re-welds it from your game's definition within a second, and reloading or rejoining a room always restores bodies intact.
• Scrolling a list inside a creator panel or any interactive game UI no longer also zooms the world camera behind it. The panel scrolls; the world holds still. Scrolling over the open world (or plain HUD text) zooms exactly as before.
• Games whose scripts read lots of objects per tick run noticeably smoother — reading an object's position no longer pays hidden costs for forty properties the script never asked about. On busy worlds this was the difference between a stable tick and visible stutter.
• If a playSound call carries an option the engine doesn't know (like an invented soundId:), Savi now gets told once — with the real option list — instead of the call silently ignoring it.
• If stopSound is handed an id that was never a real sound handle, it says so once (stopping a sound that already finished stays quiet — that's normal, not an error).

Engine v5.2.10

Released July 30, 2026

• Gear attached to a character's bones (armor, hats, held items) now moves welded to the body — no more trailing a beat behind when you run or spin. No script changes needed; interpolation: null workarounds can stay or go, they no longer matter.
• Editing a live effect now just works: save the .fx.js and every running emitter picks up the new program — no more destroy-and-respawn, no filename rotation. visible: false actually hides an object's particles now (and your own torch flame stops rendering inside your first-person camera), and fx.paused: true keeps suspending the deck like before.
• Fast vehicles and characters no longer hop on flat ground. The engine used to briefly lift the physics body ~25 cm at speed and float it back down — cars read as bouncing, and collision/traction wobbled with it. The body now stays glued at any speed; slopes, stairs, and kerbs still climb exactly as before.
• If your game's input map carries a binding that can't work — a misspelled key name, an axis declared with no source, an engine-owned axis name — Savi now sees exactly which binding is broken and why the moment it's written, instead of your controls silently half-working until someone debugs it. Working bindings are never affected by a broken one.
• Look scripts can now tile textures: ctx.texture("/cdn/paper-fibre.png", { wrap: "repeat" }) repeats past the texture's edge instead of smearing the last row of pixels into streaks across the screen. "mirror" reflects instead; offscreen targets take the same option.
• You can design your phone controls now: twin sticks, gas-and-brake pedals, drag-to-aim buttons, touch pads — and swap layouts per player mid-game (driving vs on foot). Savi can finally read exactly what's on a phone screen, and the engine tells her when a button didn't fit instead of quietly hiding it.
• Buttons in custom game UI can be held down now (sprint, charge shots), and hand-built on-screen sticks stop snapping back under your thumb.
• Fixed two ways a 3D model could silently render nothing: a model file the device can't decompress now reports a clear load failure (instead of an invisible "successful" load), and a model that's taking unusually long to generate now says so — to you and to Savi — instead of leaving empty floor with no explanation.
• NPCs told to walk somewhere while facing something — moveTo(target, { face: player.id }) — now actually keep facing it the whole way: backing away while aiming, strafing a range band, or sidestepping around obstacles no longer snaps their gaze to wherever their feet point. Drop the face option and they look where they're going again.
• When a game looks frozen because your tab is hidden (solo rooms pause while you're away — that's by design), Savi can now see and explain exactly that instead of chasing a phantom engine bug.
• Spawned models show their concept art in seconds now: while the 3D model is still generating, the spot where it will land shows a billboard of its 2D image (the one Savi's generation mints almost immediately) instead of just the loading swirl — and the real model replaces it the moment it finishes cooking.
• Fixed a silent failure where, in worlds with very many uniquely-shaped generated objects, newly added ones could stop appearing entirely — with no error anywhere — once a rendering batch filled up. The engine now tells Savi exactly which batch filled and what frees space, the moment it happens.
• Worlds with very many uniquely-shaped generated objects no longer hit an invisible ceiling where newly built things stop appearing: the rendering batches now grow with the world (up to what the player's GPU can actually hold, which is several times the old limit). If a device's true limit is ever reached, it still announces itself instead of failing silently.
• Savi can now actually see your game's UI when she checks it — before, a technical wall meant her UI checks always came back empty, and she could mistakenly report your HUD as broken (and prescribe reloads) while you were playing through it just fine. Her reads now also come with the engine's own delivery receipts, so false alarms about invisible UI stop at the source.
• On a shaky connection, multiplayer games no longer stutter backwards: NPC timers, animations driven by state clocks, and moving objects run by your game's scripts keep advancing smoothly instead of repeatedly snapping back a half-second every time the connection strains.
• On a bad connection that goes one-way (you can still see the world but the game stops hearing you), the server no longer yanks you back to your landing spot every ~30 seconds forever — after a few minutes of provable silence it tells your game to reconnect once, you land back in your own body, and play continues.
• Fixed a bug where nudging just one rotation axis (like rotation.roll) on an object could silently do nothing — the object stayed frozen at its old angle. Single-axis rotation writes now turn the object, keeping the axes you didn't touch.
• Savi can finally see what she builds: her inspection camera now carries your world's look and bloom (godray scripts, grades, vignettes — the same pixels you see), and she can read exactly where your sun is instead of guessing from shadows. Look work stops being "a bet until you turn around and look."
• If a scripted object's geometry script produces an empty mesh (nothing to draw), Savi now finds out immediately — the error log names the object and the script, and asking her to look at the object tells her the geometry came up empty instead of guessing it's still loading.
• Stepping off a moving boat onto a dock (or any ground) now cleanly ends the ride — no more being dragged along the pier at boat speed. Riders also survive players coming and going and tab-away/return without getting glued to the boat.
• Moving platforms just work now: stand on a boat, elevator, or any moving object and you ride it — walk around on deck at normal speed while it moves, jump and you keep its momentum, step off and you're free. No follow scripts needed, and the ride is glued at render cadence (no more shaking while the deck moves).
• Fixed a bug where long-running rooms could get stuck naming every new thing with the exact same id — weapons, projectiles, and effects would silently replace each other and cleanup would miss. Affected rooms heal themselves the moment they mint their next id; no reset needed.

Engine v5.2.9

Released July 29, 2026

• Saving a script in a world that rebuilds its objects (city generators, wave spawners, destroy-and-respawn builders) no longer makes everything blink out and back over and over — rebuilt objects land once and stay.
• When the room does refuse to create something (flood limits, permission gates), your game's log now says so by name instead of the object just quietly never appearing.
• Models you place while they're still being prepared now show up on their own once they're ready — no more invisible props that stay gone until everyone rejoins the room.
• When Savi checks the scene, a model that actually failed now reads as failed instead of "still generating" forever.
• Firefox players get your world instead of a black screen — a shader Firefox refused to compile is fixed, and every shader the engine generates is now checked against Firefox's rules before it can ship.
• Safari and iPhone players stop losing their session to "graphics device stopped responding" — a Safari bug the engine now works around automatically.
• Big outdoor worlds run roughly twice as fast on phones (one test iPhone went from ~15 to ~27fps), and phones get their own lighter bloom so glow effects stop eating the frame budget.
• Scattered objects (forests, rocks, crowds) now respect every setting you put on their template — most visibly castShadow: false: turning shadows off on a scatter of 400 trees actually turns them off now, instead of silently ignoring you and paying the full shadow cost.
• Savi got sharper at two things this build: kills in multiplayer combat feel instant for the shooter (no wait-for-server hitch in the death reaction), and floating-island worlds get true open sky below the horizon instead of a fake ground haze — she now reaches for both patterns on her own.
• When a texture script draws something but the texture comes out blank, Savi now gets told exactly that — instead of the engine calling it a success and leaving you staring at an untextured object wondering why.
• Fixed a runaway save loop: some games were silently saving new versions every second (one hit 2.6 saves per second, thousands of junk versions) — burning storage and making version history useless. Saves only happen when something actually changed now.
• Savi can now look at your game the way a phone player sees it — checking that menus and HUDs fit a small screen — instead of only ever seeing the desktop view.
• Side-facing walls (facing: 'x') with off-center doors or windows now collide where the opening is drawn — no more invisible wall in a visible doorway with a secret walk-through spot mirrored across the wall's center.
• Savi's 3D-model workshop got a box of professional modeling shortcuts — custom models come back with nicer edges and surface detail in one pass.
• Your game has a real database now — one save file per game, with your build room's data kept physically separate from live players' data. Savi writes ordinary SQL for save systems, load-at-join, save slots, shared world state, and analytics queries — and games that saved before the database keep every old save, carried over automatically.
• Misspell or invent an option on an effect sprite/ribbon/light and Savi now gets told exactly which word the engine doesn't know, with the list of words it does — instead of the effect quietly ignoring it and leaving everyone staring at a fireball that "should" have soft edges.
• Games with always-on regen, timers, or meters no longer flood their version history with a save every half-second — pure player-state ticks batch up quietly (real changes still save instantly, and nothing is lost if the room crashes).
• Ask for crouch in a first-person game and Savi now lowers the camera the way you'd expect, instead of tilting it toward the floor.
• Swapping or deleting sprite art mid-session no longer leaves the engine silently re-requesting the dead art every 10 seconds until someone reloads the room.
• Dragging a file from your computer onto the game view works now — the drop lands in the import overlay instead of vanishing into the game.
• Right after sending a voice message, tapping Tab opens the chat box again instead of doing nothing.
• Cold animation sheets no longer flash giant — the engine holds the whole last frame until the new sheet lands.
• Safari and iPhone players get another big speed-up: the engine stops using a rendering path Safari secretly rebuilds from scratch every frame, and three per-tick busywork loops that hit Safari's JavaScript engine hardest are gone entirely.

Engine v5.2.8

Released July 28, 2026

• Floating-island and sky-world builds: set atmosphere: { ground: false } and the world stops pretending there's a ground below the horizon. Look down past an island's edge and you see real sky haze deepening toward the depths — not the flat sea-colored band. One line, per place; everything else about the sky (day/night, clouds, stars, fog) keeps working exactly as before.
• Joining a world no longer risks a false "physics is slowing down" alert: the engine now waits out the normal loading blip (the first seconds after joining or entering a new area) and only reports physics slowdown to Savi when it actually persists for several seconds. Real slowdowns still get reported with the same numbers and fixes as before.
• Power lines got their poles back — a bare power line plants grounded poles with crossarms along the run again instead of leaving the wires floating in the sky. Want a cable strung between buildings with no poles? Say so: poles: false hangs it as one draped line.
• Games with HTML UI no longer risk a dead menu (or a soft-locked player) on slower devices. The UI's boot loader is now ~13x smaller, a busy device gets time to catch up instead of being cut off at 4 seconds, and if the UI ever does fail to appear it now quietly retries as you play instead of staying gone until a page reload.
• An accidental infinite loop in a script (like while (true) with no way out) no longer freezes the room forever. The engine stops the runaway loop after a very large budget (real game loops never come close), keeps the game running, and hands Savi a clear error naming the script and the loop so she can fix it — a teachable moment instead of a dead room.
• Terrain edits can no longer eat your ponds and paths by accident. Savi now adds, tweaks, and removes rivers, ponds, paths, and flatten pads one at a time, by name — so carving a new path can never silently wipe the pond you built yesterday. If anything tries the old wipe-everything write, the engine refuses and says exactly which marks it was about to delete.
• Multiplayer effects are honest about their reach now: targeting other players with audience: { kind: "nearby" | "place" | "all" } (or another player's id) on screenShake, vignette, sounds, and other juice never actually reached them — it silently played for the calling player only. The call still works exactly as before, but it now logs a clear note explaining that effects are self-only in multiplayer for now and how to do it right: fire the effect from each player's own trigger (onInput/onInteract/onTriggerEnter), or drop the audience option on world-anchored effects (bursts, decals, positioned sounds) — those already reach every nearby player.
• Fixed a leak where objects spawned with a lifetime (fireballs, pickups, timed props) could linger forever in a room whose only player closed or refreshed the tab and never came back — the room now cleans them up right on schedule even with nobody there.
• setObjectProperty("properties.light.intensity", …) now just works — keys written with the spec's properties. prefix resolve exactly like the bare key instead of being ignored with an "unknown property" warning.
• Fog values the renderer can't honor as written now tell you at patch time: linear fog with far <= near (which renders a hard fog wall instead of a gradient) and negative exp2 density (which renders like its absolute value) warn with the key, your value, and the allowed range — instead of silently rendering something you didn't ask for.
• Fixed a bug where scripts on a player rig couldn't reach the parts they'd spawned onto it — writes like api.setObjectProperty(api.id + "-gun", …) were silently thrown away with "entity not found" warnings even though the part was right there. Those writes land now: player-part color changes, attachments, and animations that never took effect come alive, and the warning flood that came with them stops.
• Looking up an object by a short id that doesn't exist is now effectively free instead of costing a scan of every object in the world — games that check stored ids every tick no longer pay a hidden per-miss tax that grew with world size.
• Fixed a multiplayer bug that hit solo sessions hardest: switching tabs (for example to chat with Savi), refreshing the page, or a brief connection stall could permanently desync your room — you kept playing normally on your screen while the room stopped counting your progress (pickups, health, wave triggers silently dead), and only a full room restart fixed it. Your progress now keeps counting across those interruptions.
• Debug dumps now show whether your game's UI is actually repainting: if a menu looks stuck on screen while the game itself is fine, the dump names exactly which step stopped — including HUDs the engine refused to mount because of a broken button handler, which previously froze silently.
• Fixed a multiplayer bug where switching away from the tab and coming back could leave you in a frozen copy of the world — everything you built or spawned after returning silently vanished for everyone else, and neither reloading nor restarting the room recovered it. The engine now detects that stuck state within seconds and re-syncs you automatically; your session picks up live from the real world state, no tab close needed.
• Explosions, magic, and weather can play real animation frames now — upload one sprite sheet and it just works
• Fog and smoke hug the ground and walls instead of slicing through them, and heat shimmer over fire actually bends the world behind it
• Shell casings, hail, and debris bounce — each piece with its own weight
• Effects can orbit, spiral, and tether between moving things with exact math, and they keep up on their own
• Lights ride your effects now (fireflies light the ground they drift over)
• Marks can grow and fade on their own — a blood pool that spreads, a puddle that dries
• Objects can burn away with a glowing dissolve instead of blinking out
• A whole weapon's feel — muzzle flash, tracer, casings, impact — fits in one effect file, fired once per shot

Engine v5.2.6

Released July 27, 2026

• Fixed a failure mode where a player could sink into (or bob on) one patch of ground forever with no explanation: if the game client repeatedly fails to build the ground under a player, it now stops silently retrying, tells Savi exactly which chunk failed and why, and shows the affected player an honest "reload to rejoin" message instead of leaving them stuck.
• Fixed a bug where models spawned by scripts with a layout.maxExtents size limit could render at their raw file size forever — giant enemies, or tiny ones invisible under a floating name tag — until the room was reloaded. Size limits now apply as soon as the model's real dimensions are known, and a size already computed elsewhere is never discarded while a client is still loading.
• If your multiplayer game polls getOverlapping()/getTouching()/isTouching() from server-side code, Savi now gets told once — with the reason and the fix (read contacts in the entity's own scripts and share results as state) — instead of the game silently answering "no contacts" forever behind a generic warning.
• When a game spawns more physics props than the simulation can carry (piles of falling crates, rain-of-weapons spawners), Savi now gets told once — with the actual numbers (how many dynamic bodies, how far over the tick budget) and the fix (despawn or pool spawned props, cap spawner counts) — instead of the room silently grinding to a slideshow with no diagnostics anywhere.
• Fixed mouse-only and touch-only games permanently losing input after interacting with the chat overlay: if the engine's input mode got stuck thinking the overlay was open, keyboard games self-healed but pointer games stayed dead until a page refresh. Clicks and taps now trigger the same self-heal keys always had.
• Fixed mouse clicks doing nothing in games built on the new engine UI layer — every world click was being cancelled by a focus bounce before your onInput code could see it (keyboard bindings were unaffected, which is why key controls kept working).
• Fixed right-click over the game world popping the browser's context menu instead of reaching your game, in normal play and god mode.
• Fixed multiplayer rooms losing their server-side scheduling after an engine upgrade: crons, lifecycle hooks, shared storage writes from crons, and custom jobs all worked on 5.2.4 and silently broke on 5.2.5 (storage errors like "A player can only read/write its own storage", jobs that never came back). Server-side execution stays on for these rooms now.
• Custom jobs submitted where nothing can run them now fail immediately with an error that says why and where the job runs, instead of hanging forever.
• Objects placed by ground height in a place whose terrain isn't set up no longer get silently pinned underground forever: the engine refuses to invent a ground of 0, says so once in the logs, and places the object on the ground automatically the moment the place's terrain arrives.
• In worlds with legacy sculpted terrain, "place on the ground" now means the ground you actually see — sculpt edits count for placement exactly like they count for walking.
• getTerrainHeight returns null instead of a misleading 0 when a place has no terrain — so scripts can tell "flat ground at 0" apart from "no ground here at all".
• Physics calls that can't work where you put them now tell Savi why, once, with the fix — instead of silently doing nothing. If your enemies never moved or your traps never triggered, this is the family that now explains itself.
• Fixed multiplayer rooms losing cron autosaves and disconnect saves that touch shared storage: those writes failed with "A player can only read/write its own storage" in some rooms. Crons and lifecycle hooks now save shared storage in every room; player storage stays protected from other players exactly as before.
• Your world's look can now use multi-pass effects: motion trails, glow that accumulates over time, dreamy feedback loops, and blur chains — all from the same look scripts Savi already writes.
• Generated characters and models stopped turning near-black in shade: models whose material never said how metallic it was were being treated as polished mirrors. They now read as normal matte surfaces — fabric, skin, and painted detail show again, including models generated over the last week and a half.
• Placing things on blocky (voxel) terrain now puts their feet exactly on top of the ground — no more objects sinking into blocks or hovering over them, especially in 2D worlds with small block sizes.
• Terrain queries far from any player now say "that part of the world isn't loaded here" instead of pretending it's empty air — so a probe 100 m away can't convince anyone (Savi included) that solid ground never generated. The log line that appears alongside explains where probing works and why.
• Characters can now ragdoll: api.ragdoll(enemyId, { impulse: [300, 150, 0] }) flips a rigged character into loose physics — it crumples with its running momentum, tumbles off ledges, and settles into a heap. api.unragdoll() stands it back up with a smooth blend into animation (no pose snap). Works on players and NPCs in mantle-physics worlds; ragdolls freeze solid after settling so a battlefield of bodies stays fast.
• In first-person games the player's shadow no longer vanishes: hiding your own body from the camera used to erase its shadow too — the shadow now stays on the ground while the body stays out of view.
• First-person weapons Savi builds now line up by construction: iron sights land on the crosshair from the weapon's own declared geometry instead of guessed offsets, and hands are authored in the weapon's frame so they can't drift off the grip.
• Savi can now actually see the code-authored models she builds for you (scripted and custom geometry) in her isolated preview before they enter your world — those pieces used to be skipped, so hand-crafted props were built blind.
• Signs keep their authored size and text styling everywhere: updating a sign's text (like a score or percent counter) can no longer reset it to a giant default board after the room restarts or players come and go.
• "Delete everything and start me over" now works in one clean step: when you explicitly ask for a full wipe, Savi can reset your world to a fresh starter instantly instead of dismantling it piece by piece. Switching starters while keeping your work stays protected exactly as before.

Engine v5.2.5

Released July 26, 2026

• Physics got a big quality pass in worlds using the new physics engine — cleaner collisions, fast objects stop tunneling, vehicles handle better, and things settle instead of jittering. Busy worlds also run noticeably cheaper.
• You can now stamp marks onto the world: footprints behind a walking character, skid trails behind a drifting car, splats where things land. Marks stick to the world — never to players walking through them.
• Characters that floated above the ground (some imported models drew way above their own bodies) now stand on their feet, and clicking them works where they're drawn.
• Saving an object into one room no longer deletes a same-named object from your other rooms — your building stays built.
• Stuck rooms fix themselves instead of wedging, and games can opt into resuming exactly where everyone left off after a room recycles.
• Purchases are now stamped by the server, so scripts can't fake who bought something — and as the owner you can test your own buyables for free again.
• Scheduled game jobs survive restarts and can call external APIs again — daily events and webhooks keep firing.
• Nameplates and other HTML labels can pin to moving things without any math, worlds with lots of tile art finish loading for new joiners, and letting go of the mouse mid-move always registers.
• Press F3 for one unified debug console — everything that used to be scattered across debug panels lives in one place.
• No visible change. Games with lots of scripts (and Savi's emoji in them) hold roughly 10MB less server memory per world, which means more headroom before a big world hits the per-room memory cap.
• Scripts can declare how often they need to think — export const updateSchedule = { every: 10 } (or { seconds: 0.5 }) runs update() on that cadence, and near: { tag: "player", radius: 50 } lets far-away objects sleep until someone gets close. The engine skips the skipped ticks entirely — no more hand-rolled tick % N gates — and api.setUpdateSchedule({ every: 1 }) wakes a script to full speed the moment it needs it.
• Worlds full of decorated, interactable-but-idle objects run measurably cooler: scripts that only react to touches, collisions, or timers no longer pay a per-tick cost at all.
• If your graphics driver crashes mid-session, you now get a clear "reload the page" prompt instead of a frozen black screen — and Savi is told your screen went dark so she doesn't misread her camera tools as a game bug.
• When Savi's object previews or scene views fail, the error now says why (for example, a lost graphics device), so she can tell a broken shader from a broken GPU session instantly.
• No visible change. When a player's graphics device dies, the engine's internal report now names the GPU and its memory pressure at the moment of loss, so device-specific crashes get diagnosed faster.
• Webhooks and external API calls from custom jobs work again in single-player rooms — fetch() inside a job script reaches the public internet with sane safety limits, so Discord pings, external leaderboards, and third-party APIs behave the way the docs always said they would. In multiplayer rooms, fetch inside a custom job keeps browser rules (CORS applies) — unchanged.
• Logging a huge value (like baked geometry) from a script no longer stalls the world building megabytes of log text — you get a compact summary like [Float32Array(34992)] instead, and everything ordinary logs exactly as before.
• Night skies are much cheaper to look at — starfields are now precomputed instead of recalculated for every pixel every frame, so GPU power draw no longer spikes when the camera points at a starry sky. Bright stars still twinkle live, and star brightness no longer secretly depends on your screen resolution.
• Fixed a progress-wipe loop for solo players on a bad connection: if your game got stuck in a way the engine's automatic recovery couldn't fix, 5.2.4 kept retrying that recovery every ~20 seconds — and each retry reset the place, wiping your unsaved progress in your own world. The engine now tries the automatic fix exactly once; if the same stuck state comes right back, it stops resetting your world and leaves the place frozen (your local progress intact) until the connection genuinely recovers or another player can host.
• Fixed lights (and other script-animated values) visibly flickering several times a minute in multiplayer games whose looks are driven by behavior scripts — spec refreshes used to briefly snap script-driven objects back to older values before the scripts re-asserted themselves.
• 2D characters can now stay perfectly straight while they walk. Engine-driven NPCs turn their body toward where they're going, and top-down sprites used to visibly tilt with that turn — walking villagers looked crooked or sideways. Set upright: true on a sprite (or ask Savi) and the art stays axis-aligned no matter what turns the character; cars, ships, and anything that should visibly turn keep working exactly as before.
• Games can now opt into UI that holds the same size on every monitor. If your HUD was built on a big screen and looks huge (or tiny) on other displays, ask Savi to normalize it — existing layouts keep working unchanged, they just scale to match every player's screen.
• Uploaded and generated (CDN) models now always get real collision shapes, even when their prepared collision shape can't be downloaded — the engine builds a collision shape from the model's own visible mesh instead of leaving a permanent invisible 1×1 m placeholder box. This ends the class of bugs where props ghost-rolled forever, players stood on invisible boxes, or objects reacted to hits with the wrong shape whenever a collider download failed.
• On Mantle-physics voxel worlds, placing a block into your own character (or digging and refilling under yourself) no longer freezes you in place forever — the character now pushes out of solid blocks to the nearest opening, the way it already worked on the default physics engine. If there is genuinely no opening (fully buried), you stay put instead of tunneling through blocks.
• On Mantle-physics worlds, uploaded/CDN models now collide exactly where they look like they should. Before this, a model's collision shapes floated half the model's height above its visual — balls flew through the bottom of scaled models, and dynamic models tipped and reacted strangely because their mass was centered too high.
• On Mantle-physics worlds, joints now pivot exactly where you author them. Before this, every joint anchor silently shifted by half the body's height, which made motorized platforms shake objects off and hinges swing around the wrong point.
• Night-sky fixes: the strange vertical chains of duplicate stars are gone (a hash precision bug), and stars stay crisp points instead of soft blobs when the engine renders below native resolution. Star brightness and layout keep their look; individual star positions reshuffle once.
• The bubble over objects that are still popping in now says "Loading…" instead of making it look like your world was re-generating its stuff on every visit. Nothing is being re-made — already-created things just take a moment to download, and the label now says so. Only genuinely broken things still say "Couldn't spawn."
• Your game can now declare player-settings defaults (e.g. reduced flashing on by default) and a perf ceiling in your game's settings — ask Savi to "make my game default to reduced flashing" and it's one edit.
• Players' accessibility choices always win over game defaults — a player who needs reduced flashing keeps it in every game, including yours.
• Dev-only conveniences finally work the way you'd expect: a script that checks api.getRoomMode() now gets the right answer everywhere — including the code that runs on each player's own machine, which used to always claim "live" even in your build room. Gate test spawners, debug HUDs, or level skips on it and they work for you AND everyone building with you, then switch themselves off in the posted game — no account checks needed.
• String lights, bunting, and power cables now hang the way you'd picture them — one graceful draped line through the points you place, bulbs and flags spread along the whole run. No more surprise forest of poles around your plaza! If you do want poles under a line, say so and they'll plant themselves along the run.
• Characters and machines you build from moving parts (each part moved by your scripts every tick) no longer leave a ghostly motion trail behind them — they now look just as sharp in motion as the built-in animated avatars.
• Your game's UI now runs in its own sealed sandbox. Everything you could build before still works the same way — buttons, panels, saves, sounds, drawing tools, tilt controls — but a game's UI can no longer reach into or break the Spawn page around it, and a crashing UI can't take the game down with it.
• When UI code does hit the sandbox wall, you get a clear message in the logs saying exactly what isn't allowed there, instead of a button that silently does nothing.
• Fixed terrain brushes, path drawing, and object handles sometimes only working for a single click instead of a smooth drag in god mode. Drags now track reliably every time.
• String lights got a glow-up: small warm bulbs that actually blaze, hanging under lines that sag deeper the longer the crossing — like real festoon lights across a plaza.
• String lights are properly dense now — a blazing festoon of ~2-3 bulbs per meter instead of a sparse dotted line, and you can tune it with bulbSpacing if you want lanterns instead of fairy lights.

Engine v5.2.4

Released July 19, 2026

• Fixed top-down (2d-top) characters colliding ~1m south of where their sprite stands: walking into a wall from the north stopped short, from the south overlapped, and the debug collider circle drew below the character's feet. Colliders now sit exactly at the sprite's feet regardless of the object's rotation.
• Camera scripts can now say exactly who owns the view: declare orientation: { source: "script" } on a custom camera and the screen shows precisely what the script authors (death cams, cinematics, forced framing — even while reading the mouse), or source: "look" for engine mouse-look at your declared sensitivity with getViewAngles() to read back what's on screen. Existing cameras are completely untouched — nothing changes unless a camera declares.
• Glowing models are back: materials using glowTexture: true (an emissive tint that glows through the model's own texture) render their glow again instead of a flat solid color — including rigid attachments on rigged characters, which now glow in the same tint as the rest of the model. If you put glowTexture on a model with no texture, on a scripted material or scripted part, or on a part that also wears its own texture, the engine now tells you why nothing glows instead of staying silent.
• iPhones opening a game they hadn't touched yet could get permanently marked as "slow devices": iOS slows the page's drawing until the first tap, the engine misread that slowdown as graphics overload, cut visual quality to the floor, and remembered the floor for every future visit. It now recognizes browser-limited frame delivery — even the deep kind — keeps the quality you actually earned, and never lets that state write itself into the device's memory.
• For devices that were already stuck at low quality by the old behavior: recovery is gradual by design — a stored quality setting fades out over 7 days unless a session confirms it, and one quality step lost at startup comes back each session, so a previously-affected device climbs back over its next few sessions rather than instantly.
• Worlds now load in whole scenes instead of objects popping in one at a time.
• God-mode clicking is more predictable: invisible helper objects no longer steal your click from the visible thing under the cursor, and parts glued to a character's bones no longer half-select.
• Long trails and heavy effects stop cutting out mid-stream in effect-dense worlds.
• Path glows and other fading trails now fade all the way out instead of leaving a faint ghost.
• Games can now upload images at runtime and use them as real assets (player-drawn art, generated posters, photo walls).
• Objects spawned with a lifetime now expire on schedule even if the player whose behavior spawned them disconnects or refreshes mid-lifetime — no more leftover markers, projectiles, or effects haunting a room until it restarts.
• Slow, precise camera look — orbiting an object while keeping it centered, fine aim adjustments — no longer stutters against the frame rate, especially on trackpads and high-refresh displays. Fast flicks are untouched: full speed, no added latency.
• Invisible data-holder objects (like a leaderboard's storage object) now show up in tag searches again — no more "No survivors yet" over a board that actually has scores.
• Scripts that chain thousands of .add()/.mul() steps onto a ctx.params value in a loop now keep that param live-patchable — changing it updates the material in place instead of silently rebuilding the whole shader every time.
• Scripts that build very long material or look chains in a loop (thousands of .add()/.mul() steps) no longer crash the material rebuild with a "Maximum call stack" error — they compile and draw like any other material.
• Single-player save systems now actually save your game: auto-saves, load-on-join, and save-on-exit hooks run inside the world you're playing instead of a stale server copy — no more progress resetting to an old snapshot after you close the game, and no more live sessions getting wiped back to a first-quest state by a reconnect.
• Single-player saves stop fighting a ghost: auto-save code in your behavior scripts used to also run in a hidden stale copy of your world, which kept overwriting the real save with day-one data. Now only the world you're playing in writes your storage.
• Walking and moving character sprites no longer ghost or smear under the high-quality upscaler — sprites now tell the renderer exactly how they moved each frame.
• Fixed getTerrainHeight() (and getTerrainNormal()) sometimes answering from the lower-detail terrain a device happens to be rendering — on stepped-down devices hilltop heights could read several meters low, so scripts placed or "corrected" objects into the ground. Height reads now always answer the true authored terrain, matching where y: { terrain: N } placements actually land, on every device.
• A physics engine crash inside a game now recovers by itself within a second instead of leaving the game's physics frozen (objects stuck in place, collisions dead) until the player reloads the page.
• Older worlds get their object sizes, attachment sockets, and model parts filled in way more reliably now — the game figures them out right in a player's browser using the same access that already renders the models, instead of a server that sometimes couldn't reach them.
• Sprites' sizes, ground anchors, and collision shapes stay perfectly consistent for everyone in a room, and load a bit faster on return visits.
• When a physics shape truly can't load (broken or removed model), Savi now gets one clear message about it instead of the engine quietly retrying forever.
• Grass and decorations no longer grow-shrink-grow repeatedly while a world first loads — the grow-in now plays exactly once per reveal, and far terrain streaming in never re-grows the field around you.
• Timers set with runInSeconds/runInTicks no longer vanish when a player alt-tabs or reconnects — they hold and fire as soon as that player is back. Timers set by a player who then leaves still end with their tab: for deadlines that must survive that, use spawn lifetime or a target tick in state.
• Big built worlds got dramatically faster: the engine's per-tick bookkeeping for object hierarchies, world hashing, and script writes now scales with what CHANGED instead of how big your world is — a 7,000-object world that was spending its entire frame budget on bookkeeping (and freezing ~150ms every time a script wrote something) now pays almost nothing for the same edits.
• First-person held items are real now: attach a gun, tool, or hands to the camera (feetPosition: { attach: "camera" }) and it rides the view with zero lag — full 3D models and meshes, not just sprites. Add material: { depthTest: false } (models honor it now too) and the held item never clips into walls. Savi knows the whole recipe: aim-down-sights, bob and sway, per-player viewmodels.
• "Press E" prompts stop haunting you: interact prompts hide when their object is invisible, gone, or already in your hands — no more permanent "Take" prompt floating on the gun you're holding.
• Material scripts that displace a surface (mountain relief, painted planets) can now read the surface normal while doing it — those looks compile and draw instead of falling back to a bare white shape.
• When a look transition can't fade (scripted looks snap by design), Savi is now told at the push — with the recipe for doing the fade inside the script — instead of promising you a smooth dissolve that hard-snapped.
• Saving a script edit no longer freezes the room: the new version boots in the background while the game keeps running, then swaps in an instant.
• Savi's changes reach your game much more reliably in singleplayer: rooms with no tab open run the change on the server, a hidden tab answers honestly in ~2 seconds instead of stalling Savi's turn for 20, and work a hidden tab can't do reroutes to the server instead of failing.
• A game that can't finish joining now fails fast and loud instead of holding you on a silent black screen forever.
• Music and sound generation that hits your hourly budget now waits politely and resumes when the window lifts — and Savi is told exactly which sound is capped — instead of that audio silently dying for the rest of the session.
• Destructible worlds keep their damage across script saves: geometry your scripts carved or changed at runtime no longer snaps back to pristine while the collision still remembers every crater.
• When an image or model is blocked by content policy, you and Savi learn immediately that it was rejected (and why) instead of watching a fake "still generating…" countdown for something that was never coming — only a reword can fix it, and now Savi knows that.
• Way fewer duplicate error alerts while you build: one broken script is one report (re-armed when Savi actually fixes it, not on a timer), and a script hammering a missing object logs once a minute instead of tens of thousands of times.
• Sprites no longer vanish for the rest of the session after you tab away: stuck texture loads time out and retry, failed GPU work re-tries itself, and returning to the tab revives anything that broke while you were gone.
• When the physics engine itself crashes, the errors now say so — instead of blaming your game's scripts and sending Savi chasing a bug that doesn't exist. You and Savi both hear about it honestly, and a reload cures it.
• Flat painted ground is a real look now: terrain with a tint and no texture stops warning forever about a "missing texture" you never wanted in the first place.
• Multiplayer places no longer wait on a player who never finished loading while a fully-loaded player waits.
• Savi learned to carry run state (inventory, dice, boarding passes) THROUGH place transitions the reliable way — seeded on the travel itself — instead of passing it through storage, which can lose it at the boundary.
• Dense top-down and 2.5D worlds with lots of depth-sorted sprites (ySort) run dramatically faster — hundreds of trees, bushes, and props that used to each cost their own draw now share batches, with pixel-identical layering (soft-alpha cutout: false sprites keep their old per-sprite path, so their layering is unchanged too).
• ySort on ordinary sprites is now free: give it to everything on the interleaving layer without a performance tax.
• Fast-paced worlds that spawn lots of physics props (bombs, projectiles, debris) no longer slowly lose their visual effects: entities the room silently dropped used to linger invisibly and eat effect capacity until explosions just stopped rendering — now they clean themselves up within seconds, effects included.
• A model that genuinely has no collision shape now tells Savi so once, clearly — instead of the engine silently re-asking forever and slowing down every other asset load in your world.
• Physics objects no longer twitch while rolling after bumps — a rolling ball or tumbling cube keeps its spin through network corrections instead of freezing and jerking.
• Savi now gets a log when a squash amount is out of range instead of silence.
• Savi's script edits now reliably wake up in your world — including worlds nobody has open — instead of occasionally sitting inert until a reboot.
• Saving a script edit can no longer kick everyone out of the room: one save is one seamless background swap, even when several update signals race.
• Mouse-look games with on-screen HUD panels no longer trap your cursor: click the game world and you're back to looking around, with the panel still on screen. Real menus and dialogs keep the cursor until you close them, like always.
• Savi now gets an accurate explanation when event handlers set up while spawning an object don't stick — the error tells her exactly where to move them, so she fixes it on the first try instead of being pointed back at what she already did.
• Panels you've already clicked past no longer flicker the cursor back when their UI re-renders — the engine now recognizes a re-rendered panel by its id even when the re-render rebuilds the element.
• Night scenes and colored atmospheres finally show the color you authored: a deep navy vignette is deep navy, a 9% haze reads as 9% — dark looks stop washing out into a pale veil.
• Multiplayer places no longer freeze up permanently when one player's connection quietly breaks one way — the room notices within seconds and keeps going on its own, instead of needing Savi to restart the room.
• Equipment and body rigs are one declaration now: give any object tree parent: "player" and EVERY player in the room wears their own copy — swords, boards, flashlights, full composed rigs — with no pooling scripts, no ownership wrangling, and no more "works with one player, vanishes with two."
• Fixed a loading screen that could stay stuck at "Starting game…" over a game that was actually running — anyone hitting it had to be told their world was fine; now the curtain lifts as soon as the game is drawn and its content is loaded.
• Fixed a bug where games with a custom camera and no camera script (common in UI/card games) got stuck on "Starting game…" forever. They load normally now.
• Custom player models set from scripts finally obey your animations: the default avatar's built-in walk/run no longer hijacks a model your script dressed and animated — your idle/walk/run play the moment your script writes them.
• Savi's singleplayer fixes land even when your tab is closed or hidden: her script runs on the server instead of failing with "no client" — the biggest remaining class of "Savi said she fixed it but nothing happened" in solo worlds.
• Savi's teaching got truer in the corners: she now knows spawned objects must live in a resident place to replicate, that one building is one place (no more place-per-floor), how to stamp bone-mounted equipment on every player, and to let YOU be the judge of whether a fix worked.
• Tilemap tiles can animate now: stack frames vertically in a tileset atlas and set tilesetFrames + tilesetFps — shimmering water, flickering torches, whole layers playing in lockstep. Worlds that don't use it render exactly as before.
• Deleting a state key finally sticks: patchState({ done: undefined }) survives restarts, and the new api.deleteState("cells.3,4") deletes nested keys — no more stringified-doc or tombstone workarounds for "clear".
• Bulk property writes (batchSetObjectProperties, setPositions) made in persistent scripts now save like single property writes instead of silently reverting on reload.
• Cursor-followers stop freezing during movement — the pointer ray now always tracks the camera you see. Cursor rings, placement ghosts, and aim markers stay glued to your pointer while you move.
• When an art or voice budget runs out mid-build, Savi now learns the real time generation resumes — no more silently missing sprites, and no more "back in an hour" promises over a parked daily budget.
• Terrain with small repeating ground textures stops reading as an obvious grid from above: tight repeats now get the natural per-tile variation they were always meant to have, while larger hand-authored patterns (8m and up) keep their exact look. Cliff sides are unchanged.
• Passing a long digits-only string to a drawn-art texture script no longer scrambles it into a giant number — encoded pixel payloads arrive exactly as written, no letter-prefix workaround needed.
• Sound range finally means what it says: give an ambient sound a maxDistance and it fades out smoothly and goes fully silent at that distance, instead of carrying across the whole map. playSound can take a maxDistance too.
• api.getInputRay(input) now returns exactly the ray through the pixel the player saw — cursor-following objects (rings, placement ghosts, aim markers) no longer lag or land offset from the cursor while the character is moving.
• Mouse button releases can no longer get lost under heavy pointer movement: a short press during fast mouse motion releases exactly when the player lets go (held actions stop, keyup-pulsed actions fire).
• Fixed a multiplayer bug where every light in the room could flicker off and back on (about a fifth of a second, sometimes twice in a row) while someone was editing the game. Spec updates that needed a full refresh used to rebuild the player's whole world; now they refresh just the game spec, invisibly.
• Rays now hit what players see: api.raycast intersects visible sprites by default — paper enemies, sprite tiles, and decor are targetable without adding physics bodies. Billboarded sprites are hittable from every direction, exactly like they're visible from every direction. Pass { includeSprites: false } if a ray should only see physics colliders.
• Fixed billboard sprite picking testing a quad mirrored below the sprite's feet.
• Voxel edits no longer flicker back to the old state when the world is busy: placing or clearing blocks next to active automata (flowing water, busy zoo ponds) used to show your edit for a frame, revert it for about a third of a second, then re-apply it. Your edits now stick the first time.
• Player sprites keep the size your scripts give them: wearing a skin with an explicit sprite.size no longer snaps to the artwork's minted height when the engine's sprite metadata arrives (the "my character grew mid-walk" bug). Skins worn without a size still auto-size from the asset's declared world height — including when a player jumps straight from an explicitly-sized skin into an auto-sized one.

Engine v5.2.3

Released July 15, 2026

• Fixed god mode getting stuck at an invisible floor in games with terrain turned off — you can now fly down to builds below height 0 instead of being silently held at the old ground level.
• Fixed characters sometimes staying squashed after a fall — the un-squash now always completes, even on slower devices.
• Recoloring or retexturing your terrain no longer hitches the whole game — tint and texture changes now apply in a blink (roughly 10× faster) instead of quietly rebuilding the entire landscape each time.
• Retro pixel looks are razor sharp again. If your game renders at a chunky low resolution on purpose (PS1/N64 vibes), you get crisp pixel stairs back instead of the smoothed-soft image the new renderer's anti-aliasing was giving you.
• Savi learned professional 3D tooling — she can now build game assets in Blender 5 (scattering, fracturing, tree generators, UV cleanup and more) and checks her own renders before the art lands in your game.
• Rivers, ponds, and oceans can now wear fully custom looks — Savi can write a shader just for your liquid (glowing lava, cartoon water, murky swamp) instead of only styling the built-in water presets.
• Art your game draws in code now works in your HUD and menus too — the same textures your scripts paint can show up as images in game UI.
• The game quiets itself while you record a voice message, so your words come through clean instead of competing with your own soundtrack.
• Sun shadows got cheaper while the camera moves — big outdoor scenes now spend noticeably less GPU drawing the same shadows, which means more headroom for everything else.
• Animated art your game draws in code now animates in menus and HUDs too — a flickering torch or spinning coin painted by a script plays in your game UI the same way it plays in the world (it used to show only the first frame).
• When one broken model spawns in lots of copies, you and Savi now get ONE clear error naming the model instead of a flood of identical errors — the flood used to bury the actual problem.
• Trying to remove a player's custom look could silently bring their profile avatar back — it looked like the removal failed. Savi now gets told exactly what happened and how to actually clear it.
• Savi edits game files with sharper, more reliable tools — fewer fumbled edits and clearer errors when a change doesn't land.
• Savi can now restyle the parts of a 3D model separately — glowing brake lights on a car, a marble fountain with brass spouts, a new texture on just the roof — by naming the model's built-in parts. No model re-export, and it works on animated characters too.
• Removing a mod now checks that nothing in your game still depends on its files first. If something does, you get a clear list of what to fix instead of a broken game.
• Fixed multiplayer worlds sometimes refusing to spawn things for several seconds (or minutes) after someone alt-tabbed or hit a network blip — a moment of turbulence no longer stalls the world.
• Savi can now keep track of the walls, boxes, and props she builds with her quick shortcuts — hide-and-reveal effects (like roofs that peel away indoors) and interactive doors work reliably instead of silently losing track of pieces.
• Savi builds better platformers on the first try — players standing on moving platforms now ride them smoothly instead of sliding off or overshooting at the turnaround.
• Savi can now offer a "craft pass" on a part of your game that's grown messy from lots of small changes — same behavior, sturdier bones — and she'll tell you honestly when it's not needed.
• Spawn something and use it right away — it just works now. Shots that fire the instant they spawn, portals that teleport on creation, chains of spawns acting on each other: no more "entity does not exist on the server" errors, and no need for little delays before acting.
• Objects wearing legacy or unsupported materials now show up with a plain fallback look instead of turning invisible, and Savi is told exactly which object and material need re-authoring.
• Grass, flowers, and terrain decorations now appear smoothly instead of popping at nearby distance bands, while using much less graphics memory.
• Decoration slope and height rules plus clear-scatter zones now work consistently, and sprite decorations can use cropped texture regions with custom ground anchors.
• Overlapping pixel-art trees and props now keep the correct front-to-back order as the camera moves.
• Sound effects no longer crackle or pop when several loud loops play at once or when your scripts fade volumes and pitches every tick — loud mixes are caught by a safety limiter and volume changes glide instead of stepping.
• Switching to another tab no longer makes the engine think your game is running slowly — no more false low-framerate alerts to Savi or your custom materials getting paused while you're away.
• Your game can always tell who the current player is: the player's account id is now consistent across every script surface, in singleplayer too — no more empty ids that made per-player saves unreliable.
• Fast-travel and portal trips no longer leave screen effects stuck on: temporary looks (like a warp overlay) and camera lens changes (like a widened FOV) from the previous place release automatically when you arrive, instead of persisting until a refresh.
• A script bug that produces an invalid camera FOV can no longer permanently warp the view — the camera holds its last good lens and the problem is named in the logs.

Engine v5.2.2

Released July 14, 2026

• Fixed sprites and objects that had stopped moving randomly lurching a few pixels out and back in quiet scenes (most visible on parked critters in 2D games). Resting entities now hold their position exactly until they actually move again.
• Savi can now see everything playing in your world — the soundtrack, every looping sound effect (with the handle to stop it), and every object with a sound attached — in one read, api.audio.playing(). Great for hunting down that one rogue sound.
• If your game music points at a file that can't load, Savi and you now get told ("no client could load … Is the asset loadable?") and the game stops pretending it's playing — before, it reported a silent track as playing forever.
• Asking to stop music when nothing is playing now says so instead of silently doing nothing.
• Savi can now check the water level at any spot in your world. Before, asking the wrong way silently answered "no water" — even over a healthy ocean — which could make working water features look broken and send fixes chasing a problem that wasn't there.
• Fixed worlds sometimes loading with a washed-out white/grey sky (fog and sky settings silently not applied) that stuck for the whole session until someone touched the atmosphere. The engine now re-asserts the sky on its own once the world finishes loading, and logs when a boot-time loss was healed.
• Objects and effects no longer flash as dark solid shapes while their textures are still generating or loading — a decal, particle, or textured shape simply stays invisible until its art is ready, then appears correctly. If a texture fails to load, the object stays hidden instead of rendering as a wrong-looking solid block.
• Fixed a failure where every custom material in a world could go grey/plain mid-session and only a page refresh brought them back. A renderer error is now contained to the one thing that failed — the rest of the scene keeps updating — and material rebuilds retry on their own.
• Fixed players arriving in 2D scenes stuck facing the wrong way — rotation carried over from the previous area (or snapped toward the teleport jump) used to stick to the player sprite and its nameplate. Entering a 2D place now lands with clean facing, while rotations your scripts set on purpose still work.
• Fixed lights and shadows sometimes jumping or looking wrong for a while after the renderer recovers from a GPU error. Shadow maps are re-rendered after a recovery instead of reusing stale copies.
• Authored animation clips now play in multiplayer worlds. Clips you define as motion code (export function swim(t) played with updateChannel) used to work only in singleplayer — in a multiplayer room the character froze in rest pose while the console warned the clip wasn't found. The same script now animates the character for everyone, immediately for the player who triggered it.

Engine v5.2.1

Released July 14, 2026

• Growing black patches are gone. On some machines, dark blotches could appear on screen (worst at night) and spread until they swallowed the whole view — reloading didn't help. Fixed at the source, for good.
• The realistic night sky no longer shows irregular black patches after dark — stars and the Milky Way shine everywhere they should.
• Walls, floors, and objects with realistic (PBR) textures stopped showing up after the 5.2 update — they render again, textures and all.
• Scripts that do heavy work in bursts (every few ticks) used to slip past the safety net and could grind your game to a halt until the tab crashed. The engine now catches them within seconds and pauses them with advice that actually fixes the problem.
• If the game picture ever freezes while the game itself keeps running underneath, you now get a clear "reload" prompt within seconds — no more silently stuck screens you have to diagnose yourself.
• The volume slider works every time now — it applies immediately to all game sound, including sounds already playing and music or videos inside game menus.
• Two looks that quietly changed in 5.2 are back to how you authored them: glowing objects (suns, halos) can shine through fog again when you told them to, and see-through cutout surfaces once again hide what's behind them.
• Models no longer get stuck as placeholder rings after a room hiccup — when the connection comes back, everything finishes loading on its own.
• Ask Savi for a "free cursor plus hold right-click to look around" camera and she gets it right now.
• Right-click selection works on every object again, whatever material it wears — objects with custom scripted looks had stopped being selectable in build mode.
• Savi can now convert a world you've already built to a different starter kind (like 2D ↔ 3D) — you see exactly what would change before agreeing, your creations survive, and any starter scripts you'd edited are parked for reference instead of deleted.
• "Fires once" effects — fire-pit coal beds, one-shot bursts — no longer vanish permanently for players who joined while the world was still warming up.
• Built-in rain, sparks, and fireworks read as real motion streaks now instead of a wall of tilted cards.
• Converting a 2D tile place back to heightmap terrain no longer flattens the ground to zero wherever tiles had been painted.
• Pressing interact no longer triggers an action twice when a key and a controller or touch gesture share the same binding.
• Cliffs and steep terrain show their real rock strata again instead of vertically stretched streaks.
• The blur effect works again — death flashes, dash juice, and scripted blur looks that went quietly sharp in 5.2 are back.
• Big lakes no longer draw over nearby bushes and shore objects at certain camera angles.
• Scripted looks on model parts and decoration layers now survive save and reload instead of silently reverting.
• Slash and shockwave effects no longer flash a black wedge from certain angles.
• Objects anchored to terrain stop visibly bouncing on other players' screens while terrain is edited live.
• Name tags and floating text stay crisp while whatever they're attached to runs around — no more smeared, doubled-up labels on moving players.
• Savi no longer gets falsely told a texture script "was not found" after you switch objects off it — retired paint scripts step aside quietly, keeping whatever they last drew on screen.
• Switching between games in the same tab no longer wedges the world when the previous session was a live/play session — the engine cleanly resets to the new game instead of refusing its updates.
• Camera scripts that set their own yaw/pitch every tick — locking the camera on your killer during a death animation, cinematic snaps, forced framing — now actually control the screen again in mouse-look games. The engine used to keep following the mouse and silently ignore what the script wrote; now the script wins the moment it disagrees, and normal mouse look stays as smooth as before.
• When your game's renderer dies mid-session — including the "GPU error storm" way, where the screen silently freezes while everything else looks alive — you now get an honest reload prompt within about a minute instead of never, and Savi is told your screen is frozen so she stops narrating changes you can't see and suggests a refresh instead.
• Worlds heavy on foliage, fences, grates, and other see-through-cutout surfaces render faster — especially on phones and tablets — with zero visual change.
• Fixed a family of silent failures when addressing objects by the wrong name: deleting or editing an object that doesn't exist now says so (and if you used a list position like "5", the message names the object actually sitting there); reading the spec by list position tells you the object's real id; and objects attached to the camera (HUD elements, music emitters) now show up when you list objects by tag.
• Fixed a bug where a player whose tab sat hidden while players came and went (or who was mid-session when the room restarted) could get permanently out of sync — ghost objects only they could see, builds half-applied — until they manually reloaded. The server now detects the stuck session and quietly re-syncs it within seconds; nobody has to leave and rejoin.
• Rewriting painted fields through spec edits (or cancelling a brush stroke) now updates everything that reads them at once: the terrain mesh, NPC pathing, terrain-anchored props, scatter beds and their footprint ribbon, instanced scatter, and painted foliage density all pick up the new paint immediately instead of keeping the old state until something else changed.
• Some iPads and phones were being drawn blurry and sparse for no reason: when the browser itself limits how fast frames arrive, the engine kept cutting visual quality trying to fix a slowdown the graphics weren't causing. It now recognizes that situation, gives the quality back, and keeps the game exactly as smooth as the browser allows.
• When a device limits its own frame rate (Low Power Mode, battery saver, browser throttling), the player now sees one small note saying so, and Savi gets told it's the device's environment — not the game — so neither of you burns an evening debugging content that was never the problem.
• Fixed a shimmer where nested see-through objects (like layered translucent shells around one center) rapidly flickered over each other once they split into multiple materials — the draw order between such layers is now steady frame to frame.
• Fixed a bug where a mod's on-screen HUD (buttons, sliders) stopped working after installing the mod into another game, even though it worked fine in the mod's own dev game — HUD button presses now reach the mod's scripts in fresh installs.
• NPCs now see the hills you sculpt: units path over (and get blocked by) god-mode-raised terrain instead of walking through it at ground level, and re-route as soon as you keep sculpting.
• Fixed a bug where a look pushed by a script (fog, murk, color grades via pushLook) could permanently fail to appear — with a wrong "script not found" error — even though the script file existed. Look edits now show up, and the error only appears when the script really doesn't exist.
• Games whose scripts persist changes every tick — spawning crops, saving building edits, updating persistent object properties — no longer freeze for seconds when their world re-syncs.
• Pixel-art sprites no longer shimmer or crawl at fractional camera zooms — texels stay crisp and stable while the camera pans, at every zoom level instead of only exact integer scales.
• A leftover broken terrain-mark entry in your game's data can no longer crash the whole server over and over (it used to force restarts and spam error DMs). The engine now skips the broken entry, keeps your rivers, ponds, and roads working, and logs which entry to delete — and the way it used to sneak into your game (deleting a terrain mark that didn't exist) is fixed at the source.
• Savi now finds out when one of your game's textures fails to load or draw on players' screens — before, those failures only appeared in the player's browser console, so she could confidently ship a broken visual without knowing. She also stops promising that a script interrupted by a hidden game tab will run by itself later: she'll tell you plainly the change hasn't happened and ask you to keep the game on screen so she can retry.
• Tiles your game's scripts dig, sow, or paint now stick in multiplayer: they reach the server and every other player, survive rejoins and players coming and going, and save with the world — no more garden beds wiped back to grass mid-session.
• 2D tilemaps no longer show faint vertical or horizontal seam lines at certain zoom levels — tile edges stay clean at every camera zoom instead of occasionally sampling a sliver of the neighboring tile in the tileset.
• Fixed a bug where leaving a testing/monitoring client alone in a multiplayer room could freeze the game world and make Savi's script runs time out — rooms now keep running, and recover the moment a real player walks in.
• Fixed props with custom-shaped colliders sometimes losing their real collision shape for a whole session (players could clip into trees, rocks, and vehicles that looked solid). The engine now recovers the real shape instead of getting stuck retrying a dead-end fetch.
• Physics objects that end up turned exactly halfway around (180°) no longer read back facing the wrong way.

Known issues (being worked on staging right now — this version stays in testing until the first one is fixed):

• Houses and other multi-part builds can visibly wobble between two positions. This one blocks the release: the version won't go out while it's happening.
• Fast-moving flat sprites (2.5D characters and props) can look blurry or ghosted in motion — a top-priority fix is underway in its own thread.
• Some floating text can still smear while moving (name tags over players are already fixed in this version; the rest is in progress).
• On flat worlds you can sometimes see where the ground stops being drawn at the far horizon — a known design limit being redesigned.
• Worlds with lots of sounds recover automatically instead of going silent.
• Grass and ground cover now reach the horizon on desktop.
• Distant grass fills the horizon better on flat worlds: blades near the edge of the grass field stand a little taller, so the field covers the bare ground beyond it instead of stopping in a visible line.
• World labels stay sharper and steadier while the camera or their parent moves, and tiny distant text fades away cleanly instead of turning into shimmer.
• In 2D worlds, text can use sortingLayer and sortingOrder to sit between sprite layers, while ordinary signs and unlayered labels still obey walls and other foreground geometry.
• Reverted a camera change from this release that caused a stutter/jump-back while rotating in games with custom camera scripts. Custom camera scripts that write yaw/pitch every tick return in a later release.
• Layered flat effects (cracks, decals, panels) now stack in the right order from every camera angle.
• Fixed brand-new worlds crashing on their first load when dense ground decoration was enabled.

Lume: engine v5.2.0

Released July 10, 2026

The big one: the rendering engine was rebuilt in-house.

• Same look, faster loads — and custom materials keep working exactly as documented: measured against the full catalog, every published custom material and look keeps working exactly as before.
• Games use a fraction of the GPU power they used to (typically 30–95% less), which means cooler machines, quieter fans, and much longer battery life at higher frame rates.

And everything else that lands with it:

• Switching camera kinds (e.g. a first-person ↔ third-person toggle via setCamera) now cuts instantly to the new camera instead of gliding the view through your character. Zoom easing and camera smoothing within one camera are unchanged.
• Painting grass and flowers feels completely different now: strokes go straight into the massive GPU grass system, so you can paint whole meadows — hundreds of thousands of blades and blooms — with instant feedback under the brush.
• Erase works both ways: clear the flowers you painted, or thin out naturally-growing grass to carve paths and clearings.
• Every decoration layer in your world gets its own Foliage brush, so you can hand-shape where the grass grows.
• Edits to generator scripts now reach everyone in the room. Before, if you (or Savi) edited a script that generates scattered objects or scripted spline shapes, those objects — flowers, rocks, cloud-seas, even player rigs — could turn permanently invisible for everyone else, surviving rejoins, with no error anywhere. Now a generator edit rebuilds those objects for the whole room the instant it applies.
• Grass is alive now! Fields sway and gust with your world's wind direction — turn the wind and the whole meadow leans with it.
• One line gets you a full meadow: deck: "meadow" (or clover, alpine, autumn, lavender) plants tuned grass and flowers that inherit your ground colors.
• Ground cover is way denser near you — thick carpets instead of sparse tufts — and every blade varies a little in color, so fields stop looking flat.
• New worlds start with a living meadow instead of bare ground.
• Buttons, doors, chests, shops, and vehicles now respond the instant any player presses — not only for one player in the room.
• When a sprite animation can't be generated, Savi now learns exactly why and can fix it right away — instead of everyone waiting on retries that could never succeed.
• Point and spot lights now illuminate every material — matte (Lambert), glossy (Phong), cartoon (Toon), custom scripted materials, and water — not just standard PBR surfaces, sprites, and tilemaps. A lamp next to a toon house lights the house; lanterns reflect in lakes at night.
• Switching a place between 3D and 2D while people are in it now updates everyone's look immediately. Before, players (and objects) kept their old-mode visuals — in a 2D world your character could turn invisible because it was still wearing its 3D avatar — until each person refreshed. Flipping back to 3D restores 3D models and profile avatars the same way. Also fixed 2D worlds silently not showing image-based (png) models placed in the world spec.
• A lag spike no longer permanently costs you your drawn textures or scripted materials. Before, one bad stretch (a busy device, a backgrounded tab) could park a texture script or flatten your scripted materials for the whole session — things like a sprite's drawn halo or a planet's shader skin went missing until someone refreshed. Now the engine retries before parking, one stalled texture variant no longer takes down its siblings, and once the frame rate recovers, parked work comes back on its own — carefully, one piece at a time, re-parking only a piece that actually causes trouble again.
• Walking through a portal now starts loading the destination's models, textures, and sounds immediately instead of after the server confirms the travel — and places you haven't visited yet warm quietly in the background during idle frames, current place first. Transitions hold their loading veil for less and same-dimension arrivals land with real art instead of placeholders popping in. Nothing costs the current place a frame, and nothing changes about who is allowed to travel.
• Other players and NPCs now start moving with a visible wind-up and settle when they stop, instead of moonwalking into their walk cycle or skating to a halt — network delay reads as character weight, not lag. When someone's connection stalls, their avatar eases to rest instead of running in place. Your own character is untouched, and it stays out of the way of your own animation: actors driven by your mixer channels or an authored speedOverride are never touched, and interpolation: false disables it with the rest of motion smoothing.
• Hits land where they look like they land: on jittery connections, damage numbers, hit flashes, and impact sounds from other players now present the same frame as the body they land on, instead of flashing up to ~130 ms ahead of it. Your own actions stay instant.
• Behind-the-scenes: sprite loading failures now record exactly why they failed, so problems get fixed faster.
• HUD animations driven by game state (momentum counters, timers, scale pops, fades computed in your ui.js render) update 3× more often — 30 times per second, up from 10 — so they look noticeably smoother. For perfectly smooth motion at any display refresh, keep using CSS transitions/keyframes in your UI html. New knob: api.patchEngine({ ui: { targetFps: 10 } }) (5–30) if you'd rather dial a mostly-static HUD down.
• A second of flaky wifi no longer leaves permanent broken-image icons in your game's UI. Images that fail to load now quietly retry on their own (after 2s, then 8s), and even one that gives up comes back on the next screen change or image swap — refreshing the page is no longer the only fix. Your own onerror fallbacks on images keep working exactly as you wrote them.
• Guards, creatures, and anything using canSee/awarenessOf now notice players the moment they come into view instead of up to a couple of tenths of a second late. Sneaking past a patrol, chases, and "the shopkeeper looks up as you walk in" all feel more alive — and the authored feel (awareness rise time, vision cones, gradual loss of sight) is untouched.
• Lights work in 2D worlds again — lanterns pool warm light on the ground, windows glow onto the yard, a firefly carries its own drifting glow — and dark scenes sit at the same brightness they did before the renderer swap instead of reading washed-out.
• Fixed custom materials sometimes staying stuck as flat gray/tinted after joining or refreshing a world — the engine now notices when a material didn't finish building at join and retries it automatically, including after reconnects.
• Custom geometry that swaps textures mid-mesh (a table with oak top and weathered legs) shows its textures again, and lantern-style objects that mix glass with solid parts draw in the right order — the solid cap and base sit in front of or behind the glass like they should, instead of the glass smearing over them.
• castShadow: false and receiveShadow: false on objects now actually work — models stop casting when told not to, and both models and primitives set to not receive shadows shade fully lit instead of darkening anyway. Worlds that turned shadows off per object for looks or performance get that back.
• Textured surfaces no longer turn flat white when a world mixes texture sizes — the iso-town cars keep their paint and rust next to the playground's oak tables, no matter which loads first.
• Fixed models turning entirely white when a wind-sway or other vertex-animation material script was applied — the staging-zoo pine that waved correctly but lost its bark and foliage colors. A script that only moves vertices now keeps the model's own textures, colors, and vertex paint; scripts that set their own color still win.
• Fixed skinned characters in crowds sinking waist-deep into the ground (and rendering at the wrong size) when their script asked for an animation name the model doesn't have — they now stand on their feet in the model's rest pose, exactly like a single copy of the same character would.
• Lights, particles, and scripts you attach to an object's children now actually run when your game boots — before, they could silently do nothing until an unrelated edit woke them up. And any script can now address a child object by the id you gave it in the spec, not just from its own parent.
• When an asset's generation fails hard on the server, your game now stops hammering the dead asset (which was slowing everything else down, including the retry that would fix it) — Savi gets one clear message saying what happened and that regenerating the asset is the fix, and once it's regenerated it loads again on its own.
• If your scripts spawn objects into a place nobody has entered yet (like pre-building a match arena from a lobby), you now get a clear warning telling you those objects would silently vanish — with the fix: bake them into definePlace's objects[] or create them at entry with enterPlace createIfMissing.
• Worlds whose scripts re-set the same values on every boot no longer jam the save pipeline — the engine now recognizes "nothing actually changed" and skips those saves instead of retrying them forever, so real edits and state changes save promptly again.
• Characters and objects with "breathing" or squash-and-stretch scale animations no longer secretly rebuild their physics every frame — worlds full of animated creatures run smoother, and idle characters stay cheap like they're supposed to.
• When a bunch of script-generated objects appear at once (a whole block of generated buildings restocking), other players' games no longer freeze for a moment — the shapes stream in over a few frames while everything else keeps moving.
• You can outline things in up to 8 different colors at once now (up from 4). When a world asks for more than fits, the most important outlines stay visible — your god-mode selection no longer vanishes — and Savi is told exactly which outline colors got dropped instead of them silently not appearing.

Known issues (being polished on staging):

• In dense scenes with many overlapping transparent sprites, front/back ordering can still occasionally pop wrong — the specific reported cases are fixed, and deeper ordering work continues.
• Water detail is temporarily simplified: ripple normals, crest foam, and caustic sparkle use placeholder patterns until the real textures are wired into the new renderer.
• A few very advanced material scripts that reach past the documented vocabulary pause safely with a message naming what's missing instead of rendering — that vocabulary is being filled in now. Everything written from the Custom Materials and Looks docs works unchanged.

Engine v5.1.13

Released July 8, 2026

• When your game's music code hits a wrong note — an unknown drum name, a bad pattern — Savi actually hears about it now, with a helpful nudge toward the closest real instrument. And "tabla" just works.
• Games open behind a smooth veil instead of flashing a half-assembled world for the first second — the reveal waits until the scene has actually come together.
• Holding Ctrl while scrolling in god mode no longer flies the camera — Ctrl+scroll is reserved for your game's own bindings (and your browser's), so a zoom binding doesn't fight the editor.
• Box colliders on scripted meshes now sit exactly where the mesh is — an off-center shape (like a car whose body reaches forward of its pivot) no longer leaves an invisible wall behind it or lets players walk through its front.
• Testing in your dev room no longer touches your players' real saves — dev gets its own save space (starting fresh), while your published game's saves stay exactly as they are. Shared world data (terrain edits, shops, chat) still flows from build to publish like before.
• If god mode gets switched off in your game while someone is still flying around in it, they can now always land back into normal play — no more being stuck as a ghost until they reload.
• The god-mode help overlay now tells you Ctrl is sprint.
• Games can now have real, permanent leaderboards! Scores survive server restarts and rank players across every room and session — all-time high scores, fastest laps, daily bests. Time trials work too: mark a board as lowest-wins and the best time comes out on top.
• Liquid marks (paint-a-pond terrain) no longer leave invisible ghost objects piling up on the server for every player who joins — and rooms clean up the ghosts left behind by older sessions on their own.
• When a 3D model can't download, Savi now gets a clear "model failed to load" message naming the asset — instead of the game silently showing a placeholder all day with nothing in the logs.
• Games that build asset paths with ${…} templates no longer try to download those half-written paths behind the scenes — the phantom fetch errors that spammed logs every session are gone.
• AI-generated models with layered shells (hollow casings, double-walled builds) stop coming out with scorched-black patches — ambient shadows now bake from the surface you actually see.
• Game scripts can now ask which room they're in: api.getRoomMode() returns "dev" in your build room and "live" in your published game — handy for keeping test data (scores, shop stock) separate from your players' while world data keeps flowing from build to publish.
• When Savi looks at your game, she now sees exactly what players see — your color grading and glow included — so her verdicts on how things look are finally trustworthy.
• Scripted materials that failed to arrive after joining a room used to silently show up as plain default surfaces forever — now the engine retries the handoff on its own and tells Savi exactly what went missing.
• Editing your scene reuses already-built materials instead of rebuilding all of them, so edits land faster and smoother.
• Players on slower machines no longer get trapped in a rebuild-the-world loop that ends in a disconnect — if the world falls behind, the engine recovers once and then backs off instead of thrashing.
• When a terrain texture can't load, that layer now shows a neutral grey instead of hanging invisible or wrongly-colored — and Savi gets told exactly which layer failed and why. If the texture recovers later, the real look comes back on its own.
• Transparent generated shapes (glass, paper lanterns, light shafts) render both sides again — translucent builds that turned inside-out (caps floating, fins splayed) snap back to their assembled look.
• When a game hits its voice-generation limit, the engine now waits exactly as long as the server asks before trying again — instead of hammering the same request every few seconds for hours.
• Savi can read each device's live render-quality state again (api.getClientHealth()), engine-bug reports include per-device health instead of nothing, and api.resetQualityLanding() actually resets a stuck quality landing — all three had been silently dead since mid-June.
• Setting a rotation hinge on a character mid-game no longer makes them jump sideways — the object stays exactly where it is when a script sets or clears its pivot, and only turns around the new hinge from then on.
• Pixel-art sprites no longer get permanently stuck broken when the network rate-limits during loading — no more whole sprite sheets squeezed into one tile, wrong-size buildings, or characters that ignore the lighting. The engine now keeps retrying politely until the art arrives.
• Characters no longer blink invisible for a moment when turning or changing animation in 3D games with pixel-art sprites.
• Fixed 2D characters turning invisible after walking between places — leftover 3D animation names can no longer hijack a sprite's animation and point it at an empty image.

Engine v5.1.12

Released July 7, 2026

• Fixed a reconnect trap that could freeze a player's world forever: if the room restarted while a tab stayed open, that player could get stuck repairing hundreds of times and never recover without a reload. Recovery now works in one clean step.
• Fixed a timing window where changes Savi made right as a place was loading could report success but never reach players or the save — the room quietly ran a different world than the one on disk until a restart. If the two ever drift again, the engine now says so instead of staying silent.
• Saving your changes is much harder to lose now: if the save path hits server hiccups (timeouts, gateway errors), the engine keeps retrying in order until it lands — and if it truly can't land, Savi is told loudly. Before, a bad enough hiccup could quietly drop the change and you'd only notice much later.
• The "world stopped updating" self-repair no longer thrashes: repair attempts now back off and stop at a bound, and when repair can't win, the engine reports exactly why — instead of silently rebuilding a player's whole world every few seconds for half an hour.
• Script-generated shapes now show up for every player: geometry a script invents at runtime (custom meshes, procedural props) used to exist only for the player whose world spawned it — everyone else stared at nothing while the engine retried forever. Now the recipe travels to every client and each one builds the shape locally.
• Squash and shake effects can no longer permanently deform or teleport an object when timing goes wrong — they're pure visual juice now, and the object's real size and position stay untouched no matter what interrupts the animation. Squash also lands a touch crisper. (Worlds already stuck with a deformed object: restart the room once on this version and the fix sticks.)
• You can now say what a rotation rotates around: pivot: "center" to spin in place, "top" to hang and swing, or a door hinged at its edge — on any object, with no invisible hinge-parent tricks. Colliders, nameplates, and anything attached follow exactly, and it works the same on parents and children.
• 2D sprites can finally bank and tilt: a lobbed projectile tips its nose along the arc, a leaning character actually leans — sprites now show the rotation their physics always had, turning around the same anchor point the art and hitbox share.
• Objects spawned by scripts now behave exactly like objects placed in the world from the start: NPC behavior, custom 2D colliders, and IK settings (like turning off automatic foot-grounding) all land identically either way — no more "it works when it's in the spec but not when a script spawns it."
• Fixed a race where a command aimed at a just-spawned object could be lost — spawn-then-command now always works.
• Switching camera styles no longer leaves your body wrongly invisible (or wrongly visible): the old camera's "hide me" setting dies with the camera that set it, in both directions — first-person hides you, third-person shows you, every time, without restarting.
• Looping sounds now stop when the thing making them goes away: destroying an object, swapping its sound clip, or moving to another area no longer leaves a loop droning forever until the page reloads — and api.stopSound actually stops the sound.
• Savi's scripts work on the first try regardless of import/export style: both dialects (export function and module.exports) are accepted everywhere — behaviors, shared modules, UI, effects — and when a module still fails to compile, the error explains exactly what to change instead of a cryptic parser message.
• Clearing a player's model no longer makes them invisible: players fall back to their profile avatar instead of silently rendering nothing. (Deliberately body-less characters are still one explicit setting away.)
• One catastrophically slow session can no longer curse your game into opening blurry forever after on that browser: saved quality settings now start no lower than "everything visible," and the emergency low-quality modes have to be re-earned by actual measurement each session instead of being remembered as the default.
• When a script can't run and the engine knows why — a behavior whose script file is missing mid-edit, or a manager paused because no one is in that area — Savi now gets told exactly what's inert and why, instead of you both staring at "my code isn't doing anything."
• A script repeating the same small mistake thousands of times no longer floods the logs and drowns out everything else: the engine teaches the mistake once, in full, then keeps a quiet count — so Savi's view of your game's logs stays readable.
• While we run an engine-stability push, the engine reports much more of what happens on players' screens (including renderer warnings that used to stay invisible to us) — so the bugs you feel get found from our side, without you filing anything.
• Phones whose graphics support can't run the engine (a class of older/budget Androids) now see an honest "this device's graphics support isn't enough" message instead of loading into a broken world where sprites show but every textured or scripted material is invisible.
• When a texture permanently fails to load, Savi can now see it in the logs (with the reason) instead of the object silently keeping a placeholder forever.
• Custom cameras that position and aim themselves entirely from script (cinematic rigs, planet-surface cameras, shot-follow cams) now always show exactly what the script authored. Previously, if such a camera never used lookAt(), the engine's mouse-orbit camera could silently take over the view — pointing the camera somewhere the script never sent it (even through the ground). Mouse-look cameras are unaffected and stay just as smooth.
• Scripted-geometry meshes that mix solid parts with translucent parts (a ship hull with a glowing afterburner cone, a building with glass windows) now render correctly: the solid parts stay solid — they hide what's behind them and cast shadows — while only the translucent parts are see-through. Previously one translucent detail made the entire mesh ghostly, letting internals show through hulls and turning the object's shadow off.
• Cars can now feel their tires! Each wheel reports how hard it's sliding, how much grip it has left, how much weight it's carrying, and what surface it's touching — perfect for skid marks, tire smoke, drift scoring, and ice/dirt/road grip changes.
• Long-running, high-action worlds stay fast: an internal history log used to get fully re-packed every single tick, quietly eating a bigger and bigger slice of each frame as a busy world accumulated history. It now only tidies up when there's real garbage to clear, so big worlds keep their speed.

Engine v5.1.11

Released July 6, 2026

• Savi can now invent animations for your characters — a swim stroke, a dance, a wing-flap — by writing them as motion code, no animation files needed. They play (and blend) just like regular animations, and edits take effect at the next loop so nothing pops mid-motion.
• Savi can now watch your game in motion, not just look at frozen screenshots — she grabs a short filmstrip of live frames, so she can actually judge whether the walk cycle slides, the jump feels floaty, or the boss swing lands on beat.
• Game managers can now be read from anywhere! Add replicate: "world" to a manager object (like your game's phase or score tracker) and every player can see its state no matter which area they're in — no more copying state onto each player to work around it.
• Scripted splines work again: paths that sweep a custom cross-section you describe in a script (walls, tubes, ribbons — any shape) now save properly instead of being rejected. Scripts can also scatter objects along the path — lamp posts down a walkway, pillars under a bridge — and they'll appear right where the path runs.
• Effects no longer silently switch to a lower-quality renderer under load — the engine fits many more effects at once (128 default-sized effects on desktop, up from ~12–16), and anything truly beyond budget waits its turn instead of changing how it looks. When an effect does have to wait or shrink, the engine now says so instead of staying silent.
• Fixed a bug where a big world could get stuck blinking — the whole scene vanishing and popping back every few seconds, forever. If a piece of scenery ever fails to reach a player now, the world stays put and the engine reports the problem instead of strobing (that one piece may need a reload to appear).
• Fixed a leak that could slowly fill up your graphics card during long sessions in big worlds — especially ones that rebuild the scene a lot. No more "my GPU crashed" after a long build session.
• Animated characters no longer show up pitch black in softly-lit scenes. If your character model looked fine near a lamp but turned into a silhouette everywhere else, that's fixed.
• Feet touch the ground: sprites with empty space baked below the art (most generated side-view creatures and props) used to float above the floor — now they stand exactly on it, and their colliders line up with what you see.
• Your ambient light now does what you asked: worlds that set the ambient color and brightness in the common flat form used to silently render a dim gray instead. Existing dark 2D worlds get the brightness their creator originally wrote as soon as they update to this engine version.
• Cameras tuned with a small smoothing value (like 0.15) now follow the way you meant — snappy, not floating seconds behind the player. The engine recognizes the common "fraction per frame" style and applies the matching follow speed.
• Generated shapes now render both sides — backwards-facing surfaces stop going invisible. When Savi writes procedural geometry (roofs, furniture, terrain details), a face wound the "wrong" way used to vanish when viewed from the intended side; now it just renders.
• Name tags sit where they belong on resized characters: giants no longer wear their names inside their heads, and tiny characters no longer have names hovering way above them.
• Rigs and builds made of many custom-geometry panels that share one material script (like skeletal character rigs) no longer freeze the game for seconds on first spawn — all panels now share one compiled material, each still rendering its own colors and atlas regions.
• Scripts that return odd values no longer lose their changes: if Savi's script ended by returning something that couldn't travel back in the reply (a live logs handle, a function), the engine used to throw away everything the script had built — "my changes keep disappearing." Now the changes land and only the return value is replaced with a note explaining what to return instead.
• Savi's script changes stop vanishing over reply problems, part two: a script that successfully changed your game but returned a value the reply couldn't carry (a circular structure, a BigInt) used to have the whole answer thrown away — Savi was told her changes failed, rebuilt the same thing by hand, and the saved game never got the changes. Now the changes always land and save; only the unreportable return value is replaced with a note telling Savi what happened.
• Editing scripts while your game is running is much more reliable now: event handlers always pick up your latest code — no more "my fix doesn't work until I restart the room", and no more handlers firing twice (or four times) after repeated edits.
• Live script edits can no longer leave an object secretly deaf to events: if an edit orphans an object's old event handlers, the object now tells you loudly — naming the event and the script, with the fix (re-save the script; if it stays deaf, restart rooms) — instead of your correct fix looking like a no-op.
• When a script accidentally uses the wrong import/export style, the error now explains exactly what to change instead of a cryptic one-liner — so Savi fixes it on the first try instead of guessing.
• World thumbnails and Savi's screenshots recover cleanly when the graphics engine stalls, instead of silently hanging forever.
• Your world's shelf image refreshes while you build — the picture on your worlds list updates every few minutes during a live session instead of freezing at the first screenshot.
• Savi learned from this week's play sessions: she now fully deletes things you ask her to remove (no invisible leftovers), makes "hesitant" NPCs pause to think instead of moving in slow motion, wires up saving correctly for spawned objects, and has worked examples on tap for combat waves, enemy AI, and damage zones.
• Enemies and props whose 3D models are still generating no longer get reported as permanently broken: the engine used to log hard "extraction error" failures while a model was simply mid-cook (so Savi and dashboards read your placeholder pills as abandoned), and now it correctly treats "still generating" as waiting — it keeps checking on schedule and the real model swaps in the moment generation finishes.
• Fixed a chronic multiplayer glitch family: after a reconnect or a shaky connection, players' body parts and other respawning objects could silently stop syncing to everyone else (the server kept rejecting them as "already exists"). They now heal in place automatically.
• Building in god mode no longer leaks editor gizmos into the shared world — friends will stop seeing stray rings and handles hovering around objects you were editing.
• Fixed the worst "my game is frozen for one player" bug: on a slow or congested connection, a player's world could stop updating forever — joins that never load, props that never spawn, refreshes that don't help — while everything looked connected. It now recovers within seconds, so the worst case is a brief hiccup instead of a permanently frozen world.
• Sky clouds are back: worlds using the realistic sky's built-in cloud layer have been rendering an empty sky since engine 5.1.9 — the settings were right and saved all along; the engine was quietly throwing away the clouds' first paint while their shader warmed up, then never repainting. It now retries until the paint actually lands, so your clouds show up seconds into the session, every session. Night skies get the same fix for the milky way.

Engine v5.1.10

Released July 4, 2026

• 2D games got a big placement upgrade: backgrounds and distant scenery can now be glued to the camera, so they always fill the screen — no more backdrops drifting away from the view, floating set pieces, or stretched skies. Repeating strips tile seamlessly across the whole view, parallax layers slide at their own speeds, and everything holds up at any screen shape from tall phones to ultrawide.
• Mid-ground scenery (trees, ruins, set dressing between the backdrop and the play area) now sits properly on the ground across its whole parallax drift instead of floating over dips or drowning in hills.
• onSoundEnd fires again: scripts that sequence dialogue or music off a sound actually finishing (instead of guessing with timers) work in real games, not just single-thread test harnesses.
• Building a place and walking players into it in the same script now works — and place-travel errors show up in your logs instead of vanishing.
• On phones, selection handles are now sized for thumbs — big enough to grab, never covering the object — and brush/draw tools have a visible ✕ to exit.
• Objects you attach to a parent in another place now go where the parent is, deleting a parent cleans up its attached objects everywhere, and Savi gets told when something can't be saved instead of it quietly breaking on the next load.
• Fixed a bug where one broken sprite could permanently turn off automatic sprite sizing and pixel-accurate collision shapes for every other sprite in the room.
• Spinning objects now tumble realistically instead of holding a fixed axis — long or flat objects thrown with spin will wobble and flip the way real ones do.
• Your game has a music system now: api.music.play("cdn/music-….mp3", { fadeMs: 800 }) starts or crossfades the room's soundtrack, stop fades it out, duck dips it under dialogue, now() tells you what's playing and where it is. Layers let you stack stems ({ layer: "drums" }). Players joining mid-song hear the right spot, and editing your UI never restarts the music.
• api.audio.duration(clip) gives you a clip's real length in seconds (null until it's known) — no more measuring rituals for timed sequences.
• playSound finally honors bus: ("Voice", "UI", …) so the right volume slider governs each sound, plus priority: for lines that must not be culled.
• Your game no longer creeps down to its worst-looking quality while you're actively building — loading hitches from edits don't count against your hardware anymore.
• Games that swap through lots of big 3D models (previews, galleries, dress-up rooms) no longer slowly fill graphics memory until rendering dies.
• Game controls and menus now stay clear of the iPhone notch and home bar.
• Editing big games is way snappier: script-heavy worlds apply Savi's changes in a fraction of the time they used to (a 3,000-object world went from ~2 seconds to ~0.3 per edit), and the engine no longer quietly does every edit twice.
• Saving game data just got a lot safer: the new api.updateStorage reads your data, applies your change, and writes it back without ever overwriting someone else's save that landed in between — if two things touch the same save at once (double-click purchases, two rooms, an autosave racing a reward), both changes survive instead of one silently erasing the other. Perfect for coins, inventories, and gacha-style rewards that must land exactly once.
• Save and load can no longer falsely report an empty save when storage is briefly unreachable — instead of your save looking blank (and risking a fresh session overwriting your real progress), the game now sees an honest "storage isn't ready yet" error it can retry.
• Worlds built by scripts that painted tons of individual voxels no longer freeze for many seconds when the room starts — and they stay snappy while you keep editing.
• Turning terrain off (or switching terrain types) now actually takes — no more ghost settings from the old terrain sticking around, and when a script gets rolled back, you're told everything it would have changed.
• Music patterns written in standard strudel vocabulary now either just work (.lpq, .distort, .duck) or tell Savi exactly which vibe verb to use — no more cryptic "is not a function" crashes in your soundtrack.
• pbr: true now works on custom geometry: sculpted and scripted meshes that paint textures with ctx.albedo() get the same derived normal/roughness/metalness detail your textured boxes and terrain already enjoy — each textured face derives maps from its own texture, no extra authoring.
• Editing big worlds got faster again: the engine now re-processes only the objects your edit actually touched — a one-object tweak in a 3,000-object world costs what it would in a 10-object world, and an edit that changes nothing is near-free.
• Worlds with heavy build scripts stay responsive: when lots of timers come due at once, the work spreads across ticks instead of freezing the room in one long stall — and any script that runs slow gets named in your logs (with how long it took and how to split it up) instead of freezing the game anonymously.
• Publishing from your phone works properly now: the cover screenshots Savi needs get taken on mobile too, and a game whose flythrough picture failed once will quietly retake it next time you visit instead of staying stuck.
• Edits that fail to save no longer disappear silently: when an edit can't be saved, the game's logs say so and Savi gets told "N spec writes were rejected and did not save" — so "my changes keep disappearing after reload" becomes diagnosable in-session instead of a mystery. Edits to an object spawned an instant earlier now save.

Engine v5.1.9

Released July 3, 2026

• ⚠️ If your world suddenly looks different after this update: your custom look script is running again. It was silently crashing on the last few engine versions (since around 5.1.5), so your world was rendering with no look applied at all. The crash is fixed and your authored look applies again — that new appearance is your own look script working. If it feels off (too dark, too bright, too saturated), ask Savi to retune the exposure — don't delete the look.
• If a model ref in your world is malformed (a name the asset server can't parse), the logs now tell you once, clearly, which ref is broken and why — instead of retrying it silently in the background forever.
• Behind-the-scenes: game-server logs now identify which world and engine version they came from, so problems in live games get traced and fixed faster. Nothing changes in your worlds.
• Savi now judges a custom material's cost by the measured GPU number in every preview, calibrated against real games' materials — expensive shaders (especially layered fur and transparency) get priced honestly before they ship instead of being mistaken for free.
• Wrong-shaped primitive keys no longer fail silently: writing topRadius where the engine wants radiusTop now warns with the correct spelling instead of quietly rendering your shape with default dimensions — and Savi's other dead-end errors (misplaced primitive dims, event handlers in one-shot scripts, mis-called primitive helpers) now say what to do instead of just what went wrong, so she fixes them in one step.
• Behind-the-scenes: the engine now reports exactly where script runs spend their time, so slow run_script moments get found and fixed faster. Nothing changes in your worlds.
• Worlds with lots of effects now render far more of them on the GPU: idle effects lend their GPU budget to the ones actually firing (and take it back when they fire again), instead of the first few effects permanently hogging it while everything else dropped to the low-quality fallback renderer.
• Fixed rain and similar effects falling through flat terrain on the GPU path — drops now land and die exactly at the ground (splashes, rings, and hearts appear on the surface instead of underground).
• Behind-the-scenes: effect re-fires stay correct and warm around edited effect art and slow texture loads. Nothing changes in your worlds.
• Fixed a ~1s whole-game hitch (sometimes "all meshes reloading") when a trigger effect fired again after sitting idle for minutes — level-ups, kill ceremonies, and other occasional effects now keep their GPU resources warm and re-fire instantly.
• Effects can now burst into multiple children on death: when(heart.dies, { count: 8 }) shatters every dying heart into 8 shards (up to 32 per death). Combine with probability to make only some deaths shatter — a shattering death always bursts the full count. The shards' spread, speed, and look stay yours: author them in init:/inherit: like any population.
• Objects no longer silently vanish after joining: if a generated mesh gets lost on the way to your screen, the engine now notices within seconds and re-sends it automatically — and it leaves an honest log entry instead of nothing, so "the spec says it exists but I can't see it" stops happening (and stops looking like Savi lying about your world).
• Savi now builds isometric and 2.5D sprite buildings from modular floor, wall, and roof pieces on the grid — with doors and windows as wall variants and roofs that hide when you walk inside — instead of painting each building as one flat image.
• Fixed images and models with transparent edges (cutouts, sprites, foliage) showing solid black around them — transparency renders correctly again.
• Material previews now show the real GPU cost of your material — the number that actually decides whether a shader is cheap — instead of only the CPU cost, which stayed misleadingly flat even for very expensive materials. Savi reads it with every preview, labeled as one point on the cost curve (your device, preview resolution), so expensive materials get caught before they ship.
• Worlds with extremely dense decoration carpets no longer risk freezing on the first frame of weaker devices — the engine caps how many instances it builds at once (generously), tells Savi in the logs when it did, and the quality system keeps tuning from there.
• Scattered decorations (grass, flowers, rocks) now stay out of buildings stamped as terrain structures — no more flowers poking through walls or grass carpeting a roof. Want plants inside a ruin on purpose? Set filter: { avoidStructures: false } on that scatter.
• Savi's script edits now reach you while you're in the game: previously in singleplayer, once you'd built anything in-session, every fix Savi saved was silently ignored by your running game — it looked broken until you refreshed the page, while friends joining fresh got the working version. Edits and version restores now apply live, and if an edit ever is withheld, the game says so in the logs instead of staying silent.
• Heavy building no longer stutters the world for players — when Savi and her wisps save in rapid bursts, the room now applies the newest state once instead of hitching on every save.
• Fixed: one malformed field in your game's spec can no longer break ALL building — before, a single badly-shaped list (for example after asking for a full game wipe) silently blocked every change from reaching the game for minutes. Now the engine repairs what it can, keeps applying everything else, and tells Savi exactly which field was wrong so she can fix it in seconds.
• Savi can now truthfully wait for the world to finish loading: api.getWorldResidency() reports when everything has actually streamed in on a player's machine (and how much is still pending), so start buttons, intros, and loading screens can gate on the real thing instead of timers or framerate guesses.
• Behind-the-scenes: game tabs left open for hours no longer keep hammering the server with expired credentials — nothing changes in your worlds.
• Behind-the-scenes: connection-health reporting got more accurate — nothing changes in your worlds.
• One long stall no longer snowballs into a permanent slideshow: when your tab hiccups for over a second (backgrounding it, a big world update landing), the engine catches the renderer up with one full refresh — it used to mistake its own refresh for another stall and refresh forever (climbing memory, a hot GPU, an eventual crash on a world you were just standing in). Now one stall means one refresh, then the game goes back to normal streaming.
• Repeated "nothing changed" updates stopped chewing the frame budget: per-tick scripts that re-apply the same particle or light settings every tick, and re-delivered identical terrain configs, now recognize "same content" and stay quiet — real changes flow exactly as before.
• Fires that never burned out now burn out: seconds() with no argument now reads the current game clock in seconds instead of silently returning 0, so scripts measuring elapsed time with it (campfire fuel, cooldowns) work the way they always meant to.
• Big terrain worlds stopped slowing down while nothing moves — the biggest cause of "server running behind" slowdowns in large worlds is gone, and heavy terrain editing stays smooth.
• Game menus no longer trigger the browser's right-click/copy-paste menus, text-drag selection, or image drag-to-save — automatic now, no script guards needed. Want copyable text somewhere? Add select-text to that element; a deliberately draggable image just needs draggable="true".
• Real WebAudio for your games: write playlists, crossfades, ducking, and custom mixes as plain WebAudio in your UI script's onMount — the engine hands you its live audio graph (audio.context, audio.bus("Music"), audio.buffer(ref)), your sounds respect every player's volume settings, and the engine cleans your graph up on every edit automatically.
• Music can finally end: track-end transitions, playlists, and menu→gameplay music are now ~15 lines of vanilla WebAudio instead of workarounds around musicShift.

Engine v5.1.8

Released July 2, 2026

• Side-scroller levels with visual-only heightmaps no longer get fake ground snaps or repeated collider rebuild warnings.
• Color-grading looks that adjust saturation build correctly again instead of failing with a shader error.
• A broken or still-compiling look can no longer darken your world: the screen always shows your plain, correctly-lit scene until the look is healthy, and Savi still gets told what failed.
• Games can now author their render resolution: api.patchEngine({ graphics: { renderResolution: [480, 270] } }) renders the whole game at 480×270 and upscales to fill the screen — retro/PS1 looks, pixel-perfect low-res, or a performance cap for heavy scenes. It applies live (no reload), acts as a ceiling (players' devices can still auto-reduce under it when struggling, and it never exceeds their native resolution), and renderResolution: null removes it.
• Player progress now saves when a stuck world update forces a room restart — players rejoin the fresh room with their latest progress instead of losing everything since their last save.
• A model can now sit offset from its physics body: model: { id, offset: [x, y, z] } slides the rendered mesh in meters along the entity's local axes — no more child-entity workarounds when a model's art doesn't line up with its hitbox (e.g. an avatar mesh 1m behind its capsule).
• Paint parts of a model: model: { id, materials: { PartName: { ... } } } layers color, metalness/roughness, opacity, and glow onto one named part of a GLB while the rest keeps its built-in look — make the blade glow without touching the grip, light the brake lights, tint one building's windows. Typos in part names warn in logs with the names that would match.
• Switching a game into a different built-in camera style now changes both its framing and movement behavior.
• Blueprint placement is more reliable across larger multi-area games.
• God-mode labels and status text (like "Generating…") stay readable while the UI is still loading.
• Switching in and out of god mode keeps player placement more consistent.
• Games built from many scripted shapes load smoothly when you join — no more lag spiral or briefly vanishing objects in scripted-geometry-heavy worlds.
• God mode gets its 10x pass: pressure-feathered brushes with a two-ring cursor, snapping, slider widgets, an fx shelf (seeded firework shows, rain that streaks along its fall, layered mist), spline and spotlight feel, emitter shape wireframes when selected, and a library plus genre pages.
• Screen effects no longer flash the whole screen when they turn on.
• Blur and desaturate effects actually work now — and looks with saturation (noir, underwater, vhs) stop washing toward white.
• Re-triggering a timed effect no longer cuts it short.
• Regenerating scripted shapes stop blinking (and their shadows stop flickering).
• Plug in a controller and the right stick looks around in every game.
• Music that leaves the screen actually stops: no more invisible ghost copies stacking up behind your soundtrack.
• The new anti-aliasing path is stepping back to opt-in while we fix sprite ghosting and material fade — visuals return to the previous default
• Brushes got a feel upgrade: a new Feather control (hard edge → soft airbrush), and the brush cursor now shows two rings — solid where you're painting at full strength, dotted where the effect fades out.
• The brush remembers your radius, strength, and feather per tool now — no more re-dialing every time you pick a brush back up.
• Sliders! Brightness and volume (and anything Savi builds for you) can now be dragged smoothly instead of picking from presets.
• Buttons Savi makes for you are more reliable: broken ones can't take down the rest of your editing tools anymore, and missing icons show a letter instead of nothing.
• God-mode icons are getting a fresh, consistent look (they regenerate as you play — a few may take a moment to appear the first time).

Engine v5.1.6

Released June 26, 2026

• Large terrain worlds spend much less CPU maintaining stable physics colliders.
• Weapons and other items attached to animated characters no longer jitter or warp while the character moves.
• Objects you add or delete in GOD-MODE now stay added or deleted in multiplayer worlds.
• Custom events triggered by interactions now work reliably in multiplayer, including while players join or leave.
• A broken UI handler now leaves the last working UI in place and tells Savi which UI script needs repair.
• Sprites now appear reliably during startup even when camera setup changes while their shaders compile.
• Preloaded voice lines and sound effects now play immediately even when their optimized audio version is still being prepared in the background.

Engine v5.1.5

Released June 23, 2026

• Bloom is now much more performant.
• Finished combat effects are cleaned up correctly in multiplayer games instead of accumulating and slowing the room down.
• Custom event listeners and sound-finished hooks now work on player-owned and shared-room objects.
• Visiting players can get in and drive vehicles with the correct seat and follow camera.
• Games on Retina displays are faster.
• Shadows are cheaper for inactive lights.
• Custom paired controls now follow the order you write them, so reversing a pair reliably reverses the control.

Engine v5.1.4

Released June 22, 2026

• Performance improvements for spoin animations also make games run faster.
• Sprite-heavy games no longer freeze when attacks, effects, or animations reveal a new sprite texture for the first time.
• Optimized the performance of debug instrumentation.

Engine v5.1.3

Released June 22, 2026

• Savi can now notice and help fix visual effects, interface panels, sounds, and other game behavior that fails only on a player's device.
• Games with lots of changing primitive shapes render more efficiently.
• Savi now builds more consistent 2D character animations without swapping the character's visual identity between movements.

Engine v5.1.2

Released June 19, 2026

• Scripted materials no longer lose their shading after reloading a game.
• Players now recover normally when terrain collision rebuilds instead of continuing to fall through the world.
• Games with lots of coins, enemies, and other objects stay responsive when scripts look for players.

Engine v5.1.1

Released June 19, 2026

• Room-based multiplayer games now recognize the correct room on every player, so shared lobby counts, match progression, and room controls keep working.

Connection: engine v5.1.0

Released June 18, 2026

• Sound effects load reliably the first time you trigger them — no more silent first clicks while assets warm up, and sounds that haven't been generated yet now cook themselves instead of going quiet forever.
• Game sounds and music download much smaller on browsers that can play Opus — same audio, faster loads. Nothing changes about how sounds get added, and browsers without Opus support keep getting the mp3 automatically.
• Multiplayer got a major upgrade under the hood. Your own moves, hits, and actions now happen instantly and never rubberband — and worlds stay smooth even when the server is busy or more friends pile in. Nothing to change in your game; it just works.
• Walking across big worlds no longer causes constant background terrain rebuilds — smoother frames while exploring.
• Ground and collision now build reliably even when asset processing is backed up — fixes falling through the world (or bouncing in place) after exploring while models were still generating.
• Animated material effects no longer cause frame hitches while they play.
• Fixed controls staying dead even after the engine tried to recover the connection — completes the 5.0.15 input fix.
• Fixed controls staying dead on a long session even after the engine tried to recover — completes the input-recovery fix.
• Animated material effects now update instantly with zero hitches — param changes never rebuild shaders.
• Objects that use a custom material now pop in smoothly the first time they appear — the engine compiles their shaders ahead of time in the background, so there's no stutter when a new one shows up.
• When the game server falls behind, players now see a "Server running behind…" notice at the top of the screen — if you spot it, tell us! It means lag is coming from the server being overloaded (often heavy onTick scripts or huge object counts), not your connection, and the report helps us find it fast.
• Long-running game servers no longer slow down over hours of play — fixes worlds getting laggier the longer a room stays up.
• Enemy waves and crowds no longer freeze the game when they spawn — crowd shaders compile once and get reused.
• Saves, inventories, settings, achievements, and progression now follow the logged-in player identity more reliably across joins and rooms.
• Existing games that wrote saves under player/... keys need their scripts migrated to user/${objectApi.userId}/....
• Fixed worlds where ground, water, or shadowed objects could turn invisible while editing — a texture set to pixelated (nearest) filtering, or a depth effect without its compare mode, could silently knock out the whole shader for everything drawn with it. Those materials now draw correctly instead of disappearing.
• Other players can see your shots and visual effects in multiplayer games.
• Recovering from a long stall now skips old gameplay history instead of rewinding and replaying movement and effects.
• Characters in new 3D games now face where the camera is looking, including while strafing or moving backward.
• Savi now preserves correct character facing when building first-person cameras.
• Drawn-in-code textures no longer get stuck on the loading spinner forever — if the engine can't bake one, it now says so in the logs instead of hanging.
• Drawn-in-code terrain and object textures now load reliably after joining, reconnecting, or changing places.
• Drawn-in-code sprite animations now play normally instead of remaining on their first frame.
• Drawn-in-code textures now work on objects created or skinned by your scripts at runtime (spawned pickups, the player's facing art, etc.), not just objects placed directly in the scene.
• Multiplayer damage, knockback, and similar effects now land reliably even while players' other state is changing.
• Other players can now consistently see projectile effects such as Fireballs in multiplayer.
• Fixed multiplayer guests seeing the world flash in and out with severe lag after reconnecting or resynchronizing.
• Fixed multiplayer guests seeing large sections of the world repeatedly disappear and reappear during normal play.
• Fixed VFX becoming invisible to other players when cast from a player's own gameplay objects.
• Fixed projectile effects sometimes being invisible to other players in multiplayer while direct effects such as Flamethrower remained visible.
• Short-lived effects cast by other players now appear reliably in multiplayer, including under latency.
• Player and controlled-vehicle movement now stays smooth in multiplayer without making your own controls or camera feel delayed.
• Solo games no longer freeze when player-attached objects such as balloons, equipment, or effects are built as child objects.

Engine v5.0.15

Released June 12, 2026

• Multiple moving shadow-casting lights now all keep their shadows — previously only one moving light at a time could.
• Fixed long lag-behind sessions endlessly rubber-banding — the game now does one clean catch-up resync instead.
• Fixed buttons and controls permanently dying after a slow game load — presses no longer "work for a split second, then snap back". If your game's UI broke when you updated past 5.0.7, this is that fix.
• Lights are now easy to select in god mode — the click target is the light itself, not its entire glow radius.
• Fixed a rare condition where the game stopped responding to your controls after a server restart until you reloaded.
• Fixed a bug where a world's ground and collision could fail to load (players falling or floating at spawn) when an asset server was slow — terrain now builds reliably even when assets are having a bad day.
• Worlds with freshly generated models load more reliably — slow first-time asset processing no longer makes physics and models fail to show up until a retry.
• Ground textures in 2D games no longer shimmer while the camera moves.
• If your world ever stops drawing, the engine now notices within seconds and tells Savi exactly what happened — that it's a graphics-driver problem a browser restart fixes, not a bug in your game — instead of leaving a silent black screen.

Engine v5.0.14

Released June 12, 2026

• Colored and projector light shadows now work for as many lights as your scene needs — they previously stopped working past one or two on many graphics cards.
• Fixed mouse-look games erroring on Firefox when capturing the mouse.
• Worlds with lots of lights and detailed terrain now pick a fitting quality automatically on limited graphics cards instead of failing to draw.
• A texture script that takes too long to draw can no longer freeze your game — the engine stops the draw within its budget, keeps the texture's last good image, and tells Savi exactly which script ran long and for how long.

Engine v5.0.13

Released June 12, 2026

• Boardwalks built down slopes with tight switchback corners now render coherently — no more railing bars shooting past hairpin turns or flickering planks on long straight runs.
• Savi editing scripts while you play no longer makes the world's grass and decorations flash and hitch — the scatter only rebuilds when you actually change the decorations.
• Calling an api method that doesn't exist — whether it was removed in an engine update (like api.patch, removed in 4.5.2) or never existed at all (like api.removeObject) — now tells you the real method to use instead of a bare "is not a function".
• When a script calls an old removed API name, the error now tells you the new name to use instead of a bare "is not a function".
• The breeze is back! Grass, flowers, and reeds with wind on them sway again — bases planted, tips swirling in the wind you authored.
• Screenshots no longer hitch the game: when Savi peeks at your world, a thumbnail gets captured, or you snap a shot for chat, the frame used to stall for ~8 frames mid-gameplay. Captures are now visually identical and nearly free.
• Platformer fix: characters now fall off platform edges cleanly instead of stuttering up and down at the lip. Walking down slopes and stairs still feels glued, exactly like before.
• A spotlight given a too-big cone angle (like an angle in degrees) used to go completely invisible with no error. Now it lights up at its widest cone instead, and Savi gets a log telling her exactly how to convert the value to radians.
• Games with rich terrain no longer gray-screen on GPUs with strict texture limits — the engine now simplifies terrain shading on those machines instead of failing to draw the world.
• Placing objects on the room grid now works in every spawn shape the docs show: spawn({ properties: { feetPosition: { tile: [x, y] } } }) (with optional offset) lands on the tile like the 3d-rooms guide says, including inline children. Mistyped tile positions get precise messages instead of a generic rejection, and using a tile position in a world without rooms terrain tells you why the object landed at the origin.
• Walking through translucent things — light shafts, ghosts, holograms, glass effects — no longer slices the screen with hard edges. They now dissolve gracefully as you get close, exactly like you'd expect.

Engine v5.0.12

Released June 12, 2026

• Sounds in 2D games are actually audible now! Dig thunks, impacts, and pickups were playing at a tiny fraction of their volume because the game listened from the camera instead of your character.
• Scripts can now know when a sound finishes and how long clips really are — timed dialogue and voice-over sequencing stop guessing with timers (no more overlapping lines, dead air, or drift).
• Looping sounds and music now wrap smoothly — no more click, gap, or hiss at the seam every time a generated loop repeats.
• Sounds no longer burst all at once after a slow load — anything timed that "played" while the loading screen was still up is skipped instead of piling up, and your music/ambient loops start cleanly the moment the world appears.
• Fixed a rare server bug where a player could fall through one spot of the terrain forever — the engine now detects when its self-repair isn't working and rebuilds the whole area's ground instead of retrying the same broken fix all night.
• Game servers now recover from rare internal freezes in about a minute on their own — previously a frozen world could stay stuck (changes not applying, joins hanging) until we shipped an update.
• Small characters stand still now! Tiny avatars and creatures (gnome-sized and down) had vibrating, jittery legs from the automatic foot grounding — their feet now plant just as solidly as full-size characters.
• Statues and frozen poses no longer twitch or slowly twist their feet — characters without playing animations hold exactly the pose you gave them, and turning foot grounding off returns them to their authored pose.
• Big sprites, animations, and textures that are generated mid-game show up way faster and more reliably — one generation pass instead of repeated stalled attempts.
• The cursor does what your game says, immediately: pointer-lock changes from Savi or scripts apply live, hideCursor()/showCursor() work in every camera mode, closing a dialog still snaps you straight back into mouse-look, and converting a 3D world to 2D frees the cursor on its own.
• Multiplayer smoothness: fixed a bug where tumbling or settled physics objects could trigger constant invisible corrections, quietly burning performance. Ragdolls and debris now cost what they should.
• Multiplayer resilience: a client that fell badly out of sync could spiral — correcting nonstop until the game ran out of memory. Corrections now pace themselves under load (a brief moment of catch-up instead of a freeze), and the common case got cheaper across the board.
• Savi and creator scripts now get an immediate, precise error when a particles/material/physics value has the wrong shape (e.g. sizeOverLife: [1, 0.4] instead of [[0, 1], [1, 0.4]]) — at the moment of the write, naming the exact field, instead of the value silently landing and breaking rendering later.
• Particle emitters support shape: { kind: "disc", radius, jitter?, lift? } — particles spawn across a horizontal disc (ground fog, ritual circles, splash rings) instead of a single point.
• Savi can now draw animated sprites in code, frame by frame — walk cycles, attack swings, and idle bobs bake instantly into a sprite sheet that plays through the normal animation controls. No waiting on image generation to see your characters move.
• Tilemap worlds no longer need a size! Skip width/height and your tile generator paints forever in every direction — walk a thousand tiles out to sea and the ocean keeps coming, just like infinite terrain in 3D. Existing maps with a set size work exactly like before.
• Vignettes can now fade themselves out — ask Savi for a damage flash that pulses the screen edges red and melts away on its own, no cleanup timers needed.

Engine v5.0.11

Released June 11, 2026

• Savi's script tools work again in solo games with mouse-look cameras — a 5.0.10 regression broke her ability to run scripts there.

Engine v5.0.10

Released June 11, 2026

• Fixed a bug where talking to Savi with your voice could get stuck in a silent retry loop if the microphone pipeline failed to start — it would quietly hammer away forever and flood our error logs while voice just didn't work. Now it tries a few times, tells you plainly that voice is off for this session, and typing keeps working (reloading the page may bring voice back). Quick tap-and-re-hold on the mic can no longer be mistaken for a real failure.
• If music modules ever fail to load in a game, the game now says so once and keeps playing everything it can — including .grain notes, which fall back to plain sample playback — instead of silently re-downloading the broken piece all session or delaying the music while it retries.
• Fixed the "suddenly I'm sprinting at 10x, then my game breaks" multiplayer bug: when a game server fell badly behind, your character could rubber-band violently and your controls could go dead for minutes. The game now notices within a couple of seconds and snaps cleanly back in sync.
• Your inputs can no longer get silently eaten after one of these episodes — movement and actions land again as soon as the game resyncs.
• Your game never freezes while Savi works anymore: her scripts now run beside the game instead of inside its heartbeat, so players keep moving even while she rebuilds half the world.
• Runaway scripts get stopped cleanly instead of locking the room, and Savi gets told exactly what happened so she can split the work up.
• Long-running scripts no longer undo things that happened while they ran — if players scored points or took damage mid-script, that progress survives.
• Edits you make in god mode while a script is running are safe now too: the script re-runs against your latest version instead of overwriting it.
• Cars and other physics-driven builds hold together now: body panels spawned onto a moving chassis no longer freeze in place, drift apart from the wheels, or vanish entirely after a repair pass. Rebuilding a vehicle while a script error is being fixed no longer produces a dead, invisible car.
• No creator-visible changes.
• Changing world settings mid-session (like switching the physics engine) no longer makes script-built vehicles and contraptions fall apart — all their parts stay attached.
• When a generator script can't run, you and Savi now get one clear message naming the script and what to change — instead of the same cryptic error repeating forever in the background while the object silently renders flat.
• Generator scripts written with export const / export class just work now; ones using import get told exactly how to switch to require().
• Cars built from primitive parts under a vehicle parent exist again — the engine's own default for those parts was being rejected by its own validator, so the body pieces silently never spawned and you got an invisible chassis driving around.
• When a build script does fail while Savi runs it, the error now comes back to her instead of disappearing — she can see what broke and fix it instead of telling you it worked.
• Loading placeholders are now clean holograms — the translucent bubble around each generating object is gone, and overlapping holograms now layer correctly by distance instead of in arrival order. Scenes spawning many assets at once no longer fill the view with overlapping bubble shells while things build.
• Savi can now see how your game actually runs on each player's device — including when a device quietly lowered its own render quality in a past session and kept it that way. If your game looks blurry for no reason, ask her: she can check it and (with your OK) reset that device's quality so it re-measures fresh.
• Savi can also measure multiplayer smoothness now — when something rubber-bands or feels laggy, she can see exactly which part of the game keeps correcting and fix the right thing.
• Singleplayer mode no longer drops fps while moving on terrain games — the engine was building and tearing down the same far terrain ring about once a second, and now it doesn't.
• Worlds with animated sprites (2D characters, billboard NPCs) no longer stutter from constant prediction corrections — sprite animation is smooth even in multiplayer.
• Fixed a bug where pointing a 2D tilemap's tileset at an animated texture turned the whole game black — every tile now draws that texture's first frame instead, and the game keeps running.
• Fixed: in singleplayer, a hitch (a big particle moment, assets installing, shaders compiling) could get blamed on whatever scripts happened to be running, parking perfectly innocent scripts for 10 seconds with a "blew its tick budget" warning. The watchdog now tells the difference between "your script was slow" and "the game hitched around it" — genuinely heavy scripts still get caught exactly as before.
• Fixed a bug where players with a profile character loaded their 3D avatar into 2D games — if your game gives the player a sprite, the sprite is what everyone wears now.
• Fixed a bug where dying to an enemy could leave you permanently dead: if an enemy's attack used the built-in combat module, your own death code (the "YOU DIED" moment, the respawn timer) never got a chance to run — the game just stopped responding to movement with no message. Your script now always sees your health hit zero and gets to decide what death means: respawn, game over screen, spectator mode — your call.
• Fixed players jittering or getting yanked around while standing on props (docks, bridges, scattered trees) in multiplayer — the ground under you is now exactly as solid on your screen as on the server.
• Default terrain stops looking like wet plastic. Ground built with pbr: true materials now reads as matte dirt, grass, and rock under full sun — the auto-derived gloss maps were trusted too much and most ground was riding the engine's gloss floor. The texture detail and natural variation all stay.
• The roughnessIntensity knob now does what its docs always said: 2 is genuinely fully matte (it used to stall at semi-gloss on most textures), 1 uses the derived map as-is, below 1 is unchanged for wet/polished looks.
• Loading holograms now sit on the ground where the object will appear instead of hovering in mid-air, and grow upward in place as the asset's real size becomes known.
• Shrink and grow mechanics now feel right out of the box: when a script scales the player, the camera follows the body — first-person eyes drop to the new height and third-person cameras orbit closer — instead of staying stuck at full-size height.
• Worlds Savi builds now come in noticeably lusher: flower beds, undergrowth, and ground cover are taught ~50% denser and ~50% bigger, and unsized decoration sprites default to a size you can actually see. Bare-ground-showing-through forests should be much rarer.
• Savi now knows how terrain ground cover actually scales: she builds dense carpets from several plant variants per layer instead of cranking a density number that silently did nothing.
• Fixed a bug where terrain textures could randomly fail to appear when a world mixes texture sizes — some or all ground materials rendered as flat solid colors depending on download luck. Every texture in a mixed-size set now always shows up.
• A 2D tilemap floor whose art is still generating (or failing to fetch) now shows a quiet gray loading wash instead of disappearing into black. Your art swaps in the moment it finishes cooking — no reload needed.
• Savi mixes her soundscapes properly now — ambient beds (wind, water, hum) sit quietly under the game instead of blasting at full volume, with sound effects spiking above them.
• Debug reports now include a snapshot of what the renderer is holding (draw calls, triangles, shader and texture counts, GPU memory), so when a world slows down we can tell whether something is piling up over time or the scene is simply heavy — straight from the report, without asking you to reproduce it.
• Savi's edits now read back correctly: getSpec() in a script reflects every property change earlier scripts made this session, instead of the world as it was when the room booted. Read-modify-write edits (like tweaking a scatter you set up a few messages ago) no longer silently undo earlier work.
• Terrain generators written as heightAt(x, z) or heightAt(x, z, ctx) now just work — the engine recognizes the shape and routes position and helpers correctly. (The documented contract stays heightAt(ctx).)
• A broken terrain generator can no longer fill your world with mountains you never wrote: faulted samples render flat ground and Savi gets told exactly which function failed and why.
• If you open your game in two tabs with the same account, the older tab now tells you the game moved to the new tab instead of silently eating your clicks — buys and moves no longer "happen" and then undo themselves in the tab that lost the session. Fixed a rare state where outdoor worlds lit by the sky (no authored ambient light) could lose their ambient fill for the whole session — shadows rendered near-black under a clear sky. The sky's light contribution now continuously self-heals, so even if a frame of it is lost, the world recovers within seconds.
• Things placed on the ground now stay on the ground when the ground changes. Fences, roads, scattered props, and anything placed at terrain height follow the terrain when it's reshaped — no more boats or race tracks floating in the sky after a terrain fix.
• Objects you placed at an exact height stay exactly where you put them — the engine only moves things it placed on the terrain for you.
• If a terrain script has a bug, the ground now stays honestly flat and Savi gets told exactly what's wrong (including the classic heightAt(x, z) instead of heightAt(ctx) mix-up) — instead of the engine quietly inventing hills that everything gets built on top of.
• Side-view platformer cameras hold a steady zoom: jumping no longer makes the screen breathe in and out. (Cameras with an explicit zoom keep it, as always.)
• vignette(x) now reads like the knob says: low values draw a subtle rim at the screen edge and 1.0 closes in for real drama. A hidden boost used to max it out early, so if your game has a vignette it will look different — better.
• Rapid-fire sounds stay punchy: when the same sound effect is spammed past its voice limit, the newest shot always plays (the oldest copy fades out underneath it) instead of new shots going silent.
• Sprite animations play at their authored speed — no more temporary 8fps guess sticking around after the real animation data arrives.
• Joining a multiplayer game no longer flashes your character down to a tiny sprite for a moment.
• Visitors who open a game that hasn't been published yet now see "This game hasn't been published yet" right away instead of an endless loading screen. Publish your game and the link works on the next load.
• Color grades no longer crush dark scenes to black, and vignettes are round by default — moody looks keep their detail.
• A script error inside a timer or promise can no longer crash your game's server — you'll see the real error message in the script result instead.
• Parked cars drive again the moment you hit the gas — vehicles that had settled into their power-saving sleep no longer ignore the throttle.
• Animations no longer get stuck after a jump: the "jump pose while walking" bug can't happen anymore — animation calls are now free to make every tick, and Savi's playbooks build platformer animation that way from the start.
• Jump arcs animate cleanly through the peak: the taught pattern covers the whole airborne range, so sprites no longer flash their walk or idle pose at the top of a jump.
• Cars no longer freeze after you hop in: a heavy moment earlier in a script's life (or a busy server) could quietly pause an object's update loop for 10 seconds, and if you mounted a vehicle during that pause it would ignore the gas pedal entirely. Taking control of an object now always lifts that pause immediately.

Engine v5.0.9

Released June 9, 2026

• 3D models are now automatically optimized for better performance, with additional simpler versions used as they move farther away.
• Objects built from connected moving parts now stay together during movement and animation.
• Fixed a bug where players could repeatedly fall through solid terrain instead of being placed safely back on the ground.
• Fixed a bug where heavy terrain edits could leave the ground non-solid on the server — players fell forever while the world looked normal. The engine now detects and repairs missing ground under players automatically, and reports it instead of failing silently.
• Fixed a bug where leaving god mode could leave your character deaf to controls — interactions dead and jumps snapping you back to spawn until a refresh.
• Fixed god-mode edits in busy worlds appearing to fail with a 30-second hang — saves now confirm immediately.
• You can put the game in a box now: build a HUD around it, shrink it into a panel, letterbox it to a fixed shape — just drop <spawn-canvas> into your UI and style it like any other element
• Card games, strategy views, retro consoles-in-a-frame: the 3D view is finally just another piece of your layout
• Things can jiggle now! Set jiggle: true on any object — slimes squash when they land, tails and ears sway and whip on characters with dangly bones, signs wobble on their posts. Tune it with amount, bounce, and gravity.
• Games with HUGE crowds are now real: armies, swarms, flocks of thousands of units that all think and move every tick
• A runaway script can no longer freeze your game — the engine benches it for a few seconds and tells Savi exactly what was slow
• Attach things to the right PART of a model — attachment: { socket: "muzzle" } puts a flash on the gun barrel, a hat on the head, a rider in the saddle. Savi names the spot; the engine finds it on the actual 3D model.
• New getSocket lets scripts aim from those spots too — spawn projectiles from the muzzle, not from the object's feet.
• Shadows no longer pop in and out when you turn the camera: objects behind or beside your view — walls, pillars, props, characters — keep casting their shadows into the scene.
• Point and spot light shadows look noticeably sharper and softer-edged: shadow maps now use the free space in the shadow atlas instead of leaving it idle, and shadow edges get a proper soft falloff instead of a hard stair-step.
• Preview thumbnails while a model generates now show a clean cutout of the object. White-ish objects no longer turn semi-transparent in the preview, and previews appear several seconds sooner.

Engine v5.0.8

Released June 8, 2026

• Shadows now fit every graphics card the same way: machines with tighter limits (many Macs) keep full shadow quality at every tier instead of dropping to a single sun shadow. Secondary sun shadows in big worlds render slightly smaller on low and medium quality.
• Your posted game is now truly pinned to what you published. Switching engine versions, editing with Savi, or saving work-in-progress no longer touches anyone playing your posted game — players keep running exactly the version you shipped until you hit publish again.
• The automatic graphics governor now actually engages in heavy scenes: worlds that stream assets or compile effects continuously used to keep it switched off, so weak devices stayed at 14fps with full effects. It also now notices devices stuck around 25–35fps, not just total collapses.
• Distant mountains stay on the horizon — big foggy worlds keep their silhouettes without the loading cost
• Content Savi adds appears all at once again — no more piece-by-piece assembly
• When an NPC's model can't animate at all (the asset has no skeleton or animation clips baked in), Savi now gets told exactly that — instead of your enemies sliding around in a T-pose with no clue anywhere about why.
• Switching your world to nighttime no longer drops the frame rate the way it used to. The moon, milky way, and stars look exactly the same — the sky just stopped doing invisible work for every pixel, every frame.
• Fixed a scary "Unable to reconnect" banner that could appear over a perfectly healthy game and never go away. If your connection is fine, the engine no longer cries wolf.
• Traveling between areas rebuilds terrain fresh each time — simpler and more predictable.
• Reverting to a previous version now fully resets the live world to that version — runtime leftovers from removed scripts no longer survive the revert. Objects a script had moved snap back to their saved positions, and script-written state is cleared to what the version saved. Players are never teleported or reset by a revert.
• Attaching multi-part objects to a character's hands (or any bone) no longer makes the parts fly apart or swirl around before snapping into place — they ride the wearer from the first frame, in solo and multiplayer games alike.
• Fixed a crash that could freeze the game (with an endless "Unable to reconnect" message) for everyone in the room when terrain decorations were written with missing or misshapen fields. Invalid decoration patches now fail immediately with a precise error, and clients skip any broken decoration entries instead of crashing.
• Fixed visual effects from one place leaking into other places. Effects spawned by an object that removes itself (like an explosion left behind by a grenade) used to land in your world's default place and pile up there forever — swapping places could greet you with effects that were never spawned there. Effects now always live and die with the place they were created in.
• Fixed objects from a place you just left occasionally staying visible in the place you arrived in. A network hiccup around the moment of travel could resurrect the objects nearest you as ghosts that rendered in every place and never went away until a full reload — most visible as a cluster of exhibits from the previous zone hanging in the air. Ghosts can no longer be created; leaving a place now reliably takes its objects with it.
• Fixed a bug where ponds or lakes with foam or caustics could turn the whole world black (except the water itself) after turning water refraction off. If your world went dark with no errors, this was likely it — it renders correctly now.
• Savi's changes now show up live for everyone in the room, every time — no more "I had to refresh to see it" moments.
• Games that drive movement or aiming from scripts (setAxis) no longer freeze players mid-stride after a reload
• Fixed a multiplayer bug where a brief server or network stall could leave a player rubber-banding for minutes — snapping back to an old position (and rolled-back health) about once a second. Recovery is now a single correction.
• Games that drive movement or aiming from scripts (setAxis) no longer freeze players mid-stride after a reload
• Savi now knows that bullets fired by your character should be spawned right where you pressed fire — in multiplayer they leave your muzzle instantly instead of trailing behind you while you move.
• Fixed stripey/banded shadows that could appear on big flat surfaces when the engine steps lighting quality down to keep your game smooth — shadows now stay clean at every quality level.

Engine v5.0.7

Released June 7, 2026

• Games now automatically turn down expensive graphics on hardware that can't keep up — effects cadence first, then shadow distances, then bloom and resolution, and only on the struggling device. Same game, same content, smooth on more machines; the device remembers where it landed so the next session starts there.
• When something goes wrong inside a game, the Spawn team can now see it and fix it faster — crashes and errors in your worlds reach our monitoring instead of vanishing into the void.
• Fast place switching no longer leaves the screen frozen on a stale frame with graphics errors. A rendering hiccup during a place swap could previously wedge the renderer into a state where nothing new reached the screen until another effect kicked in — the frame now always presents to the canvas.
• Effects no longer hitch the game the first time they appear on screen.
• God mode effects are now dramatically cheaper — fire, rain, snow and friends run on the GPU, so you can scatter them around your world without the lag. They're also real effect scripts now: ask Savi to open scripts/effects/fire.fx.js and make it yours, and tune Intensity/Scale right from the chip strip.
• Walking back into a place you just left is fast now — the world you built there stays warm instead of rebuilding from scratch, so door round-trips (cabin to wilderness and back) no longer freeze the game.
• Big foggy worlds load lighter: the engine no longer prepares terrain your screen can't actually see past the fog.
• Effects that mix several sprite textures — most legacy fire/smoke/sparks/rain presets and any effect using a texture pack — now run on the GPU like everything else. The last big class of laggy particles is gone.
• The F2 inspector's Parameters tab now has a Tier control: see what tier your device detected and force another one to taste your game as a phone/tablet or at low/medium/high/ultra quality (reload applies it). The label always shows forced vs detected, so you know exactly what you're looking at.
• Fixed the root cause of a rare mid-session flicker-and-repair (or, before 5.0.3, a permanent black screen) on some graphics setups — usually after resizing the window or entering fullscreen with refractive water or similar depth effects in the scene. The render pipeline no longer disagrees with itself about MSAA, so the repair never needs to fire.
• Singleplayer mode no longer drops fps while moving on terrain games — the engine was building and tearing down the same far terrain ring about once a second, and now it doesn't.
• World text with characters the font doesn't have — emoji, fancy symbols — now shows a small gap instead of a ?. Curly quotes, em-dashes, ellipses, and accented letters render as their plain-text equivalents, so "the keeper's door" finally reads right.

Engine v5.0.6

Released June 7, 2026

• Savi can now find the ugly effect on the first try: her live view names the biggest particle effects on screen over the last few seconds — which script, which population, which texture, how much of the frame — so a giant glowing blob traces straight back to the line that drew it, even when the effect only flashes for a fraction of a second. Asking her about an effect also tells her exactly how big it renders (spawn size → peak size) without reading the math.
• Characters in mantle worlds no longer slowly slide down hills they should be able to stand on — slopes up to the climbable angle hold firm, and minSlopeSlideAngle on the character controller is now honored by mantle just like Rapier.
• Statues, temples, and other placed models are solid again in solo worlds — singleplayer games stopped building collision for CDN models after 4.6, so players could walk straight through objects that were solid in multiplayer.
• Screen ripples and water refraction no longer black out the frame — shockwave pulses and water with refractionStrength render their distortion over the scene again instead of wiping it.
• Fixed sound effects permanently going silent over a long session (and a burst of backed-up sounds playing all at once after dying or changing places). Sounds that reference a missing audio asset now fail cleanly instead of jamming the audio system.
• Fixed games where NPC managers went blind after an engine update or mid-session: scripts that look up objects by tag (query({ tags: [...] })) could suddenly see nothing — NPCs frozen in place, delivery/wave loops silently stopped — while the objects were clearly standing in the world. Tag lookups now always see every live object, no matter how it entered the world.

Engine v5.0.5

Released June 7, 2026

• Savi stops nagging about performance: she now hears about it at most once an hour, only when a game has genuinely been slow for minutes on end (never during loading), and the note explicitly tells her it's informational — she won't change or remove anything in your game over performance unless you ask her to.

Engine v5.0.4

Released June 7, 2026

• Mobile is now opt-in at the door: your game plays on phones once mobile support is declared on the box and the game runs engine 5.0.3 or newer. Undeclared games stay desktop-only — phone visitors see an honest notice (with a "Try anyway") instead of broken touch controls.
• Skies cost almost nothing now — the same sunsets, the same drifting clouds, a fraction of the GPU. Cloudy skies that used to be the single most expensive thing on screen (especially on phones) now render from one texture lookup.
• Multiplayer sessions stop randomly reconnecting — players are no longer dropped for 8-11 seconds at a time.

Engine v5.0.3

Released June 6, 2026

Engine v5.0.2

Released June 6, 2026

• The editor cursor finally feels like your real mouse — pixel-for-pixel, no more laggy ghost trailing your hand in god mode
• Joining a world that's mid-wake retries automatically instead of sometimes sitting on a silent loading screen

Engine v5.0.1

Released June 6, 2026

• Scripts that animate with Math.sin, ease with Math.exp, or steer with Math.atan2 now give the same answer on every machine. Cars and props you drove through obstacles no longer stutter mid-drive. Math results may shift by amounts far below anything perceivable (the same everywhere), in exchange for driving, easing, and orbiting code that stays smooth.
• Way faster world loading on big landscapes — your game no longer builds a kilometer of invisible terrain before it lets you in
• Fixed a freeze-then-storm that could happen if terrain got stuck building behind the scenes
• Savi gets honest signals while your world is still loading, so she stops guessing at the wrong cause
• Custom cameras in 2D worlds work again — the camera you authored is the camera you get
• Smoother building: changing fog or adding textures mid-session no longer causes frame hitches
• Editing room layouts updates the physics instantly — no more invisible walls where old walls used to be
• Removing a world's terrain actually removes it now
• Room-builder worlds got a deep clean: doors at corners and junctions no longer leave holes, doors in raised rooms actually open onto the floor, pits are really pits, and indoor spaces finally have proper shadows
• Savi can't silently go quiet mid-build anymore — if a reply fails, she tells you and your message is safe to resend
• The ground half of realistic skies follows your chosen ground color now (sunset tints it like everything else)
• Cars and other multi-piece builds no longer look like they're pulling apart while you drive them — wheels, body and spoiler stay welded to the chassis on screen, including when you slam into things on a laggy connection.
• Walking into a door or portal no longer rubber-bands you right after you arrive — the first steps in a new place are smooth instead of snapping you back once before settling.
• Long play sessions no longer hiccup every 10 minutes — the brief "Connection lost. Reconnecting..." freeze that interrupted games on a timer is gone. Your game's server now stays up as long as anyone is connected, and still winds down a few minutes after the last player leaves.
• Multiplayer physics gets calmer: crates and props you stand next to (or on) no longer jitter around settled piles. Pushing, shoving, and knocking stacks over feels exactly the same — things still react the moment anything actually touches or hits them.
• Cars, physics props, and characters stay in sync while you drive: steering, gear/RPM, and follow distances no longer jitter between what you see and what others see.
• Big builds feel smooth while they appear: dropping in lots of models or recoloring many things at once no longer freezes the frame — new content fades in as it's ready instead of stopping the world
• Changing the sky or environment mid-session no longer hitches the whole scene
• Giant interior worlds (room builder) load dramatically faster and stay fast
• A typo in a room layout can't erase your terrain anymore — Savi gets a note about exactly which character was wrong and the rest of the world builds fine
• Rivers and lakes stop glowing in the dark — water finally goes properly moody at night
• Movement on a shaky connection feels calmer: brief input hiccups smooth out in one correction instead of repeatedly tugging you back
• God mode got a polish pass: material edits stick, placed shapes stay put, every part of a combo object gets its tuning chips, menu picks always hit the item you clicked, and opening god mode no longer triggers your microphone
• Joining a world that's still waking up now waits at the loading screen instead of dropping you into an empty default world

For Real: engine v5.0.0

Released June 4, 2026

5.0 is the biggest engine release Spawn has ever shipped. The theme, if it has one: your world got real. The sky scatters actual sunlight and hands over to a moon at night, the ground has depth you can see and edit instantly, enemies can genuinely find you, and multiplayer runs on a new engine — with matchmaking your game controls. Nothing here needs migration: your game stays on the engine it was built with until you take the update — ask Savi, or hit the "New features" button in the project tab — and when you do, it keeps working exactly as written: much of this turns on the moment you update, and the rest is one flag or one sentence to Savi away.

Storms, explosions, magic — a million particles. Effects used to hit a hard ceiling around twenty thousand particles; now the graphics card runs them itself.

• Ask Savi for a snowstorm you can stand inside and she builds it — over a million particles without slowing down. The nebula in the clip below is about half a million motes you can walk through.
• Effects carry real light: a campfire genuinely warms the cave around it, an explosion flashes the walls.
• When Savi invents a brand-new effect mid-conversation, it appears the same instant — no shader compilation, no stutter.
• Ask her for smoke that darkens the room instead of glowing and she has the tool: a new subtract blend mode for particles and sprites — smoke shadows, ink clouds, energy drains.
• Glow, smoke, and fog finally play fair: bright glows always draw on top of smoke, overlapping smoke puffs sort properly instead of flickering, and distant fire keeps its color in fog instead of turning gray. Effects using the old screen blend now render as additive glow, which behaves correctly on bright scenes.

Every light you place actually lights the world.

• Streetlights, neon signs, lanterns, torches — hundreds at once (our test scene runs roughly 950) instead of only the few nearest the camera, and the lighting no longer shifts when you turn around.
• The sky now gives your world soft ambient light when you haven't set your own, so outdoor scenes stop looking dim — blue-tinted by day, warm at sunset, dark at night.
• Sun shadows are steadier (no more flickering while nothing moves) and reach farther into the distance, and the engine picks lighting quality to match each player's device, so big lighting setups stay smooth on phones.
• Point a spotlight at something by saying where: light: { kind: "spot", aim: { x, y, z } } — no more yaw/pitch math to rake a spot down onto a pedestal. aim: "down" for ceiling lights, aim: "forward" for headlights and flashlights.
• Anything you set yourself — ambient, hemisphere colors, sun values, or a deliberately pitch-black scene — stays exactly the way you made it.

Ground and walls with real depth. One flag — pbr: true — turns any texture into a real material.

• Terrain blends like actual ground: grass grows up between cobblestones instead of cross-fading, the surface has real relief up close, and materials respond to light correctly (normals, roughness).
• Tell Savi a wall should be brick and it's actually brick: she sets one flag — pbr: true — and on capable desktops it gets depth, self-shadowing between bricks, notched brick silhouettes along its edges, and true displaced geometry up close — with the detail handing off smoothly as you walk away. No extra setup.
• Tiled floors and long paths stop looking like a copy-pasted grid: textures repeated across big surfaces now vary subtly tile to tile, the way real stone and brick do — automatically, with small textures and props keeping their exact authored look.
• Resize a texture pattern the natural way: textureScale: 2 makes cobbles, bricks, or planks twice as large — it composes with the automatic real-world tiling instead of fighting it.
• Everything is tiered for the player's device: phones and weaker laptops keep the simpler look at full speed.

Dig and build with no lag — and it's saved for good.

• Terrain editing is instant now: break a block and it's gone, place one and you're already standing on it. Big builds land at once instead of trickling in block by block.
• Savi got bulk tools too — big builds land as a few commands instead of hundreds: fill a region, carve a moat, stamp a whole watchtower in one go. A wall that used to take 512 separate commands is now 4, so building together keeps pace with the conversation.
• Every edit is saved automatically, in every 5.0 world, with no setting to remember — come back tomorrow and your tunnel is still your tunnel.
• Block worlds finally sit in their lighting: terrain casts shadows now, so a tower throws a long shadow at sunset and a canyon floor falls into shade.

The sky is real now. Every world with a procedural sky gets a physically real one, automatically, the moment it's on 5.0.

• Sunrises, sunsets, twilight, and a sun you can look at. Stay out past dusk and the stars fade in, the milky way arcs overhead, and a moon with real phases rises — and actually lights the world, so a full-moon night is silvery-bright and a new-moon night is properly dark.
• One number scrubs the whole day: set timeOfDay and sun position and color, ambient light, reflections, fog, stars, and the moon all move together with no scripts. 0.8 is a sunset; one cycle line is a day/night loop that runs forever.
• Clouds live in the sky itself now: they drift with the wind, catch sunset colors, glow silver under the moon, and dim the world when it's overcast — the way an overcast day actually feels.
• Want somewhere else entirely? Sun size, horizon tint, milky way brightness, moon size and phase are all dials now — ask Savi for "a Mars sky" or "permanent golden hour" and the atmosphere itself changes, lighting your whole world with it.

Multiplayer, rebuilt — and your game runs the door.

• Multiplayer got a whole new engine: smoother movement, and hits on moving players land where you actually aimed — if your crosshair was on them, the hit counts.
• Rooms hold about 100 players, and when one fills, a fresh room opens automatically and the next player rolls in — your game scales sideways with zero setup.
• Click Play and you're in: joining a world that's already awake lands in about a second, and waking a sleeping one now overlaps with your page load instead of stacking after it.
• Ask Savi for matchmaking and she writes it into your game: keep returning players on their old server, fill the fullest open room before starting a new one, shard by region — a few lines of routing code your game owns and decides which room each player joins. No code at all gets you sensible defaults.
• Rooms have a real player cap: a full room turns players away at the door and routing automatically rolls them into the next room, creating a brand-new one when everything's full. Players just land somewhere playable.
• Ask Savi for a live server browser and she builds it from real data: server lists, matchmaking queues, and per-server saves can now be listed, queried, and locked from in-game scripts.
• Preview: Mantle physics — opt-in per world via physicsEngine: "mantle"; existing games keep their current physics by default.

Enemies have brains. Ask Savi for "an enemy that patrols and chases me when it spots me" — one sentence, and the engine handles everything that used to go wrong.

• Smart movement — enemies walk around obstacles, through doorways, and around each other instead of bumping into walls or piling up. No more zombies stuck on fountains.
• Smooth movement — NPCs walk, break into a sprint, and turn at a natural rate instead of snapping or moonwalking.
• They see and hear — give an NPC vision and it spots you (or loses you when you hide); throw a noise and guards come to investigate. Hide and seek is a real game now.
• Fair fights — enemy groups can take turns attacking instead of mobbing you all at once, and archers keep their distance while staying aimed at you.
• Tune it yourself — select an NPC in god mode and drag its vision ring, pick its speed and hearing, right in the world.

Savi sees your game now — and she's a shader artist.

• Savi can watch your game while you play — through your camera, or an invisible one she flies to check the back of the castle without moving your view. What she reports is her view of the world, and she catches her own mistakes by looking, the way you would.
• Ask for a force field and she writes the actual shader: glowing energy, glass, lava, holograms, dissolves — on anything in your world. Say "slower pulse" or "more green" and it updates live.
• Ask her to preview something and she'll show you a picture before it lands in your world — even a little filmstrip of it animating, or a sweep of variations.
• Whole-screen looks: film grain, retro pixelation, scanlines, color grades, underwater moods. Savi writes the look as a tiny script, tweaks it live, and can fade it in and out during gameplay.
• Every new game now opens with its look already written out as an editable script — the world looks exactly as before, but the dials for color, glow, grain, and vignette are sitting right there. "Warm it up a little" is a one-number edit.
• If a fancy shader ever makes a game run slow, the engine steps in to keep it smooth and tells Savi exactly what to fix — players never get stuck with a laggy world.
• For big asks she fans out a whole team of background builders — splitting the work, gathering it back, sending reviewers over anything that isn't right. You watch the flames in the studio footer while it happens, and if the server blinks mid-build, the team picks up where it left off.

Characters and crowds.

• Characters plant their feet on slopes and uneven ground instead of floating or clipping — and Savi can make them reach, grab, and look: "hand the player the sword" works with no animation files.
• Ask Savi for a marching army or a festival crowd and the engine animates everyone sharing a model in one pass — the clip below runs 360 characters at once, each still walking at its own pace.

Making a mod is exactly as hard as making a folder.

• Put your scripts in a folder with a small mod.json, and that folder is the mod — publishing ships every file in it, including teaching docs for Savi and slash commands for players, so there's no way to forget a piece and ship something broken.
• Every game has a real mod catalog now: browse, search, like, comment, and install in one click — with public, unlisted, and private visibility, so you can soft-launch to friends or keep a mod to yourself.
• Savi knows the catalog: ask her for a shop system and she checks whether another creator already built a great one before building from scratch.
• Installed mods are starting points, not sealed boxes: ask Savi to change how one works and she edits it in place — your edits survive the author's updates, and uninstalling removes exactly what the mod brought.

Building in god mode. Editing by hand got quicker and more physical.

• Spotlights place in two clicks: one for where the light sits, one for what it shines on — the beam follows your cursor between them.
• Right-click anything for its dials: recolor a lantern from a palette, drag its glow radius, set a sound's volume and range, tune an effect's rate and size — all in place, no typing.
• Click a house, get the house: selecting grabs the whole assembly instead of one plank, and clicking again drills down to the tower, the door, the doorknob.
• Every brush erases: hold Alt and brush the extra daisies back out — the ring tints warm so you always know which mode you're in.
• Paint with anything: turn any object — a mushroom, a crystal, a gravestone — into a scatter brush and sweep copies across the hillside.
• Building makes sound now: placing, painting, erasing, and undoing each answer back with their own little sound.

Atelier: engine v4.6.0

Released June 1, 2026

• God mode is a real in-world editor now. Grab any object and move, rotate, scale, or stretch it with on-object handles. A toolbar at the bottom gives you shapes, paths, and brushes, and your tools live in tidy tabs in the top-right. Made a mistake? Ctrl+Z to undo, Ctrl+Y to redo (top-left).
• Paint your world. Sculpt hills and valleys with terrain brushes, paint different ground materials, and scatter plants and objects across the land. Right-click anything you've scattered to tune the whole patch at once — amount, size, spacing, sway, and how it grows on slopes.
• Sculpt while you play. Terrain you raise, lower, or repaint updates live underfoot — and since edits sync to everyone, you and your friends can build the same world together in real time.
• More material looks — give objects toon, phong, matcap, and other lighting styles, not just the standard one.
• Per-object shadows — turn shadow casting and receiving on or off for any object — handy for glass, signs, and effects.
• Animations just work. Name a clip loosely (say "walk") and it still finds the right one instead of freezing in a T-pose, and you can layer upper-body-only animations over a full-body one.
• Walk-through archways — archway openings reach the ground, so players walk straight through the doorway.
• Smoother and sharper — a rebuilt renderer keeps frame rates steady, holds detail on distant models, and keeps memory in check on big scenes. Custom camera styles run smoothly again.
• Sculpting feels right on hills and cliffs. The brush lands exactly where you point — even on steep ground — strokes stay strong on slopes, and the brush ring hugs the terrain instead of floating as a flat circle.

Engine v4.5.2

Released May 27, 2026

• Animated models always play something — falls back to an available animation instead of standing still.
• Savi can now catch editing mistakes that made parts of your world disappear or stop moving.
• Savi uses clearer, more specific commands when editing your world's atmosphere, terrain, camera, and other settings.

Engine v4.5.1

Released May 23, 2026

• Ponds run much smoother without changing how they look.
• Plants and ground decorations now stay on the ground when you reshape terrain.

Surface Tension: engine v4.5.0

Released May 22, 2026

• Water you can swim in — add ponds, lakes, and oceans to your worlds. Players dive under, float back to the surface, and splash going in, with waves rolling across the top and foam gathering at the shore.
• Shapes that look like real things — the shapes Savi builds by hand can now look like wood, stone, or brick instead of a flat color.
• Patterns fit whatever size you build — stretch a crate and the wood grain spreads across it naturally instead of smearing.
• Recolor one copy without touching the rest — give a single barrel its own shade without making a whole new one.
• Surfaces look cleaner from across the room — detail holds up when you're looking at things from an angle.

Engine v4.4.3

Released May 21, 2026

• Fixed some characters appearing too small.

Engine v4.4.2

Released May 20, 2026

• Build bigger worlds with lots of places — areas no one is in quietly sleep so the game stays smooth, and snap back to life the moment someone walks in. Your spawn area is always ready.
• Joining a game is more reliable — fewer hangs on the loading screen when you click play.
• Busy worlds stay in sync — when lots of players are exploring different corners of the same game, things no longer snap or jitter on screen.
• Avatars don't vanish on you anymore — Savi catches her own slip-ups when updating your character, instead of accidentally making it disappear.

Engine v4.4.1

Released May 16, 2026

• Savi places things on top of anything now — models, primitives, sprites, custom geometry, or text, she knows the size and lands the placement first try.
• Custom uploaded models that disappeared after the animation migration are back — your characters keep their model and animations switch correctly.
• Non-square images render on walls and floors again — photos, screenshots, and posters no longer come out as blank white spots.

Solid: engine v4.4.0

Released May 15, 2026

• Stacking just works. A mug on a chair on a house keeps its size. Ask Savi to put something on top of something else and she'll land it first try — huge for any game where things sit on shelves, stack into towers, or get carried around.
• Worlds load clean. Things appear at the right size right away. No more pop-in where stuff suddenly grows or shrinks as the level comes in.
• Clicks land where you point. The sky doesn't steal clicks anymore, and big crowds of repeating things (trees, rocks, props) can be clicked one by one. Shooters, click-to-place, and pick-up-anything games all feel sharper.
• Effects stick to surfaces the right way. Bullet holes, splats, dust puffs and decals face the wall they hit instead of floating sideways.
• Camera stays still when you open the menu — no more drift while you're trying to read.
• Heads up: a few old scenes might look a little different where you'd attached one thing to another. Take a peek and tweak if anything looks off.

Engine v4.3.1

Released May 13, 2026

• Walls and floors are back in 3D Rooms games. Players land cleanly, walls stop the player, and skeletons stand on the floor instead of falling into it.

Groovy: engine v4.3.0

Released May 13, 2026

• Savi is your DJ now. Ask her for a song and she'll score your game live — the music reacts to what's happening, so when things get tense, the music gets tense.
• No more jitter. Players and cars walk and drive clean.
• Controls feel right. What you press is what you get.
• God mode pointer works again. Clicking and dragging in build mode is fixed. Bigger god mode upgrades coming soon.
• Way more clouds. Skies can be way more dramatic without slowing things down.

Continuum: engine v4.2.0

Released May 9, 2026

Saved games, smoother animation, sharper aim, and a basket of polish fixes you'll feel right away.

Save your games

• Player progress persists across sessions — position, inventory, and stats all come back when players return.
• World state persists too: tag objects to save, set up cron jobs to auto-save on a timer, and graceful shutdowns save everyone before the server goes down.
• Multi-place persistence — walk through a portal, disconnect, and come back in the same place with your stuff.
• Static initial values on an object's state field are applied automatically. Add new fields later and returning players get the defaults without losing their saves.
• One unified state system — no more confusing split between "persistent" and "ephemeral" state.

Animation, reborn

• One animation system now: named mixer channels driven by updateChannel from your scripts.
• Two-clip blending (Walk over Idle, Cast over Run) is first-class — give channels names and they layer cleanly.

Smarter pointer & raycasts

• The "I shot myself" bug is gone — api.raycast excludes the caller by default.
• Sphere casts now work for aim assist and area effects: { shape: { sphere: radius } }.
• Click-to-throw, click-to-shoot, and other click actions fire exactly where you're looking. No more first-person balls flying off behind you.
• The first click that locks the cursor no longer wastes your first action.

Bug fixes you'll feel

• Signs Savi makes no longer spin their text to face you and clip through the panel.
• Strands of fairy lights and bunting now actually look like strands — a thin cord drooping through your points with cute bulbs or flags hung from it, no random poles in the scene.
• Stacks of bottles, mugs, and other small lathe-shaped objects don't explode into orbit anymore. They just sit on the table.

Behind the scenes

Existing games migrate to all of these automatically when you upgrade:

• One api.patch() method replaces eight separate per-slice patches.
• One way to make tubes, roads, pipes, and fences: spline. The redundant path property is gone.
• Eight pointer/aim/raycast methods replaced by two clearer ones.

Foundations: engine v4.1.0

Released May 4, 2026

Spawn's first big engine update. Faster, smoother, smarter — and a small mountain of fixes.

• Huge engine perf upgrade. The whole renderer was rebuilt, terrain streams better, and big scenes draw faster and smoother.
• Savi's tools are way more reliable, and she can now see and poke at your game's UI — huge unlock for UI-heavy games (Discord-style chat games, dashboards, card games, etc.).
• Multiplayer feels much smoother — camera, controls, and effects (vignettes, particles, music swells) all stay in sync now instead of glitching during rollback.
• Hundreds of fixes — actually hundreds. Screen flashes, object juice, screenshots, voxel marks, query ordering, and a long tail of small things that used to glitch now just work.
• New animation stuff! Savi can now tween any property on any object — bounce a chest open, pulse a crystal, fade things in, flash red on hit. More animation features coming soon.

Genesis: engine v0.1.0

Released April 29, 2026

Welcome to engine versioning! Your game now tracks which engine version it runs on. You can see updates and choose when to upgrade.