Jittery Rigidbody Movement in Unity: Why It Happens and How to Fix It

Your character moves, but it stutters. The camera follows, but the player shakes on screen. Everything looks smooth in the Scene view and jittery in the Game view. Jittery Rigidbody movement is one of the most common Unity complaints, and it almost always comes from the same root cause: physics runs on a different clock from rendering, and something in your setup is mixing the two. This guide explains why it happens and gives the fixes in order, for both 3D Rigidbody and Rigidbody2D, including the camera cases that cause most of the trouble.

Why Rigidbodies Jitter

Unity runs two loops:

• Update runs once per rendered frame: 60, 144 or however many frames per second your game renders, and that number varies.
• FixedUpdate and the physics simulation run at a fixed rate, by default 50 times per second (Fixed Timestep 0.02).

At 144 FPS with 50 physics steps per second, most rendered frames have no physics step at all, and a few have one. Without help, a Rigidbody’s position only changes on those frames, so it appears to move in uneven little jumps. At 60 FPS some frames get one step and some get none, which is visibly uneven too.

The jitter gets worse when something else moves every rendered frame (usually the camera) while the Rigidbody moves only on physics steps. The two are out of sync, and the one you’re looking at relative to the other appears to shake.

Fix 1: Turn On Interpolation

This is the fix for most cases. Select the Rigidbody and set Interpolate to Interpolate. On Rigidbody2D, the setting is Interpolate too.

With interpolation on, Unity renders the object at a smoothed position between its last two physics positions every frame, so it moves smoothly at any frame rate. The cost is a tiny visual lag (at most one physics step), which nobody notices in practice.

• Interpolate blends between the previous and current physics positions. Smooth and stable. Use this by default.
• Extrapolate predicts the next position. No lag, but it overshoots when the object changes direction or hits something. Rarely worth it.

Only turn it on for objects the player watches: the player character, the ball, the car. Leaving hundreds of background physics props un-interpolated is fine and cheaper.

Fix 2: Move the Rigidbody the Right Way

Interpolation only works if physics is moving the object. If your code sets transform.position or calls transform.Translate on an object with a Rigidbody, you bypass the physics engine, interpolation has nothing to smooth, and the object also tunnels through walls.

Body type	Move it with	Don’t use
Dynamic (non-kinematic)	rb.linearVelocity, rb.AddForce	transform.position, Translate
Kinematic	rb.MovePosition, rb.MoveRotation	transform.position

A simple, smooth, physics-friendly character mover:

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class PlayerMover : MonoBehaviour
{
    [SerializeField] float speed = 6f;
    Rigidbody rb;
    Vector2 input;

    void Awake()
    {
        rb = GetComponent<Rigidbody>();
        rb.interpolation = RigidbodyInterpolation.Interpolate;
        rb.constraints = RigidbodyConstraints.FreezeRotation;   // stop it tipping over
    }

    void Update()
    {
        // Read input every frame so no key press is missed
        input = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
    }

    void FixedUpdate()
    {
        Vector3 move = new Vector3(input.x, 0, input.y).normalized * speed;
        rb.linearVelocity = new Vector3(move.x, rb.linearVelocity.y, move.z); // keep gravity
    }
}

On Unity versions before 6, linearVelocity is called velocity. If you use the new Input System, read your action’s value in Update the same way.

Fix 3: Read Input in Update, Apply in FixedUpdate

Two opposite mistakes cause trouble here:

• Applying forces in Update. AddForce in Update applies force once per rendered frame, so the result depends on frame rate. Faster PCs push harder, and the motion is uneven. Apply physics in FixedUpdate.
• Reading one-shot input in FixedUpdate. GetKeyDown or a “pressed this frame” action is only true for one rendered frame. If no physics step happens on that frame, FixedUpdate never sees it, and jumps get “eaten”. Read input in Update, store it, and consume it in FixedUpdate:

bool jumpQueued;

void Update()
{
    if (Input.GetKeyDown(KeyCode.Space)) jumpQueued = true;
}

