Motion Matching: The Future of Game Animation Explained

Introduction: Why Game Animation Is Changing

For twenty years, game animation relied on the same fundamental architecture: animation state machines. A designer would define a set of discrete animation states—Idle, Walk, Run, Jump, Fall—and connect them with transitions triggered by gameplay events. The approach works, but it has a ceiling. No matter how many hand-crafted blend trees you build, characters eventually feel mechanical. Transitions are visible. Foot plants slip. Direction changes snap.

Modern motion matching systems use inertia-based blending (inertialization) instead of traditional cross-fades. Inertialization preserves the momentum of the outgoing animation by offsetting the incoming pose and decaying that offset over time, producing smoother transitions without blending two clips simultaneously.

Motion Matching is the technology that breaks through that ceiling. Used in FIFA, For Honor, The Last of Us Part II, and increasingly in indie titles via Unreal Engine 5, motion matching produces character movement that feels continuous, reactive, and genuinely physical. This guide explains how it works, what it requires, and how to start using it.

At runtime, motion matching performs pose matching — comparing the character's current pose and trajectory to every frame in the database and selecting the best continuation. Pose matching evaluates joint positions, velocities, and future trajectory to find a clip that minimizes the visual discontinuity of the transition.

What Is Motion Matching?

Motion Matching is an animation selection algorithm. Instead of transitioning between predefined states, it continuously searches a large database of motion capture poses and selects the best matching frame to play next—based on the character's current pose, velocity, and trajectory.

Each frame in the database is described by a compact feature vector — a set of floats encoding key joint positions, velocities, and trajectory points. The matching algorithm finds the frame whose feature vector is closest to the character's current state, making the search fast enough to run every frame.

The core idea, formalized by researchers at the Natural Motion company and popularized by Michael Buttner's 2015 GDC talk on the "Motion Matching" system used in For Honor, is elegantly simple:

At every frame, find the animation pose in your database that best matches where the character is right now and where it needs to go next. Play that pose. Repeat.

There are no explicit state machines. No hand-crafted transitions. The database does the work.

Motion Matching vs. Traditional State Machines

To understand what motion matching changes, it helps to understand what state machines struggle with:

State Machine Limitations

• Combinatorial explosion: Adding a new movement type (say, "walking while reloading") requires new states, new transitions, new blend trees. Complexity grows multiplicatively.
• Visible seams: Transitions between states always involve a blend, and blends are visible. Quick direction changes expose this immediately.
• Foot sliding: State machines often can't guarantee foot contact because the animation playback isn't synchronized to physics—the character's speed changes but the animation cycle doesn't.
• Predictability: State machines produce the same animation response to the same input, every time. Real humans don't move identically—they adapt continuously.

What Motion Matching Solves

• Natural continuity: Because the system is selecting frames that physically match the current pose, transitions are invisible. The character never "snaps" to a new animation.
• Direction changes: A character changing direction mid-run looks correct because the database contains those exact transition moments—captured from a real person changing direction.
• Foot contact: Foot locking can be enforced naturally because the system selects frames with feet in the correct contact state.
• Emergent variety: Because the system selects from a large database, natural variation in motion emerges without explicit randomization.

How Motion Matching Works: The Pose Search Database

The technical heart of motion matching is the pose search database. Here's how it's built and queried:

Building the Database

1. Capture a large, varied mocap dataset: The database needs to contain every movement type your character will perform—walking at many speeds, running, stopping, starting, direction changes, pivots, idles. Each of these needs many variations captured at different timings and styles.
2. Process into poses: Every frame of every animation becomes a "pose"—a vector describing joint positions, velocities, and trajectory information (typically where the feet and hips will be in the next 0.1, 0.2, and 0.3 seconds).
3. Build a searchable structure: Poses are indexed in a KD-tree or similar spatial data structure so that nearest-neighbor searches can be performed efficiently at runtime—within a single frame.

Querying at Runtime

Every frame, the system builds a "query pose" from the character's current state: current joint positions and velocities, plus the predicted future trajectory based on player input. It then finds the database pose that minimizes a cost function—typically a weighted sum of differences between the query and database poses across joint positions, velocities, and trajectory.

The best matching pose is selected and played. If the current pose is already good enough (within a threshold), the system continues playing the current animation rather than jumping to a new one—preventing jitter.

UE5's Built-in Motion Matching: Chooser and PoseSearch Plugin

Unreal Engine 5.4 shipped with production-ready motion matching support via two systems:

PoseSearch Plugin

The PoseSearch plugin implements the pose database, query system, and search algorithm. To use it:

