2d character sprite sheet generator

2D Character Sprite Sheet Maker

Build aligned 2D character sprite sheets for platformers and RPGs, then export a PNG atlas and a manifest.json with frame rectangles and fps.

live sprite · 8f @ 12 fps
▶ Knight Walk · 8F
Pack workbenchFree · aligned baseline · JSON manifest

Pack a 2D character sheet

Frames into an aligned atlas plus manifest.json.

  • Pack idle, walk, and action frames together
  • Shared baseline keeps characters grounded
  • Manifest with per-state rects and fps

Drop files here to jump straight into the workbench

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

Instant Demo — Try Without UploadingKnight · 8 frames · 10 FPS
Knight live animation preview
Packed Alpha Sheet (2432×420 px · 304×420 cell)
Knight 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

Load your character's idle, walk, and action frames.

Step 022
FOOT BASELINE LOCK

Align the baseline

Use one cell size so every state stands at the same height.

Step 033
atlas.pngmanifest.json

Export the sheet

Download the atlas and manifest.json with exact 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.

Standard manifest.json Frame Layout Schema

Download free sample PNG + manifest.json →

Every export includes a clean PNG atlas plus a machine-readable manifest.json (alongside one-click Godot .tres, Phaser 3 JSON, Unity .meta, Aseprite JSON, and FNF XML):

character.manifest.jsonjson
{
  "characterId": "knight",
  "sprite_sheet_alpha": "knight.png",
  "cell": { "width": 387, "height": 460, "safe_margin_x": 6, "safe_margin_y": 6 },
  "animation": {
    "cellWidth": 387,
    "cellHeight": 460,
    "columns": 25,
    "rows": {
      "walk": { "row": 0, "frames": 25, "fps": 12, "loop": true }
    }
  },
  "frame_layout": {
    "sheetWidth": 9675,
    "sheetHeight": 460,
    "cellWidth": 387,
    "cellHeight": 460,
    "rows": {
      "walk": [
        { "x": 0, "y": 0, "w": 387, "h": 460 },
        { "x": 387, "y": 0, "w": 387, "h": 460 }
      ]
    }
  }
}
All coordinates are integer pixel rectangles from the top-left corner of the PNG atlas — zero floating-point UV rounding drift.

What a 2D Character Sheet Needs

A 2D character sheet holds the frames for one character's states: idle, walk, jump, attack, and more. Each state is a short animation of its own, but they all belong to the same character and share the same proportions. All those states must align to the same ground line, or the character appears to hop or shrink at each transition.

A manifest records each frame's rectangle and per-state timing, so the engine maps states without ambiguity. The data replaces guesswork about cell counts and per-state offsets, and it lets a loader pick frames by name rather than by a fragile index. Consistent cell size across states is the simplest way to keep the character stable.

The manifest also carries a loop flag, so a looping walk and a one-shot attack can live in the same file with correct behavior. Without that flag, an engine might loop an attack forever or play a walk once and freeze, and the bug would be in the data rather than the art.

A character sheet is also the unit of iteration. When you want to add a dash or a hurt state, you add frames to the same sheet and re-pack, and the manifest grows with it. Keeping one sheet per character avoids scattering related frames across many files.

Building the Sheet

Group frames by state and order them by step. Filename ordering drives the default pack order, so clear names save manual sorting and reduce mistakes. Pick one cell size across all states, and a jump frame may be taller, so give the character room and keep the feet anchored to the baseline.

Align every state to a shared baseline. That single choice fixes most of the visual jitter between animations and makes transitions feel solid rather than floaty. Preview each state in the animator and confirm timing before you export the final atlas, so a bad loop is caught before it reaches the engine.

Keep padding between cells so filtering never bleeds one state into another. Adjacent high-contrast frames are where bleed shows first, and it looks like an art bug rather than a settings problem. A few pixels of padding is cheap insurance against a seam that follows the character across the screen.

Draw the idle and walk first, since most of the screen time is spent in those states, and polish them before adding rare action frames. A character that idles and walks well feels finished even if a seldom-seen attack is rough, and players notice the common states most.

Why the Manifest Beats a Uniform Grid

A uniform grid assumes all frames match. A tall jump or wide attack then clips at the cell edge, and the lost detail is gone for good once the atlas is packed. Exact rectangles keep every state intact, and the engine draws the true box whatever its size, so a big action frame stays whole.

The manifest also stores fps and a loop flag per state, so run speed, idle pace, and one-shot attacks are all documented in one place instead of scattered through code. Adding a new state later is simple: pack it and read the updated rectangles, with no re-deriving of cell counts or per-state offsets.

It also keeps the sheet portable. Any loader that reads rectangles can play the states without a custom importer for each engine you target, so a prototype can move between a browser build and a native build without re-exporting the art or rewriting the animation logic.

Finally, the manifest documents the character's state list. A reader can see that this sheet has idle, walk, jump, and attack, and how many frames each uses, which is far clearer than opening the atlas and trying to infer the boundaries from the image.

Workflow Tips for 2D Games

Keep the ground line fixed across states so transitions read cleanly. Animate around a stable anchor rather than recentering each frame, which causes a subtle vertical bounce. Use the manifest fps when building animation clips so the engine matches your preview, because small speed differences change how a jump or a dash feels.

Packing and preview are free in the browser. Only AI generation spends credits, and failed runs are refunded automatically, so the free path covers most 2D pipelines. Draw the idle and walk first, since most screen time is spent in those states, and polish them before adding rare action frames.

Re-export from the originals after edits, because hand-editing the atlas desynchronizes it from the manifest and is overwritten on the next pack. Keep the manifest and the PNG together in version control so a fresh checkout rebuilds the same states and no one has to recount frames.

Document the cell size and baseline the project expects. A short note stops a new artist from exporting at a slightly different scale, which is the kind of mismatch that only appears after integration and is hard to trace back to a single file.

Watch how the hitbox and the visual frame line up, because a wide attack frame may extend well past a character's collision box. If the sprite looks like it hits before the weapon connects, the visual and the logic disagree, and the fix is in the data, not the art. Keep the anchor at the feet so the ground line is stable, and let the manifest carry the frame rectangles the engine uses for effects. Test a transition between idle and attack, since that seam is where many small alignment issues surface. If a state feels floaty, check the baseline before adding frames, because a shared anchor fixes most jitter without touching a single pixel of the art.

FAQ

Frequently asked questions.

What kinds of 2D games does it suit?+
Platformers, RPGs, and action games all work. Any game that draws frames by rectangle can use the atlas and manifest.
Is packing free?+
Yes. Packing, slicing, and export are free in the browser with no account. Only optional AI generation uses credits.
How do I stop state changes from jittering?+
Use one cell size and a shared baseline across every state. Keep the feet anchored so the character stands at the same height.
Can I mix states of different sizes?+
Yes. The manifest gives each frame an exact rectangle, so a tall jump and a wide attack both stay intact.
Do my frames get uploaded?+
No. Packing and export run locally. Frames reach a server only if you request an AI step.
Can I preview each animation?+
Yes. The free animator plays a sheet as a loop and shows fps, so you can check timing before importing.
Can I use the sheets commercially?+
You keep rights to your own art. For AI output, confirm your use complies with the applicable license before shipping.