Pack your frames into a sprite sheet — with a JSON atlas your engine can read
Bring your frames in as a GIF or an existing sheet — or draw and AI-draft them — arrange them on a timeline, and export a packed PNG with a JSON atlas that lists every frame’s coordinates. It runs in your browser, and it’s one part of a full pixel studio: draw or generate a sprite, animate it, then pack it. Free for early adopters — sign in with Google.
From frames to a packed sheet, in four steps
The core job first — turn a set of frames into a single sheet plus the coordinate data your engine needs. Here is exactly how that runs in Tsubu.
- 01
Bring your frames in
Drop an animated GIF and Tsubu decodes each frame, reading its per-frame delays to set the FPS (up to 32 frames). Or drop an existing sprite sheet — a zip or a PNG + JSON pair slices straight back into frames, and a bare PNG sheet slices by frame size with a live grid overlay so you can line the cut up. No frames yet? Draw them, or let the optional AI draft a first pass. Everything lands as real, editable pixels.
- 02
Line them up on the timeline
Arrange the frames on a frame-by-frame timeline — reorder, retouch a stray pixel, add or delete a frame — and scrub the preview at 1–30 FPS (8–12 is the pixel-art sweet spot). What you see playing is exactly what gets packed, in the same order.
- 03
Set the packing
Choose the layout: a single horizontal strip or a grid of N columns, with padding between cells if your pipeline wants a gutter. Pick a clean nearest-neighbor upscale — 1×, 2×, 4× or 8× — so a 16×16 or 32×32 sprite stays crisp at any size.
- 04
Export the sheet + atlas
One click gives you a zip with a packed PNG and a JSON atlas: every frame’s x/y/w/h rectangle, its duration in milliseconds, and a whole-animation frame tag. Prefer a single image or a preview loop? Export a transparent PNG or an animated GIF from the same asset.
What goes in, what comes out
Concretely — the formats the maker reads, and the files it writes. The import and export atlases use the same schema, so a sheet you export re-imports to the same frames.
Imports
- Animated GIF — decoded frame by frame; the per-frame delays set the FPS
- Sprite-sheet zip, or a PNG + JSON pair — sliced back into editable frames (a true round-trip)
- Metadata-less PNG sheet — sliced by frame size with a live grid-overlay preview
- Grids from 1×1 up to 256×256 per side; larger art is downscaled to a grid you choose
Exports
- Packed sprite sheet — a PNG plus a JSON atlas in the Aseprite / TexturePacker array shape
- Per-frame x/y/w/h rectangles, millisecond durations and a whole-animation frame tag
- Single-frame transparent PNG, or an animated GIF, from the same frames
- Nearest-neighbor upscale at 1×, 2×, 4× or 8×, with configurable columns and padding
One honest note on how Tsubu packs: it builds the sheet from an animation’s frames — drawn, generated or imported — not from a pile of separate image files, so the packing step is the end of an editing loop rather than a standalone drop-the-folder tool.
A packer that hands you editable pixels, not just a PNG
Most sprite-sheet tools take images you already finished and arrange them — genuinely useful, and to be clear, plenty of free web packers even export engine-ready atlases, so packing and atlas export aren’t the differentiator here. Tsubu’s difference is that it sits a step earlier and a step later: the frames you pack are live, editable pixels on a canvas.
That means you fix a jittery pixel, swap a palette colour or add an in-between frame right where you pack — no bouncing a PNG out to a separate editor and back through a packer. The sheet is the last step of a loop, not an isolated chore.
Draw it, or let AI draft the first pass — then edit every pixel
Start on a real pixel canvas with keyboard-first tools — B pencil, E eraser, G fill, I eyedropper, M select-and-move, [ and ] to size the brush, Ctrl+Z to undo — over a checkerboard that shows exactly which pixels stay transparent. Or turn on the optional AI: type “a tiny knight with a red cape”, pick 16×16 or 32×32, and it drafts a grid-true, limited-palette, transparent sprite — a strong first pass, not a finished asset. Already have a sprite? Hand it over and the AI drafts animation frames onto the timeline for you to retouch.
It’s AI-assisted and human-refined: the model drafts, every pixel stays yours to edit, and what it drafted stays separable so you can disclose it. AI is entirely optional — you can pack a hand-drawn or imported sheet without ever prompting it. On training data and provenance the wider field hasn’t settled the question, and we’d rather flag that plainly than wave it away.
Grid-true output your engine can actually slice
The point of a sheet is that your engine can find each frame. Tsubu writes the familiar Aseprite / TexturePacker array atlas: Phaser and Pixi read that JSON directly, and Unity and Godot slice the sheet through their own importers — with real per-frame rectangles and millisecond durations, so nothing is guessed. Output is grid-true, palette-constrained and transparent-background: pixel-true, not pixel-style.
The maker stays engine-agnostic on purpose — it names Unity, Godot, Phaser and Pixi evenly and doesn’t bake in any one engine’s quirks. The deeper per-engine import walkthroughs (Godot’s SpriteFrames and AnimatedSprite2D, for instance) get their own dedicated pages rather than crowding the packer.
Free during early access — and honest about what that means
Tsubu runs in your browser with nothing to install, and it’s free for early adopters right now, with AI usage sponsored by the platform so there’s no per-generation credit meter. That’s a limited-time launch offer — the honest version of the word, not “free forever”.
There’s no credit card. There is a Google sign-in, so unlike the open-the-page-and-pack tools you do sign in first — the trade is a cloud library that keeps every sheet and its editable frames with you between machines.
Sprite sheet maker — common questions
- How do I make a sprite sheet from a GIF?
- Drop the GIF onto Tsubu. It decodes each frame and reads the per-frame delays to set the FPS, up to 32 frames, landing them as editable pixels. Tidy or reorder them on the timeline, then export a packed sheet with a JSON atlas — a PNG plus per-frame coordinates.
- What format is the sprite-sheet atlas?
- A JSON atlas in the Aseprite / TexturePacker array shape: each frame’s x/y/w/h rectangle, its duration in milliseconds, and a single whole-animation frame tag, zipped with the packed PNG. Phaser and Pixi read that JSON directly; Unity and Godot slice the sheet through their own importers.
- Can I import an existing sprite sheet to edit it?
- Yes. A zip — or a PNG + JSON pair — exported in the atlas format slices straight back into editable frames, a true round-trip. A bare PNG sheet with no metadata slices by frame size with a live grid-overlay preview, so you can watch the cut line up before importing.
- Does it work for Unity, Godot, Phaser and Pixi?
- The sheet is a PNG plus a JSON atlas in the TexturePacker / Aseprite array format. Phaser and Pixi consume that JSON directly; Unity and Godot slice the sheet through their own importers. Free packers export engine atlases too — Tsubu’s difference is that the frames stay editable in the same tab.
- Can I make a sprite sheet without AI?
- Yes — AI is entirely optional. Draw every frame by hand on the keyboard-first canvas, or import a GIF or an existing sheet, and pack it. No prompt is required at any point.
- Is Tsubu really free, and do I need an account?
- It’s free for early adopters for a limited time, with AI usage sponsored so there’s no per-generation credit cap — a launch-window offer, not free forever. There’s no credit card, but you do sign in with Google, which is how your sheets and frames save to a cloud library.
Pack your first sheet
Bring in a GIF or an existing sheet, tidy the frames, and export a packed PNG + JSON atlas. Free for early adopters — sign in with Google.
Open the editor