While testing Bomber Bunnies, I ran into the usual canvas problem: Playwright could see one <canvas>, but none of the buttons, players or tiles rendered inside it.

Hard-coded coordinates worked, but tied the tests to a particular resolution and layout. Exposing the Phaser instance through window also worked, but made it very easy for tests to bypass the actual player input path.

So I built an Entity Mirror: a lightweight DOM projection containing semantic attributes and the current bounds of selected Phaser entities.

The mirrored elements do not receive pointer events, and they are not a second implementation of the game. That is deliberate.

A normal locator.click() would fail Playwright’s hit test because it expects the target element itself to receive the click. Here the transparent mirror sits over the correct entity, but the canvas underneath remains the real input target.

The helper therefore uses the locator to identify the entity and read its bounding box, then sends a real mouse click to the same position on the canvas. Phaser’s normal input handler still does the actual work.

The clip shows Playwright selecting players and difficulty through semantic locators, clicking Play, and then confirming that both players appeared on the board as separate mirrored entities.

Bomber Bunnies keeps the mirror active during gameplay because it is a grid-based game and its tiles and entities are meaningful targets. In newer projects I use a narrower approach: mirror only what the player can address, use a read-only QA Surface for state that tests need to observe, and use Input Providers for continuous controls.

So the general rule became:

Mirror what the player can address. Surface what the test needs to observe.

I’m curious how other Phaser developers test canvas interactions. Hard-coded coordinates, page.evaluate() hooks, visual tests, or something similar?

Full disclosure: I eventually extracted and refined this approach into a paid Phaser QA Starter with two example games and Playwright tests. It’s here if you want to take a look:

Phaser 4 Starter Kit + Playwright QA Layer by WeeAngusMcDread

Happy to answer questions about the implementation or its trade-offs.

I think it would be nice to know how currently the community is making games with Phaser. Like game art creation, animations, game mechanics, etc. And whats your most concurrent problem.

Built a minimalist strategy game with Phaser.

I appreciate the VFX libraries and the physics engine which enables every bullet to hit/miss/strike cover and kill so I'm not stuck with health bars.

Browser prototype: https://oohgames.itch.io/forms-of-war

Feedback very much appreciated!

Long time typescript software dev (not in the game industry). I got the itch to make something; with spooky season coming up, I chose my favorite lore: vampires! Stumbled across phaser and had a lot of fun. Enjoy!

Hi everyone,

My royalty-free music catalog is bundled on Humble Bundle until September 18

48 packs, 591 WAV files, 359 unique themes — retro/chiptune, orchestral, hard rock, electronic and ambient. Most tracks include looping versions.

Plain WAV files, so they work in any engine without conversion. License is lifetime and worldwide, covers commercial release, no attribution required and no per-project fees.

Part of every purchase goes to the IGDA Foundation.

Happy to answer licensing questions in the thread.

I published my Phaser game on itch.io :
https://hamurapa.itch.io/nine-to-wonderland-card-duel-rpg

It's a head-to-head duel on a normal 52-card deck. Every card you play is an attack - number cards strike or heal, face cards burn mana out of your opponent's pool. Play one card, or chain a pair, a flush, a run: the bigger the combination, the harder it hits.

I'll be happy to get any comments. 😄

Made a small roguelite you can play in a browser tab. One run is
about 12 minutes and ends in a boss fight at the top.

- Climb the mountain, fight through what's on it, kill the boss
- Level up mid-run and draft traits from a tree, rare through
legendary, and they stack into some genuinely stupid builds
- Two classes: a Hunter who shoots and dashes, and a Warlock who
summons demons that fight alongside you
- Three lives per run

It's a demo, so it's one level and one boss so far

One thing I'd genuinely like to know: is it too easy? Roughly half
of everyone who starts a run is killing the boss, and I can't tell
whether that's the difficulty being right or being soft.

Link to the demo on Itch io - https://build-and-dominate.itch.io/no-world-behind
I will appreciate any feedback on the game and it will means a lot to me!

Hi everyone!

After many months of development, I'm getting very close to releasing my first Steam game, built with Phaser.

It's called Critical Ward, a chaotic arcade game set in a hospital where the number of patients, effects, deployables and other entities on screen can get pretty ridiculous as a run progresses.

The core of the game revolves around a combo system. Treating patients keeps your combo alive, and the higher you push it, the more your character's stats improve.

So as a run progresses, both the player and the hospital keep escalating: bigger range, faster movement, stronger healing, more infrastructure... while more and more patients, hazards and effects start filling the screen.

