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.