Create a Player Animation Set

Build idle, walk cycle, and sword swing animations in Blockbench.

Introduction

30 Second Summary

Think about the last game you played. Even when your character was standing still, they were probably breathing, shifting their weight, or fidgeting. That subtle movement is what separates a living character from a frozen mannequin.

In this project, you will create three player animations from scratch in Blockbench's Animate mode: a breathing idle, a walk cycle, and a sword swing attack.

What You'll Build

A set of three game-ready player animations that teach core techniques including keyframe animation, interpolation modes, and the pose-to-pose workflow.

By the end of this project, you'll have:

A smooth, looping idle animation with gentle breathing that gives your player character life when standing still.
A walk cycle with properly timed, mirrored limb movement and natural body bob.
A non-looping sword swing attack with anticipation, follow-through, and varied easing curves.
Secret Mission: Create a wave emote that layers head tilt, arm motion, and body lean into a polished gesture.

Are there any prerequisites?

You need Blockbench installed on your computer and a player model .bbmodel file ready to animate. If you have not set these up yet, complete the player modeling project first.

Get Oriented in Animate Mode

Before you can bring your player model to life, you need to understand the workspace where all animation happens.

Blockbench's Animate mode gives you a dedicated interface for creating keyframe animations. In this step, you will switch into that mode, explore its panels, and place your first test keyframe.

In this step, get ready to:

Switch to Animate mode and identify its key panels.
Create your first animation and explore the Timeline.
Place a keyframe and understand interpolation options.

Switch to Animate mode

Your player model is currently open in Edit mode, which is for shaping geometry. To work with animations, you need to switch to a completely different interface layout.

Click the Animate tab in the top-right corner of the interface (the Mode Tabs area).
The interface reconfigures to show the Animations Panel (left sidebar), the Timeline (bottom), and the Bone Panel (right sidebar).
In the Outliner, note the bone hierarchy of your player model. You should see bones like root, body, head, left_arm, right_arm, left_leg, and right_leg.
Click on different bones in the Outliner and observe how they highlight in the viewport.

What is a bone hierarchy?

In Blockbench, groups are the bones, pivots are the joints, and cubes are the flesh. Bones are organized in a parent-child tree so that moving a parent (like body) also moves its children (like head and left_arm).

This hierarchy is what makes animation possible. You rotate a bone at its pivot point, and everything attached follows along naturally.

Don't see bones in the Outliner?

Make sure you are in Animate mode (the Animate tab should be highlighted in the top-right). If the Outliner is empty, your model may not have groups set up as bones. Verify that your .bbmodel file has grouped cubes into a bone hierarchy in Edit mode before switching.

Help me figure out why my Outliner isn't showing bones in Animate mode.

Create your first animation

The Animations Panel on the left manages all the animation clips in your project. Each animation has a name, a length, and its own set of keyframes.

In the Animations Panel (left sidebar), click the plus icon to add a new animation.
Name it animation.player.idle.
Double-click the animation to open its properties and note the length slider.
Set the length to 2 seconds.

Why this naming format?

Animation identifiers only support snake_case, strings, and dots. They cannot contain colons or dashes. The animation.player.idle format follows the convention of animation.entity.action which keeps your animation library organized as it grows.

Now explore the Timeline at the bottom of the screen.

Look at the Time Ruler at the top of the Timeline. The blue square bracket indicates the end of your 2-second animation.
Find the Playhead. It is the blue vertical line with an arrow at the top that shows your current time position.
Drag the Playhead left and right to scrub through time.
Note the Timecode in the top-left corner of the Timeline. It displays the current Playhead position and you can type a value to jump to a specific time.

Snapping the Playhead

By default, the Playhead snaps to valid frame times as you drag it. Hold Ctrl while dragging to disable snapping and move it smoothly to any position.

Place a test keyframe

Keyframes are the start and end points of any change in an animation. They tell Blockbench what value a bone should have at a specific moment in time. Blockbench fills in the motion between keyframes automatically using interpolation.

Select the body bone in the Outliner.
In the Timeline, channel rows appear for that bone: Rotation, Position, and Scale.
Click the plus icon next to Rotation to create a keyframe at the current Playhead position. You can also press Q as a shortcut.
A diamond shape appears on the Timeline Track. This represents a keyframe with Linear interpolation.

What do the keyframe shapes mean?

