Fix: Unity Cinemachine Camera Snapping on Scene Load

The scene fades in and for a split second the camera is pointing at the wrong corner of the level, then it snaps — or slowly drifts — to where it should be. Players notice it even on a loading screen fade. Cinemachine’s snap-on-load is one of the more confusing bugs in Unity because it depends on the order in which MonoBehaviours initialize, and the fix is not obvious from the Cinemachine documentation.

The Symptom

On the first rendered frame after a scene load, the camera is positioned at an unexpected location — typically the world origin (0, 0, 0), the position the Follow target had before your character controller moved it to the spawn point, or wherever the virtual camera GameObject happened to be placed in the scene. The snap or drift lasts anywhere from one frame to several seconds depending on your damping settings.

You may also see a related symptom: the camera works correctly in the first scene you open in the Editor but snaps every time you load the scene additively or via SceneManager.LoadSceneAsync.

What Causes This

1. Follow/LookAt target moves during Awake or Start

Cinemachine Brain ticks in LateUpdate. If your character controller moves the player to the spawn point in Start, the Cinemachine camera sees the player at position A (origin or prefab default) on the first Brain update, and then on the next frame the player is at position B (spawn point). The Brain interpolates between them according to your damping settings, creating a visible drift. With high damping it can last several seconds.

The root problem is that Awake and Start execution order is not guaranteed across different MonoBehaviours unless you explicitly configure it in Project Settings › Script Execution Order. Your spawn manager might run Start after Cinemachine has already sampled the scene.

2. Follow or LookAt target assigned to a disabled object

If the Follow target is assigned in the Inspector but the target GameObject is disabled at startup, Cinemachine treats the target as absent and falls back to the virtual camera’s own Transform. When the target is later enabled and the vcam picks it up, the camera jumps. Check that your Follow target is enabled before the scene’s first LateUpdate.

3. Priority conflicts between multiple virtual cameras

Cinemachine Brain always activates the virtual camera with the highest Priority value. If you have two vcams — one for a cutscene and one for gameplay — and both start enabled, whichever has higher priority wins. If the cutscene camera has priority 11 and the gameplay camera has priority 10, the Brain starts on the cutscene camera. Then when you disable it, it blends to the gameplay camera. If the blend duration is 0 (Cut), you see a snap.

The classic mistake is forgetting to disable non-gameplay cameras in the Inspector before entering Play mode. Always disable virtual cameras that should not be active at startup.

4. Brain default blend set to Cut

The CinemachineBrain component has a Default Blend property. If it is set to Cut with duration 0, any transition between virtual cameras — including the implicit transition from “no active camera” to “first active camera” — is instantaneous. This is technically not a snap caused by the target moving, but it looks identical from the player’s perspective.

The Fix

Use ForceCameraPosition after spawn

The most reliable fix is to force the Cinemachine virtual camera to match the Follow target’s position explicitly, before the first rendered frame. ForceCameraPosition bypasses all damping and sets the camera’s internal state directly:

using Cinemachine;
using UnityEngine;

public class PlayerSpawner : MonoBehaviour
{
    [SerializeField] private CinemachineVirtualCamera playerVCam;
    [SerializeField] private Transform spawnPoint;

    private void Start()
    {
        // Move the player to the spawn point first
        var player = playerVCam.Follow;
        player.position = spawnPoint.position;
        player.rotation = spawnPoint.rotation;

        // Then tell Cinemachine where the camera should be right now.
        // This prevents the camera from interpolating from origin.
        playerVCam.ForceCameraPosition(
            spawnPoint.position + new Vector3(0f, 2f, -5f),
            Quaternion.LookRotation(spawnPoint.forward)
        );
    }
}

If you’re using a transposer or composer, Cinemachine still re-applies its offsets on top of the forced position, so you may need to teleport to a position that accounts for the body offset. Alternatively, use the OnTargetObjectWarped method, which is designed for exactly this scenario:

using Cinemachine;
using UnityEngine;

public class PlayerRespawn : MonoBehaviour
{
    [SerializeField] private CinemachineVirtualCamera vcam;

    /// Call this whenever the player teleports to a new location.
    public void TeleportTo(Vector3 position, Quaternion rotation)
    {
        transform.position = position;
        transform.rotation = rotation;

        // OnTargetObjectWarped tells the vcam the target has warped,
        // so it should not interpolate from the old position.
        var delta = position - vcam.Follow.position;
        vcam.OnTargetObjectWarped(vcam.Follow, delta);
    }
}

Control initialization order with a coroutine

If you can’t easily call ForceCameraPosition synchronously (because the spawn is async), wait one frame after the target is in place before enabling the virtual camera:

using System.Collections;
using Cinemachine;
using UnityEngine;

public class CameraInitializer : MonoBehaviour
{
    [SerializeField] private CinemachineVirtualCamera vcam;

    private IEnumerator Start()
    {
        // Keep the vcam disabled while the scene sets up
        vcam.gameObject.SetActive(false);

        // Wait until end of frame so all Start() methods have run
        // and the player is at the correct spawn position
        yield return new WaitForEndOfFrame();

        vcam.gameObject.SetActive(true);

        // Force position now that the target is in place
        vcam.ForceCameraPosition(
            CalculateIdealCameraPosition(),
            CalculateIdealCameraRotation()
        );
    }

    private Vector3 CalculateIdealCameraPosition() { /* ... */ return Vector3.zero; }
    private Quaternion CalculateIdealCameraRotation() { /* ... */ return Quaternion.identity; }
}

Fix the Brain’s default blend

For transitions between virtual cameras to feel smooth, change the Brain’s Default Blend from Cut to EaseInOut with a duration of 0.5–1.0 seconds. For specific camera pairs, create a CinemachineBlenderSettings asset (Assets › Create › Cinemachine › BlenderSettings) and assign it to the Brain’s Custom Blends field to control each transition independently.

Related Issues

• Camera snaps when player respawns mid-game. Always call OnTargetObjectWarped whenever the Follow target teleports, not just at scene load. This covers respawn points, fast travel, and level streaming.
• Multiple virtual cameras fighting for priority. Use a dedicated priority manager that sets all non-active vcam priorities to 0 and the active one to 10. Avoid leaving multiple vcams at the same priority.
• Cinemachine FreeLook snapping. FreeLook cameras have three rigs, each with their own damping. Call FreeLookCamera.m_RecenterToTargetHeading.m_enabled = false during initialization to prevent the heading snap, then re-enable it afterward.
• Screen shake still active after scene reload. Cinemachine Impulse sources persist across scene loads if their host GameObject is marked DontDestroyOnLoad. Explicitly call CinemachineImpulseManager.Instance.IgnoreTimeScale = false and clear any lingering impulse signals on scene load.

The one-frame coroutine delay is an ugly workaround but surprisingly reliable — if you can arrange initialization order explicitly, use ForceCameraPosition and keep the coroutine as a fallback.