AI Sprite Generator: Make and Animate Game Sprites

FAQ

• ---

  Is the AI sprite generator free?

  You can start free, with no card needed. The free sample sprite sheets on this page, the Ludo toolbox and the sprite sheet packer need no account at all.

• ---

  Do I own the sprites I generate?

  Yes. You own the assets you generate with Ludo and can use them however you like, commercial games included. No attribution is needed.

• ---

  How do I tell Ludo what motion I want?

  Four ways: a text motion prompt, keyframes you set (up to three: first, middle and last), a reference video whose motion is transferred to your sprite, or a named motion preset. With keyframes the motion prompt is optional, because the motion comes from the frames you give it. In the app any keyframe slot can be left as an Empty Frame as long as one holds an image; through the API the initial frame is required. Supplying only a final frame gives straight two-keyframe interpolation.

• ---

  How many frames do the animations have? At what resolution?

  Animations run up to 5 seconds, in sheets of up to 64 frames (pick 4, 9, 16, 25, 36, 49 or 64 as the maximum; a short animation can give fewer). The sprite is drawn from 32 to 384 px, or at Max (full resolution), True Size (lined up with your input image) or with an AI 1.5x upscale. Alongside the PNG sheet you can take an animated GIF, the individual frames or an MP4.

• ---

  What art styles can I use?

  Any style, if you upload your own art: the animation follows the image. Generate the sprite with Ludo and you can pick from 32 art styles, five of them pixel art (Micro Pixel, 8-Bit, 16-Bit, 32-Bit and Free Pixel), plus cel-shaded, hand-painted, anime, chibi, watercolor, voxel and more.

• ---

  Which animation model should I use?

  Hydra, the default, has the best motion and prompt adherence and adds a matching sound effect. Griffin gives the highest resolution and the best image fidelity, also with sound. Forge is the cheapest, for simple body shapes and simple actions. Forge Pixel is made for low-res pixel art. A sheet made on Forge or Forge Pixel can get a sound effect afterwards with Generate Audio.

• ---

  Can I fix an animation without regenerating it?

  Yes. Edit Animation takes a text instruction to restyle a sheet or change its motion. Three one-click fixes need no prompt: Fix Loop for an animation that does not loop cleanly, Zoom Out for a character that drifts out of frame, and Improve Details to re-render a sheet with finer detail. Adjust Sprite Sheet changes the frame count, size and loop trim for free.

• ---

  Can I get a JSON atlas or engine files for my sprite sheet?

  Yes. Sheet + JSON in the app downloads the PNG sheet with TexturePacker-format frame data for Phaser and PixiJS, and an Animation Pack exports a whole moveset the same way. The sheet is a regular grid, so Unity, Godot and GameMaker can also slice it by frame count and size. After you download, the free, offline Ludo toolbox writes a Godot SpriteFrames file or a sliced Unity import for any sheet, with no account needed.

• ---

  Can I animate characters I have already drawn?

  Yes. Upload a static image of your character and animate it with a motion prompt, keyframes, a reference video or a preset. An image that holds only the character works best.

• ---

  How do I make a sprite face another direction?

  Use Change Pose on the still sprite to turn it to any of 8 camera angles, or to restage it in a new pose. To carry a finished animation to the new angle, use New Direction: it re-renders the animation facing the new way and keeps its motion and timing. The step-by-step version is in How to make an 8-direction sprite sheet.

• ---

  Can I use it from code or an AI assistant?

  Yes. The API, the MCP server and the CLI make the same assets as the web app. Results from the API are kept for 7 days, so download what you want to keep. Setup is on the developer page.

Sprite Generator documentation