1. Enable the PoseSearch plugin in your project settings.
2. Create a Pose Search Database asset and add your motion capture animation sequences to it.
3. Configure the schema—define which features are included in each pose (bone positions, velocities, trajectory).
4. Pre-process the database (a one-time cook step).
5. In your Animation Blueprint, use the Search Pose Database node to query and drive your character.

Chooser Framework

The Chooser is a general-purpose selection table system that complements motion matching. While PoseSearch handles continuous locomotion matching, Choosers handle discrete selection—picking which database or animation to search based on gameplay context (weapon equipped, stance, speed tier). Together they form a complete replacement for traditional state machines in UE5.

Motion Warping

UE5's Motion Warping system integrates with motion matching to solve the "last mile" problem: precisely aligning the character to targets like ledges, cover points, or interactive objects. Motion warping adjusts root motion in real-time to guarantee pixel-perfect alignment—something impossible with pre-authored state machine transitions.

Unity Motion Matching Implementations

Unity doesn't have a built-in motion matching system equivalent to UE5's PoseSearch, but the ecosystem has solutions:

KinematicaSoup Motion Matching (Kinematica)

Unity's experimental Kinematica package (now archived but still functional) was Epic's first attempt at a Unity motion matching framework. It introduced pose search databases and continuous matching to Unity developers. While no longer actively developed, it remains usable in Unity 2021.x and earlier.

Community and Third-Party Solutions

