Sprite Sheet Generator for Unreal Engine

Generate animated 2D sprite sheets for Unreal Engine. Export PNG sheets and JSON frame data, then build Paper 2D Sprites, Paper Flipbooks, and Blueprint-driven playback faster.

Try AutoSprite Free

Content/Sprites/Player_Run.png

Example AutoSprite character sprite sheet for Unreal Engine import

Paper 2D import

PNG sheet to Paper Flipbooks

Paper 2D Sprites

Extract Sprites

Flipbook playback

PluginPaper 2D

AssetsSprite + Flipbook

RuntimeBlueprint or C++

Output fit

What AutoSprite exports for an Unreal Engine project

Paper 2D works best when every sheet has predictable frame dimensions, clean alpha, and animation states that can become separate Flipbooks.

Unreal needs

Paper 2D plugin available in the project
Sprite frames extracted from a predictable texture grid
Flipbook assets that match gameplay states

AutoSprite gives

PNG sheets with transparent backgrounds
JSON metadata for frame sizing reference
Per-animation outputs for clean asset naming

Transparent PNG sheets

Export one clean sheet per character move so Unreal can import the texture and split it into Paper 2D Sprite assets.

JSON frame reference

Use AutoSprite metadata to confirm frame dimensions, columns, and frame counts before extracting sprites from a grid.

Per-animation outputs

Keep idle, walk, run, jump, attack, hit, and custom actions separate so each one maps cleanly to a Paper Flipbook.

Consistent characters

Start from a prompt or single reference image and keep the same silhouette, costume, and camera angle across the move set.

Export files at a glance

PNG spritesheet

Texture source

The Unreal import starts from the PNG sheet, then Paper 2D extracts Sprite assets from the grid.

JSON frame data

Frame reference

Unreal does not consume AutoSprite JSON by default; use it as a reference or for a custom import script.

Multiple sheets

Separate Flipbooks

Keep animation states separate so asset naming and Blueprint playback stay straightforward.

Packed atlas

Custom pipeline

Use this only if your project has a custom atlas importer or editor automation around Paper 2D.

Actual workflow

From AutoSprite to Unreal Paper 2D in four passes

AutoSprite supplies frame art while Unreal keeps ownership of the Content Browser, Paper 2D assets, movement, collisions, and runtime gameplay state.

Generate the artExtract SpritesPlay Flipbooks

Prompt or image

Start from a character brief or existing concept art.

PNG sheet

Download one uniform sheet per move from AutoSprite.

Paper Sprites

Extract the imported texture into individual Sprite frames.

Paper Flipbook

Assemble frames into playback assets and switch them from game state.

Start with the Paper 2D asset path in mind

Plan the generated character around Unreal assets you can import, extract, and play back.

Upload a concept image or describe the player, enemy, NPC, pickup, or effect you need.
Name the game camera, silhouette, art style, and target scale before generating frames.
For a Paper 2D project, verify the Paper 2D plugin is enabled — it usually is by default in UE5.

AutoSprite upload step for creating an Unreal Engine sprite character

Choose moves that become Paper Flipbooks

Pick animation states that map directly to the Flipbooks your Blueprint or C++ character will play.

Select idle, walk, run, jump, attack, hit, or a custom action.
Keep each move separate so every generated sheet can become a focused Flipbook asset.
Use names that fit Unreal asset conventions such as Player_Idle, Player_Run, and Player_Attack.

Animation selection screen for Unreal Engine sprite sheet generation

Generate, preview, and check the frame grid

Inspect the take before it lands in your Content Browser.

Check motion timing, readable silhouettes, foot sliding, weapon drift, and clipped frame edges.
Confirm the sheet uses a uniform grid so sprite extraction is predictable.
Regenerate or adjust the prompt before you import the texture into an Unreal project.

AutoSprite preview screen showing generated Unreal animation frames

Import, extract sprites, and create Flipbooks

Bring the PNG into Unreal, split the sheet into Sprites, then assemble those Sprites into Paper Flipbooks.

Import the PNG as a Texture asset and use the Paper 2D Sprite extraction workflow for grid frames.
Create a Paper Flipbook for each action and set its Frames Per Second to match the generated motion.
Drive a PaperFlipbookComponent from Blueprint or C++ while Unreal owns input, collision, movement, and state changes.

Paper 2D import path

Import PNG sheets, extract Sprites, then assemble Paper Flipbooks for the actions your character needs.

