How Many Frames Should a Sprite Animation Have?

The short answer

For most 2D games: an idle needs 2–6 frames at 4–8 fps, a walk 4–8 frames at 8–12 fps, a run 6–8 frames at 10–14 fps, an attack 3–8 frames with uneven timing, a hurt reaction 2–3 frames and a death 4–8 frames. Fewer frames are not a shortcut that looks cheap; they are a style. What makes an animation feel good is timing — which frames you hold and which you skip — far more than the raw count.

Frame count and fps by animation type

These ranges are starting points for pixel art and hand-drawn 2D sprites. Smaller sprites (16–32 px) sit at the low end; larger, higher-resolution characters need more frames because every movement covers more pixels and gaps become visible.

The poses that carry each motion

Before deciding how many frames to draw, decide which poses the motion cannot do without. Everything else is an in-between, and in-betweens are the first thing to cut when a sprite is small or time is short.

A walk has four key poses per step: contact (both feet on the ground, legs widest apart), down (the body at its lowest, weight on the front leg), passing (the back leg swings past the standing leg) and up (the body at its highest as it pushes off). Draw them for the left step, mirror the leg roles for the right, and you have an 8-frame cycle. Drop down and up and you have the classic 4-frame walk; the up-and-down bob of the head then has to be faked by moving the whole sprite one pixel on the passing frames.

An attack needs at least anticipation (pulling back), strike (the weapon at full extension, often with a smear or motion trail) and recovery (returning to the guard pose). A run differs from a walk by a frame where both feet are off the ground and by a forward lean. A hurt reaction only needs a recoil pose and the return, which is why two or three frames are enough when combined with a white flash or a knock-back.

Loop length: the arithmetic

The duration of one loop is frames divided by fps. A 6-frame walk at 10 fps loops every 0.6 seconds, an 8-frame walk at 12 fps every 0.67 seconds. A relaxed human walk takes roughly one second for a full cycle of two steps, so game walks are usually a little faster than life, which reads as lively rather than sluggish.

Engines differ in how they express speed. Godot's SpriteFrames uses fps per animation. GameMaker sprites use frames per second or frames per game frame. Unity clips have a sample rate, and the spacing of keyframes on the timeline sets how long each sprite shows. They all come down to the same number: how long each drawing stays on screen.

Hold some frames longer than others

Even timing is what makes many generated or beginner animations feel floaty. Real motion accelerates and decelerates: an attack has a slow wind-up, an almost instant strike and a held follow-through. Showing every frame for the same time flattens that.

A typical 6-frame sword attack might be timed like this at a base of 12 fps: wind-up 2 frames held for 3 ticks each, strike 1 frame for 1 tick, impact 1 frame for 2 ticks, follow-through 2 frames for 2 ticks each. The player sees the anticipation clearly, the hit lands immediately, and the recovery leaves a window for the enemy to punish.

• Godot 4: each frame in SpriteFrames has a duration multiplier; set the wind-up frames to 2.0 or 3.0.
• Unity: spread keyframes unevenly on the Animation timeline, or duplicate a sprite key.
• GameMaker: duplicate frames in the Sprite Editor, or use a Sequence with per-frame lengths.
• Any engine: an impact pause (hit-stop) of 2–6 game frames when an attack connects sells the hit better than extra drawings.

Match the walk to the movement speed

Foot sliding happens when the character moves across the ground faster or slower than its feet move. Measure how far a planted foot travels backwards over one full cycle in your sheet — that is the distance the body should move in one loop. Then movement speed in pixels per second is that distance divided by the loop duration.

Example: in an 8-frame walk at 10 fps (0.8 s per loop) the planted foot covers 32 pixels per cycle, so the character should move at 32 / 0.8 = 40 pixels per second. If your design needs a faster character, raise the animation fps proportionally rather than just increasing the speed, or the feet will skate.

const STRIDE_PX := 32.0     # distance per walk cycle, measured on the sheet
const FRAMES := 8
const BASE_FPS := 10.0

func _physics_process(_delta: float) -> void:
    var speed := velocity.length()
    if speed > 1.0:
        $AnimatedSprite2D.play("walk")
        # 40 px/s plays at the authored 10 fps; faster movement plays faster.
        var authored_speed := STRIDE_PX / (FRAMES / BASE_FPS)
        $AnimatedSprite2D.speed_scale = speed / authored_speed
    else:
        $AnimatedSprite2D.play("idle")
        $AnimatedSprite2D.speed_scale = 1.0

Jumps are states, not one animation

A jump is controlled by physics, so its length changes with how long the player holds the button. Rather than one long animation, split it into short pieces and pick by vertical velocity: a take-off frame or two on the ground, a rising pose while velocity points up, an apex pose when it is near zero, a falling pose while it points down, and a landing squash of 1–2 frames when the character touches the ground.

Where more frames do not help

Extra frames cost time to draw, review and fix, and at small sizes they can make animation look mushy: if a 16 px character's arm moves one pixel between frames, adding an in-between that also moves it one pixel just doubles the frame without adding motion. The test is whether each new frame shows a pose the player can actually see.

More frames do help for large sprites, slow and smooth motions (a floating spirit, a waving flag, water), and anything filmed in close-up such as a portrait or a title screen.

How SpriteLab's frame options map to this

In SpriteLab's Animate tool you choose 4, 6 or 9 key poses for an AI animation (7, 11 or 12 credits). Smooth mode adds AI in-between frames, giving 8, 12 or 18 frames for 5 or 7 extra credits. The preview sets a starting speed — 8 fps for 4 poses, 10 fps for 6 and 12 fps for 9; smooth mode doubles it so the loop keeps the same length — which you can change before downloading. Idle breathing and hovering are done differently: the original sprite is gently deformed over 24 frames instead of redrawn, which avoids flicker and costs 3 credits.

What SpriteLab does not do is time the frames for you: every frame in the exported strip is shown for the same time. Holding wind-up frames, adding hit-stop and matching walk speed to movement all happen in your engine, as described above.