void FixedUpdate()
{
    if (jumpQueued)
    {
        rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
        jumpQueued = false;
    }
}

Fix 4: Fix the Camera Follow

If the player looks smooth in the Scene view but shakes in the Game view, the camera is the problem. The camera must follow the interpolated position, updated every rendered frame, after everything else has moved.

• Custom follow script: move the camera in LateUpdate, reading the target’s transform.position (which is the interpolated one). Don’t move the camera in FixedUpdate, and don’t read rb.position for the camera, because that’s the raw, non-interpolated physics position.
• Smoothing: if you use Vector3.SmoothDamp or Lerp, do it in LateUpdate with Time.deltaTime.
• Cinemachine: on the Cinemachine Brain, set the Update Method to Smart Update or Late Update, and make sure the target Rigidbody has interpolation on. Fixed Update on the Brain causes exactly this jitter with an interpolated target.

public class FollowCamera : MonoBehaviour
{
    [SerializeField] Transform target;
    [SerializeField] Vector3 offset = new Vector3(0, 5, -8);
    [SerializeField] float smoothTime = 0.15f;
    Vector3 velocity;

    void LateUpdate()
    {
        Vector3 goal = target.position + offset;
        transform.position = Vector3.SmoothDamp(transform.position, goal, ref velocity, smoothTime);
        transform.LookAt(target);
    }
}

Setting up a proper third-person camera? Our Cinemachine 3 guide covers it step by step.

Fix 5: Check the Fixed Timestep and Frame Rate

In Project Settings > Time, Fixed Timestep is 0.02 (50 Hz) by default. With interpolation on, you usually don’t need to change it. Some notes:

• Lowering it (for example to 0.01, which is 100 Hz) makes physics more precise but doubles its CPU cost. Only do it if you need precision, such as fast racing games.
• Don’t change Time.fixedDeltaTime to match the frame rate at runtime. It’s a common tip that trades one problem for others.
• If you change Time.timeScale for slow motion, interpolation keeps things smooth. Without it, slow motion looks choppy.
• Uneven frame pacing makes any movement look jittery. Turn on VSync (Quality settings) or set Application.targetFrameRate, and test in a build. The Editor’s frame pacing is always worse than a build’s.

Other Causes: Fast Objects, Collisions and 2D

Fast objects vibrate against walls or pass through them

Set Collision Detection to Continuous (or Continuous Dynamic for fast objects hitting other moving ones). Also make sure you’re not pushing the object into a wall with a velocity every step. Zero the velocity component toward a wall you’re touching.

The character shakes while standing on a moving platform

Move the platform as a kinematic Rigidbody with MovePosition in FixedUpdate, with interpolation on. A platform moved by transform in Update fights with physics every frame.

Parent and child Rigidbodies

A Rigidbody inside another moving Rigidbody’s hierarchy gets moved twice. Only one object in a chain should have a non-kinematic Rigidbody, or connect them with joints instead of parenting.

2D specifics

Everything above applies to Rigidbody2D: Interpolate, linearVelocity/MovePosition in FixedUpdate, camera in LateUpdate. For pixel art, a Pixel Perfect Camera snaps rendering to whole pixels, which can make slow movement look steppy. That’s a style issue, not physics jitter. Compare with the Pixel Perfect Camera disabled to tell which one you’re seeing.

Troubleshooting by Symptom

Symptom	Most likely fix
Object stutters at high frame rates	Interpolate on the Rigidbody
Player shakes, background smooth	Camera in LateUpdate / Cinemachine Brain not on Fixed Update
Background shakes, player smooth	Camera moving in FixedUpdate or following rb.position
Speed differs between PCs	Forces applied in Update; move to FixedUpdate
Jumps sometimes ignored	GetKeyDown read in FixedUpdate; queue it in Update
Interpolation does nothing	Code moves transform.position directly
Vibrates against walls	Continuous collision, stop pushing into the wall
Smooth in build, jittery in Editor	Editor frame pacing; judge smoothness in builds

FAQ