Paper 2D overview

Flipbook playback

Use Flipbooks for frame sequences, then switch those assets from a PaperFlipbookComponent.

Paper Flipbook docs

AutoSprite export screen for downloading Unreal sprite sheets and JSON

Paper 2D import

Settings that keep Unreal assets predictable

A good Unreal handoff keeps the texture, extracted Sprites, Flipbook assets, and runtime component easy to inspect.

Paper 2DSprite extractionFlipbook assets

Unreal Paper 2D checklist

Plugin

Paper 2D

Verify Paper 2D is enabled (it usually is by default) before working with Sprites, Flipbooks, and Tilemaps.

Texture asset

Imported PNG

AutoSprite's sheet starts as a normal texture in the Content Browser.

Sprite extraction

Extract Sprites

Use the frame size and grid count from AutoSprite metadata instead of guessing cells by eye.

Animation asset

Paper Flipbook

Assemble extracted Paper Sprites into Flipbooks for idle, run, jump, attack, and other states.

Runtime playback

PaperFlipbookComponent

Use a PaperCharacter, Actor, Blueprint, or C++ class to swap Flipbooks during gameplay.

Pixel rendering

Nearest-style filtering for pixel art

Right-click the texture and use Sprite Actions > Apply Paper2D Texture Settings so pixel sprites stay crisp when scaled.

Asset flow

Keep AutoSprite output mapped to Unreal Paper 2D systems

Unreal works best when the generated sheet, extracted Sprites, Flipbooks, and runtime character state are separate enough to debug quickly.

Import Player_Idle, Player_Run, and Player_Attack as separate texture sheets.
Extract Paper Sprites from each sheet with consistent frame sizing.
Create Flipbook assets like FB_Player_Idle and switch them from Blueprint or C++ state logic.

Paper 2D asset flow

Content/Sprites

Texture

T_Player_Run_Sheet

Sprites

SPR_Player_Run_00...11

Flipbook

FB_Player_Run

Runtime

PaperFlipbookComponent

Flipbook assets

FB_Player_IdleFB_Player_RunFB_Player_Attack

State drivers

VelocityInputAttack events

AutoSprite supplies the sheets. Unreal owns imported assets, Flipbooks, movement, collision, and runtime state.

Import guardrails

Common Unreal sprite-sheet mistakes to avoid

Most Unreal issues come from skipping Paper 2D setup, guessing grid dimensions, or expecting JSON to create assets without tooling.

Paper 2DFrame gridTexture settings

Paper 2D is not enabled

Sprites and Flipbooks live in the Paper 2D workflow. The plugin ships enabled by default, but verify it under Edit > Plugins if the Sprite Actions are missing.

JSON is treated as a native import format

AutoSprite JSON is useful metadata, but Unreal does not automatically convert it into Paper 2D assets without custom tooling.

Frame dimensions are guessed

Use the exported frame width, frame height, columns, and frame count so extracted sprites line up with the generated cells.

Pixel art gets blurred

Check texture filtering, compression, and project render settings when scaled pixel art looks soft in the viewport.

Collision and scale are left for later

After import, verify pivots, pixels-per-unit scale, collision, and capsule size before wiring movement logic.

Workflow decision

When this Unreal workflow is the right fit

Use AutoSprite for animation coverage, then let Unreal own imported assets, Flipbook playback, character state, and gameplay.

Use AutoSprite when

Your Unreal prototype needs 2D motion quickly

Use this workflow when input feel, enemy behavior, hit timing, or readable Paper 2D animation is blocked by missing frames.

Use Paper Flipbooks when

The animation is frame-based

Flipbooks are the direct Paper 2D fit for a series of extracted Sprite frames played in sequence.

Use Blueprint when

Designers need to tune state logic

Blueprints are a clean place to switch idle, run, jump, attack, and hit Flipbooks from movement or gameplay events.

Use C++ or editor utility when

You are automating import at scale

Custom tools make sense when a production project needs repeatable import, naming, and Flipbook creation across many sheets.

Pipeline fit

Built around the way Unreal turns textures into Paper 2D assets

AutoSprite sits before Unreal's Content Browser, Paper 2D Sprite assets, Paper Flipbooks, PaperFlipbookComponent, and Blueprint or C++ runtime logic.
Use it when missing 2D character motion is blocking a Paper 2D prototype, a hybrid 2D/3D scene, or an animation-heavy gameplay test.
The practical handoff is concrete: generate the character, import the PNG, extract Sprites, create Flipbooks, and switch those Flipbooks from game state.

