Animating in Blender

Animation in Blender 5.x (5.2 LTS): the timeline, keyframes, the Dope Sheet, Graph Editor and NLA, actions and their slots (4.4+), armatures, weight painting, Rigify, shape keys, Mixamo, baking, and the glTF animation export modes. What keyframes, bones and skinning are is in Animation & rigging fundamentals; the destinations are Three.js, Godot and GTA V.

Timeline, frame rate & range

Since 5.0 every animation editor (Timeline, Dope Sheet, Graph Editor, NLA) has the same Playback Controls footer: play buttons, frame range, keying popover and auto-key.

glTF, three.js and Godot store seconds, not frames: a key on frame 49 at 24 fps is at 2 s.

Keyframes & keying sets

A keyframe (key) stores a property's value at a frame; Blender interpolates between keys along an F-Curve (one curve per animated property channel, e.g. X location).

Key types (Right-click a key › Keyframe Type, or R in the Dope Sheet) only color-code keys: Keyframe, Breakdown, Moving Hold, Extreme, Jitter, Generated.

Dope Sheet & Graph Editor

The Dope Sheet shows keys as diamonds per channel (timing); the Graph Editor shows the F-Curves themselves (value over time, spacing). Its Action Editor mode edits one action at a time.

F-Curve modifiers do not export to glTF on their own: the exporter samples the evaluated curve over the action's range, so a Cycles modifier gives you one period, which you then loop in the engine.

Actions & slots

An action is the data-block that stores animation (its F-Curves); objects, materials and shape keys point at an action the way a mesh points at a material. Since 4.4 an action has slots: each slot holds the channels for one animated data-block, so one "DoorOpen" action can drive the door object (slot OBDoor) and its handle (slot OBHandle) together.

NLA editor & naming clips

The NLA (NonLinear Animation) editor stacks actions as strips on tracks, like layers. The orange top row is the active action; everything below is strips.

For export, each action you want as a clip must be the active action or pushed down / stashed on an object. Exception: with one armature in the export, Export all Armature Actions (on by default) also exports every other action that fits it, stashed or not; delete or rename test actions first. The glTF clip name is the action name; with Merge Animation set to NLA Track Names (or the NLA Tracks mode) it is the track name instead. Name them for the engine:

Prefix actions per character (Knight_Walk) when several rigs share a file: every action is visible everywhere.

Armatures, weights & IK

An armature is a skeleton object made of bones; the mesh follows the bones through vertex groups (one per bone, weights 0–1) and an Armature modifier. Model the character in a T-pose or A-pose, facing −Y, with applied scale (Ctrl A › All Transforms) before rigging.

Bone roll is the twist around the bone's own axis; inconsistent roll makes mirrored poses and retargeting go wrong. IK (inverse kinematics) rotates a chain so its tip reaches a target (feet on the ground, hands on a rail); a Pole Target aims the knee or elbow. IK always evaluates after other constraints on those bones.

Weight painting fixes what automatic weights get wrong (armpits, hips, clothing):

1. Armature in Pose Mode, then select the mesh and switch to Weight Paint (Ctrl Tab pie). Uncheck Edit › Lock Object Modes if it blocks you.
2. Alt LMB (or Shift Ctrl LMB) a bone to show its group; paint with LMB. Red = 1, blue = 0.
3. Brushes: Paint (blend modes Mix, Add, Subtract…), Blur, Average, Smear, plus the Gradient tool; X mirror in the header.
4. Weights menu: Normalize All (every vertex sums to 1), Limit Total to 4 influences (the common engine limit; glTF exports 4 by default), Clean (drop tiny weights), Mirror Vertex Group.
5. Test with extreme poses; keyframe a few test poses on frames you delete later.

Ryan King Art's beginner rigging tutorial: watch for bone placement, automatic weights, and fixing weights at the joints.

Rigify & game skeletons

Rigify generates a full animation rig (IK/FK arms and legs, spine, fingers, face) from a simple meta-rig. It ships with Blender; enable it in Preferences › Add-ons › Rigify.

