Fix: Unity Addressables Build Size Bloated 10x

Here is how to fix a Unity Addressables build that is 10x larger than it should be. Your source assets are 300 MB. You run the Addressables build. The output bundles total 3 GB. Nothing about the group configuration looks obviously wrong. The asset count is correct. The bundles just weigh an absurd amount more than the inputs do.

The Symptom

You have a project with hundreds of addressable assets spread across tens of groups. When you build Addressables, the output folder is enormous compared to the raw asset size. You check individual bundles in a tool like AssetBundleBrowser or just by extracting them, and you notice the same textures, shaders, and even entire ScriptableObjects appearing in three, five, sometimes fifteen different bundles.

The player download size explodes. Catalog loads take longer because Unity has to track all those duplicated entries. Memory usage spikes at runtime because the same shader variant gets loaded under multiple internal IDs when different bundles are active. And worst of all, a tiny patch — changing a single material — invalidates every bundle that happened to include that material as an implicit dependency, so players redownload half the game.

What Causes This

Addressables tracks two kinds of references: explicit entries (the assets you marked addressable and dragged into groups) and implicit dependencies (assets that those entries reference but that you never marked addressable). Unity guarantees that when you load an addressable, all of its dependencies are available. If a dependency is not itself addressable, Unity copies it into every bundle that needs it.

Consider a common scenario: you have a Characters group containing 50 character prefabs, and a UI group containing 30 UI prefabs. Both sets reference a custom TMP font, a standard shader variant, and a shared material for outlines. None of those three assets are marked addressable. When Unity builds, the font, the shader, and the material get duplicated into both bundles. If you have 10 groups referencing these same dependencies, you pay 10 copies.

The second factor is the group packing mode. Pack Together merges every entry into a single bundle — efficient if the group is cohesive, disastrous if the group mixes rarely-used and frequently-used content because the whole bundle has to load to access any one asset. Pack Separately creates one bundle per entry — which multiplies per-bundle overhead if you have thousands of entries. Pack Together By Label groups entries by shared labels, which is almost always the right answer for mixed groups.

A third, often missed cause is scene dependencies. If a scene is addressable and references non-addressable prefabs or materials, those get pulled into the scene bundle. If the same prefabs are also referenced from a prefab group, you get duplication between the scene bundle and the prefab bundle.

The Fix

Step 1: Run the Analyze tool. Open Window → Asset Management → Addressables → Analyze. Expand Check Duplicate Bundle Dependencies and click Run Selected Rules. This scans every bundle-to-bundle dependency and prints a list of assets that are duplicated, showing which groups reference each one.

The report will usually show a pile of shaders, a handful of textures, some ScriptableObjects, and often a few prefabs that nobody remembered were shared. This is your target list.

Step 2: Create a Shared group. Right-click in the Addressables Groups window and create a new group named something like Shared_Dependencies. Set its bundle mode to Pack Together (these dependencies change rarely and always load together) and disable any remote settings — shared fundamentals should live in the base local catalog.

Then let Unity fix the duplicates automatically. In the Analyze window, right-click the Check Duplicate Bundle Dependencies rule and choose Fix Selected Rules. Unity moves all duplicated implicit dependencies into a generated group. Review and rename it to your Shared_Dependencies group.

Step 3: Audit group packing modes. For each group, consider what the runtime load pattern looks like. A group of 500 weapon icons used throughout the game should be Pack Together By Label, where each label corresponds to a weapon tier or chapter. A group containing a single massive scene should be Pack Separately — there is only one entry anyway. A group of 20 closely-related prefabs that always load together should be Pack Together.

Step 4: Use labels instead of group fragmentation. Rather than creating dozens of groups to subdivide content, put everything in a small number of groups and apply labels. Labels let you load by category without forcing bundle boundaries:

using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class LevelLoader : MonoBehaviour
{
  public async Task LoadChapter(string chapterLabel)
  {
    // Load every asset tagged with the chapter label
    AsyncOperationHandle<IList<GameObject>> handle =
      Addressables.LoadAssetsAsync<GameObject>(chapterLabel, null);
    await handle.Task;

    foreach (var prefab in handle.Result)
      Instantiate(prefab);
  }
}

Step 5: Explicitly address shared assets you reference from code. If you use Addressables.LoadAssetAsync<Shader>("MyShader") or similar, the shader must be marked addressable. Otherwise Unity duplicates it into every bundle that has an implicit dependency on it and your load by key will fail at runtime.

A good rule of thumb: any asset that appears in the duplicate report, or any asset you load by address from code, should have its own addressable entry in a dedicated shared group.

Why This Works

Addressables bundles are self-contained. When you build a bundle, Unity serializes every object that the explicit entries transitively reference. If an object is not addressable itself, Unity has no way to say “this lives in a different bundle” — so it must copy it. Marking the shared dependency addressable gives it a location (its own bundle) that other bundles can reference instead of duplicating.

Once you explicitly address the shared dependencies, the other bundles become reference-only: they remember “I need Shader X from bundle Y” and Unity loads bundle Y on demand. This is why the build size collapses so dramatically — you go from N copies of every shared asset to one.

Group packing mode controls the trade-off between bundle count and bundle granularity. Pack Together By Label with meaningful labels is the sweet spot for most projects: a small number of bundles, each containing content that loads together, with no duplication across them.

Related Issues

If Addressables bundles fail to load on device but work in the editor, see Fix: Unity Addressables Remote Catalog Not Loading — the catalog URL and CDN headers are the usual culprit.

For Addressables memory leaks where released handles still hold bundles in memory, see Fix: Unity Addressables Memory Leak from Unreleased Handles.

Run Analyze. Fix duplicates. Audit packing modes. Your build size cuts in half every single time.