We shipped the Early Access v2 version a week ago and then, in the finest tradition of engine developers everywhere, made a video about it and went quiet. There's a shocking amount in here we've never written down: terrain, oceans, going underwater, voxel worlds, and ten grid-game logic packs that appeared while nobody was looking.
So here's what's in v2, and more usefully, what to type at the Phaser Game Agent to get it.
That second part is the one I care about. It's lovely that the engine can render caustics on sand. It's more useful to know you can ask for a scuba game and get them.
Every prompt below is a real thing you can paste at the agent. They're written the way you'd describe a game to a person, not as API calls, because the agent reads the engine's capability docs and works out which knobs to turn.
First, the boring-but-important bit
v2 needed WebGPU. Not everyone has WebGPU. That was, to put it charitably, a problem.
Now Game.create() tries WebGPU, and where it isn't available it quietly boots the same game on WebGL2. Same API, same game code, nothing to configure. Water, grass, shadows, SSAO, god rays and voxels all run on both. A handful of things stay WebGPU-only (clustered scenes past 8 lights, spot-light beam shafts, custom WGSL with no GLSL twin) and those degrade to a warn-once no-op rather than exploding. game.renderer tells you which one you got.
Every new game the agent builds now uses v2. Existing games keep the engine they were built with and we're looking at ways to migrate them, but the new bits are only in v2.
The 3D stuff, which is most of it
Terrain from one call
world.terrain() gives you a seeded heightfield (islands, hills, mountains, dunes) chunked into GPU-culled meshes and coloured by height and slope. No assets. It also comes with heightAt() and normalAt(), so karts, characters and balls sit on the ground instead of hovering an inch above it in that way that makes everything look cheap.
Prompt: "Build me an exploration game on a big procedurally generated island with hills, valleys and a beach, and a character who runs around on the terrain following the ground properly."
A sky with a day/night dial
world.sky() puts up a procedural dome with clouds, sun, stars and moon. Then sky.time is a single number from 0 to 24 that runs the entire day. It moves the sun, recolours it, and drives the ambient light, the fog and the environment bake. Drag it from noon through sunset into a starry night and everything in your scene follows. There's a sky.storm too, because of course there is.
Prompt: "Make a survival game with a full day/night cycle. I want to see the sun set and the stars come out, and I want it to get properly dark and a bit frightening at night."
Actual water
world.water() is Gerstner-wave sea with soft foam breaking against the shore. It has heightAt(), which means boats float on it correctly rather than clipping through. The same system does lakes, and stream and waterfall ribbons along a path.
Prompt: "I want a little fishing boat game with a proper rolling sea, foam on the shoreline, and the boat riding the swell realistically."
And then you go underneath it
This is my favourite thing in the engine and I will not be taking questions.
world.underwater() lets you dive below the surface, and it feels underwater. Per-channel light absorption, so red drains out with depth and everything goes blue and murky the way it does in real life. Caustics dapple the sand. Look up and you get Snell's window, the bright circle of sky you see from below the surface.
Prompt: "Make a diving game where I swim down through a coral reef looking for treasure. I want the light to fade and go blue as I go deeper, with caustics rippling on the sand."
Snow that remembers where you've been
terrain.deformable plus terrain.carver gives you persistent trails carved into snow or sand. Your board leaves a rut that survives for hundreds of metres. Look back up the mountain and your whole line is still there. Sand heals shut over time, snow doesn't. The ruts are real geometry, not a decal: they're in heightAt, so they change what you ride over.
Prompt: "Build me an SSX-style snowboarding game down a mountain where my board carves a trail in the snow that stays behind me."
Grass, at two scales
terrain.grass does compute-driven blades close up and billboard cards out to the horizon, as one field with density and dynamic sliders. One technique per distance band, rather than one technique pretending to cover all of them.
Prompt: "A peaceful game where I wander through a huge meadow of grass that moves in the wind."
Shadows, ambient occlusion, god rays
world.shadows(true) renders the scene from the sun into a shadow map and PCF-filters it. world.ssao(true) adds screen-space ambient occlusion, so creases and contact points darken and everything stops looking like it's floating. world.rays() gives you light shafts past silhouettes. Lens flare comes free with the sky and is depth-occluded, so it hides behind objects.
Prompt: "Make the lighting in my game look really good: proper sun shadows, ambient occlusion in the corners, and god rays through the trees."
Voxel worlds, with the controls already done
world.voxels() builds a chunked, editable block volume, and vox.landscape({ type, seed }) fills it with a finished world (island, plains, hills, mountains, flat) solid all the way down so you can dig. You get chunked exposed-face meshing with baked AO, raycasting to hit blocks, a walk/jump character controller, AI mobs, and a block editor with outline, ghost preview and break/place events.
mcControls is the entire first-person rig: pointer-lock mouse-look, WASD, sprint, jump, fly, break, place, hotbar, plus the whole mobile touch layout with joystick and drag-look.
Prompt: "Build me a Minecraft-style block world I can walk around, dig into and build in, with first-person controls that work on mobile too."
Models, animation and crowds
Load real models with world.loadObj and world.loadGlb, PBR textures and normal maps included. Animated skinned GLB characters play clips with crossfade via model.play(clip). Parent things to world.group() nodes for assemblies.
Then world.agents moves them with intent: steering, flocking, fields, panic-flee, path and leader following. Fish shoals and bird flocks are a couple of lines.
Prompt: "A cluster of fireflies that flock and scatter when I get close."
The 2D side didn't go anywhere
Easy to forget with all the water about, but v2's 2D stack got a lot too.
Particles (game.fx) are the cheapest way to make a game feel expensive. Explosions, sparks, thruster flame, confetti, smoke, colour ramps, the lot. Here's the shmup stress test: twin bullet streams, a flaming thruster, and every kill detonating a full boom recipe, all while asteroids scroll past.
Prompt: "Build me a side-scrolling shoot-em-up with a flaming thruster on my ship, chunky explosions when things die, and debris flying everywhere."
2D lighting (game.lights2d) does additive point and spot lights with soft falloff, hard shadows cast off actual scenery, colour mixing and candle flicker, over SDF shapes or plain PNG sprites. Only the lights visible to the camera get computed, so the count is effectively unlimited and the cost is bounded by what's on screen. Sweeping searchlights throw soft shadows in a direction, and the penumbra moves as things wander through.
Prompt: "A night-time stealth game where every street lamp casts real soft shadows and sweeping searchlights hunt for me."
Fog of war (FogGrid) is recursive shadowcasting with unseen/explored/visible memory, multiple light sources, and a canSee() for AI. Visibility2d does the non-grid version, with shadows thrown by real scenery geometry.
Prompt: "A top-down dungeon crawler with fog of war, where I can only see what's in my torchlight and the walls cast real shadows."
Sprite deformers are my sleeper favourite. Pass a deform to any sprite and it stops being one flat quad and becomes a 24×24 grid pushed around entirely in the vertex shader. No new object, no CPU vertex work, still one instanced draw. You get wave (cloth ripple, pinned left), sway (pendulum bend, pinned bottom), jelly (volume-preserving squash wobble) and flip (a fake-3D card turn, swapping to the back frame once it passes 90°).
d.sprite(F_FLAG, x, y, { deform: { kind: 'wave', amount: 8, speed: 0.7 } });
d.sprite(F_SLIME, x, y, { deform: { kind: 'jelly', amount: 0.15 } });It's one property on a draw call, and it turns a static banner into a flag or a static blob into something alive. The page curl in the shot below isn't even built in: custom deformers arrive as data, so that one is a DeformDef the example registers itself with no engine changes.
Prompt: "Make a card battle game where the cards flip over in 3D, and give my banners a cloth ripple in the wind."
Prompt: "A platformer with slime enemies that squash and wobble when they land, and plants that sway as you brush past them."
Tower defense, both flavours: FlowGrid for flow-field pathing, where one search from the goal steers hundreds of units, and Track for the Bloons-style fixed path that forks and merges.
Prompt: "Build me a tower defense game where enemies follow a track that splits into two routes and I place guns along it."
The game packs, which are a bit ridiculous
This is where things got out of hand, in the best way.
v2 ships logic packs: self-contained artifacts that only load if your game asks for them. They're pure logic, with no rendering and no opinions about how your game looks. You get the rules, the state, and an ordered list of what just happened, and you animate it however you like. Every one is seeded, so the same seed gives the same game. Replays and daily challenges come free.
Match-3 got the most attention by a mile. The core board does shape-classified matching (3, 4, 5, L, T), specials and combos, jelly and chains and vines and crates, cascades, goals, and autoplay. Then the variants: click-to-collapse like Toon Blast, chain-drawing like Two Dots, merge-and-explode levelling, Puzzle Quest mana-and-skull battles, split boards that refill by teleport, paint-every-cell levels, rotating 2×2 groups, wraparound row shifts, Panel de Pon rising stacks, Triple Town place-to-merge with the bears, and a versus channel that pipes attacks between two players.
Prompt: "Make me a match-3 game with bombs and rockets, ice blocks that take two matches to break, and vines that grow across the board if I don't clear them."
Prompt: "Build a Puzzle Quest style match-3 battle where matching gems fills my mana, skulls damage the enemy, and I can cast spells."
Tetris and friends live in the faller pack, which handles the active piece properly: SRS wall kicks, 7-bag randomisation, hold, lock delay with a reset cap, T-spin detection. The bits homemade versions always get wrong. The same pack covers Puyo, Columns and Dr. Mario, because they're all one piece falling into a grid with different match rules.
Prompt: "Build me a proper Tetris with wall kicks, hold, a ghost piece and T-spins."
Block Blast, 1010! and Woodoku come from placer. Drag pieces from a tray onto a static board, complete a region, watch it clear. Regions are data, so rows and columns work out of the box and Woodoku's nine 3×3 boxes are one extra call.
Prompt: "A Woodoku-style block puzzle: 9×9 grid, drag pieces from a tray, clear rows, columns and 3×3 boxes."
Because they all share a shape, we built the rest of the canon at the same time. Minesweeper with first-click-safe placement and a deduction solver. 2048 and Threes. Sokoban with unbounded undo and a BFS solver. Picross, Lights Out and Flood-It, each with a generator that can only produce solvable puzzles. Netwalk and Pipe Mania. Boulder Dash and Snake. Puzzle Bobble on a hex grid. Zuma.
Prompt: "Make me a Minesweeper where the first click is always safe and there's a hint button that only ever tells me provably-safe squares."
Prompt: "Build a Sokoban puzzle game with undo, and warn me when I push a crate somewhere it can never come back from."
Your games now have a workbench
Open one of your games on the site and you'll see a Files button in the controls at the top. That's new, and it's yours only. It opens a workbench for that game.
Ask questions about your own code. There's an AI-powered assistant in the left panel that can read your game's source and its design spec. Ask it how the scoring works, or where the collision handling lives, or what the art style doc says the palette is meant to be. It's read-only, so it can't edit anything, but it's completely free to use.
Read the source. Every file the agent wrote, syntax-highlighted, in a browser tab. No downloads.
Read the design docs. The game manifest and the art style guide, the two documents the agent writes before it builds anything, rendered properly.
Rebuild and republish, free. Rebuilding runs the publish step only, without the agent, so it costs no credits at all. If a game ended up stuck or half-published, this is how you get it out. Hit the button, wait for the version to tick up, done.
See your assets. Every sprite, background and logo the agent generated, in a grid. Click any image to view it full size. Music tracks come with a player, so you can listen to what it made without leaving the page.
Read the build reports. For games built by the Phaser Game Agent you get the full story of each run: what you asked for, what the agent replied, what it was thinking, and every tool call it made along the way. Games you built locally through the MCP show their tool timeline here instead. The agent's own reasoning for those lives in your local Claude logs, since that conversation never touched our servers.
Go and break something
You don't need to know any of the API names in this post. They're here so you know what's possible. The prompts are the interface. Ask for the game, and if you want the water to be proper water or the snow to remember your tracks, say so, because the agent knows where those live. And if you just want to experiment, you can ask for something daft and see what it makes. You don't have to make games, you can just ask for a technical demo of a feature and see how it works.
Then open one of your own, hit the new Files button, and have a poke at how it was put together.
Now go and ask it for something daft.
Prompt: "Make a game where I ride a giant snail through a procedurally generated desert, capturing creatures that glow in the dark."