Fix: Unreal Control Rig Rewinding During Blend

Here is how to fix Unreal Control Rig that rewinds or snaps backward during a blend. Your character has a procedural foot-IK Control Rig that pins feet to uneven ground. It looks beautiful when running. The moment the player triggers a Reload animation that blends in over 0.3 seconds, the feet snap to the setup pose, slide backward six inches, then catch up. The IK is correct on the frame before the blend and the frame after, but during the blend the rig appears to rewind. The cause is not the IK math — it is how the rig output participates in the blend graph.

The Symptom

A Control Rig that produces a stable per-frame output (foot IK, look-at, spine bend) appears to snap backward, rewind to a neutral pose, or visibly stutter during the blend into or out of another animation. The artefact is most visible at the start of the blend (when blend weight goes from 0 to non-zero) and at the end (when it returns to 0).

Snapping at blend start. On the frame the blend begins, bones controlled by the rig snap to their setup pose, then catch back up to where they were on the previous frame within one or two frames. This looks like a one-frame teleport followed by a fast slide.

Drift during the blend. While the blend is in progress, rig-controlled bones drift slowly in one direction even though the source animation is not moving them. The drift correlates with the blend duration and stops the moment the blend completes.

Inconsistent IK contact. A foot-IK rig that should pin the foot to the ground throughout the blend instead lifts the foot, drags it across the surface, then slams it back down at blend completion. The contact point is correct on either side of the blend but wrong during it.

Look-at oscillation. A look-at rig pointed at a fixed target visibly oscillates between the rig’s solved orientation and the source animation’s baked head rotation. The oscillation frequency matches the engine framerate.

What Causes This

Forwards Solve resets every frame. Control Rig’s default execution model runs the Forwards Solve event every frame the rig is evaluated. Forwards Solve starts from the input pose (the bones as they were before the rig ran) and applies rig logic to produce the output. When the rig is blended in at weight 0.5, the input pose is whatever the source animation provides, but the rig still runs from scratch. The output is correct but the path to get there involves resetting and reapplying transforms, which is visible if the blend weight changes between frames.

Layered Blend Per Bone weight inversion. Layered Blend Per Bone takes a base pose and a layer pose, then for each bone uses the layer pose at the layer’s weight and the base pose at one minus that weight. If the rig is the layer and the source animation is the base, a weight of 0.5 means half the rig output and half the un-rigged source. The half-rigged result is a pose that does not match either the rig’s intent or the source’s intent, and it shifts every frame as the weight ramps.

Cached Pose stale across blends. If you use a Cached Pose node to share the rig output between branches of the AnimGraph, the cache only updates when its source is evaluated. If the rig branch is gated by a state machine that is currently blending out, the cache holds the last value from before the blend started, which can be many frames stale by the time the new state evaluates it.

Use Animation Asset toggled mid-blend. Some rigs expose a Use Animation Asset boolean that determines whether the rig consumes a baked animation or operates purely procedurally. Toggling this in code while a blend is in progress causes the rig to switch input sources mid-frame, producing a one-frame discontinuity that is amplified by the blend interpolation.

The Fix

Step 1: Cache the rig output and blend the cache, not the live rig. Insert a Cached Pose node immediately downstream of your Control Rig node. Wire the cached pose into the blend, not the rig itself. The cache evaluates the rig once per frame regardless of blend weight, so the rig produces a stable per-frame result that the blend can interpolate cleanly.

// AnimInstance C++ helper to validate cache freshness
void UMyAnimInstance::NativeUpdateAnimation(float DeltaTime)
{
    Super::NativeUpdateAnimation(DeltaTime);

    APawn* Pawn = TryGetPawnOwner();
    if (!Pawn) return;

    // Force the rig to run before the blend evaluates
    bShouldEvaluateRig = !Pawn->GetVelocity().IsNearlyZero()
        || bAnyActiveBlend;

    if (bShouldEvaluateRig)
    {
        LastRigEvalFrame = GFrameCounter;
    }

    // Detect stale cache by comparing frame counters
    if (GFrameCounter - LastRigEvalFrame > 1)
    {
        UE_LOG(LogAnimation, Verbose,
            TEXT("Rig cache stale by %d frames"),
            GFrameCounter - LastRigEvalFrame);
    }
}

The bAnyActiveBlend flag is the critical piece. The rig must keep evaluating during a blend even if the gameplay state would normally skip it — otherwise the cached pose used by the blend goes stale and produces the rewind artefact.

Step 2: Convert Layered Blend Per Bone to Apply Additive. If your rig produces an offset rather than an absolute pose — foot adjustments, look-at deltas, spine corrections — bake the offset as additive and apply it on top of the source animation. Apply Additive does not compete with the source for bone authority, so the source pose is unaffected and the rig delta blends in cleanly.

// In Control Rig graph, output a delta instead of absolute pose
void UMyControlRig::ExecuteRig()
{
    // Solve IK to find target bone transform
    FTransform Target = SolveFootIK(InputPose.RightFoot);

    // Output the DELTA from input to target, not the target
    FTransform Delta = Target.GetRelativeTransform(
        InputPose.RightFoot);

    OutputPose.RightFoot.Location = Delta.GetLocation();
    OutputPose.RightFoot.Rotation = Delta.GetRotation();

    // Mark output as additive for the blend node downstream
    OutputPose.AdditiveType = EAdditiveAnimationType::AAT_LocalSpaceBase;
}

Once the rig outputs additive, replace the Layered Blend Per Bone in the AnimGraph with an Apply Additive node. The blend now adds the rig delta to the source pose at the blend weight, with no competition for absolute bone values.

BlendOption and Cubic Smoothing

Even with cached poses and additive output, you may see one-pixel jitter at the very start of a blend. This is the rig’s first-frame solve being compared to the source animation’s zero-weight pose. The simplest fix is to change the transition’s BlendOption from Linear to Cubic or HermiteCubic. The eased curve approaches zero asymptotically, so the first two or three frames of the blend contribute only a few percent of the rig output — not enough to be visible.

Avoid the Step blend option for Control Rig outputs entirely. Step jumps from 0 to 1 in a single frame, which exposes any rig recomputation jitter as a visible snap. If you need an instant transition, use a Linear blend with a one-frame duration instead — the engine handles the boundary more gracefully than Step does.

RigVM Forwards Solve Discipline

If you author your own Control Rig, follow one rule in Forwards Solve: do not write to the same bone twice in one execution. The first write sets the value, the second overwrites it, and any node downstream that reads the bone gets the second value. If different code paths fire on different frames depending on game state, the bone value oscillates between paths frame to frame, which appears as rewind during a blend.

“The blend is just doing what you told it. The rig is just doing what you told it. The bug is that you told them different things and made them argue. Cache the result of the argument, then blend the cache.”

Related Issues

If your Control Rig also leaks performance during a blend, see Control Rig Double Evaluation Cost for evaluation gating. If foot-IK still slides after fixing the blend, check Foot IK Sliding on Stairs for ground-trace and pelvis-adjustment patterns.

Cache the rig, blend the cache. Live rig output and blend weights do not mix.