texture atlas maker

Texture Atlas Maker

Pack a texture atlas from your frames with padding and clean edges, then export a PNG atlas and a manifest.json with exact frame rectangles.

live sprite · 8f @ 12 fps
▶ Mecha Walk · 8F
Pack workbenchFree · padding controls · JSON manifest

Pack a texture atlas

PNG frames into a padded atlas plus manifest.json.

  • Pad and space frames to avoid bleeding
  • Exact rectangles for every frame
  • Transparent PNG for clean edges

Drop files here to jump straight into the workbench

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

Instant Demo — Try Without UploadingRobot · 13 frames · 12 FPS
Robot live animation preview
Packed Alpha Sheet (3302×460 px · 254×460 cell)
Robot 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 images

Drop the frames or tiles you want in one atlas.

Step 022
FOOT BASELINE LOCK

Set padding

Choose cell size and spacing so edges never bleed.

Step 033
atlas.pngmanifest.json

Export the atlas

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

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.

What a Texture Atlas Is

A texture atlas packs many small images into one larger texture. Drawing from one texture is faster than switching between many separate ones, so it saves draw calls every frame. Games use atlases to cut draw calls, and a well-packed atlas also loads as a single file instead of dozens of small ones, which simplifies asset loading.

The main risk is bleeding. When filtering samples near a frame edge, it can pull colour from a neighbouring frame and leave a visible seam that follows the sprite in motion. Padding between frames prevents that, and a manifest then tells the engine exactly where each frame sits, so the layout and the data agree.

A good atlas balances packing density with clean edges. Too tight and seams appear; too loose and you waste texture memory that could hold more art. The right padding depends on your filter settings and how much the sprite is scaled, so check it at the scale you actually ship.

An atlas also reduces state changes in the renderer, which often matters more than raw file size. One texture bound for a whole character or a whole scene lets the GPU batch draw calls, and that is where the real frame-time savings come from in a busy game.

Packing With Padding

Set a cell size large enough for the biggest frame, then add padding between cells. A few pixels is usually enough to stop bleeding at common filter settings. Keep the background transparent so edges stay clean against any scene, and export preserves the alpha channel, which makes compositing simple and avoids a halo.

Check the preview for frames that touch a neighbour. If they do, raise the padding before exporting so filtering has room to breathe and cannot reach across the gap. Write the manifest from the same grid, so every rectangle matches the packed result exactly and the data describes the real layout rather than an idealised one.

If your engine uses power-of-two textures, round the atlas size up. Padding and rounding together keep sampling stable across different hardware and drivers. Leave a margin at the atlas border too, not just between frames, since filtering at the outer edge can also pull unwanted colour into the nearest frame.

Group assets that appear together into one atlas so they batch well. Do not mix unrelated scenes into the same page for no reason, since that hurts batching and makes the atlas harder to reason about when one scene changes and re-packs the whole texture.

Why a Manifest Beats a Uniform Grid

A uniform grid wastes space when frames differ in size. Small icons get padded up to the biggest cell, which is pure waste in a big atlas and can push it over a memory limit. Exact rectangles pack tighter and stay correct, so the engine reads true boxes instead of assuming a grid and clipping the odd frame that does not fit.

The manifest also documents frame names and sizes, which helps when many artists share one atlas and need to find a sprite quickly without opening the art. Reuse is easier too: add a frame, re-pack, and the rectangles update together, so the atlas and its data never drift apart and a late addition does not break earlier work.

It also makes the atlas portable across engines and tools, since rectangles are a universal way to describe regions of a texture and every loader understands them. That portability means an atlas built for a prototype is not trapped in one runtime when the project moves to another engine.

Finally, the manifest keeps the atlas auditable. When a sprite looks wrong, you can check its rectangle against the source art instead of guessing whether the packer or the filter caused the problem, which shortens debugging from an afternoon to a few minutes.

Workflow Tips for Atlases

Group assets that appear together into one atlas so they batch well, and do not mix unrelated scenes into the same page. Use power-of-two sizes where your engine prefers them, and keep padding consistent across the whole atlas so sampling behaves predictably from frame to frame.

Packing and preview are free in the browser. Only AI generation spends credits, and failed runs are refunded automatically, so iterating on a layout costs nothing. Leave a margin at the atlas border too, not just between frames, because filtering at the outer edge can also pull unwanted colour into the nearest sprite.

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 manifest and the PNG together in version control so a fresh checkout rebuilds the same atlas without anyone re-measuring frames by hand.

Measure the real memory cost of the atlas before shipping. A generously padded atlas can be larger than expected, and knowing the numbers early tells you whether to split it or trim the padding before it becomes a load-time problem on a low-end device.

If an atlas grows past your engine's comfortable texture size, split it by scene or by state and give each piece its own manifest. A single huge atlas can exceed a mobile GPU limit and fail to load at all, which is worse than a few slightly larger files. Watch the memory cost, not just the file size, because an uncompressed texture takes far more room once it reaches the GPU. Keep padding consistent across the split so each piece samples cleanly at its edges. Document the split in the manifest so the loader knows which sheet holds which frame, and a late addition does not force a full re-pack of everything.

FAQ

Frequently asked questions.

What is texture bleeding?+
Filtering near a frame edge can sample a neighbouring frame's pixels, causing seams. Padding between frames prevents it.
Is packing free?+
Yes. Packing, slicing, and export are free in the browser with no account. Only optional AI generation uses credits.
How much padding do I need?+
A few pixels between cells is usually enough. Raise it if the preview shows frames touching or seams appear at runtime.
Does it keep transparency?+
Yes. Export preserves the alpha channel, so frame edges stay clean against any background.
Can I control the atlas layout?+
Yes. Set cell size and padding, and the manifest is written from those values so rectangles match exactly.
Do my images upload anywhere?+
No. Packing and export run locally. Images reach a server only if you request an AI step.
Can I use the atlas in a commercial project?+
You keep rights to your own art. For AI output, confirm your use complies with the applicable license before shipping.