• ---

  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.
  • Get synchronized sound with every animation made on the default Hydra model — including talking or singing animations — or add a sound effect to any animation afterwards.
  • 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 six modes. Pick one in the Generation Mode menu at the top left of the interface; each entry shows a short example of what the mode does:

  • 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 (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.
  • New Direction: Re-render an existing animation facing another direction: the same motion and timing, seen from a new angle (a side-view walk turned into the same walk toward the camera).
  • 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 modes at any time; each remembers its own settings, inputs, and uploaded images. The Sprite Sheet Options (frames, sprite size, loop) are shared: whatever you last set in one mode is applied in the others.

  Every generating mode 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.

  All animation modes default to the Hydra model, which is the right choice for most work. Griffin makes high resolution animations for highly detailed sprites, in Animate, Keyframe Animation and Edit Spritesheet. Older models are kept only for accounts that already have projects running on them; see Choosing a Model.

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

  Not sure which mode 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 mode: 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. Pick "New Sprite" in the Generation Mode menu. This is the default mode 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 Pixel, 16-Bit Pixel, 32-Bit Pixel) 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 mode, 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.

  • In Animate, that's the First Frame and the optional Final Frame.
  • In Keyframe Animation, 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, in both modes, 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. In Animate you can empty the first or the final frame; in Keyframe Animation 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 mode turns a static image, one you generated in Ludo or uploaded, into a sprite animation described with a text prompt.

  1. Pick "Animate" in the Generation Mode menu. If you used the Use as First Frame button, your image will already be loaded here.
  2. Upload or select an image.
     • If the form 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. Animate 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.
     • On Hydra, the prompt can also describe the sound you want — every Hydra animation comes with synchronized audio.
  5. Choose a model and duration. Hydra is the default and the go-to model; pick Griffin for high resolution animations of highly detailed sprites; switch to Forge for a simple motion on a simple body shape (a person, a prop or an effect, not a spider or a many-limbed creature) or for sprites with very fine detail that has to be reproduced exactly (fine patterns, lettering), or Forge Pixel for blocky pixel art — see Choosing a Model. Duration is shown as a slider with the values supported by the selected model.
  6. Adjust Animation Margin. The sprite is generated on a canvas of fixed size, so every bit of margin costs resolution — keep it tight. See Framing, Margins and Resolution.
     • Auto: Recommended. Ludo trims and centers the sprite and picks the margin the motion needs.
     • Manual: Set the Horizontal and Vertical margins independently (0–100%). Around 15% is tight; raise only the axis your motion needs, e.g. horizontal for a wide sword swing, vertical for a jump.
     • No margin: The input image is animated exactly as framed — it must already have room around the sprite, and not too much. To line the result up with your input, use the True Size sprite size instead.
     • 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. Pick "Transfer Motion" in the Generation Mode menu.
  2. Select Source Image: Upload an image.
     • 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.
       • 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. Add instructions (optional): Extra guidance for the transfer, added on top of the reference motion — e.g. "keep the cape still" or "exaggerate the swing".
  5. Choose a model and adjust options: Hydra (the default) is the go-to model for both presets and your own footage; Forge is cheaper but only for simple body shapes on preset motions, and is the only model that can transfer motion onto a tiling type — see the Choosing a Model section. Just like in Animate, 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. Transfer Motion offers the same frame counts as the other modes, up to 64 frames.
  6. 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 Animate.

• ---

  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 modes, 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 or 64, in every mode).
    • 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, with no trimming. 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.
    • 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.

  Whitespace trimming. Empty transparent space around the sprite is trimmed automatically, so sprite sheets stay compact. Because of that, frame sizes vary from one animation to the next; when several animations of the same character need to line up, don't fight the trim — use Export Animation Pack or Export Sequence, which align and size them together, or export with True Size to keep the input frame exactly. Accounts that had the older Trim Animation Whitespace toggle keep it; it is not offered to new accounts.

  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.

  When the detected grid is wrong. Detection can occasionally find a pixel grid in art that isn't pixel art, so smooth or line art comes back as coarse blocks. Open Adjust Sprite Sheet and turn off Use Pixel Grid: the same animation is packed again as ordinary art, for free and without re-running the model, and later adjustments and edits of that sprite keep the setting. The switch appears only on sprites where a grid was detected (or that already have it off). If you already know your art isn't pixel art, you can also turn Use Pixel Grid off before generating, under Sprite Sheet Options. That choice applies to Animate, Keyframe Animation and Transfer Motion until you leave the page, and the switch is back on the next time you open the Sprite Generator, so it never stays off by accident. In Edit and New View it starts from the source sprite's own setting. Neither appears for Forge Pixel animations, which are always packed on their grid.

  For API and MCP users: use_pixel_grid on animateSprite, animateSpriteKeyframes, transferMotion, editSpritesheet, rotateSpritesheet and adjustSpritesheet. It means "use the pixel grid if one is detected": true (the default) packs on the grid when one is detected with confidence and does nothing otherwise; false always packs as ordinary art. To fix an existing sheet, call adjustSpritesheet with use_pixel_grid: false.