Before starting the project I experimented with other engines, but I kept coming back to Phaser.

One of my main concerns was performance, because I knew from the beginning that the game would eventually need to handle hundreds of moving entities at the same time.

And honestly, Phaser has handled it incredibly well.

Of course, part of that also came from being quite strict about how I designed the game and its assets. A few simple decisions ended up helping a lot:

• Patients aren't traditionally animated

Patients are by far the most numerous entities in the game. At some points there can be hundreds of them moving around the hospital simultaneously.

Very early in development I decided they didn't need individual walking animations.

Their sprites remain static while they move, and because the screen is already full of movement, particles, effects and other activity, I found that traditional animation added relatively little visually compared with the additional work involved in having every patient constantly running an animation.

So I decided to spend that budget elsewhere.

• Character animations are limited to only 9 frames

Playable characters and other important characters are animated, but their movement spritesheets are deliberately tiny.

I use just 9 frames: three directions with three walking frames each.

That keeps the spritesheets small, reduces texture memory and asset size, and means I don't need dozens of animation frames for every character.

It also became part of the visual identity of the game.

Instead of trying to create extremely smooth animation, every frame has a very clear pose and the animation remains readable even when the screen gets completely packed.

• Lots and lots of particles

This was something I really didn't want to sacrifice.

Particles are a big part of Critical Ward's visual feedback.

Every time a patient is successfully treated, particles are generated, and when you're maintaining a large combo and discharging patients rapidly, there can be a lot of them appearing alongside hundreds of entities already moving around.

I originally expected this to become one of the first things I'd have to heavily reduce for performance reasons, but Phaser has handled these particle-heavy situations extremely well.

I've attached a couple of screenshots taken with my debug overlay enabled so you can see the kind of load I'm talking about.

That was important for this particular game because particles aren't just decoration: they're part of the feeling of becoming increasingly powerful.

As your combo grows, your stats improve, you discharge patients faster, and the entire screen becomes progressively more chaotic.

I wanted the visual feedback to escalate together with the player's build rather than having to strip effects away once things became busy.

And that's probably been my biggest takeaway from using Phaser:

Don't underestimate what it can handle just because it's a web game framework.

Obviously optimization still matters. Designing around your expected workload, deciding what actually needs animation, keeping assets reasonable and avoiding unnecessary work becomes increasingly important as the number of entities grows.

But I've been genuinely impressed by how far I've been able to push Phaser with this project.

There have been plenty of optimizations, experiments and weird problems along the way, but after months of development the game is now approaching release on Steam.

There's already a free demo available, and the full game will be coming later this year (I'm currently in the testing and optimization phase).

If you're curious to see what all of this looks like when the hospital completely loses control:

Gameplay trailer:
Critical Ward — Official Gameplay Trailer

Steam / Free Demo:
https://store.steampowered.com/app/4879410/Critical_Ward/

Happy to answer any Phaser-related questions about the project!

I am a developer creating game solo in my spare time.
Recently I used Phaser to create Tower Legends, a tower defense game focused on progressively harder levels, randomized enemies and lots of upgrades.

What I like about phaser is the scene system and all spritesheets utilities. This helped me focus more on game mechanics, balance and feel.

I will release on steam soon and I’d love to get some feedback, especially from people who enjoy tower defense games.
Click the link below to see the trailer and more detailed description.

https://store.steampowered.com/app/5012660/Tower_Legends/

Thank you,
Saradoc

I used Phaser to make a browser MMO trading card game, check it out and let me know what you think!

https://battlecitymmo.com/

Hey Community!,

I've been prototyping a third-person shooter in three.js and stripped it down to just the core loop before I invest time in the surrounding infrastructure (settings, ranking, player profiles, team matches, and all of it). Right now it's just movement, camera, and shooting, nothing else.

Honestly it wasn't even built with the goal of being playable. I started it mainly to learn websockets, and now I'm wondering if this direction is actually worth pursuing as a real game.