Diamond shapes represent Linear interpolation (constant speed between keyframes). Circle shapes represent Smooth interpolation (gradual ease-in and ease-out). You will use both throughout this project.

Now inspect the Keyframe Panel.

With the keyframe selected, look at the Keyframe Panel in the right sidebar.
Find the interpolation dropdown. It shows four options: Linear, Smooth, Bezier, and Step.
Below the dropdown, note the X, Y, Z value inputs. These control the exact rotation values at this point in time.

What are the four interpolation modes?

Linear moves at constant speed. Smooth (also called Catmullrom) eases in and out for organic movement. Bezier gives you manual curve handles for precise control. Step holds a value until the next keyframe with no transition at all.

You will use different modes for different phases of your animations. Smooth works best for breathing and walking. Linear and Step are essential for snappy attack animations.

Don't see channel rows in the Timeline?

Make sure you have selected a bone in the Outliner (click on it so it highlights). Channels only appear for the currently selected bone. Also confirm that the animation.player.idle animation is selected in the Animations Panel (left-click it).

Help me figure out why I can't see channels or place keyframes in Blockbench.

✔️ I can see my keyframe diamond on the Timeline

You are all set. You have successfully navigated Animate mode, created your idle animation, and placed a test keyframe.

ⓧ I placed a keyframe but can't find it

Your keyframe might be off-screen. Try these fixes:

Use the scrollbar at the bottom of the Timeline to pan left or right.
Check the Timecode in the top-left corner. If it reads a time beyond 2 seconds, your Playhead was past the animation end when you placed the keyframe. Delete it and try again at 0.0s.
Make sure the body bone is still selected. Keyframes for unselected bones may be hidden if the Timeline filter is active.

You now know your way around Animate mode. Next up, you will use these tools to create a smooth breathing idle animation that gives your player character life when standing still.

Create a Breathing Idle Animation

Your player model is set up in Animate mode with a timeline ready to go. Even when a player character is standing still, a subtle breathing motion makes it feel alive instead of frozen in place.

In this step, you'll keyframe a gentle chest rise-and-fall on the body bone, then layer in small head and arm movements to complete a natural idle animation. By matching the first and last keyframes and using Smooth interpolation, the loop will play continuously with no visible pop.

In this step, get ready to:

Create the body breathing motion with Position keyframes and Smooth interpolation.
Add subtle head tilt and arm drift for a layered breathing effect.
Enable looping and verify seamless playback with no jump at the loop point.

Set up the body breathing motion

The core of a breathing idle is a simple rise and fall on the body bone's Y position. Three keyframes create the full inhale-exhale cycle: resting, inhale peak, and back to resting.

In the Animations Panel (left sidebar), click animation.player.idle to select it.
Delete any test keyframes from Step 1 by left-clicking and dragging across the Timeline to select all existing keyframes, then pressing Delete on your keyboard.
In the Outliner, click the body bone to select it.
In the Timecode field (top-left of the Timeline), type 0 and press Enter to move the Playhead to 0.0 seconds.
Click the plus icon next to Position in the bone's channel list to create a keyframe.
In the Keyframe Panel (right sidebar), confirm the X, Y, and Z values are all 0.
Move the Playhead to 1.0 seconds by typing 1 in the Timecode field.
Click the plus icon next to Position again to add a second keyframe.
In the Keyframe Panel, set the Y value to 0.2 (leave X and Z at 0).
Move the Playhead to 2.0 seconds by typing 2 in the Timecode field.
Add a third Position keyframe and confirm its values are 0, 0, 0 (matching the first frame for a clean loop).
Select all three keyframes by left-clicking and dragging across the Position track in the Timeline.
In the Keyframe Panel, change the interpolation dropdown from Linear to Smooth.

The diamond keyframe shapes on the Timeline should change to circles, confirming the interpolation switch.

Why Smooth interpolation for breathing?

Linear interpolation moves at a constant speed between keyframes, which looks mechanical. Smooth (also called Catmull-Rom) eases in and out of each keyframe, mimicking how a real chest gradually slows at the top of an inhale and the bottom of an exhale.

This single setting is the difference between "robot vibrating" and "character breathing."

Don't see the Position channel?

Make sure you have the body bone selected in the Outliner before clicking the plus icon. Channels only appear for the currently selected bone.

If you see channels but no plus icon, check that animation.player.idle is still selected (highlighted) in the Animations Panel.

help me find the Position channel for my body bone