• ---

  Framing, Margins and Resolution

  Every animation is generated on a canvas of the same, fixed size. Whatever part of that canvas is margin is canvas the sprite doesn't fill — so the more margin, the lower the resolution and detail of your sprite. Margins should be as tight as the motion allows.

  Animation Margin

  • Auto (recommended): Ludo trims the sprite, centers it and picks a margin suited to the specific animation you asked for. Leave it here unless you have a reason not to.
  • Manual: you set the horizontal and vertical margin yourself. Around 15% is tight; only raise the axis the motion actually needs (horizontal for a wide sword swing, vertical for a jump), and only if the sprite gets cut off.
  • No margin: the input image is animated exactly as framed — no trimming, no margin added. This puts the burden on your image: it must already have suitable margins.
    • If the sprite touches the edges, arms, weapons and effects get cut off the moment it moves.
    • If the image is mostly empty space, the sprite ends up small and low-detail — sometimes a fraction of the resolution Auto would have given it.
    • No margin is the way to keep a deliberately off-center sprite — say, a character standing at the left edge firing a beam across to the right. Expect less predictable results when you do.

  Lining the animation up with your input image

  Use the True Size sprite size, not No margin. Margins and trimming shape the generation; True Size only shapes the export: it puts every frame back at the size and position of your input frame, so it works with any margin mode, including Auto. (Not available in Transfer Motion, where the sprite image is not the first frame of the result, so there is nothing to align to.)

  For API and MCP users: Animation Margin is margin_ratio_mode (auto / manual / none) with margin_ratio_horizontal / margin_ratio_vertical as ratios (0.15 = 15%); True Size is frame_size: -9.

• ---

  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). Free — does not re-run the model.
  • Change Pose — Opens the Pose editor to modify the initial image of the sprite.
  • Edit Animation — Opens Edit Spritesheet 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.
  • Improve Details — On animations made with Hydra: one click re-renders the animation with the finer detail Hydra+ produces. Promoted to the front of the action bar when Ludo detects the animation has lost detail. See Editing an Animation.
  • Generate New Animation — Keeps the same inputs but lets you enter a new animation prompt. For an animation made with Keyframe Animation, this reopens that mode instead, with the original first, middle, and final keyframes still in their slots.
  • Transfer Motion — Switches to Transfer Motion with the current animation pre-set as the Reference Animation. Use this to apply the same motion to a different sprite.
  • New Direction — Opens New Direction with this animation as the source, to re-render the same motion facing another direction. See the New Direction section.
  • 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) the sound for the animation. Hydra animations already come with audio, so this reads Re-generate Audio on those. 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.

