Your character's foot clips through every staircase. Their hand hovers two inches from every door handle. Their elbow snaps to a T-pose the moment they reach for a ledge. These are classic inverse kinematics (IK) failures—and they're 100% preventable with the right setup from Blender through to your engine of choice.
This guide walks through everything: what IK actually is, how to author IK chains in Blender, how to export them without breaking the rig, and how to drive them at runtime in both Unity's Animation Rigging package and Unreal Engine 5's Control Rig.
What Is Inverse Kinematics and Why It Matters in Games
In forward kinematics (FK), you rotate each bone in a chain from the root down—shoulder → elbow → wrist. Every rotation is independent, and placing the hand at a specific world position requires manually solving each joint angle. That's fine for pre-baked animations, but useless when the target moves dynamically at runtime.
Inverse kinematics flips this. You specify the goal position (a door handle, a weapon grip, a foothold on uneven terrain), and the IK solver works backwards through the chain to find the joint angles that get the end effector there. The solver does the math; you provide the target.
For games, IK is essential in several situations:
- Foot IK: keeping feet planted on uneven ground instead of floating above or clipping into it
- Hand IK: attaching hands to interactive objects—weapons, ladders, steering wheels
- Look-at IK: rotating the head and spine to track a point of interest
- Full-body IK (FBIK): driving an entire character from a set of effectors (used heavily in VR)
The two most common IK algorithms you'll encounter are FABRIK (Forward And Backward Reaching IK—fast, stable, good for long chains) and CCD (Cyclic Coordinate Descent—good for short chains and highly constrained rigs). Both Unity and Unreal implement variants of these internally; you configure constraints and targets rather than choosing the algorithm directly.
Setting Up IK Chains in Blender
Blender uses Bone Constraints to define IK chains. Here's the standard workflow for a leg IK setup.
1. Create the IK target and pole target bones
In Pose Mode, you need two extra bones per IK chain:
- IK Target bone — the effector the foot will track
- Pole Target bone — controls which direction the knee bends
Name them clearly: `foot.IK.L`, `foot.IK.R`, `knee.pole.L`, `knee.pole.R`. Keep them in a dedicated `IK-Controls` bone collection (Blender 4.x).
2. Add the IK constraint
Select the shin bone (the last bone before the foot in the chain), then in the Bone Constraint Properties panel:
```
Add Constraint → Inverse Kinematics
Target: Armature → foot.IK.L
Chain Length: 2 (shin + thigh)
Pole Target: Armature → knee.pole.L
Pole Angle: -90° (adjust until knee points forward)
```
3. Lock rotation axes on the knee
Knees only bend on one axis. In the Bone Properties → Inverse Kinematics panel, lock the X and Z axes (set their stiffness to 1.0 or use Limit Rotation constraints). This prevents the solver from producing anatomically wrong bends.
4. Bake or keep live for export
For pre-baked animations destined for Unity or Unreal, bake your IK to FK before export:
```
Pose → Animation → Bake Action
☑ Only Selected Bones
☑ Clear Constraints
☑ Overwrite Current Action
Visual Keying: ON
```
This writes actual rotation keyframes on every bone, producing an animation any engine can read without knowing anything about your IK setup. For runtime IK (foot planting, hand attachment), keep the skeleton clean—export without baking and let the engine handle IK at runtime.
Blender IK Quick Reference
| Use Case | Bake to FK? | Chain Length | Needs Pole Target? |
|---|---|---|---|
| Pre-baked walk cycle | Yes | Any | Yes |
| Runtime foot planting | No | 2–3 | Yes |
| Runtime hand attachment | No | 2 | Optional |
| Look-at (spine/neck) | No | 3–5 | No |
Exporting IK-Ready Rigs to Unity and Unreal Engine 5
Export strategy depends entirely on whether you want baked or runtime IK.
For baked animations (no runtime IK needed)
Export as FBX with these Blender settings:
```
File → Export → FBX
Apply Scalings: FBX Units Scale
Forward: -Z Forward
Up: Y Up
☑ Armature
☑ Mesh
Add Leaf Bones: OFF ← removes dummy end bones
Bake Anim: ON
NLA Strips: OFF
Force Start/End Keying: ON
```
For runtime IK in Unity
Export the skeleton only—strip IK target and pole bones from your selection before export. These are Blender authoring helpers, not runtime bones. Unity's Animation Rigging package creates its own IK targets at runtime.
In Unity's Model Import Settings:
- Avatar Type: Humanoid (Humanoid IK) or Generic (Animation Rigging)
- Optimize Game Objects: OFF during development
For runtime IK in Unreal Engine 5
Import as FBX. In the Skeletal Mesh import dialog:
- Import Animations: ON (if bringing baked clips)
- Create Physics Asset: ON
- Update Skeleton Reference Pose: ON
UE5's Control Rig and IK Retargeter work directly from the imported skeleton—no special export preparation needed beyond a clean, properly named hierarchy.
Runtime IK in Unity: Animation Rigging Package
Unity's com.unity.animation.rigging package (included since Unity 2020 LTS) provides a component-based IK system that layers on top of the Animator.
Setup checklist
- [ ] Install Animation Rigging via Package Manager
- [ ] Add `Rig Builder` component to the character root GameObject
- [ ] Create a child GameObject named `Rig`, add `Rig` component
- [ ] Add `Two Bone IK Constraint` to a child of `Rig`
- [ ] Assign Root, Mid, and Tip bones from the skeleton
- [ ] Create an empty GameObject as the IK Target, assign it
- [ ] Create a Pole Target GameObject if needed
- [ ] Adjust `Weight` (0–1) to blend IK against the base animation
```csharp
// Dynamically set IK target position at runtime
using UnityEngine;
using UnityEngine.Animations.Rigging;
public class FootIKController : MonoBehaviour
{
public TwoBoneIKConstraint leftFootIK;
public Transform leftFootTarget;
public LayerMask groundMask;
void Update()
{
if (Physics.Raycast(leftFootTarget.position + Vector3.up,
Vector3.down, out RaycastHit hit, 2f, groundMask))
{
leftFootIK.data.target.position = hit.point;
leftFootIK.data.target.rotation =
Quaternion.FromToRotation(Vector3.up, hit.normal) *
transform.rotation;
}
}
}
```
Weight the constraint at `1.0` when grounded and blend it to `0.0` during jumps or locomotion transitions to avoid foot-locking artifacts.
Runtime IK in Unreal Engine 5: Control Rig
UE5's Control Rig is a node-based procedural rigging system that runs in-engine. For IK, the key node is PBIK (Position Based IK), which solves full-body IK from a set of effectors.
Basic foot IK with PBIK
- Open your Skeletal Mesh → Create Control Rig
- In the Control Rig graph, add a PBIK node
- Wire the Input Pose from your animation
- Add Effectors for each foot bone: `foot_l`, `foot_r`
- Add a Line Trace to find the ground position each frame
- Set effector Position from the trace hit, Rotation from the surface normal
- Set Root Behavior to `Pin Root` to prevent pelvis drift
For simpler, lower-cost cases, use the Two Bone IK node instead of PBIK—it's equivalent to Unity's TwoBoneIKConstraint and is appropriate for arm reach or basic leg planting.
Plug your Control Rig into the Animation Blueprint via the `Control Rig` node in the AnimGraph, placed after your locomotion state machine output. This ensures IK runs as a post-process layer on top of base animation clips.
Take Your Characters Further
Inverse kinematics transforms static, clip-locked animations into characters that feel alive and physically grounded. The investment in a correct Blender rig, clean export, and runtime IK setup pays dividends across your entire animation system—better foot planting, believable interactions, and VR-ready characters.
If you're sourcing pre-rigged, IK-ready character bases or environment assets to place your IK targets on, browse the BitSoul Marketplace. Every asset ships with verified skeleton hierarchies, so you can drop them straight into Unity or Unreal and start wiring IK constraints without cleanup work.
For a full library of optimized game assets—characters, props, environments, and animated rigs—visit https://bitsoulhosting.com/marketplace and filter by engine compatibility.
---
*This post is part of the Ultimate Guide to Free 3D Game Assets — BitSoul's complete reference for formats, texturing, rigging, optimization, and engine integration.*