Fix: Unity Cinemachine Camera Jittering or Shaking

Here is how to fix Unity Cinemachine camera shaking. Your Cinemachine virtual camera follows the player, but the image jitters, shakes, or stutters. The character moves smoothly on its own, but through the camera everything vibrates. This is almost always a timing mismatch between when the camera updates and when the follow target moves, compounded by damping settings that amplify small positional differences between frames.

Why Cinemachine Cameras Jitter

Cinemachine updates the camera position every frame based on the follow target's transform. The problem is that "every frame" can mean different things depending on your setup. Unity has three update loops: Update (every render frame), LateUpdate (after all Update calls), and FixedUpdate (on a fixed physics timestep). If the target moves in FixedUpdate but the camera reads its position in LateUpdate, the camera sees interpolated or stale positions, causing visible jitter.

The CinemachineBrain component controls when Cinemachine processes virtual cameras. Its Update Method setting determines which Unity update loop the camera follows. A mismatch between this setting and how your character moves is the number one cause of camera jitter in Cinemachine setups.

CinemachineBrain Update Method

The CinemachineBrain sits on your main Camera GameObject. It has an Update Method dropdown with three options:

Smart Update is the default. Cinemachine tries to detect whether the target is physics-driven or transform-driven and updates accordingly. This works for most cases, but fails when a target uses both physics and script-driven movement, or when the detection heuristic guesses wrong.

Late Update runs the camera in LateUpdate. This is correct when your character moves in Update, because the camera reads the position after the character has finished moving that frame. If the character uses a Rigidbody, this will jitter.

Fixed Update runs the camera in FixedUpdate, synchronized with physics. Use this when the follow target is a Rigidbody that moves via forces, velocity, or MovePosition. The camera and the physics target update on the same timestep, eliminating jitter.

// Verify your CinemachineBrain settings at runtime
using UnityEngine;
using Cinemachine;

public class BrainDebug : MonoBehaviour
{
    void Start()
    {
        var brain = FindObjectOfType<CinemachineBrain>();
        if (brain != null)
        {
            Debug.Log($"Brain Update Method: {brain.m_UpdateMethod}");
            Debug.Log($"Brain Blend Update: {brain.m_BlendUpdateMethod}");
        }
    }
}

If you change the Update Method and the jitter stops, you have found the cause. For most third-person games with Rigidbody characters, Fixed Update is the correct setting.

Damping Settings That Cause Shaking

Every Cinemachine Body component (Transposer, Framing Transposer, Orbital Transposer) has damping values that control how quickly the camera follows the target. These are the X, Y, and Z Damping fields in the Inspector.

Zero damping means the camera teleports to the exact offset position every frame. If the target has any micro-movement at all, the camera mirrors it instantly, which reads as vibration. Even sub-pixel jitter in the target's transform becomes visible camera shake at zero damping.

Mismatched axis damping causes the camera to lag differently on each axis. If X damping is 0 but Y damping is 2, horizontal movements snap while vertical movements smooth, creating an unsettling visual effect.

// Programmatically set damping on a virtual camera
using Cinemachine;

public class CameraConfig : MonoBehaviour
{
    [SerializeField] private CinemachineVirtualCamera _vcam;

    void Start()
    {
        var transposer = _vcam.GetCinemachineComponent<CinemachineTransposer>();
        if (transposer != null)
        {
            // Smooth, consistent damping on all axes
            transposer.m_XDamping = 1.0f;
            transposer.m_YDamping = 1.0f;
            transposer.m_ZDamping = 1.0f;
        }

        var composer = _vcam.GetCinemachineComponent<CinemachineComposer>();
        if (composer != null)
        {
            // Aim damping controls rotation smoothing
            composer.m_HorizontalDamping = 2.0f;
            composer.m_VerticalDamping = 2.0f;
        }
    }
}

Start with damping values between 0.5 and 2.0 for the Body and between 1.0 and 3.0 for the Aim. Test at your target framerate. Damping that feels smooth at 60 FPS may feel sluggish at 30 FPS or twitchy at 144 FPS because damping is frame-rate dependent in Cinemachine's default mode.

Rigidbody Follow Target Conflicts