Add head tilt and arm drift

A single bone moving looks robotic. Layering small complementary motions on the head and arms sells the illusion that the whole body is breathing together.

Select the head bone in the Outliner.
Move the Playhead to 0.0 seconds.
Click the plus icon next to Rotation to add a keyframe with X, Y, Z all at 0.
Move the Playhead to 1.0 seconds and add a Rotation keyframe with X set to -2 (a very slight downward tilt as the body rises).
Move the Playhead to 2.0 seconds and add a Rotation keyframe back at 0, 0, 0.
Select all three head Rotation keyframes by dragging across the track, then set interpolation to Smooth.
Select the left_arm bone in the Outliner.
Add Rotation keyframes at the following times and Z values (leave X and Y at 0):
0.0s: Z = 1.
1.0s: Z = 2.
2.0s: Z = 1.
Select all three left_arm keyframes and set interpolation to Smooth.
Select the right_arm bone in the Outliner.
Add Rotation keyframes with mirrored (negative) Z values:
0.0s: Z = -1.
1.0s: Z = -2.
2.0s: Z = -1.
Select all three right_arm keyframes and set interpolation to Smooth.

Why mirror the arm values?

The left arm drifts slightly outward (positive Z) while the right arm drifts the opposite direction (negative Z). This creates a subtle symmetrical sway that looks like the arms are floating gently with each breath.

Matching the first and last keyframe values on every bone guarantees the loop restarts seamlessly.

Check the Timeline. You should see keyframe circles on the Position track for body and Rotation tracks for head, left_arm, and right_arm.

Keyframes still showing as diamonds?

Diamonds mean the interpolation is still set to Linear. Make sure you selected all the keyframes on a track (left-click and drag) before changing the dropdown to Smooth.

If only some keyframes changed, you likely missed one in your selection. Click on the individual diamond and switch it to Smooth in the Keyframe Panel.

help me change my keyframes to Smooth interpolation

Enable looping and preview the animation

An idle animation needs to play indefinitely while the character stands still. Enabling the loop flag tells the game engine to restart the animation each time it finishes.

Right-click animation.player.idle in the Animations Panel.
Tick Loop in the context menu.
Click Play Animation in the Timeline Header to preview the animation.

Watch your character in the viewport. You should see a gentle, continuous breathing motion with the body rising, the head tilting slightly, and the arms drifting in and out.

What makes the loop seamless?

Your first keyframe (at 0.0s) and last keyframe (at 2.0s) have identical values on every bone. When the animation restarts, there is no sudden jump because the ending pose matches the starting pose exactly.

Smooth interpolation ensures the transition speed at the loop boundary is gradual, not abrupt. The combination of matched values and smooth easing is what produces an invisible loop point.

Seeing a pop or jump at the loop point?

Double-check that your keyframe at 2.0s has the exact same values as your keyframe at 0.0s for every bone. Even a difference of 0.1 can create a visible twitch.

If the breathing feels too fast, you can increase the animation length (double-click the animation to open its properties and adjust the length slider) then move your middle keyframe to the new halfway point.

help me fix my idle animation loop

✔️ My animation loops smoothly

Your breathing idle is complete. All keyframes use Smooth interpolation, Loop is enabled, and the motion plays continuously with no visible seam.

ⓧ I'd like to double check the keyframe values

Here is the complete keyframe summary for animation.player.idle (length: 2 seconds, Loop enabled):

body Position: 0.0s = (0, 0, 0), 1.0s = (0, 0.2, 0), 2.0s = (0, 0, 0). All Smooth.
head Rotation: 0.0s = (0, 0, 0), 1.0s = (-2, 0, 0), 2.0s = (0, 0, 0). All Smooth.
left_arm Rotation: 0.0s = (0, 0, 1), 1.0s = (0, 0, 2), 2.0s = (0, 0, 1). All Smooth.
right_arm Rotation: 0.0s = (0, 0, -1), 1.0s = (0, 0, -2), 2.0s = (0, 0, -1). All Smooth.

Compare each bone's values with your Keyframe Panel. Click a keyframe on the Timeline to see its values in the panel on the right.

Your character now breathes naturally while standing still. Next up, you'll tackle a much more complex challenge: a looping walk cycle that coordinates legs, arms, and body bob into a convincing stride.

Create a Walk Cycle

Your idle animation gives the character life when standing still. Now it is time to make them move.

