unity sprite sheet maker

Unity Sprite Sheet Maker

Build Unity-ready sprite sheets: an aligned PNG atlas plus a manifest.json listing every frame rectangle, its fps, and loop flag. Import them without hand-slicing.

live sprite · 8f @ 12 fps
▶ Knight Walk · 8F
Pack workbenchFree · alpha kept · manifest for Unity

Pack a Unity-ready atlas

PNG frames into an aligned atlas plus manifest.json for Unity.

  • Slice frames by exact rectangles, not guesswork
  • Export manifest.json with per-frame rects and fps
  • Drop the atlas straight into Unity's Sprite Editor

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 your frames

Drag in PNG frames or a folder; they are ordered by filename.

Step 022
SAFE PADDING + RECT

Set a consistent cell

Choose cell size and padding so every frame shares one baseline.

Step 033
sheet.pngmanifest.json

Export for Unity

Download the PNG 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.

Unity 2D Sprite Slice & Runtime Loader (C#)

Download free sample PNG + manifest.json →

Download the Unity Meta JSON from the Pack/Slice workbench, or slice your PNG atlas directly in C# using the exact x/y/w/h frame rectangles from manifest.json:

ManifestSpriteLoader.cscsharp
using UnityEngine;

[System.Serializable]
public class FrameRect { public int x, y, w, h; }

public class ManifestSpriteLoader : MonoBehaviour {
    public Texture2D atlasTexture;
    public FrameRect[] frames; // Populated from manifest.json frame_layout.rows
    public float fps = 12f;
    public int pixelsPerUnit = 100;

    private Sprite[] _sprites;
    private SpriteRenderer _sr;

    void Awake() {
        _sr = GetComponent<SpriteRenderer>();
        _sprites = new Sprite[frames.Length];
        for (int i = 0; i < frames.Length; i++) {
            var r = frames[i];
            float unityY = atlasTexture.height - r.y - r.h;
            _sprites[i] = Sprite.Create(
                atlasTexture,
                new Rect(r.x, unityY, r.w, r.h),
                new Vector2(0.5f, 0f), // Bottom-center foot pivot
                pixelsPerUnit
            );
        }
    }

    void Update() {
        if (_sprites.Length > 0)
            _sr.sprite = _sprites[(int)(Time.time * fps) % _sprites.Length];
    }
}
Note: Unity Sprite.Create uses bottom-left Y coordinates; this loader converts top-left manifest.json rectangles automatically.

What a Unity Sprite Sheet Needs

Unity does not read a sprite sheet by magic. It reads a texture and a set of sprite rectangles, and when those rectangles are wrong the animation plays cropped, offset, or visibly torn at the edges. The bug is easy to miss in stills and obvious the moment the character moves on screen.

A uniform grid works only when every frame is exactly the same size, and real character art often is not. An attack frame may be wider than an idle frame, so a uniform grid clips the swinging weapon and part of the arm. Padding every frame up to the largest one fixes the clip but wastes atlas space.

A manifest records every frame as an absolute rectangle, so Unity can use those values directly and a wider pose still lands inside its own cell. Each entry also lists the frame size and its position in pixels, which removes the guesswork of dividing a texture by a hand-counted column count.

The manifest carries a per-state fps and a loop flag too, so you stop re-deriving timing by eye once the art reaches the engine. The descriptor remembers what the preview showed, and a teammate who imports later sees the same motion you approved rather than their own interpretation.

Importing the Atlas into Unity

Drop the PNG into your Assets folder and select it. Set Texture Type to Sprite (2D and UI) and Sprite Mode to Multiple, because these two settings tell Unity the image holds many sprites rather than one, and they gate every slicing option that follows. Skip them and the Sprite Editor will not offer frame slicing at all.

Open the Sprite Editor and slice by grid, or write a short AssetPostprocessor. The postprocessor can read manifest.json and create sprites at the exact rectangles instead of a guessed grid, which keeps import automated and repeatable across a whole team. It also means a re-export never silently changes frames.

Set a consistent pivot, usually bottom-center, so characters stand on the ground line. A drifting pivot is the usual cause of a sprite that appears to bob or float between frames, and it is invisible until the animation plays against a floor tile. For pixel art, also set Filter Mode to Point and turn off compression so crisp edges stay crisp.

Keep the atlas free of extra margins you did not account for. If padding is part of the manifest the importer already knows it, so let the data describe the layout rather than eyeballing offsets. Hand offsets drift the moment someone re-exports the sheet with a slightly different cell size.

Why a Manifest Beats a Uniform Grid

A uniform grid assumes one size fits all, and that assumption breaks the moment an animation has a lunge, a wide swing, or a taller boss frame. The engine then samples the wrong region, so the art tears or shows a sliver of the neighbouring frame. Exact rectangles let tight art pack tightly and avoid padding every frame up to the largest one.

The manifest doubles as documentation. A teammate opening the project sees named frames and timing instead of reverse-engineering a screenshot, and onboarding a new artist becomes far simpler. When you replace one frame later you re-pack and the rectangles update together, so the art and its descriptor never drift apart.

A uniform grid also forces a single fps for every state, while a manifest can carry different fps per state. A slow idle and a fast run then coexist in one file without extra bookkeeping, and tuning one does not disturb the other. That flexibility matters as a character's move set grows.

Finally, the manifest makes the sheet portable. Any loader that reads rectangles can play the same frames, so an asset built for Unity still opens in Godot, a browser canvas, or a custom renderer. A uniform grid ties you to one engine's assumption about cell size and count.

Workflow Tips for Unity Teams

Keep the cell size identical across a character's states, because shared cells keep pivots aligned and prevent a size jump between idle and walk. Create one AnimationClip per state and set its sample rate to the fps in the manifest, so the engine plays the cycle exactly as you previewed it in the browser.

Use sprite atlases only after the sheet imports cleanly. Additional packing can reintroduce seams if done carelessly, so confirm the base sprites first and then optimize. Premature packing hides mistakes behind a second layer of indirection and makes debugging much harder.

The packing and preview tools are free in the browser. Only optional AI generation spends credits, at 15 per image or 20 to 45 per full set, and failed runs are refunded, so experimenting with a small set is cheap. If a frame looks off, fix it at the source and re-pack rather than editing the atlas by hand.

Editing the atlas by hand desynchronizes it from the manifest, and the next export will overwrite your manual changes anyway. Treat the manifest and the source frames as the source of truth, and let the exporter regenerate the atlas whenever the art changes, so the project stays reproducible from its inputs.

Commit the manifest and the source frames as one unit. If you version the atlas but not the JSON, a teammate can check out a sheet whose frame data no longer matches, and the animation breaks in a way that is hard to trace. Keep them together and the project rebuilds cleanly from a fresh clone every time, on any machine.

FAQ

Frequently asked questions.

Is this an official Unity tool?+
No. spritesgen is an independent sprite sheet tool and is not affiliated with or endorsed by Unity. It simply exports a PNG and JSON that Unity can import.
Can Unity read the manifest automatically?+
Not out of the box, but a short AssetPostprocessor can read manifest.json and create sprites at the exact rectangles. You can also slice by grid in the Sprite Editor.
Is packing frames free?+
Yes. Packing, slicing, and export run free in your browser with no signup and no watermark. Credits only apply to optional AI generation.
What does the manifest contain?+
Each frame's absolute rectangle, its size, the atlas size, and per-state fps and loop flags. Unity can map those values to sprites and animation clips.
Will my frames upload to a server?+
No. Packing and export are client-side, so source frames never leave your machine. Only an AI step you explicitly request runs on a server.
Can I use the output commercially?+
You own your art. spritesgen does not claim rights over frames you upload. Check that you have the rights to any AI-generated output you ship.
Does it work with pixel-art filter settings?+
Yes. Export keeps a transparent alpha channel, and you set Filter Mode to Point in Unity so the crisp pixels stay crisp.