The most common scenario for camera jitter is a third-person camera following a player character driven by a Rigidbody. The character moves in FixedUpdate, but the camera updates in LateUpdate. Between physics steps, the character's visual position is interpolated by Unity's physics engine. If the camera reads the transform between interpolation steps, it sees a position that does not match the rendered position, producing visible vibration.

The fix has two parts:

1. Set the CinemachineBrain to Fixed Update. This synchronizes camera movement with physics.

2. Enable Rigidbody interpolation on the follow target. Set the Rigidbody's Interpolation mode to Interpolate (not None). This smooths the visual position between physics steps, and the camera will read a smooth position even on frames between FixedUpdate calls.

// Ensure Rigidbody interpolation is enabled on the follow target
void Start()
{
    var rb = GetComponent<Rigidbody>();
    if (rb != null && rb.interpolation == RigidbodyInterpolation.None)
    {
        Debug.LogWarning("Rigidbody interpolation is None. Camera will jitter.");
        rb.interpolation = RigidbodyInterpolation.Interpolate;
    }
}

If you are using a CharacterController instead of a Rigidbody, keep the Brain on Smart Update or Late Update. CharacterController.Move runs in Update, not FixedUpdate, so Fixed Update on the Brain would cause the opposite problem.

Noise Profiles Causing Unintended Shake

Cinemachine virtual cameras have an optional Noise component that adds procedural camera shake. This is intentional for effects like footstep vibration, explosion screenshake, or handheld camera feel. But if a noise profile is assigned and you do not realize it, the camera shakes continuously and it looks like a bug.

Check the Noise section of your virtual camera. If it has a profile assigned (like 6D Shake or Handheld_normal_mild), either remove it or set the Amplitude Gain and Frequency Gain to zero when you do not want shake.

// Disable noise on a virtual camera
var noise = _vcam.GetCinemachineComponent<CinemachineBasicMultiChannelPerlin>();
if (noise != null)
{
    noise.m_AmplitudeGain = 0f;
    noise.m_FrequencyGain = 0f;
}

// To add shake temporarily (e.g., explosion), set values and reset
public void TriggerShake(float amplitude, float frequency, float duration)
{
    StartCoroutine(ShakeRoutine(amplitude, frequency, duration));
}

private System.Collections.IEnumerator ShakeRoutine(float amp, float freq, float dur)
{
    var noise = _vcam.GetCinemachineComponent<CinemachineBasicMultiChannelPerlin>();
    noise.m_AmplitudeGain = amp;
    noise.m_FrequencyGain = freq;
    yield return new WaitForSeconds(dur);
    noise.m_AmplitudeGain = 0f;
    noise.m_FrequencyGain = 0f;
}

If you want intentional screenshake in your game, use this approach: keep noise at zero by default and enable it through a controlled API. This prevents accidental persistent camera shake from polluting your normal gameplay camera.

Body and Aim Component Conflicts

Each virtual camera has a Body component (controls position) and an Aim component (controls rotation). Certain combinations fight each other. For example, a Framing Transposer body tries to keep the target within a screen-space dead zone, while a Composer aim also adjusts rotation to frame the target. Both are trying to accomplish similar goals through different means, and their competing adjustments oscillate the camera.

Common conflict patterns:

Framing Transposer + Composer: Both try to frame the target. Use Framing Transposer with Do Nothing aim, or use Transposer with Composer.

Hard Lock At + any Aim: Hard Lock At snaps the camera to a fixed offset. Any aim component that tries to rotate the camera will conflict with the hard positional lock.

Strip your virtual camera to the minimum components needed. If you want to follow and frame a target, use Transposer (Body) + Composer (Aim). If you want screen-space framing, use Framing Transposer (Body) + Do Nothing (Aim). Avoid mixing components that control the same degree of freedom.

Related Issues

If the follow target itself is jittering because of NavMesh issues, see NavMeshAgent not moving. If the camera is fine but particles on the character flicker, check particle system not playing. For camera issues during multiplayer where different clients see different things, see NetworkObject not spawning.

Smart Update is only smart some of the time. If your target uses a Rigidbody, just set the Brain to Fixed Update and stop guessing.