A walk cycle is one of the most fundamental animations in game development. You will build yours using the pose-to-pose method, where you plan key poses at specific moments and let interpolation fill in the motion between them.

In this step, get ready to:

Keyframe alternating leg movement with mirrored timing.
Add opposing arm swing and a subtle body bob for natural balance.
Preview and refine the cycle using the Graph Editor.

Create the walk animation and keyframe the legs

A standard bipedal walk cycle runs for 1 second with two "contact" poses. These are the moments where each leg reaches maximum stride.

In the Animations Panel (left sidebar), click the plus icon to add a new animation.
Name it animation.player.walk.
Double-click the animation to open its properties and set the length to 1 second.
Right-click the animation in the Animations Panel and tick Loop.

Why pose-to-pose instead of straight-ahead?

Pose-to-pose means you set the key positions first and let the software interpolate the in-between frames. For blocky characters, this gives you better control over how the silhouette reads at each key moment.

The alternative (straight-ahead) animates frame by frame in sequence. That approach can produce unpredictable results for beginners.

Now keyframe the left leg. The pattern is: forward stride at the start, back stride at the midpoint, forward again at the end to match the loop.

Select the left_leg bone in the Outliner.
Move the Playhead to 0.0 seconds.
Click the plus icon next to Rotation to create a keyframe. Set the X value to -30 (forward swing).
Move the Playhead to 0.5 seconds and add another Rotation keyframe. Set X to 30 (back swing).
Move the Playhead to 1.0 seconds and add a Rotation keyframe. Set X to -30 (matches frame 0 for a clean loop).
Select all three keyframes by clicking and dragging a box around them in the Timeline.
In the Keyframe Panel (right sidebar), change the interpolation dropdown from Linear to Smooth. The keyframe shapes change from diamonds to circles.

Now mirror the pattern for the right leg. When the left leg goes forward, the right leg goes back.

Select the right_leg bone.
At 0.0 seconds, add a Rotation keyframe with X set to 30.
At 0.5 seconds, add a Rotation keyframe with X set to -30.
At 1.0 seconds, add a Rotation keyframe with X set to 30.
Select all three keyframes and set interpolation to Smooth.

Why mirror the values?

Walking is a mirrored motion. When your left foot steps forward, your right foot pushes backward. By using opposite X rotation values on each leg at the same time positions, Blockbench interpolates a natural alternating stride between them.

Press Play Animation in the Timeline Header to check that the legs alternate. You should see one leg swing forward while the other swings back.

Both legs moving the same direction?

Double-check that your left_leg starts at -30 and your right_leg starts at 30 at 0.0 seconds. The signs must be opposite for the legs to alternate.

help me fix my walk cycle legs moving in the same direction

Add arm swing and body bob

Arms swing opposite to the legs when walking. This counterbalance keeps the body stable and looks natural.

Select the left_arm bone.
At 0.0 seconds, add a Rotation keyframe with X set to 30.
At 0.5 seconds, set X to -30.
At 1.0 seconds, set X to 30.
Set all three keyframes to Smooth interpolation.

Now mirror the arm swing on the other side.

Select the right_arm bone.
At 0.0 seconds, add a Rotation keyframe with X set to -30.
At 0.5 seconds, set X to 30.
At 1.0 seconds, set X to -30.
Set all three keyframes to Smooth interpolation.

Why do arms oppose the legs?

Notice that left_arm starts at X = 30 while left_leg starts at X = -30. The arm and leg on the same side always have opposite signs. This creates the natural counterbalance you see in real walking.

Now add the body bob. Each step pushes the character slightly upward, so the body bobs twice per cycle (once per step).

Select the body bone.
Add Position keyframes at the following times with these Y values:

0.0s: Y = 0.
0.25s: Y = 0.5.
0.5s: Y = 0.
0.75s: Y = 0.5.
1.0s: Y = 0.

Select all five Position keyframes and set them to Smooth interpolation.

Finally, add a slight body lean that shifts weight from side to side as each leg steps.

With the body bone still selected, add Rotation keyframes at these times with these Z values:

0.0s: Z = -1.5.
0.5s: Z = 1.5.
1.0s: Z = -1.5.

Select all three Rotation Z keyframes and set them to Smooth interpolation.

Preview and refine the walk cycle

With all your keyframes in place, it is time to play the animation back and verify everything moves correctly together.

