webp to sprite sheet

WebP to Sprite Sheet

Convert WebP frames or an animated WebP into a sprite sheet, then export an aligned PNG atlas and a manifest.json with frame rectangles and fps.

live sprite · 8f @ 12 fps
▶ Shroom Patrol · 8F
Pack workbenchFree · alpha kept · in-browser decode

Turn WebP frames into a sheet

WebP images or an animated WebP into an aligned atlas.

  • Decode WebP frames in the browser
  • Keep transparency from the source
  • Atlas plus manifest with rects and fps

Drop files here to jump straight into the workbench

Accepts PNG · WebP · no signup required

Instant Demo — Try Without UploadingShroom · 11 frames · 12 FPS
Shroom live animation preview
Packed Alpha Sheet (4312×460 px · 392×460 cell)
Shroom packed sprite sheet
Open the sprite sheet packerAccepts PNG · WebP

Step by step

How it works..

Step 011
GIFbounce.gif · 16f

Load the WebP

Drop WebP frames or one animated WebP file.

Step 022
DISPOSAL + LOOP

Order and trim

Remove duplicate frames and set the playback rate.

Step 033
slime.pngmanifest.json

Export the sheet

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

Why Convert WebP to a Sheet

WebP is great for the web: small files and good colour. But engines do not always load WebP as sprite animation, and support varies by platform and version. Most game pipelines prefer a PNG atlas with known frame rectangles, and converting gives you that standard format without re-drawing anything.

Animated WebP also carries frame timing, which you can preserve as fps in the manifest. The motion survives the conversion instead of being guessed from scratch, and the result imports anywhere a rectangle-based loader runs, so you are not tied to WebP support in the runtime.

The conversion runs in your browser, so files never need to leave your machine. That keeps unfinished art private and avoids upload waits for large clips. It also means you can convert on a laptop with no build tools installed, which is useful for a quick iteration between artist and developer.

Keeping the source WebP as a backup is wise, because conversion produces a new atlas and never edits the original. You can always re-run with different padding or fps if the first result is not quite right, and nothing is lost in the process.

How the Conversion Works

Drop your WebP frames, or one animated WebP, into the tool. Each frame is decoded and listed in order, ready for review before packing. Trim duplicate or broken frames, then set the playback rate you want, and transparency is kept from the source so edges stay clean against any background.

Align the frames on a shared baseline, then pack them into a PNG atlas. The baseline keeps characters grounded frame to frame and prevents a bob between poses. The manifest records each rectangle, the fps, and a loop flag, so the result imports like any sheet you packed by hand from a folder of images.

Check the loop seam in the animator before exporting. Trim a frame or adjust fps if the motion jumps at the wrap point, because a bad seam is obvious in a loop and cheap to fix at this stage. A small trim often turns a nearly-looping clip into a clean one.

Keep a consistent palette across frames. Converting does not fix colour drift between source frames, so review the set first and regenerate any outliers. A single off-colour frame is more noticeable in a loop than a slightly soft frame, because the eye catches the flash of wrong hue.

Why the Manifest Matters

WebP frames may not share a fixed size. A uniform grid would clip or pad them wrongly the moment one frame differs, and the error compounds across the animation. Exact rectangles keep each frame intact, so your engine draws the true box and the animation stays correct through the whole loop.

The manifest carries timing and loop data, so a converted animation plays as it did in the browser. Nothing is retimed by accident during the conversion, and the loop flag ensures the animation repeats rather than freezing on the last frame. That keeps the converted asset faithful to the source.

It also keeps the sheet portable across engines that read rectangles, so you are not locked to one runtime or one WebP decoder. The manifest documents frame order, which helps when you later edit or extend the animation and need to know how the original was sequenced.

Because the data is plain JSON, a build script can read it to generate previews or validate frame counts. That makes the conversion reproducible in a pipeline, so the same source always yields the same atlas and the same timing across machines.

Workflow Tips

Check the loop seam in the animator before exporting, and trim a frame or adjust fps if the motion jumps at the wrap point. Keep a consistent palette across frames, because converting does not fix colour drift and a single off-colour frame stands out in a loop.

Packing and preview are free in the browser. Only AI generation spends credits, and failed runs are refunded automatically, so conversion experiments cost nothing. If you need a shareable preview rather than a game asset, convert the packed sheet to a GIF or WebP with the dedicated tool.

Re-export from the originals after edits, because hand-patching the atlas desynchronizes it from the manifest and is overwritten on the next pack. Keep the source WebP and the manifest together so you can always reproduce the atlas if a setting needs to change later.

Test the converted animation in the engine, not only in the browser preview. Decoders and timing can differ slightly between the tool and the runtime, and catching that early avoids a surprise when the asset reaches a build.

Watch for premultiplied alpha when you convert. Some WebP pipelines store colour with alpha already multiplied in, and re-exporting without handling it leaves a dark halo around edges. If you see a fringe, convert with straight alpha or render on a transparent background before packing. Keep the source frame rate in mind too, since a web preview may run faster than the game and hide a timing issue. Test the final atlas over both a light and a dark background to catch any halo before it ships, because a fringe that is invisible on white can be obvious on a dark scene and hard to trace later. A two-minute check on both backgrounds catches it before a player does, and it costs nothing to run before the final export.

FAQ

Frequently asked questions.

Can it read an animated WebP?+
Yes. Load one animated WebP and each frame is decoded in order, then packed into a PNG atlas with a manifest.
Is the conversion free?+
Yes. Converting and packing run free in the browser with no account. Only optional AI generation uses credits.
Is transparency preserved?+
Yes. The alpha channel from the source is kept, so edges stay clean against any background.
Does it keep the original timing?+
It reads frame delays and maps them to a suggested fps. You can override the rate before exporting.
Do my files upload anywhere?+
No. Decoding and packing run locally. Files reach a server only if you request an AI step.
Can I export to other formats?+
The sheet is a PNG atlas plus JSON. If you need a preview GIF or WebP, use the sprite sheet to GIF tool.
Can I use the result commercially?+
You keep rights to your own art. For AI output, confirm your use complies with the applicable license before shipping.