Apps Part of Flipline

Pixel Sprite Atlas (Aseprite JSON)

Turn a Flipline pixel sprite into a sprite sheet PNG plus Aseprite-style JSON for game engines.

More options

Try an example: ·

More about this tool

How it works

Paste a Flipline Pixel Studio project (.flipline-pixels.json). Get one sheet PNG and an atlas in the JSON layout Aseprite exports, which Phaser, Godot and many engine importers read: frame rectangles, durations, tags, layers and slices. Identical frames, such as linked cels, can share one sheet cell.

  • Frames are composited front to back with layer opacity, exactly as Pixel Studio shows them, and scaled by whole pixels (nearest neighbour). One grid cell per frame in timeline order, placed like the Sprite Sheet Layout Planner (row-major, padding around and between cells).
  • Durations come from frame holds and the sprite FPS (hold × 1000 / FPS, rounded to 10 ms like the GIF export). Saved ranges become frameTags with 0-based inclusive from/to; ping-pong is written as pingpong. Layers are listed bottom to top. Regions become slices with bounds, pivot and nine-slice center, all scaled.
  • With merging on, frames whose composited pixels are identical (linked cels, held poses) point to the same rectangle, like Aseprite’s Merge Duplicates. The JSON never trims or rotates frames, so spriteSourceSize equals the frame.

Independent export in the documented Aseprite JSON layout; not affiliated with Aseprite. No trimming, rotation or packing other than a grid.

Sources

Part of Flipline

  • Flipline Drawing, storyboards & animation

    A few drawings. A little life. Make a flipbook in your browser.

    Open Flipline

How to use Pixel Sprite Atlas (Aseprite JSON)

Turn a Flipline pixel sprite into one sprite sheet PNG plus an Aseprite-style JSON atlas with frame rectangles, durations, tags, layers and slices.

What it is for

Game engines rarely load an animated GIF. They want one sheet image and a data file that says where every frame sits and how long it stays on screen. Aseprite's JSON export has become the common layout for that: Phaser, Godot and many importers read it. This tool produces exactly that pair from a sprite you drew in Flipline's Pixel Studio.

Paste the editable project (.flipline-pixels.json). You get sprites.png and sprites.json. The JSON lists every frame in timeline order with its rectangle and duration, your saved animation ranges as frameTags, your layers and your regions as slices with pivots and nine-slice centres. Pixel Studio's own export menu has the same option, Sprite sheet + Aseprite JSON, built on the same engine.

Worked example

The default input is Flipline's small sprout: four 32 × 32 frames held for 2 ticks at 8 frames per second, plus one extra frame that is a linked cel of the first frame, and a saved range called sprout in ping-pong. The tool answered "5 frames in 3 sheet cells, 64 × 64 px."

Worked example
FrameXYWHDuration (ms)
A small sprout 0.aseprite003232250
A small sprout 1.aseprite003232250
A small sprout 2.aseprite3203232250
A small sprout 3.aseprite0323232250
A small sprout 4.aseprite3203232250

Frames 0 and 1 share a rectangle because frame 1 is linked to frame 0. Frames 2 and 4 share one too: the "Lift" and "Settle" poses happen to be pixel-identical. Each frame lasts 2 × 1000 / 8 = 250 ms. The range came out as {"name":"sprout","from":0,"to":4,"direction":"pingpong"}.

The second example scales by 4 with 2 px padding. The sheet grew to 262 × 262 px, and the third frame moved to x = 132, because 2 + 128 + 2 = 132.

How to read the result

  • Metrics: frames in the timeline, sheet cells actually drawn, sheet size, and the number of tags and slices.
  • Frames table: the same rectangles and durations that are in the JSON.
  • Sprite sheet PNG: full alpha, nearest-neighbour scaling, no smoothing.
  • Aseprite JSON atlas: frames as a hash (name → frame) or an array with filename, and meta with size, scale, frameTags, layers (bottom to top) and slices.

Tips and common mistakes

  • Turn off Identical frames share one cell if your engine expects one cell per frame, for example when you plan to repaint the sheet by hand.
  • Tag positions are 0-based in the JSON, while Pixel Studio shows frames from 1.
  • Columns 0 picks a nearly square grid; any other value fixes the number of columns.
  • Frames are never trimmed or rotated, so spriteSourceSize always equals the frame. Engines that expect packed atlases with trimming still read it, but the sheet is not the smallest possible.
  • The sheet is limited to 16 megapixels. Lower the scale if the tool refuses.

FAQ

Is this the same file Aseprite writes?

It follows the documented JSON layout of Aseprite's sheet export with --list-tags, --list-layers and --list-slices. It is an independent export, so fields Aseprite writes only for its own features (user data, cel data, tilesets) are not included.

What are linked cels?

In Pixel Studio, Duplicate as linked frame adds a frame that shares its pixels with the original. Drawing on either changes both, which is handy for held poses. Unlink this cel gives the frame its own copy again.

Are hidden layers included?

No. The sheet shows what Pixel Studio shows: visible layers with their opacity. Hidden layers are still listed in meta.layers.

Can I import the JSON back into Flipline?

Not yet. Keep the editable .flipline-pixels.json for later changes.

Guide last updated:

For scripts and AI agents

  • JSON API: POST https://fliplinepixelatlas.usefulweb.app/api/v1/calculate (same calculation as this page)
  • Interface description: OpenAPI 3.1 · AI guide: llms.txt
  • MCP server (Streamable HTTP): https://fliplinepixelatlas.usefulweb.app/mcp · tool name flipline_pixel_atlas
Example request
curl -s -X POST https://fliplinepixelatlas.usefulweb.app/api/v1/calculate \
  -H 'content-type: application/json' \
  -d '{}'
Feedback · ideas & bug reports welcome