How does Unity track prefab overrides?

Overrides are stored in the scene or variant prefab’s YAML as PropertyModifications with the target object’s fileID and GUID. If either changes — e.g., the prefab’s .meta GUID regenerated, or sub-object fileIDs shifted — the overrides can’t be reattached and are silently dropped.

What causes a .meta GUID to change?

Deleting and recreating the .meta file via the OS file manager, having .meta files in .gitignore (so each clone regenerates them), or .meta merge conflicts that get resolved by deleting one side. Always commit .meta files and resolve conflicts carefully.

How do I migrate overrides cleanly?

Before changing prefab structure: open every scene/variant that references it, use Apply Overrides for any modifications you want preserved as defaults. Then change the prefab. Surviving overrides are documented in YAML and reattach correctly by name+GUID.

Fix: Unity Prefab Overrides Lost on Import

Quick answer: Always commit .meta files to source control with stable GUIDs. Don’t reorder serialized fields in prefab scripts without migrating overrides first. Use Apply Overrides to promote modifications you want preserved.

A teammate pushes a prefab edit. You pull. Every scene using a variant of that prefab now shows the prefab’s defaults — your custom overrides (different sprite, custom stats) are gone. The history shows your override values existed yesterday.

Overrides Are Tied to GUIDs and FileIDs

Each override is recorded in the scene/variant’s YAML as something like:

PrefabInstance:
  ...
  m_Modifications:
    - target: {fileID: 5523456, guid: a1b2c3..., type: 3}
      propertyPath: m_Color.r
      value: 0.5

The override targets a specific sub-object inside a prefab identified by fileID within that prefab’s guid. If either identifier changes, the override is orphaned and Unity discards it.

Causes of GUID/FileID Changes

.meta files not committed: each developer’s clone generates a new GUID, breaking cross-machine references.
Conflicting .meta resolution: choosing “ours” on one side and “theirs” on the other splits the GUID.
Renaming a component field without a [FormerlySerializedAs]: existing overrides reference the old name, can’t reattach.
Reordering sub-objects in the prefab: shifts fileIDs (rare but happens with major restructures).

Fix 1: Commit .meta Files

Your .gitignore (or equivalent) must NOT ignore .meta files. Standard Unity .gitignore template excludes them with explicit rules:

# Unity gitignore should include:
!*.meta

For projects already missing .meta in history: each user’s next pull regenerates, breaking references. Restore from the most recent known-good revision; commit those .meta files; communicate to the team.

Fix 2: Use FormerlySerializedAs

When renaming serialized fields:

using UnityEngine.Serialization;

public class Enemy : MonoBehaviour
{
    [FormerlySerializedAs("hp")]
    public int health = 100;
}

Existing overrides targeting hp migrate to health on next load. Without this, the override drops and the field reverts to the default 100.

Fix 3: Apply Overrides Before Restructure

If you’re about to do a major prefab restructure that will break some overrides, first:

Open each scene referencing the prefab.
For each prefab instance: right-click in Hierarchy → Apply Overrides → promote desired modifications to defaults.
Now do the restructure. Surviving overrides are the ones you intentionally left as instance-specific.

Diagnosing Lost Overrides

Open the scene file in a text editor. Find PrefabInstance blocks. Check m_Modifications — should list your overrides. If empty, they were dropped on import. Compare to a known-good revision in git history to see what was lost.

Verifying

Open scenes after the fix. Verify the overrides persist (your custom values are visible, marked with the blue bar in the Inspector). Save scenes; commit. Other team members pull and verify the same on their machines.

“Prefab overrides are GUID-anchored. Lose the GUID, lose the override. Commit .meta files.”

Run a quick “list every override” editor script as a sanity check before major restructures — reveals what would be lost.