1. Object Mode: Shift A › Armature › Human (or Basic Human, Basic Quadruped, Bird, Cat, Horse, Shark, Wolf).
2. Match the character: scale the meta-rig in Pose Mode and Apply Pose as Rest Pose, or move bones in Edit Mode. Keep knees and elbows slightly bent so the IK direction is known; delete the face bones (Face bone collection) if you animate the face with shape keys. Rigify assumes 1 unit = 1 m.
3. Armature Properties › Rigify › Generate Rig. Regenerate after editing the meta-rig; it overwrites the rig in place.
4. Parent the mesh to the generated rig with Automatic Weights.

Game engines want a small, clean hierarchy of deform bones: every extra bone costs skinning time and file size, and control bones mean nothing outside Blender. Export with glTF Data › Armature › Export Deformation Bones Only (it bakes the controls' effect onto the deform bones). Rigify's DEF- chain is not one tidy parent hierarchy, so check the result in the engine; for strict skeletons (retargeting in Godot, Unity humanoid) build a separate game skeleton that follows the rig with Copy Transforms constraints and bake it (see Baking).

Shape keys

Shape keys (morph targets, blend shapes) store alternate vertex positions of the same mesh: smiles, blinks, phonemes, corrective shapes. Object Data Properties › Shape Keys:

Mixamo characters

Mixamo (opens in a new tab) (free with an Adobe ID; not actively supported) auto-rigs a humanoid and has a large motion library.

1. Export your mesh as FBX (or OBJ) from Blender: one mesh, T-pose, applied transforms, facing −Y.
2. Upload, place the chin / wrists / elbows / knees / groin markers, and let it rig.
3. Pick animations; tick In Place for locomotion you'll drive from code. Download FBX Binary, the first clip With Skin, the rest Without Skin, at your project frame rate.
4. Blender: File › Import › FBX (5.x has a new native importer; each FBX "take" becomes an action).

Object animation for websites

Most web "3D motion" is a few transforms on a loop: a spinning product, a floating logo, a door that opens on scroll. Keep it small and seamless.

When the motion is this simple, animating in code (a rotation.y += dt or a tween) is smaller than a clip; export clips for motion that's hard to write by hand or for rigged characters. Playback on the web side is in Three.js models & animation and Web export.

Baking constraints, IK & physics

Engines understand keyed transforms of objects and bones and shape key weights. Constraints, IK, drivers, F-Curve modifiers and simulations must be baked to plain keys.

Bake Action options: Start / End / Frame Step, Only Selected Bones, Visual Keying (key the final transform with constraints applied), Clear Constraints, Clear Parents, Overwrite Current Action (off creates a new action), Clean Curves, Bake Data (Pose / Object), Channels (Location, Rotation, Scale, B-Bone, Custom Properties). The glTF exporter samples animation by default and has Bake All Objects Animations for constrained objects, but an explicit bake is what you can inspect and fix.

glTF animation export

File › Export › glTF 2.0 › Animation panel. Only object transforms, pose bones and shape key values are exported in the core format; material, light and camera property animation needs the experimental Animation Pointer option (NLA Tracks or Scene mode only).

three.js: each clip is an AnimationClip in gltf.animations. Godot: each becomes an Animation in the imported AnimationPlayer, looping if the name has loop / cycle. Checklists live in Web export and Godot export.

Recipes

Loop a walk cycle for Godot

Use for any looping locomotion clip.

1. Key the contact pose on frame 1 and copy it (Ctrl C / Ctrl V in the Dope Sheet) to frame 25; key the passing and opposite contact poses in between (13 is the mirrored contact: Pose › Paste Pose Flipped).
2. Graph Editor: select all, Shift E › Make Cyclic; smooth the seam with handles, not extra keys.
3. Action Editor: name the action Walk-loop; in the sidebar set Manual Frame Range 1–25 and Cyclic Animation. The range includes the closing key, and the exporter uses it as the clip length (1 s at 24 fps), so the engine wraps from frame 25 to the identical frame 1 without a hitch.
4. Push Down. Export glTF, Animation mode Actions, "Set all glTF Animation starting at 0" on.
5. In Godot the clip imports as Walk (suffix stripped) with looping on; enable root motion or move the body in code.

Export several actions as clips

Use for a character with Idle / Walk / Run / Jump for three.js or Godot.

1. Create each clip with Action Editor › New, name it, animate, then Push Down (or Stash).
2. Check the NLA: one track per action on the armature; mute nothing you want exported.
3. Export: Animation mode Actions, Export all Armature Actions on, Reset pose bones on, Deformation Bones Only if you used Rigify.
4. Verify in glTF Viewer (opens in a new tab) that the clip list matches.

The same stashing from Python (5.x API, slots set explicitly). Exported with Merge Animation › NLA Track Names, the clips are Walk, Run…; with the default they keep the action names:

import bpy
 
arm = bpy.data.objects["Knight"]
ad = arm.animation_data or arm.animation_data_create()
for act in bpy.data.actions:
    if not act.name.startswith("Knight_"):
        continue
    track = ad.nla_tracks.new()
    track.name = act.name.removeprefix("Knight_")
    strip = track.strips.new(act.name, 1, act)
    if act.slots:
        strip.action_slot = act.slots[0]
ad.action = None  # nothing active; all clips on tracks

Turntable for a product page

Use for a 360° product spin that loops forever.

1. Parent the product to an Empty at the origin; animate the Empty's Rotation Z.
2. Frame 1: key Z = 0°. Frame 121: key Z = 360°. Select both keys, T › Linear, Shift E › Make Cyclic.
3. For a rendered video, set the scene range 1–120 (frame 121 would repeat frame 1). For glTF, keep the action's full 1–121 range and leave Limit to Playback Range off: the clip lasts exactly 5 s at 24 fps.
4. Export with Animation mode Actions and "starting at 0"; in three.js play it with LoopRepeat.

Fix a Mixamo character for the web

Use when a Mixamo FBX looks right in Blender but wrong in the browser.

1. Import all FBX clips; merge their actions onto one armature and push each down with a clean name.
2. Rename bones to drop mixamorig:. Blender renames the matching channels in the actions the armature uses (active and on its NLA tracks), so push every clip down first, then play each one to check.
3. Remove the extra armatures and meshes; apply transforms last, or leave the 0.01 scale and let glTF carry it.
4. Export: Actions mode, Deformation Bones Only off (Mixamo bones already all deform), Limit Total weights 4.

Bake an IK rig for export

Use when feet slide or hands float in the engine but look right in Blender.

1. Select the armature, Pose Mode, select all bones (A).
2. Pose › Animation › Bake Action: frames of the clip, Visual Keying on, Clear Constraints on, Overwrite Current Action off, Bake Data Pose.
3. Rename the baked action (Knight_Climb), push it down, and export only the baked actions.
4. Keep the original rigged action (fake user) for further edits.

Face animation with shape keys

Use for blinking, lip sync or expressions on a web or Godot character.

1. Model Basis, then keys Blink, Smile, A, O, M (edit each in Edit Mode with the key selected).
2. Key the Values in an action (or drive them from a jaw bone).
3. Don't enable "Apply Modifiers" on export (it drops shape keys); apply Mirror or Subdivision before making the keys.
4. three.js: set morphTargetInfluences[dict["Blink"]]; Godot: mesh.set_blend_shape_value().

References

• Blender Manual: Animation (opens in a new tab): keyframes, keying sets, actions & slots, shape keys, constraints, drivers
• Blender Manual: Actions (opens in a new tab): slots, slot types, assigning and replacing actions
• Blender Manual: Graph Editor (opens in a new tab), Dope Sheet (opens in a new tab) and NLA Editor (opens in a new tab): shortcuts, F-Curve modifiers, Bake Action options
• Blender Manual: Armatures (opens in a new tab), weight painting (opens in a new tab) and Rigify (opens in a new tab)
• Blender Manual: glTF 2.0 (opens in a new tab): animation modes and every export option
• Blender release notes 5.0 (opens in a new tab), 5.1 (opens in a new tab) and 5.2 (opens in a new tab): what changed in animation
• Godot: node type customization (opens in a new tab): the loop / cycle clip names
• Mixamo Rig (opens in a new tab) and Import Mixamo – Root Motion (opens in a new tab) extensions
• Animation & rigging fundamentals: the concepts behind this sheet