Ludo.ai
Ludo.ai
Pricing
Features
Blog
Docs
What's New
Contact

You've got questions? We've got answers!

Explore our comprehensive documentation for in-depth information about Ludo.ai and its powerful features.
Generating Game AssetsAPI & MCPAudio GeneratorSprite GeneratorVideo Generator3D Asset GeneratorFAQUser Account and SubscriptionProjectImage GeneratorGame IdeatorAsk Ludo

Sprite Generator

  • Introduction

    The Sprite Generator is a powerful AI tool designed to streamline the creation of 2D game assets. It combines image generation and video animation to produce both static sprites and fully animated sprite sheets from simple text prompts or existing images. This tool is perfect for rapid prototyping, creating unique characters and objects, and generating game-ready assets without needing advanced artistic or animation skills.

    With the Sprite Generator, you can:

    • Create static sprites from a text description — characters, VFX, UI elements, item icons, portraits, logos, tiling sprites, parallax layers, map tiles, textures, and card art.
    • Animate your own images or newly generated sprites with a text prompt.
    • Pin down a specific action by animating between three keyframes — a first, a middle, and a final frame you control.
    • Transfer motion from a reference video, an existing animation, or a library of over 600 ready-made animation presets.
    • Edit existing animations with free-text instructions and optional reference images — swap items, change colors, add effects, restyle, and more.
    • Extend animations forwards or backwards in time, or generate smooth transitions between two animations.
    • Chain multiple animations into a single continuous sequence, or bundle them into an Animation Pack ready for Unity, Godot, Unreal, GameMaker, or any engine that reads sprite-sheet PNGs.
    • Animate pixel art on its own pixel grid, with a dedicated pixel-art model and automatic grid preservation.
    • Generate synchronized sound effects, and even talking or singing animations with built-in audio.
    • Export your results as sprite sheets, individual frames, videos, or GIFs.

    For how the Sprite Generator fits with Ludo's other tools and how to keep one style across all your assets, see Generating Game Assets.

  • Getting Started

    The Sprite Generator offers five main workflows, accessible via tabs at the top left of the interface:

    • New Sprite: Start from scratch by describing the sprite you want to create with text. The AI generates a static image, which you can then choose to animate.
    • Animate: Start with an existing image — either one you've generated in Ludo or one you upload — and describe the animation you want to apply to it.
    • Keyframe Animation: Animate between three frames you control — a first, a middle, and a final keyframe. Use it when you need a specific action (a punch, a swing) or a VFX that appears and disappears, and prompting alone isn't getting you there.
    • Transfer Motion: Apply the specific movement from a video reference, an existing animation, or one of Ludo's animation presets to a static sprite image.
    • Edit Spritesheet: Modify an existing animation with a text instruction and optional reference images — change items, colors, effects, or the overall style while keeping the motion.

    You can switch between tabs at any time; each remembers its own settings, inputs, and uploaded images. The Sprite Sheet Options (frames, sprite size, loop, trim) are shared: whatever you last set on one tab is applied on the others.

    Every generating tab starts with the sprite type — what kind of asset this is. It decides how the asset is framed, whether its background is removed, whether it has to tile, and which models can animate it, so it is worth getting right before anything else. See Sprite Types.

    Numbered step chips run across each form; hovering one gives you a short summary of what that step is for.

    Not sure which workflow you need? See How to Choose the Sprite Animation Mode.

  • Keeping a Consistent Style Across Sprites

    The most reliable way to keep a set of sprites on-model is to start every animation from a still image you already trust. Create your character once in the Image Generator (using a fixed Art Style and a style reference), then bring it into the Sprite Generator's Animate tab: animation preserves the look of the input image, so ten animations of the same still stay recognizably the same character.

    When you need the same character in a different starting position, use the Pose Generator: it keeps the character identical and changes only the pose. This is especially useful for prompt-based animation, where the starting pose shapes the result. Transfer Motion is the alternative when the starting pose matters less, since it applies movement from a reference video or an existing animation onto your static sprite without restyling it. And when a finished set of animations drifts in scale or framing, the Animation Pack export aligns and normalizes them into one consistent bundle.

  • Creating a New Sprite (Text-to-Sprite)

    This workflow is ideal when you have an idea but no starting visual.

    1. Select the "New Sprite" tab. This is the default view when you open the tool.
    2. Select the sprite type. The picker offers every type the Sprite Generator can animate — Sprite, VFX Sprite, UI Element, Item Icon, Game Logo, Character Portrait, Horizontal and Vertical Tiling Sprite, Parallax Layer, Map Tile, Texture, and Card Art. Each one changes how the asset is generated and framed, so pick the one that matches what you're making. See Sprite Types.
    3. Describe your sprite. In the main text prompt box, write a detailed description of the static sprite you want to create.
      • Focus on its appearance, not its movement.
      • Example: "A magical sword with a glowing blue blade and a golden hilt."
    4. Apply filters (optional):
      • Art Style: Choose the specific visual style. The pixel-art styles (Micro Pixel, 8-Bit, 16-Bit, 32-Bit) generate on a known pixel grid, which matters later when you animate — see Pixel Art Sprites and Animation.
      • Perspective: Select a camera angle like Isometric or Side-Scroll. Not every type offers every perspective.
      • Aspect Ratio: You can leave this on "Auto" for the best fit.
    5. Generate the sprite. Click Generate Static Sprite. The AI will produce a set of static images based on your prompt.
    6. Iterate. If you're not happy with the results, refine your prompt and generate again.
    7. Proceed to animation. Once you have a static sprite you like, hover over the image card and click Use as First Frame. This automatically moves your chosen image into the Animate tab, carrying its sprite type with it, ready for the next step.

    If you need a wider range of image types than the ones listed above — backgrounds, scene art, gameplay screenshots, splash screens — generate them in the Image Generator instead.

  • Preparing Animation Keyframes

    Before generating an animation, it's crucial that your keyframes accurately represent the points the motion has to pass through. The AI uses them as its primary guide.

    • On the Animate tab, that's the First Frame and the optional Final Frame.
    • On the Keyframe Animation tab, it's the First, Middle, and Final Frame — see Keyframe Animation.

    This is the most important step for a good result. For example, if you want to create a "walk right" animation, your First Frame sprite must be facing to the right. If the sprite in your First Frame is facing forward, the resulting animation will likely be incorrect.

    Every keyframe slot, on both tabs, gives you two tools directly under its preview to help you prepare that frame: "Change Pose" and "Open In Editor".

    Change Pose

    This tool is built specifically for adapting character sprites into new poses. When you click "Change Pose", a modal will appear where you can:

    • Select a Pose Preset: Choose from a wide range of common game poses (like 'Idle (Right Facing)', 'Walk / Run (Left)', 'Crouching', etc.) to automatically re-orient your character.
    • Use Additional Instructions: You can also select a base preset and then provide text in the "Additional instructions" box to further refine the pose.
    • If the provided sprites don't match your desired pose, select "Other" and describe the pose in the prompt box.

    Open In Editor

    The "Open In Editor" button provides a more general and powerful way to modify your keyframes. This is ideal for making specific changes or touch-ups that "Change Pose" doesn't cover.

    Inside the Image Editor, you can use various tools. For instance, selecting the "Full Edit - Smart edit" mode allows you to make precise changes using only text instructions. If you want more precise control, you can select an "Inpaint with Mask" edit mode.

    Together these two tools are how you build an apex pose for a Keyframe Animation: take your idle sprite, re-pose it into the extreme of the motion (fist extended, sword raised, knees bent), and use that as the Middle Frame.

    Empty Frames

    Any keyframe slot can be set to an Empty Frame — a fully transparent frame — using the option in the slot's picker. This tells Ludo that at that point in time, there is nothing on screen.

    Empty Frames are what make effects fade in and out: an explosion that starts from nothing, a pickup sparkle that dissipates, a character that materializes. On the Animate tab you can empty the first or the final frame; on the Keyframe Animation tab you can empty any of the three, as long as at least one slot holds a real image and no two Empty Frames are adjacent.

  • Animating a Sprite

    The Animate tab turns a static image, one you generated in Ludo or uploaded, into a sprite animation described with a text prompt.

    1. Select the "Animate" tab. If you used the Use as First Frame button, your image will already be loaded here.
    2. Upload or select an image.
      • If the tab is empty, you can upload a new image or choose one from your history.
      • Tip: The image should contain only the sprite. If you upload a cut-out type that still has a background, Ludo runs a free background removal and opens a Review the background removal window so you can inspect the result — zoom in on it, try it against different backdrops, and either accept it or cancel and fix the image first. A clean input yields better animations.
      • You can also optionally provide a Final Frame to define the end pose of the animation. Use the Copy First / Copy Final buttons between the two slots to duplicate one keyframe into the other as a starting point.
    3. Check the sprite type. The Animate tab exposes the same type picker as New Sprite, and it follows the image you select: pick a Ludo-generated asset and its own type is applied automatically. Correct it by hand if you're animating an upload. The type decides framing, background handling, tiling and available models — see Sprite Types.
    4. Describe the animation (optional).
      • In the text prompt, describe the action (e.g., "jump," "attack," "glowing pulse").
      • You can leave this empty to let the AI infer a natural motion (like breathing or idling) based on the image.
    5. Choose a model and duration. Each model has different speed, cost, and quality trade-offs — see the Choosing a Model section for guidance. Duration is shown as a slider with the values supported by the selected model.
    6. Adjust Animation Margin:
      • Auto: Recommended. The AI determines how much space the sprite needs to move.
      • Manual: Set the Horizontal and Vertical margins independently with two sliders (0–100%). Use this if your sprite gets cut off during large movements — increase the axis where the motion needs room (e.g. more horizontal margin for a wide sword swing, more vertical margin for a jump).
      • No margin: The input image is not cropped and no margin is added. It is animated exactly as it is.
      • Full-bleed types (Texture, Card Art) fill their whole frame, so there is no content box to put a margin around: leave the margin on Auto for those.
    7. (Optional) Sprite Sheet Options. You can adjust the sprite sheet options before generation to preview with the right settings. These do not affect the underlying generation and can be re-adjusted for free after the animation completes. See the Sprite Sheet Options section for details.
    8. Click "Animate" to generate the animation.

    If the generate button shows an amber marker, Ludo has spotted a combination that often fails — hover it to see what and why. Some of those warnings come with a one-click fix button. See Known Limitations.

  • Transfer Motion

    The Transfer Motion feature allows you to take the specific movement from a video or an existing animation and apply it to a static sprite. This is a powerful tool for replicating complex movements or ensuring consistency across different characters.

    Use Cases:

    • Instant Professional Animations: Use the built-in animation presets to instantly apply standard game movements (walk cycles, attacks, deaths) without needing to prompt.
    • Character Consistency: Create animations for new characters that move exactly like your existing ones.
    • Skinning: Re-animate the same character model wearing different outfits or holding different weapons.
    • Real-world Reference: Upload a video of a specific movement (e.g. a person performing a karate kick) and apply that exact motion to your game sprite.

    How to Use:

    1. Select the "Transfer Motion" Tab.
    2. Select Source Image: Upload an image or choose a sprite from your Favorites.
      • This is the static character or object you want to animate.
      • Important: The pose in your source image should approximate the initial pose of the reference animation as closely as possible — matching orientation, facing direction, and rough body position. It doesn't have to be perfect, but the closer it is, the better the result. For example, if the animation is walking away from the camera (north), the image should show the character from the back; if the animation starts crouched, a standing sprite will transfer poorly. If your sprite is in the wrong pose, use the Change Pose tool to re-orient it first.
    3. Select Reference Animation: Provide the motion you want to transfer to the source image.
      • Presets (Recommended): Browse a library of over 600 game-ready animations to guarantee specific movements.
        • Find the move. The presets are organised into groups — Movement, Poses, Combat, Weapons, Interaction, Social and Creatures — each split into subcategories such as Movement: Climbing & Traversal, Combat: Hit Reactions, or Weapons: Bows & Crossbows. Use the category index down the left side to jump to a group or drill into one subcategory, or type in the search box to filter by name.
        • Choose Animation: Click a specific move (e.g. "Run Forward," "Sword Slash," "Crouch Walk") to open its preview.
        • Configure Perspective: In the preview window, use the tabs to select your game's camera style: Side, Hero, Isometric, Tactical, or Top-Down. Not every animation offers every perspective.
        • Set Direction: Use the directional wheel to choose exactly which way the character should face and move (e.g. clicking the "SE" arrow for an isometric run towards the bottom-right).
      • Upload Video: You can upload a video file from your device.
      • Choose from Favorites: Select a previously generated sprite animation or video from your Ludo favorites.
      • Video Requirements: For best results, reference videos should be relatively short (up to about 5 seconds), have sufficiently high quality (at least 480p), and feature minimal or no background with only the subject present.
    4. Choose a model and adjust options: Forge (the default) offers the best price-to-quality ratio and works especially well with the built-in presets; Tango is a safer choice when transferring motion from a video you uploaded yourself — see the Choosing a Model section. Just like the standard animation tab, you can also adjust the animation margin and the sprite sheet export parameters; the latter can be changed for free after the animation by re-exporting. Note that Transfer Motion caps the sprite sheet at 36 frames.
    5. Click "Transfer Motion" to generate the new animation.

    The result is a sprite animation that you can preview, download, or export as a sprite sheet, identical to the results from the standard "Animate" tab.

  • Sprite Sheet Options

    Before generating an animation, expand the Sprite Sheet Options menu to control the technical specifications of your output. These options can also be adjusted on existing animations by clicking Adjust Sprite Sheet on the animation card — re-adjusting is free and doesn't re-run the model. Whatever you set here is carried over to the other tabs, so you only have to set it once.

    • Number of Frames: How many frames the sprite sheet will contain (4, 9, 16, 25, 36, 49, 64; Transfer Motion stops at 36).
      • Higher numbers create smoother animations but produce larger files.
      • This is the maximum — the actual frame count can be lower if the animation duration is short or if Ludo automatically removed low-quality frames.
    • Sprite Size: Resolution of the sprite within each frame. Options:
      • 32, 64, 96, 128, 192, 256, 384 px — Fixed pixel sizes. The frame itself may be slightly larger to accommodate whitespace around the sprite.
      • Max — Full resolution of the generated sprite, with no downscaling.
      • True Size — Keeps the size and alignment of the input frame. Use this when you need the output to line up exactly with your input (e.g. for re-importing into an existing project). It needs a cut-out sprite, so it isn't available for full-bleed types, and it locks Trim Whitespace off.
      • Upscale 1.5x — Runs an AI upscaler on the frames for extra resolution. Slower but produces sharper output.
    • Loop Animation: Toggle ON for repeating movements like walking, running, or idling.
      • With both first and final frames: removes the duplicate final frame so the animation loops seamlessly.
      • With only a first frame: trims the animation to find the best possible loop point.
      • A smooth loop is never guaranteed — the result depends on the motion.
    • Trim Animation Whitespace: Toggle ON to crop empty transparent space around the sprite. The sprite sheet will be smaller, but frame sizes will vary between animations. Shown disabled and forced off when True Size is selected, since the two settings contradict each other.

    Pixel Art and Sprite Size

    When Ludo can tell that your input is pixel art, it keeps the output on that same pixel grid: the sprite comes back with the same number of logical pixels it went in with, whatever Sprite Size you pick. The Sprite Size then only decides how large each of those pixels is rendered — a 64-pixel-wide sprite exported at 128 px has 2 px blocks, at 256 px it has 4 px blocks, and the artwork is identical either way. Pick a size that is a whole multiple of the sprite's own pixel count and the blocks stay perfectly square.

    When Ludo cannot detect a grid — see Pixel Art Sprites and Animation for when that happens — there is no grid to hold on to, and Sprite Size behaves exactly as it does for any other art: it sets the output resolution, and the frames are resampled to it.

    Either way, an existing animation can be re-exported at a different Sprite Size for free using Adjust Sprite Sheet — no need to re-run the model.

  • Viewing and Interacting with Results

    After an animation is generated, it appears in the gallery below the input area. Each animation card exposes two distinct sets of controls: an action bar at the bottom of the card and a download menu (three-dot icon). Both are also available in the fullscreen viewer, so you don't have to close it to act on a result.

    Video Preview

    The default view is a video of the animation on a neutral background. This lets you preview exactly how the animation will look with the selected number of frames. Audio plays automatically when present; use the speaker icon to mute.

    For tiling types, the fullscreen viewer adds two extra preview modes next to the single-copy view: one scrolls the asset endlessly through itself, the other lays copies side by side — both along the axis the type repeats on, so you can check the seam actually lines up.

    Action Bar (bottom of card)

    • Adjust Sprite Sheet — Re-export the existing animation with different Sprite Sheet Options (frames, size, loop, trim). Free — does not re-run the model.
    • Change Pose — Opens the Pose editor to modify the initial image of the sprite.
    • Edit Animation — Opens the Edit Spritesheet tab with this animation pre-loaded, so you can modify it with a text instruction and optional reference images. See the Editing an Animation section.
    • Fix Loop — One-click attempt to repair a bad looping seam. When Ludo detects that the animation doesn't loop well, this action jumps to the front of the action bar. Not guaranteed to succeed. See Editing an Animation.
    • Zoom Out — One-click attempt to bring the sprite back inside the frame when the animation goes out of view. It extends the picture outwards rather than shrinking the sprite. Promoted to the front of the action bar when Ludo detects the problem. Not guaranteed to succeed. See Editing an Animation.
    • Generate New Animation — Keeps the same inputs but lets you enter a new animation prompt. For an animation made on the Keyframe Animation tab, this reopens that tab instead, with the original first, middle, and final keyframes still in their slots.
    • Transfer Motion — Switches to the Transfer Motion tab with the current animation pre-set as the Reference Animation. Use this to apply the same motion to a different sprite.
    • Generate Transition — Generates a smooth in-between animation that morphs from this animation into another one you select. See the Generate Transition section.
    • Generate After — Generates a new animation that continues from the last frame of this one. See the Generate Before / Generate After section.
    • Generate Before — Generates a new animation that ends on the first frame of this one. See the Generate Before / Generate After section.
    • Generate Audio / Re-generate Audio — Adds (or replaces) a sound effect for the animation. Tap the icon, optionally describe the sound, and submit. See the Generating Audio section.

    Download Menu (three-dot icon)

    • Download Sprite Sheet — PNG of all frames in a grid.
    • Download First Frame / Download Sprite — PNG of the source still image.
    • Download Video — MP4 of the animation.
    • Download GIF — Animated GIF.
    • Download All Frames — ZIP of individual frame PNGs.
    • Download Sheet + JSON — Sprite sheet plus a JSON metadata file describing frame layout, useful for game-engine import.
    • Download Audio — MP3 of the generated audio (only shown when audio exists).
    • Get Help With This — Opens the documentation assistant with this specific animation attached, so you can ask why a result came out the way it did. It also shows the animation's ID, which is what our team needs if you report the result on Discord.
    • Delete — Removes the animation from your history.

    Add to Favorites

    The heart icon saves the animated sprite to your Favorites so you can pull it into other tools (e.g. as a Source Image in Transfer Motion).

  • Exporting Sprite Sheets

    There are two ways to export from the Sprite Generator: per-animation downloads, and bundled exports across multiple animations.

    Per-Animation Downloads

    For a single animation, use the three-dot download menu on its card. This is the fastest way to grab a sprite sheet, video, GIF, individual frames, or a sprite sheet + JSON bundle. See the Viewing and Interacting with Results section for the full list of download options.

    The primary game-engine asset is the sprite sheet — a single PNG containing all animation frames arranged in a grid. It can be directly imported into Unity, Godot, Unreal Engine, and most other engines.

    Bundled Exports

    Above your generated results, the Export button opens a menu with two bundled options:

    • Animation Pack — Normalize and bundle multiple animations of the same character (e.g. Idle + Run + Attack) into a single export with consistent sizing and ground alignment. See the Exporting Animation Packs section.
    • Animation Sequence — Chain multiple animations into one continuous clip with automatic frame alignment between them. See the Animation Sequence section.

    Both bundled exports let you choose between Pixel Art and Smooth Art styling, so the same source animations can be exported either way without re-running the model.

    Free Plan Watermark

    On the free plan, downloaded sprite sheets carry a Ludo watermark on each frame, and a notice appears after the download explaining why. Subscribing to any paid plan removes it — and not just from new generations: every sprite sheet already in your history becomes watermark-free the moment you subscribe, with nothing to regenerate. The watermark is only ever applied to the downloaded copy, so editing or animating a watermarked sprite never bakes the logo into the result.

  • Generating Audio

    You can add sound effects to your animations directly within the tool.

    1. On a generated animation card, click the musical note icon.
    2. An input box will appear. Describe the sound you want to hear.
      • Example: "shattering glass sound," "whoosh of a sword swing," "robotic footsteps."
      • You can also leave the input box empty. The AI will generate suitable sounds automatically.
    3. Click the arrow to generate. The audio will be added to the video preview.
    4. You can download the audio as a separate MP3 file from the three-dot menu.

  • Choosing a Model

    The Animate, Keyframe Animation, Transfer Motion and Edit Spritesheet tabs let you pick which animation model to use. Each model has a different trade-off between predictability and motion quality. There is no single "best" model — when one isn't producing what you want, switching to another is often the fastest fix.

    The dropdown shows what each model costs (credits per second, plus any minimum charge) and the durations it supports, along with either a short note about what it's good at or two bars rating its visual quality and motion stability. Older models are grouped under a Legacy models heading at the bottom. The list is served by Ludo and changes as models are added or retired, so treat the notes below as guidance rather than a fixed roster.

    Animate tab:

    • Blitz — The most predictable and stable model. Motion quality is lower than Eagle's, but it rarely deviates from the input. Excellent for basic animations like walking, idling, or simple loops where consistency matters more than dynamism.
    • Eagle — More capable than Blitz. Handles complex animations well, but can sometimes deviate from the input, zoom in, or introduce visual effects you didn't ask for. Try this when Blitz produces motion that's too stiff or too simple.
    • Eagle with Audio — Same visual quality as Eagle, but also generates synchronized audio. Your prompt can describe the audio as well as the motion. Useful for animations where sound is part of the action (a sword swing with a whoosh, a coin pickup with a ding), and for talking or singing animations where lip-sync matters.
    • Forge — The best prompt follower of the group: it tends to do what you actually asked rather than reinterpreting it. Reach for it on straightforward animations and on sprites with a simple morphology — an ordinary body plan, a prop, an effect. What matters here is the shape of the character, not how detailed the artwork is: unusual anatomy, many limbs, or tangled silhouettes are where it struggles. It is also the only family that can animate a tiling type or run a keyframe animation.
    • Forge Pixel — A variant of Forge built for pixel art. It renders on the sprite's own pixel grid, so blocks stay square and aligned instead of dissolving into soft, shimmering edges. It is at its best on low-resolution, chunky pixel art; on very fine pixel grids the other models can look better, because at that density the grid matters less than the motion. It expects genuine pixel art as input — see Pixel Art Sprites and Animation.

    Keyframe Animation:

    • Only the Forge family runs keyframe animations, since they are the only models that can animate through a middle keyframe. Pick Forge for ordinary art and Forge Pixel for pixel art; no other model appears in the selector on that tab.

    Transfer Motion:

    • Forge — The default. It delivers quality on par with Tango at about half the price, and works especially well when the reference motion is one of the built-in animation presets.
    • Tango — Roughly twice the price of Forge, but a safer choice when the reference motion is a video you uploaded yourself rather than a preset. Available only on this tab.

    Edit Spritesheet:

    • Forge — The default, and the model behind the one-click Fix Loop and Zoom Out repairs. It is also the only edit model that uses all of your reference images.
    • Eagle — The alternative edit model. It only uses the first reference image, so prefer Forge when you're guiding the edit with several references.
    • Eagle with Audio — Same as Eagle, but also generates audio for the edited animation.

    Tiling types: only the Forge family preserves a seamless tile. Pick any other model for a tiling sprite, a parallax layer or a texture and the result won't repeat cleanly — Ludo warns you before you generate, and offers to switch you to Forge.

    Pixel art: when you edit or repair an animation that was generated as pixel art, Forge automatically stays on that animation's grid, so you don't have to pick the pixel variant yourself.

    Rule of thumb: for the Animate tab, start with Blitz for everyday movement, jump to Eagle when you need more dynamic motion, use Eagle with Audio when sound or dialogue is part of the animation, try Forge when you want the prompt followed closely on a straightforward animation, and use Forge Pixel for blocky pixel art. For Transfer Motion, Forge is the default and the best value, but switch to Tango for your own footage. If results look wrong with one model, try another before re-prompting.

  • Exporting Animation Packs

    An Animation Pack bundles multiple animations of the same character into a comprehensive export for your game engine (Unity, Godot, Unreal Engine, GameMaker, and others). This is essential for creating a consistent character moveset — it lets you manually align and resize multiple animations (e.g. Idle, Run, Jump) relative to each other before exporting them as a single bundle.

    1. Click the Export button above your generated results, then choose Animation Pack from the menu.
    2. Select Animations. A gallery appears. Click to select all the animations you want to include in this character's pack (e.g. Idle, Run, Attack).
    3. Align and Resize (Crucial Step).
      • The tool displays your selected animations side-by-side.
      • Manual Adjustment: Use the controls directly underneath each animation preview to fix alignment issues:
        • Size: Adjust the scale percentage if one animation generated a character that is slightly too small or large compared to the others.
        • Vertical (Y) & Horizontal (X) Offset: Manually shift the sprite up, down, left, or right. Use this to ensure the character's feet plant on the same "ground line" across all animations.
        • Snap: Quickly re-center the sprite in the frame.
    4. Configure Export Settings.
      • Choose whether you want a ZIP of sprite sheets or a ZIP of individual frame images.
      • Toggle between Smooth Art and Pixel Art to control the visual styling of the exported frames.
    5. Click "Export Animation Pack" to download a ZIP containing perfectly aligned sprite sheets (or frames) for every selected animation.

  • Animation Sequence

    An Animation Sequence chains multiple separate animations into one continuous clip, with frames aligned automatically between them. Use this when you want to present a character's full moveset as a single demo, or to build a complete in-game action by stitching shorter clips together (e.g. crouch → aim → fire → reload).

    This is different from an Animation Pack — a Pack exports each animation as its own sprite sheet for use in a game engine, while a Sequence merges them into a single output.

    How to Use:

    1. Click the Export button above your generated results and choose Animation Sequence.
    2. Select Animations. Pick the animations you want to chain together, in the order they should play.
    3. Review and Adjust. The tool aligns the end of each animation with the start of the next. You can adjust the order and per-animation export settings.
    4. Configure Export Settings. Choose ZIP of sprite sheets or ZIP of individual frames, and toggle between Smooth Art and Pixel Art.
    5. Click "Export Animation Sequence" to download the result.

  • Generate Transition

    The Generate Transition tool (also called "tweening") fills in the gap between two existing animations by generating an in-between animation that morphs from the last frame of one into the first frame of another. This is ideal for connecting moveset states smoothly — e.g. linking an idle into a run, or a block into a counter-attack.

    How to Use:

    1. On any generated animation card, open the action bar and click Generate Transition.
    2. Select Target Animation. A gallery appears. Pick the animation you want to transition into.
    3. Choose Direction. Use the A → B / B → A toggle to choose which animation is the source and which is the destination. This lets you generate the transition both ways without having to start over.
    4. Generate. The result appears as a new animation in your gallery, ready to be combined with the originals in a Sequence or Pack.

    The source and target animations must each have a usable first/last frame — the action only appears on animations where Ludo has those frames available.

  • Generate Before / Generate After

    Generate Before and Generate After extend an existing animation in time, either forwards or backwards, by using its first or last frame as a new keyframe.

    • Generate After — Uses the last frame of the current animation as the first frame of a new one. Use this to continue an action (e.g. after a jump up, generate a land).
    • Generate Before — Uses the first frame of the current animation as the last frame of a new one. Use this to build up into an action (e.g. before an attack, generate a windup).

    How to Use:

    1. Open the action bar on an animation card and click Generate After or Generate Before.
    2. The Animate tab opens pre-loaded with the appropriate keyframe in place.
    3. Adjust the prompt, model, and settings as needed, then generate.

    Combined with Generate Transition, this lets you build long, multi-stage animation sequences entirely from short generated clips.

  • Editing an Animation

    The Edit Spritesheet tab lets you modify an existing animation with a simple text instruction — and optionally guide the edit with reference images — while the original animation keeps driving the motion. Instead of re-generating an animation from scratch and hoping for the same movement, you edit the one you already have.

    What you can do with a text instruction:

    • Replace elements — "Replace the sword with a flaming axe."
    • Add elements — "Add a billowing red cape," "Give the knight a horned helmet."
    • Remove elements — "Remove the shield."
    • Change colors and materials — "Make the armor golden," "Change the slime from green to purple."
    • Add visual effects — "Add a glowing blue aura around the character," "Add sparks trailing from the blade."
    • Restyle the whole animation — "Convert to a watercolor style," "Make it look hand-drawn with thick outlines."
    • Combine edits — a single instruction can mix several changes at once, e.g. "Give the wizard a red robe and make his staff glow."

    Reference images (optional, up to 5): add images to show the AI exactly what you mean instead of describing it. References can provide:

    • A specific object or character to swap in — e.g. upload your game's actual axe and ask to replace the sword with it.
    • A target art style — e.g. a screenshot of your game's look, asking to restyle the animation to match.
    • An outfit or skin — re-dress the same character to match a reference design.

    How to Use:

    1. Select the "Edit Spritesheet" tab, or click Edit Animation on any generated animation card to jump there with that animation pre-loaded.
    2. Choose the spritesheet to edit. Pick an existing animated spritesheet from your generations or favorites.
    3. Write the edit instruction. Describe what should change — the motion and everything you don't mention are preserved.
    4. (Optional) Add reference images to guide the edit.
    5. Choose a model and set the max duration. If the source animation is longer than the duration, it will be compressed to fit.
    6. (Optional) Adjust Sprite Sheet Options (frames, size, loop, trim) — as with other tabs, these can be re-adjusted for free afterwards.
    7. Click "Edit Spritesheet" to generate. The result appears as a new animation in your gallery — the original is untouched, so you can iterate freely.

    Models: editing defaults to Forge, which is also the only edit model that uses all of your reference images — with Eagle, only the first reference is used. Eagle with Audio additionally generates audio for the edited animation. If the source animation was generated as pixel art, Forge automatically keeps the edit on its pixel grid. See Choosing a Model.

    Bear in mind that every edit re-renders the whole animation, so colors and detail drift a little further from the original with each pass. Ludo knows which animations came out of an edit and warns you when you're about to edit one of those again. If an edit didn't work, go back to the original animation rather than stacking another edit on top — see Known Limitations.

    Fix Loop and Zoom Out

    Two special one-click edit modes are available directly on every animation card — no prompt needed:

    • Fix Loop — Attempts to repair an animation whose loop has a visible jump or seam. When Ludo detects a bad loop, this action is promoted to the front of the card's action bar; otherwise it remains available among the card's other actions.
    • Zoom Out — Attempts to pull an animation back inside the frame when the sprite moves partially out of view. It extends the picture outwards rather than shrinking the sprite. Likewise promoted to the front of the action bar when Ludo detects the problem.

    Both fixes generate a new animation and leave the original untouched. A successful fix is not guaranteed — it depends on the motion, but it's a cheap first thing to try before re-generating or adjusting margins.

  • How to Choose the Sprite Animation Mode

    The Sprite Generator offers several ways to get to an animation, and the fastest route depends on what you already have and how specific the motion needs to be.

    Start from what you have

    • Only an idea → New Sprite. Generate the static sprite first, then animate it.
    • A sprite, and a motion you can describe in a few words → Animate. One image, one prompt. Start here for anything ordinary.
    • A sprite, and a motion that prompting keeps getting wrong → Keyframe Animation. You supply the key poses; the model only fills the in-betweens.
    • A sprite, and the exact motion already existing as a preset, a video, or another animation → Transfer Motion. Copies a specific movement instead of inventing one.
    • An animation whose movement is right but whose look isn't → Edit Spritesheet. Changes what's on screen while the original motion keeps driving the result.

    The modes in one line each

    • Animate — one image (optionally plus a final frame) and a text prompt. Best for everyday movement: idles, walks, runs, hovers, simple loops, ambient VFX.
    • Keyframe Animation — first, middle, and final frames you control, with the prompt optional. Best for a specific action (a punch, a swing, a cast), for idle → apex → idle loops, and for VFX that appear and disappear via Empty Frames.
    • Transfer Motion — a sprite plus a reference motion. Best for guaranteed standard game movements from the preset library, for keeping a whole cast moving identically, and for reproducing real footage.
    • Edit Spritesheet — an existing animation plus an instruction, and optionally reference images. Best for swapping, adding or removing elements, changing colours and materials, adding effects, and restyling the whole clip. The source animation drives the motion, so the movement carries over while the appearance changes.

    If you're not getting what you want

    Work down this ladder rather than re-rolling the same prompt:

    1. Re-prompt once, more simply. One clear action beats a paragraph — see Known Limitations.
    2. Check the sprite type. The wrong type changes framing, background handling and which models are allowed — see Sprite Types.
    3. Switch models. Blitz is stable but stiff; Eagle is more dynamic but drifts; Forge follows the prompt closely; Forge Pixel is the one for blocky pixel art. See Choosing a Model.
    4. Fix the input frame. A "walk right" prompt on a forward-facing sprite will not work. Use Change Pose — see Preparing Animation Keyframes.
    5. Use a preset in Transfer Motion. If the move is a standard game action, the preset library gives you the exact motion with no prompting at all.
    6. Use Keyframe Animation. If the move is specific to your game, pose the apex yourself. This is the most reliable option, because you are no longer asking the model to guess what the action looks like.

    Repairing and extending what you have

    You rarely need to start over. Fix Loop and Zoom Out are one-click repairs for a bad looping seam or a sprite drifting out of frame. Generate After and Generate Before continue an animation forwards or backwards, Generate Transition fills the gap between two of them, Animation Sequence merges several into one continuous clip, and Animation Pack exports a whole moveset with consistent alignment.

  • Keyframe Animation

    The Keyframe Animation tab animates between three fixed keyframes — First Frame, Middle Frame, and Final Frame — instead of just a start frame and an optional end frame. Handing the model the peak of the motion is the most reliable way to get a specific action out of Ludo.

    When to use it

    • When prompting isn't getting you the action. If "punch" keeps producing something that isn't a punch, stop re-prompting: put the idle stance in the first and final slots, put the fist-extended pose in the middle slot, and the model only has to fill in the in-betweens. This is the safe way to land a specific move.
    • Idle → action apex → idle. Any motion that starts and ends in the same resting pose — punches, kicks, swings, casts, crouches, jumps — is exactly the shape this mode is built for. It also loops cleanly, because the first and final frames match.
    • VFX that appear and disappear. Use an Empty Frame for the first and final slots and the effect at full strength in the middle, and you get an explosion, a magic burst, or a pickup sparkle that fades in and out. The same trick works one-sided: effect → effect → Empty Frame for something that dissipates.

    How to Use:

    1. Select the "Keyframe Animation" tab.
    2. Fill all three slots. Each slot takes an uploaded image, a generated sprite, a favorite, or an Empty Frame (a fully transparent frame).
      • When you set a real image as the First Frame and the Final Frame is still empty, Ludo copies it into the Final Frame for you — the A → B → A shape is the most common one. Replace or clear it if you want a different ending.
      • Copy Previous duplicates the preceding slot into the current one as a starting point.
    3. Shape your keyframes. Every slot has its own Change Pose and Open In Editor buttons. The usual workflow is to take one sprite, use Change Pose or the image editor to build the apex pose for the Middle Frame, and leave the idle stance in the first and final slots. See Preparing Animation Keyframes.
    4. Describe the motion (optional). Leaving the prompt empty is perfectly fine — it means "do the obvious transition between these frames", which is usually what you want once the keyframes are right. Write a prompt when the transition is ambiguous and you need to be specific about how the sprite gets from one keyframe to the next (e.g. "steps forward as he punches" rather than punching on the spot).
    5. Set the sprite type, model, duration, margin, and Sprite Sheet Options. These behave exactly as they do on the Animate tab, except that the model selector is limited to the Forge family — see below.
    6. Click "Animate."

    Rules for the three slots

    All three are enforced before generation, so a setup that breaks them can't be submitted:

    • All three slots must be filled. A middle keyframe requires both a first and a final keyframe — there is no first + middle only.
    • At least one slot must be a real image. Three Empty Frames give the model nothing to work from.
    • Never two Empty Frames in a row. Two consecutive blanks leave the model with no motion to interpolate across that span, so it would have to invent the whole thing. The Empty Frame option is hidden on any slot where picking it would break this rule.
    • Consecutive slots holding the same image produce no motion across that span. Ludo warns you when it detects this — change one of the frames, or use an Empty Frame instead.

    Model: Keyframe Animation runs on the Forge family, the only models that support a middle keyframe. The selector offers Forge for ordinary art and Forge Pixel for pixel art, so you can still choose the right one for your sprite while knowing the quality and cost up front. See Choosing a Model.

    Results behave like any other animation — preview, adjust the sprite sheet, edit, export. Clicking Generate New Animation on a keyframe animation reopens this tab with its original three keyframes still in place, so you can tweak one frame and re-run.

  • Known Limitations

    Some input combinations are perfectly valid but are known to fail often. Ludo checks your settings before you generate: when it spots one of these, the generate button shows an amber warning marker and its tooltip explains what is likely to go wrong and how to avoid it. Some warnings also carry a one-click fix — a Switch to Forge button, for instance — that applies the suggested setting for you.

    These warnings never block generation. They are advice — sometimes the combination is exactly what you want. They also depend on what Ludo can actually detect: an uploaded image carries no style or prompt metadata, so a few of the checks below stay quiet for uploads.

    Animate and Keyframe Animation

    • Forced loop with a short duration on Blitz. First and last frame are the same image and the duration is 2 seconds or less — there is barely room to move away and come back. Raise the duration, or pick a different model.
    • Very long prompts (over 100 words). Details start competing and some get dropped. Describe one short motion well instead of everything at once.
    • Forge Pixel on art that isn't pixel art. Forge Pixel expects a real pixel grid. If the input doesn't look like pixel art to Ludo, either make sure it follows a perfect grid or is at its natural resolution, or switch to another model.
    • Two identical keyframes in a row (Keyframe Animation). Consecutive slots holding the same picture mean no motion across that span. Change one of the frames, or use an Empty Frame and let Ludo invent the in-between.

    Tiling types (Animate, Keyframe Animation and Transfer Motion)

    • A tiling type on a model that can't tile. Only the Forge family preserves a seamless tile; every other model breaks the repeat. Switch to Forge, or pick a non-tiling type.
    • An input that doesn't actually tile. If the type is expected to repeat left-to-right or top-to-bottom and the image doesn't wrap cleanly on that axis, the animation will show a visible seam when tiled. Use a seamless tile, or pick a non-tiling type.

    Transfer Motion

    • Forge with your own footage. Forge is tuned for the built-in motion presets and often fails to follow custom video. Pick a preset, or switch to Tango for uploaded videos.
    • A reference much longer than the animation. If the reference is more than twice your maximum duration, it gets heavily compressed and the motion turns rushed. Trim the reference to the part you actually want, or raise the duration.

    Edit Spritesheet

    • Editing an already-edited animation. Every edit re-renders the whole animation, so colours and detail drift a little further from the original with each pass. Ludo recognises animations that came out of an edit and flags this for you. If an edit didn't work, go back to the original animation and try again rather than stacking another edit on top.
    • Long edit instructions (over 50 words). Edits work best when they focus on a single change. Keep the prompt to the core instruction and run a second edit if you need more.
    • More than 2 reference images. Too many references reduce the model's ability to use any of them correctly. Two or three is the practical ceiling — and note that only Forge uses more than the first reference at all (see Choosing a Model).

    All animation modes

    • Too many frames for the duration. Asking for more frames than roughly 12 per second of animation means Ludo may not be able to produce them all. If you need an exact frame count, raise the duration.
    • Sprite Size larger than the input image. Exporting above the source resolution adds no detail. This also applies to Max and Upscale 1.5x on inputs under 512 px. Use a higher-resolution input, or a smaller sprite size.
    • "No margin" on an image that already touches the edges. With under 5% empty space on a side and no margin added, arms, weapons and effects get clipped the moment the sprite moves. Use Auto or Manual margin instead.
    • "No margin" on an image that is mostly empty space. If over half the image is padding, "No margin" preserves that framing exactly and the sprite ends up small and low-detail in the frame. Auto crops and recenters it for you.

    Other things worth knowing

    • A smooth loop is never guaranteed — it depends on the motion. Fix Loop is a cheap first attempt; see Editing an Animation.
    • Frame counts of 49 and above are more prone to looping issues and motion blur. The frame selector flags them.
    • Colors can still shift between your input and the animation, even with the automatic correction Ludo applies — see Color Consistency With Your Input.
    • Pixel grids can only be preserved when they can be detected — see Pixel Art Sprites and Animation.

  • Sprite Types

    Every generating tab starts with a sprite type. It isn't a label: it changes how the asset is generated and framed, whether its background is removed, whether the result has to repeat seamlessly, and which models are allowed to animate it. Picking a Ludo-generated image sets the type automatically; for uploads, set it yourself.

    Cut-out types are delivered on a transparent background, so the asset is the subject and nothing else:

    • Sprite — characters, props, objects. The default, and what most animations use.
    • VFX Sprite — an isolated visual effect: a muzzle flash, an impact, a magical aura.
    • UI Element — a button, frame, status bar or in-game icon.
    • Item Icon — a small, clear icon for inventory, shop or loot systems.
    • Game Logo — a game title logo with stylized lettering.
    • Character Portrait — a close-up for dialogue boxes, character select screens or party menus.
    • Map Tile — a single grid cell for a tilemap system.

    Tiling types are also cut out, but they are meant to repeat, and Ludo keeps the seam intact through generation and animation:

    • Horizontal Tiling Sprite — repeats left-to-right: platforms, bridges, fences, energy beams.
    • Vertical Tiling Sprite — repeats top-to-bottom: ropes, chains, vines, ladders.
    • Parallax Layer — a repeating scene layer for parallax scrolling, on transparency; repeats left-to-right.

    Full-bleed types fill the whole frame and keep their own background:

    • Texture — a seamless surface material for meshes, terrain, walls or background fills; repeats on both axes.
    • Card Art — an artistic illustration of a character or object, with its own backdrop.

    What the type changes

    • Background. Cut-out and tiling types are matted onto transparency; upload one with a background and Ludo offers you a free background-removal review before animating. Full-bleed types keep theirs, and are never matted.
    • Framing and margins. Cut-out types are trimmed, centered and padded with an animation margin. Full-bleed types have no content box to put a margin around, so leave the margin on Auto for those — an explicit manual margin is rejected rather than silently ignored.
    • Export. True Size needs a cut-out sprite with transparency, so it isn't available for full-bleed types.
    • Models. Only the Forge family preserves a tile, so tiling types (and textures) have to be animated with Forge or Forge Pixel. Ludo warns you — and offers a one-click switch — if you pick anything else.
    • Seam checking. For a tiling type, Ludo also checks that your input actually wraps on the axis it is supposed to repeat on, and warns you before generating if it doesn't. In the fullscreen viewer you can scroll or tile the result to check the seam yourself.

    If the type you want isn't in this list — backgrounds, scene art, gameplay screenshots, splash screens — generate it in the Image Generator. Those types can't be animated as sprites.

  • Pixel Art Sprites and Animation

    Pixel art is the one style where "close enough" isn't: a sprite whose blocks stop lining up stops reading as pixel art at all. The Sprite Generator handles it in two ways — a model built for it, and an automatic attempt to keep your sprite on the exact grid it arrived on.

    Forge Pixel

    Forge Pixel is a variant of the Forge model that renders on the sprite's pixel grid rather than on a free canvas. Blocks stay square, aligned and stable from frame to frame, instead of shimmering and dissolving the way ordinary models make pixel art do. It is available on the Animate and Keyframe Animation tabs.

    It is at its best on low-resolution, chunky pixel art — the blockier the art, the bigger the difference. On very fine pixel grids, where individual pixels are small anyway, the other models can give you better motion, so it's worth comparing. And it genuinely needs pixel art as input: given ordinary artwork it has no grid to hold to, and Ludo warns you before you generate.

    Automatic pixel-grid preservation

    Whichever model you use, Ludo tries to work out the logical pixel size of your sprite — how many pixels across the artwork really is, regardless of the file's resolution — and to give you back an animation on that same grid. Framing, margins and export all then work in whole pixels, so the grid never drifts by half a block.

    It works out the grid three ways, in this order:

    • From the art style. Anything you generated in Ludo with Micro Pixel, 8-Bit, 16-Bit or 32-Bit has a known pixel count, so this always works. This is the most reliable path by a wide margin.
    • From the file's own size. A small image whose sprite is at its natural resolution — one file pixel per art pixel — is read as-is. Uploading your actual game sprite at its actual size works for this reason.
    • By detecting the grid. For everything else, Ludo analyses the image and looks for a regular lattice. Blocky pixel art works here as long as every block is the same size and the grid is consistent across the image.

    When it doesn't work

    The common failure is fake pixel art: images from other AI generators that look pixelated but have no true grid underneath — blocks of slightly different sizes, soft or anti-aliased edges, a lattice that drifts across the image. There is no consistent pixel size to recover, so detection finds nothing.

    When that happens, Ludo simply doesn't apply the pixel handling: the sprite is animated and exported as ordinary art. Nothing breaks, but the output won't conform to a pixel grid (since there wasn't one to begin with), and Sprite Size just sets the output resolution the way it does for any other art (see Sprite Sheet Options). Ludo's Free Pixel style falls in this middle ground too — it produces pixel-looking art without a fixed tier, so whether the grid is recovered depends on the image.

    Two more cases to know about: Forge Pixel refuses rather than guessing — if it can't find a grid it stops and tells you to use pixel-art source art — and a "grid" so coarse that the sprite would be a handful of colour blocks is rejected as not being pixel art at all.

    Tips

    • Generate the sprite in Ludo with one of the pixel-art styles and the grid is known from the start.
    • If you're uploading, upload the sprite at its native resolution rather than an upscaled copy.
    • Don't upscale pixel art before animating it, and avoid re-saving it as JPEG — both damage the lattice detection depends on.
    • Once an animation is on a grid, editing or repairing it (including Fix Loop and Zoom Out) keeps it there automatically.

  • Color Consistency With Your Input

    AI video models drift in colour. A sprite that goes in with a specific palette can come back slightly darker, slightly washed out, or shifting over the course of the clip — a real and frequently reported annoyance when the animation has to sit next to the original sprite in your game.

    Ludo corrects for this automatically on every animation. It compares the generated frames against the keyframes you actually provided and pulls the clip back towards them, with a few deliberate safeguards:

    • The correction is bounded. It only shifts colours within a safe margin, so a mild drift is removed without repainting your animation.
    • It leaves intentional colour changes alone. A flash, a charge-up glow, a hit flicker — those are part of the animation, not drift, and they survive.
    • It backs off when it doesn't fit. If matching the reference would mean a drastic change — which usually means the reference no longer describes the clip, as after a heavy edit — the correction is dropped rather than forced.
    • It anchors on the frames you provided, so an animation with both a first and a final frame is held at both ends.

    There is nothing to switch on: this applies to animations, motion transfers and edits alike.

    It is not a guarantee. Colour shifts are a limitation of how these models work, and a large enough drift, a heavy restyle, or an animation that wanders far from its input can still come back off-palette.

    Don't stack edits. This is the single biggest thing you control. Every edit re-renders the whole animation, and the correction can only pull the result back towards the frames it was given — which, on an edit, are already one generation away from your original art. Edit an edit and you compound the drift, pass after pass. If an edit didn't land, go back to the original animation and try again from there.

    Check your input frames, not just the output. The same drift happens to still images: editing a sprite in the Image Editor, running Change Pose, or restyling it can all come back slightly off-colour. Animating that image then carries the shift into every frame — and the animation's own drift stacks on top of it. Before you animate, compare the keyframe you're about to use against your original sprite, and fix it there rather than trying to correct it later.

    If the colour of a specific asset really matters, keep the animation short, start from art you know is on-palette, and check the result against your original sprite before committing it to your project.