godot 4 sprite sheet maker

Godot Sprite Sheet Maker

Create Godot-ready sprite sheets: an aligned PNG atlas plus a manifest.json for SpriteFrames. Every frame rectangle and fps is listed, so nothing is guessed at import.

live sprite · 8f @ 12 fps
▶ Slime Bounce · 8F
Pack workbenchFree · alpha kept · SpriteFrames ready

Pack a Godot-ready atlas

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

  • Exact frame rectangles for AtlasTexture regions
  • Per-state fps and loop flags in the manifest
  • Clean alpha for AnimatedSprite2D frames

Drop files here to jump straight into the workbench

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

Instant Demo — Try Without UploadingSlime · 16 frames · 12 FPS
Slime live animation preview
Packed Alpha Sheet (8736×340 px · 546×340 cell)
Slime packed sprite sheet
Open the pack workbenchAccepts PNG · WebP · JPG · GIF · MP4 · MOV · WebM

Step by step

How it works..

Step 011
RAWframes/*.png

Load your frames

Drop PNG frames or a folder; files are ordered by name.

Step 022
SAFE PADDING + RECT

Fix the cell and padding

Set one cell size and padding so frames share a baseline.

Step 033
sheet.png.tres

Export for Godot

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

Godot 4 AnimatedSprite2D & .tres Import Snippet

Download free sample PNG + manifest.json →

Export a native Godot 4 .tres SpriteFrames resource straight from the Pack or Animate workbench, or parse manifest.json at runtime with 15 lines of GDScript:

SpriteManifestLoader.gdgdscript
extends AnimatedSprite2D

@export var sheet_texture: Texture2D = preload("res://sprites/knight.png")
@export var manifest_path: String = "res://sprites/knight.manifest.json"

func _ready() -> void:
    var data: Dictionary = JSON.parse_string(FileAccess.get_file_as_string(manifest_path))
    var sf := SpriteFrames.new()
    var rows: Dictionary = data["frame_layout"]["rows"]
    var anims: Dictionary = data["animation"]["rows"]
    for state in rows.keys():
        sf.add_animation(state)
        sf.set_animation_speed(state, float(anims[state].get("fps", 12)))
        sf.set_animation_loop(state, bool(anims[state].get("loop", true)))
        for rect in rows[state]:
            var atlas := AtlasTexture.new()
            atlas.atlas = sheet_texture
            atlas.region = Rect2(rect["x"], rect["y"], rect["w"], rect["h"])
            sf.add_frame(state, atlas)
    sprite_frames = sf
    play(rows.keys()[0])
Works in Godot 4.x with AnimatedSprite2D. Set CanvasItem -> Texture -> Filter to Nearest for crisp pixel art.

What a Godot Sprite Sheet Needs

Godot animates sprites through SpriteFrames, which holds a list of textures and a frame rate. Each texture is usually an AtlasTexture that points at one region of a sheet, so the region data is what the engine actually draws. If those regions are off by a few pixels you see seams, missing limbs, or frames that drift.

The grid must match the art exactly, not approximately, because small errors are very visible in motion on a character with a clean outline. A manifest lists each frame as an absolute rectangle, and you read those rectangles to create one AtlasTexture per frame. Every region then becomes precise and repeatable across a team, with no recounting of columns.

The manifest also records fps and a loop flag per state, which maps cleanly to a SpriteFrames animation's speed and its loop setting. Timing survives the export, and the engine reproduces what you previewed rather than defaulting to its own pace. That consistency is the difference between a prototype and a shipped animation.

Because the rectangles live in data, you can regenerate the SpriteFrames from a script whenever the art changes. That keeps the sheet and the engine resource in sync, which avoids the classic drift between art and engine data. It also means a new character set can reuse the same import routine.

Importing the Atlas into Godot

Import the PNG into your project and open it. You can slice regions by hand, but reading the manifest is faster and exact, because hand slicing drifts the moment the art changes and nobody remembers the original numbers. Create an AtlasTexture for each frame, set its atlas to the PNG, and set its region from the manifest rectangle.

Add each texture to a SpriteFrames resource in order, so the animation matches the intended sequence. Set the animation speed from the manifest fps and enable loop where the flag says so, then attach the SpriteFrames to an AnimatedSprite2D and preview it in the editor before wiring it into gameplay.

For pixel art, set the texture filter to Nearest, which keeps hard edges sharp when the sprite is scaled up in a low-resolution game. Blurry pixels ruin the retro look and make small details unreadable. If you script the import, read the JSON once and build the SpriteFrames in an editor plugin so every new sheet needs no manual steps.

Keep the manifest next to the PNG in your project and treat it as source data. That makes the import reproducible for anyone who checks out the repository, and it survives a machine rebuild. Avoid trimming frames by hand after export, and re-pack from the originals so the rectangles always match the pixels.

Why a Manifest Beats a Uniform Grid

A uniform grid assumes every frame is the same width and height, and one wide attack frame breaks that assumption and gets clipped at the cell edge. The swing loses its reach and its silhouette, which is exactly the detail that sells the move. Exact rectangles instead pack tight and skip padding every frame up to the biggest one, saving atlas space and texture memory.

The manifest is also living documentation. It names frames and timing so a new teammate understands the layout without opening the art files, and reviews take minutes rather than an afternoon. Re-pack after an art change and the rectangles follow, so the atlas and its descriptor stay in sync across the whole project and silent regressions are rare.

Per-state fps in the manifest also means one sheet can hold a slow idle and a quick run. Each animation keeps its own speed without extra configuration, so tuning one does not disturb the other. A uniform grid would force a single rate for every state and make that tuning awkward.

Because regions are data, the same sheet can drive a Godot SpriteFrames resource, a custom loader, or a tool-side previewer. That portability keeps the asset useful beyond one project, and it means a pipeline change never forces a re-export of the art.

Workflow Tips for Godot Teams

Keep one cell size across a character's states so pivots and baselines stay aligned between idle, walk, and attack. A shared cell prevents a size jump at state changes, which is the most common visual glitch in 2D animation and the easiest to prevent up front.

Use the manifest fps as the SpriteFrames speed, and play the animation in the editor to compare it with the browser preview. Small timing fixes at build time save runtime tuning, and they keep the feel consistent across states without a per-clip spreadsheet.

The free browser tools cover packing, slicing, and animation preview, while AI generation is the only paid step and failed runs are refunded automatically. Store the manifest with the PNG in version control, and re-export from the originals after edits rather than trimming the atlas by hand.

Anchor characters at the feet so they sit on the ground plane. Consistent anchors matter even more in a side-scrolling Godot scene, where a two-pixel drift reads as floating and distracts the player from the action, so a shared baseline is worth enforcing in the source art too.

Keep a shared prefix in filenames for each character so the packer groups them predictably. A consistent naming scheme means you never fight the default order, and a new state slots into the sequence without a manual shuffle. It also makes the manifest easier to read when several characters live in one folder and one import routine handles them all.

FAQ

Frequently asked questions.

Is this an official Godot tool?+
No. spritesgen is independent and not affiliated with the Godot project. It exports a PNG and JSON that you import into Godot yourself.
Does Godot read manifest.json directly?+
Not natively, but you can read it once to build AtlasTexture regions, or write a small editor script that creates SpriteFrames from the rectangles.
Is packing free?+
Yes. Pack, slice, and export are free in the browser with no account. Only optional AI generation spends credits.
How do I keep pixel art sharp?+
Set the texture filter to Nearest in Godot. Export from spritesgen with a transparent alpha channel so edges stay clean.
Can I preview the loop before importing?+
Yes. The free animator plays the sheet as a loop and shows fps, so you can confirm timing before you build SpriteFrames.
Do my frames get uploaded?+
No. Packing and export run locally in your browser. Source frames stay on your machine unless you choose an AI step.
Can I use the sheets in a commercial game?+
You keep the rights to your own art. For AI-generated frames, make sure your use complies with any applicable license before shipping.