Physics jitter is one of the most frustrating issues Unity developers face. Objects appear to shake, stutter, snap back, or teleport slightly instead of moving smoothly. This problem is especially common when using Rigidbody, player controllers, cameras, or networked objects.

This article explains what causes physics jitter in Unity, why teleportation and jerky movement happen, and how to fix them using reliable, production-safe patterns.

What Is Physics Jitter in Unity?

Physics jitter occurs when an object’s visual position does not update smoothly from frame to frame. Instead of continuous motion, the object appears to vibrate, snap, or briefly teleport.

Typical symptoms include:

• Player character shaking while moving
• Rigidbodies snapping backward or forward
• Camera jitter when following a physics object
• Objects teleporting slightly on slopes or collisions

Main Causes of Physics Jitter

Physics jitter almost always comes from a mismatch between Unity’s physics system and the frame update loop.

Cause 1: Moving Rigidbody Objects in Update()

Unity’s physics engine runs in fixed time steps, not per frame. When you move a Rigidbody in Update(), its position is modified at an inconsistent rate, causing jitter.

Incorrect approach:

void Update() {
    transform.position += Vector3.forward * speed * Time.deltaTime;
}

This bypasses the physics engine and leads to unstable movement.

Correct approach:

void FixedUpdate() {
    rb.MovePosition(rb.position + Vector3.forward * speed * Time.fixedDeltaTime);
}

Cause 2: Mixing Transform Movement with Rigidbody

Directly modifying transform.position on a GameObject that has a Rigidbody causes Unity to fight itself. The physics engine tries to correct the position every frame.

This often results in teleportation or snapping.

Wrong pattern:

transform.position = targetPosition;

Correct pattern:

rb.MovePosition(targetPosition);

If you must control position manually, set the Rigidbody to kinematic.

Cause 3: Camera Following Rigidbody in Update()

Camera jitter is extremely common when following a physics-based player.

Problematic setup:

void Update() {
    camera.transform.position = player.transform.position + offset;
}

The player moves in FixedUpdate(), while the camera updates every frame, causing visible jitter.

Correct solution:

void LateUpdate() {
    camera.transform.position = player.transform.position + offset;
}

LateUpdate() ensures the camera updates after all physics movement.

Cause 4: Incorrect Interpolation Settings

By default, Rigidbody interpolation may be disabled. This causes visible jitter when physics updates are slower than rendering.

Fix:

• Select the Rigidbody
• Set Interpolation to Interpolate

This smooths visual movement between physics updates.

Cause 5: Fixed Timestep Mismatch

If Time.fixedDeltaTime is too high or inconsistent, physics updates will feel jerky.

Recommended default:

Time.fixedDeltaTime = 0.02f; // 50 physics updates per second

Lower-end devices may require tuning this value carefully.

Cause 6: Network Position Corrections

In multiplayer games, physics jitter often comes from server position corrections.

Symptoms include:

• Small teleporting steps
• Rubber-banding
• Sudden snaps during movement

Solution patterns include interpolation and prediction:

transform.position = Vector3.Lerp(
    transform.position,
    serverPosition,
    Time.deltaTime * smoothing
);

Reliable Solutions for Physics Jitter

Use FixedUpdate for Physics

All Rigidbody movement and forces should be applied in FixedUpdate().

void FixedUpdate() {
    rb.AddForce(moveDirection * speed);
}

Enable Rigidbody Interpolation

This is one of the simplest and most effective fixes for jitter.

Separate Visuals from Physics

A common professional approach is to separate the visual model from the physics body.

• Physics object moves in FixedUpdate
• Visual model smoothly follows using interpolation

Freeze Unnecessary Rigidbody Axes

Unwanted rotation can cause visible jitter.

rb.constraints = RigidbodyConstraints.FreezeRotationX |
                 RigidbodyConstraints.FreezeRotationZ;

Use Continuous Collision Detection

Fast-moving objects can jitter due to collision corrections.

Set Rigidbody Collision Detection to:

• Continuous
• Continuous Dynamic

Best Practices Summary

• Never move Rigidbodies in Update()
• Use FixedUpdate for physics logic
• Use LateUpdate for camera following
• Enable Rigidbody interpolation
• Avoid mixing transform movement with physics
• Tune fixed timestep carefully
• Smooth network corrections

Conclusion

Unity physics jitter is not a single bug, but a collection of common mistakes related to timing, movement methods, and update order. Teleportation and jerky movement usually happen when physics and rendering fall out of sync.

By respecting Unity’s physics lifecycle, using FixedUpdate correctly, enabling interpolation, and separating visuals from physics logic, you can eliminate jitter and achieve smooth, professional-grade movement in your Unity projects.