ML Deformer for Character Production:
From High-Fidelity Data to Runtime

Unreal Engine's ML Deformer Framework is designed to approximate high-fidelity mesh deformation at runtime. A training setup connects three core inputs: a Skeletal Mesh, an Animation Sequence that samples a useful range of poses, and a Geometry Cache containing the desired target deformation for those same poses.

What ML Deformer is actually learning

The base skeletal animation provides the pose. The target Geometry Cache provides the deformation you want the final character to resemble. During training, ML Deformer learns an approximation of the difference between the skinned result and that target deformation.

This makes the system useful as a bridge between expensive offline deformation and a real-time character. Epic's ML Deformer sample demonstrates this with learned offline muscle, flesh and cloth deformation running on a high-fidelity character.

The production pipeline

1. Design training data around deformation coverage

Pose generation is not animation authoring. Its job is to expose the deformation system to useful combinations of joint rotations and, when applicable, curve inputs. A training sequence that repeatedly samples similar poses can be large while still leaving important regions of pose space uncovered.

• Include the articulation ranges the production character is expected to reach.
• Pay special attention to shoulders, hips, elbows, knees, torso compression and other areas with non-linear deformation.
• Keep skeletal pose data synchronized with the corresponding high-fidelity target frame.
• Separate training coverage from evaluation clips so you can test how the model behaves on motion it did not simply memorize.

2. Make the Geometry Cache trustworthy

The Geometry Cache is the target the model is trying to approximate, so topology correspondence, frame alignment, scale and orientation need to be predictable. Epic's setup guide uses Alembic Geometry Cache data for this target.

During Alembic import, Epic specifically recommends high position precision for ML Deformer training and notes that track naming and Flatten Tracks settings can matter when matching FBX meshes to Geometry Cache tracks. In the ML Deformer Editor, the training base and target can be scrubbed together so pose synchronization and deformation deltas can be inspected before training.

Ground truth can come from different workflows

The target deformation does not have to originate from one specific simulation package. Epic describes the training data as externally pre-generated deformation data and notes that pose/corrective generation can come from a DCC workflow. In production, the essential requirement is that the target represents the deformation quality you want the model to learn.

3. Choose the model for the deformation problem

Epic's current Unreal Engine 5.8 workflow recommends the Neural Morph Model as the default choice for flesh-like meshes and general deformation such as volume preservation and corrective shapes. The model learns highly compressed morph targets driven by bone rotations and/or curve inputs, with neural inference producing their weights at runtime.

The Neural Morph Model supports local and global modes, and its training settings expose controls such as iterations, network size, morph targets per bone/curve/group and bone masking. These are quality, memory and performance decisions, not just knobs to maximize.

4. Train, compare, then diagnose the error

Training is an iteration loop. After the model is trained, compare the learned result with both the normal skinned mesh and the target deformation. Look for systematic errors rather than only judging whether one hero pose looks impressive.

• If an entire region consistently lacks volume, inspect whether the training set contains enough variation for that region.
• If the target appears rotated or offset, fix alignment before interpreting training quality.
• If deformation breaks only on certain pose combinations, inspect pose coverage rather than immediately increasing model complexity.
• If small surface detail is noisy, distinguish source-data noise from model approximation error.
• Test production animation that was not used as the main training sequence.

The green delta visualization in the ML Deformer Editor is particularly useful before training because it exposes the relationship between the Training Base and Training Target. If those deltas are wrong, training will faithfully learn the wrong lesson. A very expensive student, basically.

5. Integrate the trained result as a character system

The trained ML Deformer asset is used with the character at runtime through the ML Deformer framework and mesh-deformation pipeline. Epic's workflow includes assigning a Deformer Graph to the Skeletal Mesh Component, and the framework provides an ML Deformer Component for runtime use.

Runtime validation should include the same questions as any other production character system: visual quality, memory, evaluation cost, LOD behavior, animation coverage and interaction with the rest of the character stack. ML Deformer should be evaluated alongside skinning, cloth, physics, Control Rig and other deformation layers rather than as an isolated demo.

Offline quality, runtime approximation

The useful mental model is not “run the original simulation in real time.” The offline process creates the target deformation; the trained model learns an approximation that can reproduce that behavior efficiently enough for runtime use. That distinction is central when deciding what belongs in simulation, training and final execution.

Common failure modes

• Training Base and Target do not match: verify frame synchronization, orientation, scale, topology mapping and Geometry Cache import.
• Good training poses, bad gameplay poses: expand pose-space coverage and validate with unseen production animation.
• Deformation loses volume: inspect ground truth and coverage before assuming the network simply needs to be larger.
• Unexpected local artifacts: inspect the source deltas and whether bone/curve inputs adequately describe the deformation.
• Great viewport result, poor runtime budget: profile the full character and make quality decisions in the target runtime context.

Production checklist

• Skeleton: stable hierarchy and repeatable poses between DCC and Unreal.
• Training animation: broad, intentional pose coverage.
• Ground truth: high-quality target deformation synchronized frame by frame.
• Geometry Cache: correct mapping, orientation, scale and precision.
• Model: selected for the deformation problem and tuned with runtime constraints in mind.
• Validation: predicted result compared against target data and unseen production motion.
• Runtime: Deformer Graph/component integration, performance and the full character stack tested in context.