Prefab Overrides are one of the most powerful but misunderstood parts of Unity’s asset workflow.
While the concept seems simple—child instances inherit values from a prefab—Unity’s internal override system is far more complex.
This guide explains exactly how overrides work, how Unity stores them, and how to avoid the common pitfalls that break entire projects.

1. What a Prefab Actually Is

A Prefab is not just a saved GameObject.
Internally, Unity stores a prefab as:

• A serialized template object
• A hierarchy of serialized components
• A reference chain that allows instances to inherit fields

Each prefab instance maintains a “diff” against the source prefab.
This “diff” is what Unity calls the override table.

2. What Counts as an Override?

Unity creates an override entry when the value in an instance differs from the value in the source prefab.
Overrides can apply to:

• Component fields (position, speed, colors, etc.)
• Added or removed components
• Added or removed children
• Reordered children
• Modified properties on nested prefabs

Unity tracks each override using a stable internal reference called a Property Modification.

3. How Unity Stores Override Data

Inside a scene, prefab instances store overrides in YAML:

m_Modification:
  m_Modifications:
    - target: {fileID: 12345}
      propertyPath: m_Speed
      value: 12.5

Every entry maps:

• target: The specific component inside the prefab
• propertyPath: The serialized path to the field
• value: The overridden data

This structure lets Unity apply only the modified fields while keeping the rest inherited.

4. Types of Prefab Overrides

4.1. Property Overrides

The most common type: changes to inspector fields.

4.2. Component Overrides

• Added components
• Removed components

4.3. GameObject Overrides

• Added child objects
• Removed child objects
• Reordered children

4.4. Nested Prefab Overrides

Unity keeps separate override tables for every nested level.
This is also where most override bugs come from.

5. Apply vs Revert: What Actually Happens

5.1. Apply

When you click Apply:

• Unity takes the override’s diff
• Writes it into the base prefab asset
• Removes the override entry from the instance
• Propagates the new value to all other prefab instances

5.2. Revert

Unity:

• Deletes the override entry
• Restores the value from the prefab

Reverting never modifies the prefab asset—only the instance.

6. Nested Prefabs: Where Things Get Complicated

Unity must track overrides on:

• The root prefab
• Each nested prefab
• Objects overridden inside nested prefabs

Unity resolves these overrides using a hierarchical resolution algorithm:

1. Apply the base prefab values
2. Apply nested prefab values
3. Apply local instance overrides

Conflicts are resolved bottom-up, giving the instance the highest priority.

7. Why Overrides Break (Common Failure Cases)

7.1. Field Renaming

If you rename a serialized field, Unity loses the propertyPath and breaks the override.

7.2. Changing Field Type

Unity cannot convert types. The override is discarded.

7.3. Moving a Child Object

If a nested prefab object is reordered, Unity may mis‑resolve the override path.

7.4. Removing a Component

Overrides targeting that component become invalid.

7.5. Script Reload / Domain Reload

Temporary loss of serialized references can break fragile override chains.

8. Prefab Override Priority Rules

Unity resolves overrides in the following order:

1. Prefab Asset
2. Nested Prefab Asset
3. Scene Instance Overrides

The deeper the instance, the stronger the override.

9. Best Practices for Stable, Maintainable Prefabs

• Do not rename serialized fields
• Avoid unnecessary nested prefab depth
• Group common values into ScriptableObjects
• Keep prefab hierarchies clean and shallow
• Use overrides only for instance‑specific values
• Think carefully before adding components to root prefabs
• Avoid structural overrides on nested prefabs

10. Detecting and Fixing Broken Overrides

Unity’s Override Inspector highlights:

• Missing property paths
• Invalid component targets
• Overrides that cannot apply

You can repair overrides by:

• Reverting broken modifications
• Re-applying correct values
• Removing invalid overrides
• Regenerating nested prefab structures

Conclusion

Prefab Overrides form the backbone of Unity’s object reuse architecture.
Understanding how override tables, nested prefabs, and modification paths work under the hood lets developers build stable, scalable prefab workflows.
With proper structure and consistent conventions, prefab systems can remain robust even in large projects.