• ---

  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. To write the engine files for a downloaded sheet (a Godot SpriteFrames .tres, Unity's sliced .png.meta and .anim, or a TexturePacker JSON atlas, with the pivot on the feet), use ludo toolbox sprite export from the free Asset Toolbox in the Ludo CLI.

  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

  Animations generated with the default Hydra model already come with synchronized audio — footsteps, impacts, whooshes, or speech when the prompt calls for it. You can describe the sound you want as part of the animation prompt. Audio plays in the video preview and can be downloaded as a separate MP3 from the three-dot menu.

  For animations made on other models, or when you want to replace the sound you got, you can generate audio on any animation card:

  1. On a generated animation card, click the musical note icon (Generate Audio, or Re-generate Audio if the animation already has sound).
  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 modes let you pick which animation model to use; New Direction runs on Hydra. The lineup is simple: Hydra is the go-to model everywhere, Griffin is for high resolution animations of highly detailed sprites, and Forge / Forge Pixel are specialists you reach for in a few specific situations. Everything else is a legacy model.

  The dropdown shows what each model costs (credits per second, plus any minimum charge, or credits per animation for Griffin), the durations it supports, and a short note about what it's good at. 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.

  Hydra — the default

  • Hydra is the default in every animation mode: Animate, Keyframe Animation, Transfer Motion and Edit Spritesheet, and in New Direction. It produces the best motion and the most faithful results across the widest range of sprites, including unusual anatomy, many limbs and tangled silhouettes.
  • Every Hydra animation comes with synchronized audio — sound effects, footsteps, speech or singing, driven by your prompt. Talking and singing animations with lip-sync are made here.
  • It costs more per second than Forge, but it usually gets the result in far fewer attempts, so in practice it often works out cheaper. Start with Hydra unless one of the cases below applies.
  • Hydra applies strict content moderation. If a request is refused on Hydra, try it on Forge.

  Griffin — high resolution

  • Griffin makes high resolution animations and is best for highly detailed sprites. It is offered in Animate, Keyframe Animation and Edit Spritesheet; Transfer Motion and New Direction run on the other models.
  • It costs a flat 10 credits per animation, whatever the motion, and a Griffin animation runs up to 5 seconds.

  Finer detail on Hydra: generate on Hydra, then use Improve Details on the animations you keep. It adds a detail pass to the animation you already have, and you only pay for it on the results worth keeping. See Editing an Animation.

  Forge and Forge Pixel — the specialists

  • Forge is cheaper and follows the prompt closely, but only on simple motions of simple body shapes. "Simple" is about the shape of the body, not how detailed it is: a person, a prop or an effect is simple, even when richly detailed; a spider, a many-limbed creature or a tangled silhouette is not. Forge also struggles with elaborate motions. Use it for cheap simple loops, for sprites with very fine detail, when Hydra's moderation refuses a request, and where it is the only option:
    • Tiling types. Forge is the only model that preserves a seamless tile. Tiling sprites, parallax layers and textures must be animated on Forge (or Forge Pixel) — Ludo warns you and offers a one-click switch if you pick anything else.
    • Fix Loop and Zoom Out. The one-click repairs always run on Forge.
  • Forge generates at a higher resolution than Hydra. If your sprite has very fine details that need to be reproduced exactly — intricate patterns, small letters or text, thin linework — Hydra may not be able to keep them intact. In that case, use Forge instead.
  • Forge Pixel is the Forge variant 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 grids Hydra can give better motion, so it's worth comparing. It expects genuine pixel art as input — see Pixel Art Sprites and Animation. When you edit or repair an animation that was generated as pixel art, Forge stays on that animation's grid automatically.

  Keyframe Animation: the selector offers Hydra, Griffin, Forge and Forge Pixel, the models that can animate through a middle keyframe. Hydra treats the middle frame as a strong guide for timing and pose; Forge holds it exactly. Hydra is the default.

  Transfer Motion: Hydra is the default for both the built-in presets and your own footage. Forge is a cheaper option for simple body shapes on preset motions only — it often fails to follow custom video.

  Edit Spritesheet: Hydra is the default, and Griffin is offered for high resolution edits of highly detailed sprites. Both Hydra and Forge use all of your reference images; use Forge only for a simple edit on a simple body shape, for fine detail that must be kept exactly, or when Hydra refuses the request.

  Legacy models

  Older models — Hydra+ (since 2 November 2026), Blitz, Eagle, Eagle with Audio and Tango — have been retired to a collapsed Legacy models group at the bottom of the dropdown. They exist only so that projects already built on them can keep generating matching animations; they should not be used for new work. New accounts don't see the legacy group at all — if the dropdown only lists Hydra, Griffin and the Forge models, nothing is missing.

  Rule of thumb: start with Hydra, and use Improve Details or Griffin when you need finer detail. Switch to Forge only for a simple body shape with a simple motion, fine detail that must be reproduced exactly, a tiling type, or a request that Hydra's moderation refuses; use Forge Pixel for blocky pixel art. 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. Animate 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 mode 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. Pick "Edit Spritesheet" in the Generation Mode menu, 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.
  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) — as in other modes, 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 Hydra, which also generates audio for the edited animation. Both Hydra and Forge use all of your reference images. Switch to Forge only for a simple edit on a simple body shape, for fine detail that must be kept exactly, or when Hydra refuses the request. 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 run on Forge, 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.

  Improve Details

  Improve Details is a one-click action on animations made with Hydra. It runs the extra detail pass that Hydra+ adds when it generates, on the animation you already have: same motion, finer detail. No prompt is needed.

  • It is offered only on Hydra animations. An animation made on Hydra+, or one that has already been improved, has that detail already, and other models can't be improved this way.
  • When Ludo detects that an animation has lost detail, the action moves to the front of the card's action bar; otherwise it sits among the card's other actions.
  • It costs the same flat rate per second as Fix Loop and Zoom Out, priced on the length of the source animation's video. Hover the action to see the exact cost.
  • The result is a new animation; the original is left untouched.

  For API and MCP users: Improve Details is editSpritesheet with edit_mode: "improve" and no prompt, on a spritesheet_url generated with hydra. Any other spritesheet is refused with HTTP 400.