Press Play Animation in the Timeline Header to preview the walk cycle.
Verify these three things: the legs alternate (when left goes forward, right goes back), the arms swing opposite to the legs, and the body bobs gently twice per cycle.

What should I see?

The character should look like it is walking in place with a smooth, rhythmic motion. The body rises slightly at 0.25s and 0.75s (the midpoints of each step). The lean shifts side to side subtly. There should be no visible pop or stutter at the loop point.

Click Toggle Graph Editor in the Timeline Header to switch to the Graph Editor View.
Select different bones and inspect the curves. You should see smooth, wave-like curves with no harsh spikes or sudden direction changes.

What is the Graph Editor?

The Graph Editor shows your animation as curves rather than keyframe diamonds on a timeline. Each curve represents how a value (like Rotation X) changes over time. Smooth curves mean smooth motion. Spikes or sharp corners mean jerky movement.

Walk looks robotic or stiff?

This usually means some keyframes are still set to Linear interpolation instead of Smooth. Select all keyframes for the affected bone and change the interpolation dropdown to Smooth. The keyframe shapes should all be circles, not diamonds.

If the stride looks too wide or exaggerated, reduce the leg rotation values. Try -20 and 20 instead of -30/30.

help me debug my walk cycle that looks stiff or unnatural

✔️ Awesome, I've got everything!

Great. Make sure your animation.player.walk animation is looping smoothly with no visible pops at the loop point.

ⓧ I'd like to double check the full keyframes

Here is the complete keyframe reference for animation.player.walk (length: 1 second, Loop enabled):

left_leg Rotation X:
  0.0s = -30
  0.5s = 30
  1.0s = -30
  Interpolation: Smooth (all)

right_leg Rotation X:
  0.0s = 30
  0.5s = -30
  1.0s = 30
  Interpolation: Smooth (all)

left_arm Rotation X:
  0.0s = 30
  0.5s = -30
  1.0s = 30
  Interpolation: Smooth (all)

right_arm Rotation X:
  0.0s = -30
  0.5s = 30
  1.0s = -30
  Interpolation: Smooth (all)

body Position Y:
  0.0s = 0
  0.25s = 0.5
  0.5s = 0
  0.75s = 0.5
  1.0s = 0
  Interpolation: Smooth (all)

body Rotation Z:
  0.0s = -1.5
  0.5s = 1.5
  1.0s = -1.5
  Interpolation: Smooth (all)

Your character now walks with a natural-looking stride. Next up, you will create a fast, punchy sword swing attack that uses different interpolation modes for each phase of the motion.

Create a Sword Swing Attack

Your walk cycle brought your character to life with rhythmic, looping motion. Now it's time to create something very different: a one-shot action that plays once and stops.

