phaser 3 sprite sheet maker

Phaser Sprite Sheet Maker

Make Phaser-ready sprite sheets: an aligned PNG atlas plus a manifest.json of frame rectangles and fps. Load it as an atlas or a spritesheet, then animate.

live sprite · 8f @ 12 fps
▶ Mecha Walk · 8F
Pack workbenchFree · alpha kept · atlas frame data

Pack a Phaser-ready atlas

PNG frames into an aligned atlas plus frame data for Phaser.

  • Exact frame rectangles for atlas loading
  • Per-state fps and loop flags in the manifest
  • Works with Phaser's atlas and spritesheet loaders

Drop files here to jump straight into the workbench

Accepts PNG · WebP · JPG · GIF · MP4 · MOV · WebM · no signup required

Instant Demo — Try Without UploadingRobot · 13 frames · 12 FPS
Robot live animation preview
Packed Alpha Sheet (3302×460 px · 254×460 cell)
Robot packed sprite sheet
Open the pack workbenchAccepts PNG · WebP · JPG · GIF · MP4 · MOV · WebM

Step by step

How it works..

Step 011
RAWframes/*.png

Add frames

Drop PNG frames; they are ordered by filename by default.

Step 022
SAFE PADDING + RECT

Choose the cell

Set a cell size and padding for a consistent baseline.

Step 033
atlas.pngphaser.json

Export for Phaser

Download the PNG atlas and manifest.json with frame rectangles.

Supported Inputs

MP4, MOV, WebM (≤15s 1080p) · Animated GIF · PNG, WebP, JPG (≤240 frames)

Native Engine Exports

PNG Atlas + manifest.json · Godot 4 .tres · Phaser 3 JSON · Unity .meta · Aseprite · FNF XML

Anti-Jitter Alignment

Bottom-Baseline Foot Lock · BBox Center Anchor · Chroma Key & Edge De-Spill

100% Client-Side Privacy

Runs locally in your browser via Canvas 2D — zero server upload, no signup, no watermark.

Phaser 3 Atlas & Spritesheet Loader (TypeScript)

Download free sample PNG + manifest.json →

Export a native Phaser 3 JSONHash atlas from the Pack workbench and load it with this.load.atlas, or slice uniform cells with this.load.spritesheet:

PlayerScene.tstypescript
import Phaser from "phaser";

export class PlayerScene extends Phaser.Scene {
  preload() {
    // Option A: Load native Phaser 3 JSONHash exported by SpritesGen
    this.load.atlas("hero", "/assets/knight.png", "/assets/knight.phaser.json");
  }

  create() {
    this.anims.create({
      key: "walk",
      frames: this.anims.generateFrameNames("hero", {
        prefix: "walk_",
        start: 0,
        end: 24,
        zeroPad: 2,
      }),
      frameRate: 12,
      repeat: -1,
    });

    const player = this.add.sprite(400, 320, "hero").setOrigin(0.5, 1);
    player.play("walk");
  }
}
Compatible with Phaser 3.60+ and Phaser 3.80+. Use 'Export -> Phaser 3 JSON' in /pack or /animate for named frame keys.

What a Phaser Sprite Sheet Needs

Phaser can load two shapes of sprite data. A spritesheet assumes a uniform grid of equal frames, while an atlas carries explicit frame rectangles of any size stored in a JSON file that travels with the image. Uniform grids are simple but brittle, because one wide frame breaks the assumption and shows up cropped in your game.

An atlas sidesteps that. Each frame has a named rectangle, so mixed sizes live happily in one sheet and the loader reads names and regions instead of dividing by a count. A manifest gives you those rectangles plus fps and a loop flag per state, which is everything Phaser needs to build animations without hand-tuning each one.

Keeping frame data in a plain JSON file also means designers can tweak timing and loop points without touching code. That speeds up iteration on feel and lets non-programmers contribute. It also keeps frame names stable, so an animation that references them by string does not break when the atlas is re-packed.

A spritesheet is still fine for uniform art, and it needs no extra JSON at all. The right choice depends on whether your frames vary in size. For anything with mixed poses, an atlas and a manifest save you from special-case code and clipped art.

Loading the Atlas in Phaser

For a uniform grid, load with this.load.spritesheet(key, url, { frameWidth, frameHeight }). This is simple and fast when every frame matches exactly. For mixed sizes, load with this.load.atlas(key, pngUrl, jsonUrl), because Phaser expects its own atlas JSON shape, so convert manifest.json into that shape once with a small build script.

Then create an animation with this.anims.create, using frame names from the atlas. Set frameRate from the manifest fps and repeat: -1 for a looping state, so the cycle runs as long as the state is active. For pixel art, set pixelArt: true in the game config, which disables smoothing so scaled sprites keep crisp edges.

Test the loop seam on a device, not only in the editor, because frame timing can differ under load and a clean editor loop can still hitch on a low-end phone. Store the converted atlas JSON in source control so frame names stay stable for animations that reference them by string across several scenes.

Avoid trimming frames in the atlas after export. Re-pack from the originals so the named rectangles always match the pixels on screen and no animation references a stale region. Keeping the manifest as the source of truth makes the whole pipeline reproducible and keeps builds identical across machines.

Why a Manifest Beats a Uniform Grid

A uniform grid forces every frame into one size. Wide attacks and tall bosses then get clipped or padded wastefully, and you lose detail at the edges exactly where the silhouette matters most. Explicit rectangles pack tight and stay correct, so Phaser reads each frame by name and nothing drifts on import even when frames vary a lot.

The manifest also carries timing and loop data, so you stop hand-tuning frameRate and loop flags for every animation. That cuts a repetitive source of bugs and keeps timing consistent across states. It doubles as documentation, because new frames and states are described in plain data any teammate can read without opening the art.

When a character gains a new state you add frames and re-pack, and the rectangles update together so the atlas and the game data never fall out of step. A uniform grid would require re-deriving cell counts and offsets for the new frames, which is exactly where mistakes creep in as a project grows.

Per-state fps is another gain. One sheet can hold a slow idle and a quick run without extra configuration, and designers can retune feel by editing a number rather than rewriting animation code. That separation of data and logic keeps a Phaser project maintainable over time.

Workflow Tips for Phaser Teams

Keep a consistent cell size for one character so the sprite origin lines up across states. Set origin once and reuse it for every animation, so a transition never shifts the character on screen. Derive frameRate from the manifest fps so the game matches your browser preview, since small speed differences change how a run or jump feels.

The browser pack, slice, and animate tools are free, and only AI generation costs credits with failed runs refunded automatically, so a first pass on a new character is cheap to try. Store the converted atlas JSON in source control, and regenerate it from the manifest when the art changes so names stay stable.

Avoid trimming frames in the atlas after export, and re-pack from the originals so the named rectangles always match the pixels on screen. Keep padding between frames to prevent filtering from bleeding a neighbour in, especially on high-contrast outlines that Phaser renders at fractional scale.

For teams, document the atlas JSON format once so everyone converts the manifest the same way. A shared script avoids drift between what the artist exports and what the programmer loads, and it makes onboarding a new developer far faster.

Write down the few lines that convert a manifest into Phaser's atlas JSON, and keep them in the repository. Once that conversion is scripted, any artist export drops into the project with no programmer time, and frame names stay identical across builds. That small investment pays back on every new character and every iteration of an existing one.

FAQ

Frequently asked questions.

Is this an official Phaser tool?+
No. spritesgen is independent and not affiliated with Phaser. It exports a PNG atlas and JSON that you load in your own Phaser project.
Can Phaser load the manifest as-is?+
Phaser uses its own atlas JSON format. Convert manifest.json into that shape once, either by hand or with a short script, then load it with this.load.atlas.
Is packing free?+
Yes. Packing, slicing, and export are free in the browser. Only optional AI generation consumes credits.
Atlas or spritesheet, which should I use?+
Use a spritesheet for uniform frames and an atlas for mixed frame sizes. An atlas is more flexible and avoids clipping wide poses.
How do I keep pixel art crisp?+
Set pixelArt: true in the Phaser game config. That turns off smoothing so scaled sprites keep hard edges.
Do my frames leave my machine?+
No. Packing and export are client-side. Frames only go to a server if you explicitly request an AI step.
Can I control loop and speed?+
Yes. The manifest records a loop flag and fps per state. Use those values when you create the Phaser animation.