Prototype before final animation polish

Use generated idle, run, jump, and attack sheets while you tune input, camera, collision, and PaperCharacter movement.

Keep Unreal as the runtime source of truth

AutoSprite supplies frame art. Unreal still owns Content Browser assets, Paper Flipbooks, components, collision, input, and rendering settings.

Treat JSON as reference unless you automate it

AutoSprite metadata is useful for frame size and count, but native Paper 2D asset creation still happens in Unreal unless you build custom tooling.

Check pivots and scale early

Sprite pivots, pixels-per-unit choices, and collision sizes affect how the character feels once movement code starts driving playback.

Blueprint or C++ handoff

Swap Flipbooks from gameplay state

After exporting AutoSprite sheets, an Unreal character can switch Flipbook assets from input, velocity, attack state, or animation events.

Verify Paper 2D is enabled (it usually is by default) before creating Sprites or Flipbooks.
Import each AutoSprite PNG sheet into the Content Browser.
Extract Sprite frames using the exported frame dimensions as reference.
Create Paper Flipbooks, then swap them from Blueprint or C++ on a PaperFlipbookComponent.

PlayerPaperCharacter.cpp

#include "PlayerPaperCharacter.h"
#include "PaperFlipbook.h"
#include "PaperFlipbookComponent.h"

void APlayerPaperCharacter::PlayMove(UPaperFlipbook* NextFlipbook)
{
    UPaperFlipbookComponent* Flipbook = GetSprite();

    if (!NextFlipbook || !Flipbook) return;
    if (Flipbook->GetFlipbook() == NextFlipbook) return;

    Flipbook->SetFlipbook(NextFlipbook);
    Flipbook->PlayFromStart();
}

void APlayerPaperCharacter::UpdateAnimation()
{
    const bool bIsMoving = !GetVelocity().IsNearlyZero();

    if (bIsAttacking)
    {
        PlayMove(AttackFlipbook);
    }
    else if (bIsMoving)
    {
        PlayMove(RunFlipbook);
    }
    else
    {
        PlayMove(IdleFlipbook);
    }
}

Unreal use cases

Where an Unreal sprite sheet generator helps most

AutoSprite helps most when missing frame animation is blocking Paper 2D gameplay tests, asset iteration, or hybrid scene work.

Paper 2D prototypesNPC motionHybrid scenes

2D character prototypes

Generate enough idle, run, jump, hit, and attack motion to test PaperCharacter feel before final art production.

Paper 2D enemies and NPCs

Create readable frame animation for creatures, townspeople, effects, and interactable objects in Unreal scenes.

Hybrid 2D and 3D projects

Use sprite characters or effects in Unreal levels while the engine continues to own camera, lighting, collisions, and state.

FAQ

Unreal Engine sprite sheet questions

These are the practical questions developers usually ask before they try the workflow in a real Unreal Engine project.

Does AutoSprite work with Unreal Engine?

Yes. AutoSprite exports PNG sprite sheets that fit an Unreal Paper 2D workflow: import the texture, extract Sprites, create Paper Flipbooks, and play them from Blueprint or C++.

Does Unreal import the AutoSprite JSON automatically?

Not by default. Use AutoSprite JSON as frame-size and frame-count reference, or build custom editor tooling if you want automated asset creation.

Should I use Paper Flipbooks for character animation?

Yes for frame-based 2D animation. Paper Flipbooks play a series of Paper Sprites in sequence and are the most direct Unreal asset for sprite-sheet animation.

Do I need to enable Paper 2D?

Yes. Paper 2D is Unreal's built-in system for 2D Sprites, Flipbooks, Tilemaps, and related components, and it may need to be enabled as a plugin.

How do I keep pixel art crisp in Unreal?

Check texture filtering, compression, mipmaps, and project rendering settings after import. Pixel art usually needs nearest-style filtering and careful scaling.

Can I use these sprites in a 3D Unreal scene?

Yes. Paper 2D can support 2D and hybrid 2D/3D projects, so sprite animation can live inside a broader Unreal scene when that fits the game.

Generate your first Unreal sprite sheet.

Start with a prompt or character image, choose the Paper 2D animation moves you need, and export PNG sheets when the motion is ready to test.

Try AutoSprite Free

AutoSprite is independent and is not sponsored by or affiliated with Epic Games or Unreal Engine.