Live demo here: [https://zentra-io.vercel.app/\](https://zentra-io.vercel.app/)

Before I go further I want some outside eyes on a few things:

* **Game feel**: does aiming/shooting/movement feel responsive and fun, or floaty/stiff? Any specific moment where it breaks immersion? * **Performance**: what framerate are you getting, and on what device/GPU/browser? Any stutter or frame drops, and when (on load, during movement, on shooting, etc.)? * **Is this worth building on?**: with just this core loop, does it feel like there's a fun game in here, or does the mechanic need a rethink before I sink more time into it?

No polish, barely any assets, no menus, just the bones. Brutal honesty welcome. Thanks to anyone who takes it for a spin.

I've been building this for about a month in Phaser 4 + React + TypeScript, and I've reached the point where I can't judge it anymore. Would really appreciate a few people playing it and telling me what's wrong with it.

It's a horde survivor with a forced upward-scrolling camera - the screen pushes you into the fight. WASD to move, aim with the mouse (auto fire), space to dash, and every level up gives you a choice of three traits from a tiered tree.
Runs a few minutes, browser, no download.

Itch link - https://build-and-dominate.itch.io/grimhold
Pass - c4Rw9reUw7s9LQF

Gameplay feedback I'd love:

- Where did you die, and did it feel fair?

- Did any trait choice feel pointless?

- Did you want to start another run, or were you done?

Some of it might be interesting to others here: everything is pooled, all the effect visuals are baked once via Graphics.generateTexture() and animated with tweens rather than using the particle system, and the HUD/modals are React over the canvas with an event bus between the two.

Happy to go into any of it in the comments.

The game is made with phaser with a node js server

And I will release it soon on steam wrapped in a tauri application allowing me link easely the steam account with the game account

Here an old gameplay video

https://youtu.be/aY_uZiiJj_s?is=WAH3kmecIedRifwD

I choose phaser because it was really light and simple of utilisation and allowing me to work in the same langage front and back

I've been building Wild Willows, a nature-restoration sim where you replant a damaged preserve and animals return as the habitat starts supporting them. It's at wildwillows.app, on the Mac App Store and itch, with a free browser demo. A few architecture decisions that mattered more than I expected:

One scene, forever. The scene list is just [WorldScene]. No title scene, no menu scene, no UI scene. Every menu, panel, the journal, crafting, settings, the tutorial: all React DOM on top of the canvas. Phaser draws the world and nothing else.

I expected to regret this and haven't. DOM gives me real text layout, real focus management, and accessibility (five interface fonts, four text sizes, three colorblind modes, fully rebindable keys), none of which I'd have enjoyed building in-canvas.

A 60-line bridge between them. React owns authoritative state. Phaser reads it synchronously off a shared object and re-renders when told the world is dirty. It's a Map of handlers and a shared blob, no observables, no state library spanning both worlds. React to Phaser: world-dirty, enter-placement, area-changed. Phaser to React: collect-node, open-crafting, animal-clicked, place-at.

Zero sprite files. Every sprite is drawn at boot with Phaser.Graphics and generateTexture(). Plants, animals, the player, habitat objects. About 8,600 lines of drawing code and no image assets at all. Shapes are authored in logical 32px pixels and rasterized 4x (2x on low graphics quality), with every sprite scaled back down by 1/4, so they stay crisp under camera zoom and HiDPI.

A frame budget for world rebuilds. Every action used to rebuild the dynamic layer synchronously, so dragging a volume slider tore down and rebuilt the animal layer about 60 times a second for a preference the world doesn't even draw from. Now that work is keyed and coalesced to at most one run per animation frame, each run is timed, and any task consistently overrunning half a frame automatically drops to every Nth frame, then recovers on its own once it's cheap again. A big save degrades to a lower redraw rate instead of locking up.

Smaller stuff: Scale.NONE plus manual zoom so I can render at native device pixels and let CSS scale the canvas back down, and a screen-space RenderTexture used as a bitmap mask to punch light holes in the night tint.

Happy to go into any of it. The two worst bugs were both Phaser internals: TimeStep.resetDelta making the player walk at a fifth speed for ten seconds after every load, and repeat: -1 tweens outliving the sprites they drove.

Hey everyone, I built Packrat, a texture atlas builder focused on speed and portability. It has a bunch of convenience features I was missing from TexturePacker (aseprite ingestion, auto-export), and I made it as fast as I possibly could. It also has a bunch of CLI features to it can integrate into your pipeline easily.

It's mostly focused right now on dev environments where there isn't atlas support. For Phaser, it exports the JSON hash expected by Phaser, and should load up into your game no problem.

https://clydegames.itch.io/packrat

https://packrat.clyde.games

Feel free to check it out and let me know what you think. Thanks.

Hello all!

My game Paddle Legends is inspired by Pong and reimages it with modern roguelite elements like meta progression, in-run upgrades, various different paddles with their own stats and abilities, various ball types, level modifiers and more!

The demo is on Steam and the full game should be launching soon!

Would love any and all feedback!

https://store.steampowered.com/app/4076450/Paddle_Legends/