Blender has become one of the most powerful free tools in a game developer's pipeline, and its animation system is more capable than many realize. Importing, retargeting, and blending professional motion capture animations in Blender is entirely achievable — you just need to know the correct steps and how to sidestep the common pitfalls. This guide covers everything from file formats to the NLA editor.
What File Formats Does Blender Support for Motion Capture?
Blender natively supports two primary motion capture formats:
- FBX (.fbx): The industry standard. FBX carries both the mesh and the skeletal animation data in a single file. Blender's built-in FBX importer handles most production FBX files correctly, though it has quirks around bone axis orientation that we'll address below.
- BVH (.bvh): Biovision Hierarchy format. This is animation-only — no mesh. BVH is one of the oldest motion capture formats and Blender has excellent native BVH support. It's widely used for retargeting workflows because the skeleton hierarchy is straightforward.
You may also encounter Alembic (.abc) for baked simulation-style animation and glTF (.glb/.gltf) for web-oriented pipelines. Blender handles both. For game development with motion capture, FBX is the format you'll use most often.
Step-by-Step: Importing FBX Motion Capture into Blender
Step 1: Prepare Your Scene
Start with a clean Blender file. Delete the default cube if present. Set your frame rate to match your target game engine: 30fps is standard for most game animation, 60fps for smoother high-performance titles. Go to Properties → Output Properties → Frame Rate and set it accordingly.
Step 2: Import the FBX File
- Go to File → Import → FBX (.fbx)
- Navigate to your animation file
- In the import options panel (bottom left), check these settings:
- Scale: Leave at 1.0 unless the imported character is massively over- or under-sized
- Apply Unit: Checked
- Use Pre/Post Rotation: Checked (this resolves most bone axis issues)
- Ignore Leaf Bones: Checked — leaf bones from FBX exports are usually empty terminator nodes that clutter your hierarchy
- Force Connect Children: Leave unchecked unless you know you need it
- Click Import FBX
Step 3: Check the Import
After import, select the armature and press Space to play the animation. Verify the character is moving correctly. Common issues at this stage:
- Character is 100x too large: The FBX was exported in centimeters. Select the armature, go to Object Properties, and scale down by 0.01, then Apply Scale (Ctrl+A → Scale).
- Animation isn't playing: Check that the armature has an Action applied. Open the Action Editor (in the Dope Sheet editor, switch mode to Action Editor) and confirm an action is assigned to the armature object.
- Bones are facing wrong directions: This is the classic bone axis problem — see the troubleshooting section below.
Retargeting Mocap to Your Own Rig (Rigify Method)
If you've imported a mocap animation onto its source skeleton and want to transfer it to your own character's rig (for example, a Rigify rig or a custom game rig), retargeting is the process you need.
Option A: Using Blender's Built-in Bone Constraint Method
This is the manual but highly controllable approach:
- Import your mocap source skeleton (the one from the FBX pack)
- Import or have open your target character with its rig
- On your target rig, enter Pose Mode
- For each bone you want to drive from the mocap source, add a Copy Rotation constraint and set the Target to the corresponding bone in the source armature
- Optionally add Copy Location for root/hips bone to capture root motion
- Bake the driven poses: Pose → Animation → Bake Action with "Visual Keying" and "Clear Constraints" checked
Option B: Using the Rigify Retarget Add-on
Blender's Rigify system includes a retargeting module. After generating your Rigify rig:
- Enable the Rigify add-on if not already active (Edit → Preferences → Add-ons → search "Rigify")
- With both armatures in your scene, select the Rigify rig
- In the Rigify panel (sidebar, Rigify tab), find the Retarget section
- Set the Source Rig to your mocap armature
- Map corresponding bones using the bone map interface
- Bake the result
Option C: Auto-Rig Pro (Paid Add-on)
For studios doing frequent retargeting, Auto-Rig Pro ($40 on Blender Market) includes a dedicated retargeting module that handles bone axis normalization automatically. It maps source skeleton bones to target skeleton bones via a UI and bakes the result to a clean action. Worth the investment if you're retargeting many animations.
Using the NLA Editor to Blend Multiple Animations
Blender's Non-Linear Animation (NLA) editor is where motion capture animation becomes genuinely powerful. Instead of having a single monolithic animation clip, you layer, blend, and sequence multiple clips together.
Setting Up Strips in the NLA Editor
- Select your armature
- Switch the editor type to NLA Editor (the timeline-like editor with stacked strips)
- You'll see your current action listed. Click the Push Down button (downward arrow icon) next to the action — this converts the current action into an NLA strip
- Import a second animation clip via FBX. It will create a new action in Blender's data
- In the NLA Editor, click Add → Add Action Strip and select the second action
- Drag the strip to position it on the timeline
Blending Between Strips
Select any NLA strip and press N to open the strip properties panel. The Blending dropdown lets you choose:
- Replace: This strip completely replaces what's below it
- Add: This strip's values are added to the layers below — useful for additive animations (head look, breathing)
- Subtract: Subtracts from layers below
- Multiply: Multiplies — rarely needed but available
Use the Strip Influence (0.0–1.0) to fade a strip in or out over time. Keyframe the influence value to create smooth transitions between two animations — for example, fading from a walk cycle to a run cycle over 10 frames.
Practical NLA Workflow: Locomotion State Machine
A minimal locomotion setup in Blender using the NLA editor:
- Idle animation → NLA strip on track 1, set to loop
- Walk cycle → NLA strip on track 2, influence keyframed 0→1 when walking starts
- Run cycle → NLA strip on track 3, influence keyframed 0→1 when sprinting
- Jump → NLA strip on track 4, non-looping, triggered on jump event
This is a simplified preview-only setup. Your actual game engine handles the state machine logic — the NLA preview in Blender helps you validate how blended clips will look before you export them.
Common Issues and How to Fix Them
Bone Axis Problem (Bones Pointing the Wrong Direction)
This is the most common complaint when importing FBX mocap into Blender. The root cause is that FBX uses a right-handed coordinate system while Blender uses a right-handed system as well, but the forward axis convention differs between exporters (Maya, MotionBuilder, and Unity all have slightly different defaults).
Fix 1: In the FBX import dialog, experiment with the Primary Bone Axis and Secondary Bone Axis settings. Common working combinations:
- Primary: Y, Secondary: X (for most Maya-exported FBX)
- Primary: Y, Secondary: Z (for some MotionBuilder outputs)
Fix 2: Check Use Pre/Post Rotation in import settings. This often resolves axis issues automatically.
Fix 3: After import, in Edit Mode on the armature, select all bones and use Armature → Bone Roll → Recalculate Roll to normalize bone orientations.
Scale Issues (Character Is Tiny or Enormous)
FBX files exported from Maya or MotionBuilder in centimeters will import into Blender at 1/100th the expected size (or 100x too large depending on the exporter's unit settings). The fix:
- Select the imported object in Object Mode
- Check the scale in Object Properties — if it reads 0.01 on all axes, that's your problem
- Press Ctrl+A and choose Apply All Transforms
- Alternatively, in the FBX import settings, change Scale from 1.0 to 100.0 before importing
Animation Not Playing or Missing
If the armature imports but no animation plays:
- Open the Dope Sheet → Action Editor. Check if an action is listed in the dropdown at the top. If the field is empty, the animation data may have imported onto a different object (sometimes it binds to the mesh rather than the armature). Check all objects in the scene.
- Ensure Armature Deform is enabled on the armature object (Armature Properties → Viewport Display)
- Check that the timeline range covers the animation's frame range
Root Motion Issues
Some mocap packs bake root motion into the hip bone rather than a separate root bone. If your character slides or drifts when you'd expect it to stay in place (or vice versa), you need to separate root motion:
- Identify whether root motion is on a "Root" bone or the "Hips" bone
- In Pose Mode, select the root/hips bone and use Pose → Animation → Bake Action to bake just that bone's position to a separate action
- Zero out the position keys on the original bone if you want in-place animation for the state machine
Mixamo vs MoCap Online: Which Is Better for Blender?
Mixamo is the most well-known free source of motion capture animations and it integrates reasonably well with Blender. But there are meaningful differences worth considering:
| Mixamo | MoCap Online | |
|---|---|---|
| Cost | Free (requires Adobe account) | Per-pack purchase, free pack available |
| Animation quality | Good for common actions | Professional optical mocap quality |
| Library depth | ~2,500 animations | Specialized packs (combat, locomotion, crowd, sport) |
| License | Requires active Adobe subscription for commercial use | One-time purchase, full commercial license |
| Blender compatibility | Exports FBX directly, generally clean | FBX and BIP formats, standard retargeting |
| Customization | Auto-rigged to Mixamo skeleton only | Standard humanoid skeleton, retarget to any rig |
| Unique content | Broad but shallow in specialized areas | Deep libraries for specific genres (combat, zombies, military) |
For a Blender workflow, Mixamo is an excellent starting point, especially for prototyping. For production work — particularly if you need a specific animation style that Mixamo doesn't cover or want perpetual licensing certainty — professional packs from MoCap Online are worth the investment.
Exporting from Blender Back to Your Game Engine
Once you've imported, retargeted, and polished your animations in Blender, export them back to FBX for use in Unity or Unreal Engine:
- Select the armature (and optionally the mesh)
- File → Export → FBX (.fbx)
- In export settings:
- Set Apply Scale to FBX All (resolves scale issues in Unity/Unreal)
- Under Armature, uncheck Add Leaf Bones
- Under Bake Animation, check NLA Strips if you're exporting a blended timeline
- Set Key All Bones if you have pose-only keyframes that need to be baked
Frequently Asked Questions
Can Blender import BVH motion capture files directly?
Yes. Go to File → Import → BVH (.bvh). Blender creates an armature from the BVH hierarchy and assigns the animation data to it. The main challenge with BVH is that you'll need to retarget from the BVH skeleton to your character's rig, since BVH skeletons rarely match game character rigs exactly.
Do I need a paid add-on to retarget mocap in Blender?
No. Blender's built-in constraint-based retargeting works well, particularly for simple humanoid skeletons. The manual bone constraint method described above is free and fully capable. Auto-Rig Pro and similar add-ons simply speed up the process for studios doing high-volume retargeting.
Why does my character slide across the floor during animation playback?
This is a root motion issue. The animation has root bone translation baked in (the character is actually moving in 3D space during the animation). Most game engines handle this with a "root motion" setting on the animation asset — in Unity, enable "Apply Root Motion" on the Animator; in Unreal, enable Root Motion on the animation asset settings. If you need a stationary in-place loop for Blender preview, manually zero out the root bone's X/Z location keys.
How do I loop a motion capture animation cleanly in Blender?
Professional packs include pre-looped clips where the first and last frames match. If you're working with a non-looped clip, you can create a loop in Blender by: (1) setting the action to cycle with F-Curve Modifiers (Cycles modifier on all F-curves), or (2) using the NLA editor to place two copies of the strip end-to-end and blending the seam using the strip's Blend In/Out settings.
What's the best way to organize multiple mocap actions in Blender?
Use Blender's action naming convention to stay organized: prefix action names with the character name and animation purpose (e.g., "HeroChar_Walk_Loop", "HeroChar_Idle_01", "HeroChar_Jump_Start"). In the NLA editor, group related actions on the same track. Use the Fake User button (F icon) on actions you want to preserve between save/reload cycles — otherwise Blender may garbage-collect unused action data.
Get Started With Professional Mocap in Blender
The best way to master this workflow is to work with real professional motion capture data. Download our free pack at MoCap Online's free pack page and follow this guide step by step. When you're ready to expand your library, browse the Blender-compatible animation collections to find packs built for your genre.
Related Articles
- FBX Animation: The Definitive Guide for Game Developers
- BVH Animation Files: What They Are and How to Use Them
- Animation Retargeting: How to Apply Mocap to Any Character
- Motion Capture Cleanup: How to Fix Mocap Data for Production
- Browse All Motion Capture Animation Packs
Blender's NLA Editor provides a powerful non-linear animation system for combining and layering motion capture clips. By converting imported FBX animations into NLA strips, you can blend between different captured performances, adjust timing, and create seamless transitions without modifying the underlying action data. This workflow is ideal for assembling motion capture packs into complete character animation sets, as each strip references the original capture while the NLA system handles the mixing and sequencing.
Retargeting motion capture data in Blender requires matching the source skeleton's bone names and orientations to your character's armature. The Rigify addon simplifies this process by providing a standardized control rig that maps predictably to common motion capture skeleton formats. Once the retargeting relationship is established, you can batch-apply entire animation libraries to your Blender characters, making it efficient to work with large motion capture collections.
For game developers using Blender as their primary animation tool, the FBX export pipeline requires attention to bone naming conventions and scale settings. Unreal Engine and Unity each expect specific skeleton hierarchies and unit scales, and Blender's default settings may not match these expectations. Establishing an export preset that handles these conversions ensures that motion capture animations maintain their quality and timing when they reach the game engine.
Blender's Graph Editor gives animators detailed control over individual animation curves from imported motion capture data. You can smooth noisy capture data, adjust the intensity of specific movements, or add secondary motion to enhance the captured performance. This curve-level editing preserves the organic feel of the original capture while allowing precise adjustments that would be difficult to achieve through full-body retakes.
Blender's Python scripting API extends the animation pipeline with automation capabilities that save significant time when working with large motion capture libraries. Custom scripts can batch-process imported animation files, automatically applying retargeting configurations, trimming clips to specified frame ranges, and exporting to engine-specific formats with consistent settings. This scripting capability is one of Blender's strongest advantages over commercial alternatives for studios that need to process hundreds of captured clips efficiently.