• DReyeVR / MotionMatching.cs implementations: Open-source Unity motion matching implementations are available on GitHub, varying in quality and production-readiness.
• Animation Rigging + Custom Matching: Teams have built custom motion matching solutions on top of Unity's Animation Rigging package and the Playables API, which gives low-level control over animation playback needed for a matching system.
• ORCA (Unity's upcoming system): Unity has announced intent to ship a native motion matching and pose graph system—watch the Unity roadmap for updates.

For now, UE5 is the platform with the most mature, out-of-the-box motion matching support.

Why Big Studios Use Motion Matching

FIFA (EA Sports)

EA's FIFA series adopted motion matching for player locomotion starting around FIFA 22. The result was dramatically more natural dribbling, direction changes, and ball control animations. Players responded immediately—character movement felt fluid in ways that explicit state machines couldn't achieve.

For Honor (Ubisoft)

Michael Buttner's GDC 2015 talk documented how For Honor used motion matching for its close-quarters melee combat. Because melee requires constant pose-aware reactions, motion matching—which always starts from the correct body pose—was a natural fit.

The Last of Us Part II (Naughty Dog)

Naughty Dog has long been at the forefront of character animation technology. TLOU2 used a variant of motion matching for Ellie and NPC locomotion, contributing to the fluid, weight-accurate movement the game was praised for.

Data Requirements: More Motion Capture Is Needed

Motion matching is not a silver bullet for animation budgets. It has one significant cost: the database must be large. A traditional state machine might need 50 animations for a locomotion system. A motion matching database for the same system might need 500–2,000 animation segments, covering all the transitions, speeds, and directions that the matching algorithm can select from.

What this means practically:

• More capture time: If you're doing your own mocap, plan for significantly more shoot time—continuous walking/running takes captured at many speeds, with many starts, stops, and pivots.
• More animation data budget: Your project's animation memory footprint increases. UE5's motion matching includes compression tools to mitigate this, but the fundamental data requirement is higher.
• Good source material is critical: Because motion matching selects frames from recorded data, the quality of your input animations directly determines output quality. Professional studio mocap produces better motion matching results than markerless capture.

Building a Motion Matching Database

Here's a practical breakdown of what to capture or purchase for a complete motion matching locomotion database:

Core Locomotion Set

• Walk cycles at 0.8m/s, 1.2m/s, 1.6m/s (slow, normal, brisk)
• Run cycles at 3m/s, 4m/s, 5m/s
• Sprint at 6m/s+
• Each speed tier: straight ahead, 45° left/right, 90° left/right strafes
• Start-from-idle transitions for each speed
• Stop-to-idle transitions for each speed
• Direction change pivots (180°, 90°, 45°) at each speed
• Idle variations (at least 3–5)

Extended Set for Production Quality

• Crouch/sneak versions of all above
• Backward movement
• Jump (ascent, peak, descent, land variations)
• Contextual starts (turning while starting to move)
• Slopes (uphill/downhill at 15°, 30°)

A complete, production-quality locomotion database typically contains 200–600 individual animation clips or continuous locomotion loops segmented into the above categories.

Cost-Benefit Analysis

When Motion Matching Is Worth It

• Third-person action games where character movement is constantly visible and scrutinized
• Sports games where movement precision matters
• Games with large open worlds where characters walk/run for extended periods
• Cinematic productions where the highest visual quality is required
• VR/XR applications where uncanny movement immediately breaks presence

When Motion Matching Is Overkill

• Top-down or isometric games where characters are small on screen
• 2D games with 3D elements (the complexity isn't visible)
• Games with limited locomotion requirements (e.g., a puzzle game with slow, deliberate character movement)
• Projects with small animation budgets where even basic state machine animations haven't been fully polished
• Prototypes and jam projects—a good state machine ships faster

How to Start with Motion Matching from Scratch

If you're new to motion matching and want to get started practically in UE5:

1. Enable PoseSearch plugin in your UE5 project (Edit → Plugins → search "PoseSearch").
2. Download Epic's sample content: Epic has released sample projects demonstrating motion matching on the Fab marketplace—start with these to understand the setup before building your own.
3. Acquire or import a locomotion mocap set: You need a locomotion database. Purchase a professional mocap pack with full locomotion coverage or capture your own.
4. Build a minimal database first: Start with just walk and run—no pivots, no starts/stops. Get the basic matching working before adding complexity.
5. Add trajectory features gradually: Start with current pose only. Add future trajectory prediction as you understand how the cost function works.
6. Profile and optimize: Motion matching has a runtime cost. Profile with Unreal Insights and add database partitioning (different databases for different locomotion contexts) to keep frame times manageable.

Frequently Asked Questions

Do I need a custom mocap studio for motion matching?

No. Professional mocap packs (like those from MoCap Online) are recorded in studio conditions and are well-suited for motion matching databases. The key is having enough variety—the packs need to cover the movement range your matching system will query against. Look for packs with multiple speed tiers and direction variations.

What frame rate should my motion matching database animations be?

30fps is the standard minimum for motion matching databases. 60fps gives finer granularity for the pose search, which is especially noticeable in fast direction changes. Most professional mocap packs are delivered at 30fps; upsampling to 60fps is possible but adds noise—capturing or sourcing at 60fps natively is better.

How much GPU/CPU does motion matching add?

The pose search itself is a CPU operation. A well-optimized database search costs 0.1–0.5ms per character. With database partitioning (limiting search scope to contextually relevant subsets), this can be reduced further. The animation playback cost is unchanged from traditional animation.

Can motion matching handle combat animations too?

Motion matching works best for continuous locomotion. Combat has more discrete, event-driven moments (attacks, hits, blocks) that often pair better with traditional state machine logic. Most production implementations use motion matching for locomotion and a state machine or Chooser table for combat, blending between them.

Is motion matching available for older UE4 projects?

Not natively. UE4 does not include the PoseSearch plugin. Some teams have implemented custom motion matching solutions in UE4, but it requires significant engineering work. Upgrading to UE5 is the recommended path for motion matching.

Conclusion

Motion matching represents a genuine shift in how game animation works—from handcrafted state management to data-driven pose selection. The results speak for themselves in the titles that use it: fluid, physically believable movement that holds up to close scrutiny. For teams willing to invest in a larger animation database and a one-time setup cost, the payoff in animation quality is dramatic.

The foundation of any motion matching system is high-quality mocap data. Explore MoCap Online's full animation library—professional studio motion capture ready to populate your pose search database.

Motion matching has fundamentally changed how studios approach animation systems by replacing hand-authored state machines with data-driven pose selection. Instead of manually defining transitions between hundreds of animation states, motion matching algorithms search through a database of motion capture clips to find the pose that best continues the current movement given the player's input. This approach produces remarkably fluid character movement because every transition happens through actual captured motion rather than blended interpolations.

The quality of a motion matching system depends directly on the breadth and variety of its motion capture database. Studios building motion matching implementations need extensive coverage of movement variations including different speeds, turning angles, start and stop conditions, and transitions between locomotion types. Pre-made motion capture packs that offer comprehensive coverage of walking, running, turning, and directional changes provide an excellent foundation for motion matching databases without requiring expensive custom capture sessions.

Studios transitioning from traditional state machine animation to motion matching should plan for a significant increase in their motion capture data requirements. A state machine might function adequately with thirty to fifty animation clips per character state, but motion matching systems perform best with thousands of frames of continuous captured movement covering every combination of speed, direction, and transition that the character might need. This data volume requirement makes comprehensive motion capture libraries and pre-made packs especially valuable for motion matching implementations.

The runtime performance characteristics of motion matching differ from state machines in ways that affect how you budget CPU time for animation. State machines evaluate a fixed number of transition conditions per frame regardless of database size, while motion matching performs a search across the entire pose database that scales with the number of candidate poses. Optimizations like kd-trees, database pruning, and pre-computed feature tables reduce this cost significantly, but motion matching remains more computationally demanding than simple state machines for equivalent character behavior.