A convincing attack animation needs more than just moving the arm forward. It needs anticipation (a wind-up that telegraphs what's coming), a fast decisive swing, and follow-through (the body recovering naturally). You'll also use different interpolation modes on different phases to control how fast or snappy each part of the swing feels.

In this step, get ready to:

Create a non-looping attack animation with four distinct phases.
Use different interpolation modes (Smooth, Linear, Step) on individual keyframes to control the feel of each phase.
Add body rotation, head tracking, and counterbalance arm motion to sell the weight of the swing.

Create the attack animation and keyframe the sword arm

Unlike your idle and walk animations which loop continuously, the attack plays exactly once when triggered. This means you won't enable Loop, and the animation needs a clear start and end pose.

In the Animations Panel (left sidebar), click the plus icon to add a new animation.
Name it animation.player.attack.
Double-click the animation to open its properties and set the length to 0.6 seconds.
Do NOT enable Loop. This animation plays once per trigger.

Why 0.6 seconds?

Professional game attack animations for responsive melee typically run 0.4 to 0.8 seconds total. At 0.6 seconds, the wind-up is readable without feeling sluggish.

The four phases you'll create are: anticipation (0.0-0.15s), swing (0.15-0.3s), impact hold (0.3-0.4s), and recovery (0.4-0.6s).

Now keyframe the right arm (the sword arm) through all four phases.

Select the right_arm bone in the Outliner.
Move the Playhead to 0.0 seconds and add a Rotation keyframe (click the plus icon next to Rotation, or press Q). Leave X, Y, Z at 0, 0, 0. This is the resting pose.
Move the Playhead to 0.15 seconds and add a Rotation keyframe. Set X to -60, Y to -20, Z to 0. This is the wind-up pose where the arm is pulled back behind the head.
Move the Playhead to 0.3 seconds and add a Rotation keyframe. Set X to 60, Y to 20, Z to 0. This is the impact pose where the arm has swung forward and down.
Move the Playhead to 0.4 seconds and add a Rotation keyframe with the same values: X = 60, Y = 20, Z = 0. This holds the impact pose briefly.
Move the Playhead to 0.6 seconds and add a Rotation keyframe. Set X, Y, Z back to 0, 0, 0. This returns the arm to rest.

What do these keyframes create?

You've placed five keyframes that define the sword arm's journey: rest, wind-up, impact, hold, and recovery. The negative X rotation at 0.15s pulls the arm backward. The positive X rotation at 0.3s swings it forward. The duplicate values at 0.4s create a brief "freeze" at the moment of impact.

Arm moving the wrong direction?

Make sure you're on Blockbench 5.0 or later. Earlier versions inverted X and Y rotation values. If your arm swings forward when it should wind up, try negating the X values.

Also confirm you have the right_arm bone selected, not left_arm.

Help me figure out why my attack arm rotation looks wrong.

Set interpolation per phase and add body rotation

The magic of this animation comes from using different interpolation modes on different keyframes. A smooth ease out of rest, a fast linear swing, a hard step hold at impact, and a gentle ease back to neutral.

With right_arm still selected, click the keyframe at 0.0s on the Timeline. In the Keyframe Panel (right sidebar), set the interpolation dropdown to Smooth.
Select the keyframe at 0.15s and set interpolation to Linear. This makes the swing from wind-up to impact feel fast and direct.
Select the keyframe at 0.3s and set interpolation to Linear. This snaps into the impact pose without easing.
Select the keyframe at 0.4s and set interpolation to Step. This holds the impact pose with no transition until the next keyframe.
Select the keyframe at 0.6s and set interpolation to Smooth. This eases back to rest for a soft recovery.

Why mix interpolation modes?

Each interpolation mode creates a different feel. Smooth eases in and out, creating natural organic motion. Linear moves at constant speed, creating decisive, snappy action. Step holds a value with zero transition, creating the "hit freeze" feel common in action games.

By mixing them on a single bone, you control exactly how each phase of the swing reads to the player.

Now add body rotation to sell the weight of the swing. The torso should wind back, then follow through past center.

Select the body bone in the Outliner.
At 0.0s, add a Rotation keyframe with Y set to 0. Set interpolation to Smooth.
At 0.15s, add a Rotation keyframe with Y set to 20 (torso winds back). Set interpolation to Linear.
At 0.3s, add a Rotation keyframe with Y set to -30 (torso follows through past center). Set interpolation to Linear.
At 0.6s, add a Rotation keyframe with Y set to 0 (returns to neutral). Set interpolation to Smooth.

Next, add head tracking so the character looks where they're swinging.

Select the head bone in the Outliner.
At 0.0s, add a Rotation keyframe with Y set to 0. Set interpolation to Smooth.
At 0.15s, add a Rotation keyframe with Y set to 10 (head glances toward the target). Set interpolation to Linear.
At 0.3s, add a Rotation keyframe with Y set to -15 (head follows the swing direction). Set interpolation to Linear.
At 0.6s, add a Rotation keyframe with Y set to 0. Set interpolation to Smooth.

What does the body and head motion add?

The body rotation makes the swing feel heavy. Without it, only the arm moves and the attack looks weightless. The head tracking adds intentionality. Your character appears to aim rather than flail.

Body or head not moving?

Make sure you selected the correct bone before adding keyframes. The channel rows in the Timeline only appear for the currently selected bone. If you see no Rotation row, click the bone again in the Outliner.

Help me debug why my body or head keyframes aren't showing movement in the attack animation.

Add secondary motion and preview the full animation

The non-sword arm should move in response to the swing. It acts as a counterbalance, pulling back slightly during wind-up and swinging forward during the follow-through. This is secondary motion. It doesn't drive the action, but it makes the attack feel grounded.

Select the left_arm bone in the Outliner.
At 0.0s, add a Rotation keyframe with X = 0, Y = 0, Z = 0. Set interpolation to Smooth.
At 0.15s, add a Rotation keyframe with X = 10, Y = 0, Z = -10 (pulls back slightly for balance). Set interpolation to Smooth.
At 0.3s, add a Rotation keyframe with X = -20, Y = 0, Z = 5 (swings forward for counterbalance). Set interpolation to Smooth.
At 0.6s, add a Rotation keyframe with X = 0, Y = 0, Z = 0. Set interpolation to Smooth.

Why is the left arm all Smooth?

The left arm is secondary motion. It responds to the main action rather than driving it. Smooth interpolation gives it a natural, follow-along feel. The hard Linear and Step modes are reserved for the sword arm where you want decisive, controlled timing.

Preview the full animation by pressing the Play Animation button in the Timeline Header.

Watch for the sequence: a brief wind-up, a fast decisive swing, a momentary hold at impact, then a smooth return to rest.
Confirm the body and head rotate to sell the weight of the swing.
Confirm the animation does NOT loop. It should play once and stop.

Use the Graph Editor to inspect curves

Click Toggle Graph Editor in the Timeline Header to see the motion curves visually. The Linear sections should appear as straight lines between keyframes. The Smooth sections should show gentle curves. The Step section should appear as a flat horizontal line that jumps instantly at the next keyframe.

Swing feels too slow or sluggish?

Check that the keyframes at 0.15s and 0.3s are set to Linear, not Smooth. Smooth interpolation eases in and out, which softens the snap you want during the fast swing phase.

If the overall timing feels off, you can adjust. Try moving the wind-up keyframe to 0.1s and the impact to 0.25s for a faster swing.

Help me make my attack animation feel snappier and more responsive.

✔️ Awesome, I've got everything!

Great. Make sure you've saved your .bbmodel file to keep all three animations safe.

ⓧ I'd like to double check the full keyframe values

Here are all the keyframe values for animation.player.attack (length: 0.6 seconds, Loop: disabled):

right_arm Rotation:

0.0s = (0, 0, 0) Smooth.
0.15s = (-60, -20, 0) Linear.
0.3s = (60, 20, 0) Linear.
0.4s = (60, 20, 0) Step.
0.6s = (0, 0, 0) Smooth.

body Rotation Y:

0.0s = 0 Smooth.
0.15s = 20 Linear.
0.3s = -30 Linear.
0.6s = 0 Smooth.

head Rotation Y:

0.0s = 0 Smooth.
0.15s = 10 Linear.
0.3s = -15 Linear.
0.6s = 0 Smooth.

left_arm Rotation:

0.0s = (0, 0, 0) Smooth.
0.15s = (10, 0, -10) Smooth.
0.3s = (-20, 0, 5) Smooth.
0.6s = (0, 0, 0) Smooth.

Secret mission

Create a Wave Emote

Your player can breathe, walk, and attack. But can they say hello? Create a polished wave emote that layers body lean, arm motion, and head tilt with staggered timing to produce a natural gesture.

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. This project runs entirely locally, so there are no ongoing costs.

Resources you used:

Four animations saved inside your player .bbmodel file: animation.player.idle, animation.player.walk, animation.player.attack, and animation.player.wave.

Keep everything running

No action needed. Choose this if you plan to continue refining your animations or adding new ones to the set.

Your animations are saved inside the .bbmodel file. As long as you keep the file, your work is preserved.
You can reopen the file in Blockbench at any time to edit, preview, or export your animations.

Pause - I'll come back to this later

There are no running processes to stop. Your animations live inside the .bbmodel file on disk.

Save the file if you have unsaved changes (Ctrl+S on Windows, Cmd+S on macOS).
Close Blockbench whenever you like. Your animations stay in the file.

Delete - I don't want to use this again

Remove the animations you created during this project. Your original player model geometry remains untouched.

Open your player .bbmodel file in Blockbench and switch to the Animate tab.
In the Animations Panel (left sidebar), right-click animation.player.idle and select Delete.
Repeat for animation.player.walk, animation.player.attack, and animation.player.wave.
Save the file to confirm the deletions.

That's a Wrap!

Nice work! You just built a complete set of player animations from scratch in Blockbench.

You've learned how to:

Created a breathing idle animation using Smooth interpolation and matched first/last keyframes for seamless looping.
Built a walk cycle using the pose-to-pose method with mirrored limb timing and body bob.
Designed a sword swing attack with anticipation, varied interpolation modes per phase, and secondary motion for weight.
Secret Mission: Created a wave emote demonstrating overlapping action and layered bone timing.

Ready to quiz yourself?