After spending some time with the Prefab changes introduced in Unity 2018, the overall direction feels fairly clear. The core ideas behind the new system seem settled, while ongoing work is mostly focused on polishing the editor workflow and smoothing out editing details.

One interesting example from a Unity public session involved a client project with an extremely deep scene hierarchy. Recursive changes to a single Prefab reportedly caused the editor to freeze for tens of minutes, and later optimization reduced that delay to just a few minutes. That says a lot about where the current limits are, but it also shows that Unity is continuing to improve the editor side of the workflow. From a user perspective, that is encouraging.

As a ready-to-use Prefab workflow, the official design is quite approachable. Artists and non-programmers should be able to pick it up quickly without much trouble.

There are three features at the center of the new system:

• Nested Prefabs
• Prefab Overrides
• Prefab Variants

What stands out in practice

Before getting into the concepts, there are a few practical issues worth paying attention to.

First, nested Prefabs inside AssetBundles need extra caution. Whether you are using nesting or variants, if multiple Prefabs are present, multiple copies of the resources can end up included.

Second, hierarchy depth still matters for performance. A Prefab with an excessively deep structure can become expensive to process. In production, it is better to encourage artists to build more reusable Prefabs and avoid overly deep nesting wherever possible.

Third, the new Prefab workflow is safest to use outside AssetBundle directories and the Resources directory when possible. That helps avoid repeated packing of duplicate resources.

Nested Prefabs

A simple way to think about Nested Prefabs is through a programming analogy. If a Prefab is treated like a class, then a nested Prefab is similar to using other classes as local members inside it, like this:

1 2 3 4 5 class PrefabMain { PrefabA a; PreafaB b; }

In this example, a and b are used inside PrefabMain, but changes made to those variables do not alter the role of PrefabMain itself in a conceptual sense. That is a useful mental model for understanding how composition works in the new Prefab system.

Prefab Overrides

This concept is already familiar to anyone who has worked with Unity scenes before. When you place a Prefab instance in a scene and modify that instance, those instance-level changes are Overrides.

So while the system is newer, the idea itself is not especially hard to grasp.

Prefab Variants

Prefab Variants are probably easiest to understand from a programming perspective as well. They behave somewhat like inheritance. A variant is based on another Prefab, and changes made to the base Prefab propagate to the Prefabs that derive from it.

The analogy used here looks like this:

1 2 3 4 class PrefabA : PrefabMain { PreafaB b; }

In that sense, PrefabA is a variant of PrefabMain. If PrefabMain is changed, the result is immediately reflected in all Prefabs that inherit from it.

General impression

At the concept level, there is not a huge amount to summarize: Unity 2018’s Prefab system mainly formalizes nesting, overrides, and variants into a workflow that is easier to use and easier to understand. The biggest concerns are less about learning the system and more about being careful with hierarchy depth, AssetBundle usage, and duplicate resource packaging.

For teams using Prefabs heavily—especially teams involving artists or non-programmers—the workflow is friendly enough to be useful right away, even if some editor-side optimization is still clearly ongoing.