• ---

  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 you need facing another direction → New Direction. Same motion and timing, re-rendered from a new angle.
  • 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.
  • New Direction — an existing animation plus its first frame turned to the new angle. Best for building 4- or 8-direction sets: every direction keeps the source's motion and timing, so they match each other.
  • 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. Check the model. Hydra is the go-to model; if you're on Forge with anything but a simple body shape and a simple motion, switch back to Hydra (unless you picked Forge to keep very fine detail). 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 mode 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. Pick "Keyframe Animation" in the Generation Mode menu.
  2. Fill all three slots. Each slot takes an uploaded image, a generated sprite, 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 in Animate, except that the model selector only offers the models that support a middle keyframe — 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 Hydra (the default), Griffin (high resolution, for highly detailed sprites), Forge and Forge Pixel, the models that support a middle keyframe. Hydra reads the middle frame as a strong guide for timing and pose; Forge reproduces it exactly, which can matter when the apex pose has to land pixel-perfect on a simple body shape. Use Forge Pixel for pixel art. 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 mode with its original three keyframes still in place, so you can tweak one frame and re-run.

• ---

  New Direction

  New Direction re-renders an animation you already have from another angle. The motion and timing come from the source animation; you supply the character as it should look facing the new direction, and Ludo animates it through the same movement. Use it to build 4- or 8-direction sets from one animation instead of prompting each direction separately.

  1. Pick New Direction in the Generation Mode menu, or click New Direction on any animation card to jump there with that animation loaded as the source.
  2. Source Animation. Choose the animation whose motion you want to keep. Its sprite sheet settings (frames, size, loop) are copied into the form, so the new direction matches it.
  3. First Frame. This is the same subject shown in the target direction, and it becomes the first frame of the result. The quickest way to make it: click Copy Source Frame to bring in the source's first frame, then Change Direction to turn it to the angle you want. You can also pick or upload your own image. Add a Final Frame only if the animation should end somewhere other than where it started.
     • Generating is blocked while the First Frame is still the source animation's own frame: that would only re-render the source from the angle it already has. Turn it with Change Direction first.
  4. (Optional) Instructions. Guide the result, e.g. its back to the camera or the kick goes to the left of the frame.
  5. Model, Duration and Animation Margin. New Direction runs on Hydra. Accounts created before 2 November 2026 can still pick the legacy Hydra+. Duration goes from 3 to 5 seconds and starts at the length of the source animation; a shorter source is re-timed to fit and a longer one is sped up. Animation Margin works as in Animate; see Framing, Margins and Resolution.
  6. Generate New Direction. Credits are held for the chosen duration (the minimum is 3 seconds, so at least 9 credits on Hydra) and you are only charged for what is generated.

  The result is an ordinary animation: preview it, adjust its sprite sheet, edit it, add audio, or export it alongside the source with Export Animation Pack.

  For API and MCP users: New Direction is rotateSpritesheet. Pass the source's spritesheet_url and, as image, the character in the new view; rotateSprite turns the source's first frame into that image.

