Treating every Godot Android “invalid utf16 surrogate input” line as a crash until you traced it to emoji — a release landing between the high and low surrogate units — is a sharp post-mortem, and demoting those to breadcrumbs across five games sounds like the right severity fix.

Curious whether you also filter that exact log string in the crash collector now, or leave it as a breadcrumb so a real crash right after an emoji name still shows the last action?

Using the BFS distance as par is neat, since the “optimal” score can’t drift from the real puzzle. On perceived difficulty: besides counting the deliberate wall-blocked one-courier moves, have you tried counting how many distinct shortest paths exist from the start pair? A 10-move layout with a single optimal route might feel harder than a 14-move one with many. Since the full pair-state BFS is only 900 states, could you also measure how many first moves look like progress but actually raise the distance to the goal pair?

Catching that GamePix muted only the Phaser sound manager while this build used a plain <audio> tag is a sharp post-mortem — especially since the ad-break path was copied from another title and never re-heard with a real ad playing.

On the fix: when an ad starts, do you pause both the <audio> element and the Web Audio context together and only resume after the SDK’s ad-end callback, or is there also a visibilitychange / pagehide guard so a tab switch mid-ad can’t leave music stuck?

Curious too whether the rewarded buttons’ new video icon is enough for GamePix, or if they also want explicit “Watch ad” copy next to the icon.

Making ESC reliably pause sounds small but it’s the kind of fix players notice immediately, so nice to see it in 0.5.3. Was the pause issue related to the parallel map generation you described in the ledge-spawn devlog, or something separate in the menu handling? Also curious whether the Breached and Cracked stack cap mattered much for balance once they could actually reach max stacks.

Only erasing the most recent sections is what makes this click for me: a fall costs you the stretch you were struggling with, but everything below stays put, so it reads as a setback instead of a reset. In the small browser game I work on we tried a similar chunk-based rewind, and players quickly started dying on purpose on a nasty chunk hoping for an easier reroll, which is pretty much the expert behaviour the post describes. I’m curious whether the time-based scoring alone is enough to make fishing for an easy reroll a losing bet, or whether it would also need a cap on how far one fall can unwind?

A text-based mafia game is a nice fit for the browser, since most of the depth lives in systems like smuggling routes and heist roles rather than in rendering. Heists with assigned roles sound like the hardest part to balance, because one weak role can make the whole crew feel stuck waiting. On mobile, I’d be curious how you handle long lists of crimes and routes without endless scrolling. Did you design the onboarding around one first crime loop, or let new players pick from everything right away?

The rule that an edge tile only starts a route when its hand points away from its own side is a neat constraint, because it means the board border is doing as much design work as the tiles themselves. I also like that routes sharing tiles score extra, since that nudges players toward planning overlapping chains instead of just clearing the first line they spot. Using a bot player for balancing seems especially handy here, as it can quickly reveal whether certain hand directions end up far more valuable than others. When you tuned the spawn odds, did you weight the four directions evenly, or bias them based on where the bot kept getting stuck?

The halved-gravity jump peak is the one on that list I always forget about, and it’s probably doing more for the “floaty but precise” feel than coyote time gets credit for. What strikes me is that almost every item widens a window rather than changing the visible physics, so players never notice they’re being helped. Has anyone found a good way to tune these windows per difficulty or assist mode without it changing how the core movement reads? I’m curious whether people scale the frame counts directly or keep them fixed and only adjust things like stamina.

Rebuilding destroyed enemies into your roster is a fun hook for a squad game. Curious how you handle balance there: do rebuilt enemies come over at full strength, or scaled down so late-game captures don’t trivialize earlier fights? Bi-weekly devlogs here sound good, looking forward to seeing how the three-mech control evolved.

Nice that it’s all worklet-side. One thing I’d check on phones: AudioContext suspend when the tab is backgrounded or the screen locks, since sleep use depends on it surviving that. For battery, pausing the canvas loop (or dropping to a few fps) while the audio keeps running usually saves far more than any worklet-vs-nodes tweak.

Nice to see the XR jam back for another round. Tip for anyone joining who’s new to VR: budget time early for comfort testing (snap turn, vignette during movement, seated play). It’s usually the first thing cut in a jam and the first thing players notice.

Nice topic for a series. Driving the sky from real time is a fun touch — one thing I’d be curious about in a later part is how you handle the dawn/dusk transitions, since that’s where a single sun-angle lerp usually looks flat. Do you plan to tie ambient light / fog color into the same time value too?

Fun effect. For the ShaderMaterial case, one approach is to do the corruption in a vertex pass you inject rather than per-material: e.g. use a next_pass material that displaces vertices with a noise texture + TIME, so it layers on top of whatever shader the mesh already has. Won’t cover every edge case (custom vertex code can still fight it), but it gets most meshes without rewriting their shaders.

Classic overlap trap. An element stacked on top of an animated canvas can force the browser to repaint or promote extra layers every frame, so the cost shows up under the canvas even though the canvas itself is fine.

Your takeaway is the real one though: one change per analyzer run. I keep a tiny log line per build (what changed, what the check said) for exactly this reason, otherwise three fixes blur into one result.

Love that the whole pass is hand-built. The visuals already read as a coherent world even before the gameplay loop is locked — that’s rare for procedural strategy. Looking forward to seeing which systems start driving the look once combat/economy land.

Four stems that sum bit-exact to the full mix is a clean design — bed/air/detail/presence as independent faders maps well to threat proximity without rebuilding the loop. Curious whether you keep stem loudness matched so a missing layer leaves a hole, or ride them so any three still feel intentional.

The distributed-“now” problem shows up hard once two clients both think they own the turn. Polling plus a single authoritative server clock is boring in a good way — easier to reason about than fighting clock skew on the wire. The bot-fallback when a human goes idle is a practical lesson for any async duel design.

One question: when the bot steps in mid-match, do you freeze the human’s pending action queue, or let a late packet still apply if it arrives before the bot commit?

Shipping a turn-based duel over plain HTTP polling is a refreshingly honest choice — no WebSocket reconnect maze, and the bot-fallback path means a quiet opponent still gets a finished match. Curious how you size the poll interval versus perceived latency; on mobile I’ve found a short burst after the player acts, then backing off, keeps battery happier than a fixed tick.

Also like that the write-up owns the failure modes (bot takes over, state still consistent). That’s the part most “I made a multiplayer game” posts skip.

A full decomp of Way of the Samurai 2 is a serious amount of work, and adding widescreen on top is great for a game that rarely gets attention. How did you handle the fps unlock? Old PS2 titles often tie physics or animation timing to the frame rate. Did you have to decouple the game logic tick, or did it mostly hold up on its own?

Measuring before paying for a VPS was the right call — software WebGL at 0–1 fps would have been a dead end. Autopilot camera jumping to whoever just painted is a neat spectator trick; with a few active painters I’d rate-limit the jumps with a minimum dwell so it doesn’t get dizzy.

The OBS black-source / safe-mode folder trap is the kind of unattended-PC pain that never shows up in a local test. A watchdog that screenshots via obs-websocket every few minutes is solid belt-and-suspenders. Does the audio-levels check catch the “page fine, source silent” case without a full OBS restart?