Procedural animation with Control Rig and Spring Interpolate

The Spring Interpolate node in Control Rig is a simulation-based tool for creating smooth, physics-like transitions between values. Unlike a standard Lerp or Interpolate node, which moves at a constant or linear rate, the Spring Interpolate node uses a spring-mass-damper model to move a value toward a target.

It is especially useful for adding secondary motion, overlap, and settle to characters without the cost of a full physics simulation.

Core variants

There are three main versions of this node, depending on the type of data you are animating:

• Spring Interpolate (Float): Best for single values such as alpha, intensity, or a single axis.
• Spring Interpolate (Vector): Ideal for translation, such as moving a bone or control in 3D space.
• Spring Interpolate (Quaternion): Designed for rotations and built to take the shortest path without flipping.

Key input pins

To get the motion you want, it helps to understand how the pins work together:

Target

This is the goal value where you want the spring to eventually settle. For example, it could be the current position of a control.

Current

This is the current state of the spring. It is usually fed back from a variable that stores the result from the previous frame.

Strength / Stiffness

This controls how stiff the spring feels. Higher values make the spring snap to the target faster; lower values make it feel heavier or looser.

Critical damping

This controls the amount of bounce.

• 1.0: The spring reaches the target as quickly as possible without overshooting.
• Below 1.0: The spring overshoots and oscillates, creating jiggle or bounce.
• Above 1.0: The spring feels slower and more sluggish, with a heavier, underwater motion.

Velocity

This is the current speed of the value. Like Current, it should be stored in a variable and fed back into the node to maintain momentum between frames.

Common use cases

Secondary motion

For tails, ears, hair, and other lightweight reactive elements, you can use a For Each loop to iterate through a chain of bones. By spring-interpolating the rotation of each child bone relative to its parent, you create automatic drag and overshoot as the character moves, without hand-animating every bounce.

This is a fast way to add natural motion to secondary systems while keeping the setup procedural.

IK grounding smoothing

When using a Raycast to align a foot to uneven terrain, a direct snap can feel robotic. Passing the Raycast hit position through a Spring Interpolate node with a high Strength and Critical Damping of 1.0 allows the foot to adjust to stairs and rocks with a more natural, weighted feel.

This is particularly useful for locomotion and grounded contact, where the movement needs to feel intentional without looking mechanical.

Implementation checklist

To use this node successfully in a graph:

1. Create variables: You need a variable, such as SpringCurrentPos, to store the output of the node so it can be fed back into the Current pin on the next tick.
2. Place it in the correct event: Make sure the Spring node is in the Forward Solve event.
3. Keep it frame-rate independent: The node automatically uses the engine’s Delta Time, so the motion stays consistent across frame rates.

Final thought

The Spring Interpolate node is one of the simplest ways to add believable motion to a Control Rig setup. It gives you the controlled, physical feel of a spring without the complexity of a full simulation. In practice, that makes it a powerful tool for characters, rigs, and procedural systems that need to feel alive.

At Lunar Lizard, we are particularly interested in how these lightweight motion systems can make character animation feel more grounded and expressive. The right use of spring-based motion can make a rig feel more natural without requiring excessive manual animation work.