• ---

  Directional Sprites

  Directional Sprites turns a character into sprite sheets seen from up to eight directions. Ludo makes a rigged 3D model of your character, draws it in the style you pick, and renders the animation from every view you ask for. The views you render together share the same frame, scale and floor, so the sheets line up in your game. Open it from Directional Sprites in the sidebar (in beta) or from the Generation Mode menu. It has its own help guide: open the help on the Directional Sprites page, or see Directional Sprites.

• ---

  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

  • Very long prompts (over 100 words). Details start competing and some get dropped. Describe one short motion well instead of everything at once.
  • Forge on a complex body shape or motion. Forge is only reliable on simple body shapes with simple motions — how detailed the sprite is doesn't matter here. Unusual anatomy, many limbs, tangled silhouettes or an elaborate action belong on Hydra.
  • 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.
  • Forced loop with a short duration on the legacy Blitz model. 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 use Hydra.

  Content moderation on Hydra and Hydra+

  Hydra (and Hydra+, the same model) applies much stricter content moderation than the other models, and a refused request comes back as an error rather than a warning. Violence, weapons, gore or suggestive content that is perfectly ordinary for a game can trip it. When Hydra refuses a generation, try the same request on Forge — the error message says so too.

  Tiling types (Animate, Keyframe Animation and Transfer Motion)

  • A tiling type on a model that can't tile. Only Forge and Forge Pixel preserve a seamless tile; every other model, Hydra included, 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. Use Hydra for uploaded videos, or pick a preset.
  • 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.

  All animation modes

  • Too many frames for the duration. Asking for more frames than roughly 16 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.
  • An input whose subject is cut off at the image edge. A half-body crop, or a prop sliced by the border, stays cut in every frame, and the result is flagged as out of frame on that side whatever margin you pick. Margins add space around the sprite, not the missing part. Use Zoom Out on the result, or start from an image with the whole subject inside the frame. (API: editSpritesheet edit_mode: "outpaint".)
  • "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

  • Hydra can lose very fine detail. It generates at a lower resolution than Forge, so fine patterns, small letters or text may not come out exactly as in your sprite. Use Forge for those — see Choosing a Model.
  • A smooth loop is never guaranteed — it depends on the motion. Fix Loop is a cheap first attempt; see Editing an Animation.
  • 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.
  • Frame sizes differ between animations because whitespace is trimmed automatically. To line up a moveset, use Export Animation Pack, Export Sequence or the True Size sprite size — see Sprite Sheet Options.

• ---

  Sprite Types

  Every generating mode 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 Forge and Forge Pixel preserve a tile, so tiling types (and textures) have to be animated on them — the default Hydra model breaks the repeat. Ludo warns you, and offers a one-click Switch to Forge, 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 in Animate, Keyframe Animation and Transfer Motion; you have to pick it yourself, since the default model is Hydra.

  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, Hydra 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 Pixel, 16-Bit Pixel or 32-Bit Pixel 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.
  • If your sprite only looks like pixel art (an AI image with soft edges or uneven blocks), run it through Convert to Pixel Art (convertToPixelArt in the API, free) before animating it with Forge Pixel. Resizing it yourself won't help unless every block ends up exactly one pixel.
  • 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.

Step-by-step guides are on the Sprite Generator docs page.