Engine v5.2.35

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.