DailyConvertTools

Frame Sheets Explained: How to Build Animation Sprite Sheets

What frame sheets (sprite sheets) are, how to plan and build one from separate animation frames, and how to use it in Unity, Godot and Phaser without flicker or bleeding edges.

Behind many smooth character movements in 2D games and web animations is a frame sheet: a single image containing every frame of an animation, arranged in a grid. Whether you're a game developer, an animator or a digital artist, knowing how to build and use frame sheets makes animation work faster and more organised.

What is a Frame Sheet?

A frame sheet (also called a sprite sheet) is an image file that contains multiple frames of an animation arranged in a grid pattern. Instead of loading many separate image files, applications can load one frame sheet and display different portions of it to create animation.

Benefits of Frame Sheets

  • Performance: loading one image is faster than loading many, and game engines can draw from one texture more efficiently
  • Organisation: all the frames of an animation live in one file
  • Consistency: a regular grid forces uniform frame sizes and spacing
  • Compatibility: most game engines and animation tools can slice a grid of frames
  • Overview: you can see every frame at once when planning and reviewing

Understanding Frame Sheet Anatomy

A well-structured frame sheet follows specific conventions:

Grid Layout

Frames are arranged in rows and columns with consistent spacing:

  • Each frame occupies the same amount of space
  • Frames are aligned in a regular grid pattern
  • Rows typically represent different animations or directions
  • Columns represent sequential frames in an animation

Frame Order

The usual reading order is left to right, top to bottom, but some projects use:

  • Column-first ordering
  • Custom sequences required by a particular engine
  • A separate row for each animation state or direction

Common Use Cases

Game Development

Frame sheets are a staple of 2D game development:

  • Character animations: walking, running, jumping, attacking
  • Environmental effects: water, fire, smoke, explosions
  • Interface elements: animated buttons and loading indicators
  • Particles: sparks, dust and magic effects

Web Animation

On the web, frame sheets are used for:

  • CSS animations (shifting the background position step by step)
  • Canvas-based animations
  • Loading indicators
  • Interactive illustrations

Motion Graphics

Animators also use frame sheets to:

  • Plan animation sequences
  • Lay out storyboards
  • Show timing at a glance
  • Share work with a team for review

How to Make a Frame Sheet

Most sprite-sheet tools and game engines follow the same basic steps:

  • Add your frames: select every image in the animation.
  • Put them in order: sort by file name or drag them into sequence.
  • Set the grid: choose the number of columns and rows.
  • Preview the layout to check the order and spacing.
  • Export the sheet, usually as a PNG.

What to look for in a sprite-sheet tool

  • Many frames at once: add a whole animation in one go
  • Flexible grid: choose your own rows and columns
  • Padding options: space between frames to prevent edge bleeding
  • Preview: see the complete sheet before exporting
  • Lossless output: PNG export at full resolution, with transparency kept
  • Metadata export (optional): a JSON file listing frame positions, which many engines can read

Popular options include TexturePacker, the sprite-sheet export in Aseprite, and the built-in tools in Unity and Godot.

Creating Effective Frame Sheets

Planning Your Animation

Before creating frames:

  • Define the animation: what movement or effect are you creating?
  • Count the frames: how many do you need for the motion to read clearly?
  • Keep one size: make every frame exactly the same dimensions.
  • Choose an anchor point: decide where the character "stands" in each frame, usually the feet, and keep it fixed.

Frame Count and Frame Rate

Two numbers control how an animation feels: how many frames are in one cycle, and how fast they play (frames per second, or fps).

  • 4 to 8 frames per cycle: typical for simple, retro-style walk cycles and idle loops
  • 8 to 12 frames per cycle: smoother movement for most 2D games
  • 12 fps: a common playback speed for hand-drawn and pixel-art animation
  • 24 fps or more: very smooth, but every extra frame is more drawing and a bigger sheet

More frames aren't always better: snappy, low-frame animation is part of many games' style.

Naming Conventions

Organize your source files clearly:

  • Use sequential numbering (frame001, frame002, etc.)
  • Include animation name (walk001, jump001)
  • Add direction if applicable (walkleft001)

Technical Best Practices

Image Format Selection

Choose the right format for your needs:

  • PNG: the standard choice, lossless and with transparency
  • WebP: smaller files with transparency support, mainly for the web
  • JPEG: avoid for sprites; it has no transparency and blurs sharp edges

Resolution Guidelines

Frame size depends on your art style and how big the sprite appears on screen:

  • Pixel art: often 16×16, 32×32 or 64×64 pixels per frame, scaled up in the game
  • Detailed 2D characters: often 128×128 to 512×512 pixels per frame
  • Web: keep sheets as small as possible for fast loading

Power of Two Sizes

Some engines and older devices prefer sheet dimensions that are powers of two:

  • 256×256, 512×512, 1024×1024, 2048×2048
  • Helps with certain texture compression formats
  • Most modern engines no longer require it, but it does no harm

Working with Game Engines

Unity

Unity has built-in sprite sheet support:

  • Import your frame sheet as a texture
  • Use the Sprite Editor to slice into frames
  • Create animations from the sliced sprites

Godot

Godot 4 uses the AnimatedSprite2D node with a SpriteFrames resource:

  • Create a SpriteFrames resource and choose "Add frames from sprite sheet"
  • Set the number of horizontal and vertical frames
  • Select the frames for each animation and set the speed

Phaser (Web)

Phaser, a popular web game framework, works directly with sprite sheets:

  • Load the sheet with this.load.spritesheet(), giving the frame width and height
  • Create animations from frame ranges with this.anims.create()
  • Play them on a sprite with sprite.play()

Advanced Techniques

Texture Atlases

For larger projects, consider a texture atlas:

  • Frames of different sizes are packed tightly into one image
  • A metadata file (JSON or XML) records where each frame is
  • Frames are referenced by name instead of grid position

Animation State Machines

For characters with many animations:

  • Use one sheet per animation, or one row per animation within a sheet
  • Plan how each state (idle, walk, jump) transitions to the others

Optimization Strategies

Keep frame sheets efficient:

  • Remove unused frames
  • Trim empty space around frames (texture atlases do this automatically)
  • Compress PNGs losslessly with an optimiser before shipping

Troubleshooting Common Issues

Flickering Animations

  • Check that every frame is exactly the same size
  • Keep the anchor point in the same place in every frame
  • Check the frame order

Bleeding Edges

Thin lines from neighbouring frames appearing at the edges of a sprite:

  • Add 1 to 2 pixels of padding between frames
  • Use "extrude" options in your packing tool, which repeat edge pixels into the padding
  • For pixel art, set texture filtering to "nearest" (point) rather than linear

Performance Problems

  • Reduce the sheet's dimensions if it's very large
  • Use lower-resolution sheets for mobile devices
  • Load sheets only when they're needed

Conclusion

Frame sheets are essential for anyone working with animation in games, web or multimedia. Plan your frames carefully, keep them the same size and choose a tool that exports the layout your engine expects.

Want to preview your animation? Our free GIF Maker turns a set of frames into an animated GIF in your browser, which is a quick way to check timing before building the final sheet.