Asset bundles and optimization in Unity - Deep Dive

Overview - Asset bundles and optimization

What is it?

Asset bundles are packages of game assets like textures, models, and sounds that Unity can load separately from the main game. They help organize and deliver content efficiently. Optimization means making these bundles and their loading process fast and light to improve game performance and reduce download size.

Why it matters

Without asset bundles and optimization, games would have to load all assets at once, causing long wait times and large downloads. This would make games slow, use too much memory, and frustrate players. Asset bundles let developers deliver content on demand, saving resources and improving player experience.

Where it fits

Before learning asset bundles, you should understand Unity basics like scenes, assets, and the Unity Editor. After mastering asset bundles, you can explore advanced topics like Addressables, memory management, and runtime asset streaming.

Mental Model

Core Idea

Asset bundles are like packed suitcases of game content that you open only when needed to keep your game light and fast.

Think of it like...

Imagine moving to a new house. Instead of carrying all your belongings at once, you pack them into labeled boxes and bring in only the boxes you need right now. Asset bundles work the same way for game assets.

┌─────────────────────┐
│     Game Project    │
├─────────────────────┤
│  Main Game Content  │
│  (Core scenes/code) │
├─────────────────────┤
│  Asset Bundles      │
│  ┌───────────────┐  │
│  │ Bundle A      │  │
│  │ (Textures)    │  │
│  ├───────────────┤  │
│  │ Bundle B      │  │
│  │ (Models)      │  │
│  └───────────────┘  │
└─────────────────────┘

Loading Process:
Main Game → Load Bundle A when needed → Use textures
Main Game → Load Bundle B when needed → Use models

Build-Up - 7 Steps

1

Foundation

What are Asset Bundles?

Concept: Introduce the basic idea of asset bundles as separate packages of game assets.

Asset bundles are files created in Unity that contain assets like images, sounds, or 3D models. Instead of including all assets inside the main game file, asset bundles let you keep some assets outside and load them only when needed. This helps keep the game smaller and faster to start.

Result

You understand that asset bundles are separate containers for game assets that can be loaded on demand.

Knowing that assets can be separated from the main game file helps you see how games can be more flexible and efficient.

2

Foundation

Creating and Building Asset Bundles

Concept: Learn how to create asset bundles in Unity and build them for use.

In Unity, you assign assets to an asset bundle by selecting them and setting their bundle name in the Inspector. Then, you use the BuildPipeline API or the Editor menu to build these bundles into files. These files can be stored locally or on a server for later loading.

Result

You can create asset bundles and generate the files Unity uses to load assets separately.

Understanding the build process is key to managing how and when assets are delivered to the game.

3

Intermediate

Loading Asset Bundles at Runtime

🤔Before reading on: do you think asset bundles load instantly or require asynchronous loading? Commit to your answer.

Concept: Learn how to load asset bundles during the game and access their contents.

Asset bundles are loaded using asynchronous calls like LoadFromFileAsync or LoadFromMemoryAsync. After loading the bundle, you request specific assets by name. This process avoids freezing the game and allows loading only what is needed when it is needed.

Result

You can load asset bundles and extract assets during gameplay without blocking the game.

Knowing that loading is asynchronous helps prevent performance hiccups and improves player experience.

4

Intermediate

Managing Dependencies Between Bundles

🤔Before reading on: do you think asset bundles are always independent or can depend on each other? Commit to your answer.

Concept: Understand that some asset bundles rely on others and how to handle these dependencies.

Some assets reference others in different bundles, creating dependencies. Unity generates a manifest file listing these dependencies. When loading a bundle, you must also load its dependencies first to avoid missing assets or errors.

Result

You can correctly load bundles with dependencies, ensuring all needed assets are available.

Handling dependencies prevents runtime errors and ensures assets work together smoothly.

5

Advanced

Optimizing Asset Bundle Size and Load Time

🤔Before reading on: do you think bigger bundles load faster or slower? Commit to your answer.

Concept: Learn techniques to reduce bundle size and speed up loading.

Optimization includes splitting large bundles into smaller ones, compressing assets, removing unused assets, and sharing common assets in separate bundles. Profiling tools help identify bottlenecks. Smaller bundles load faster and reduce memory use, but too many bundles can increase overhead.

Result

You can create asset bundles that balance size and load speed for better game performance.

Balancing bundle size and count is crucial to optimize both download size and runtime performance.

6

Advanced

Caching and Updating Asset Bundles

Concept: Understand how to cache bundles on the player device and update them efficiently.

Unity provides a caching system that stores downloaded bundles locally. When the game runs again, it uses cached bundles to avoid re-downloading. To update assets, bundles must have new versions with changed hashes. The game checks for updates and downloads only changed bundles.

Result

You can implement a system that saves bandwidth and speeds up load times by reusing cached bundles.

Efficient caching and updating improve user experience by reducing wait times and data usage.

7

Expert

Advanced Internals and Pitfalls of Asset Bundles

🤔Before reading on: do you think asset bundles can cause memory leaks if not handled properly? Commit to your answer.

Concept: Explore internal behaviors, common mistakes, and how Unity manages asset bundle memory.

Asset bundles load assets into memory, but unloading bundles does not always free all memory immediately. Developers must explicitly unload assets and bundles to avoid leaks. Also, naming conflicts and incorrect dependency handling can cause runtime errors. Understanding Unity's reference counting and garbage collection helps manage resources safely.

Result

You gain deep knowledge to avoid subtle bugs and memory issues in production games.

Knowing internal memory management prevents crashes and performance degradation in complex projects.

Under the Hood

Unity builds asset bundles by packaging assets and their metadata into binary files. At runtime, Unity reads these files asynchronously, loads asset data into memory, and tracks references to manage dependencies. The system uses a manifest file to map bundles and dependencies. Memory management relies on explicit unload calls and Unity's garbage collector to free resources.

Why designed this way?

Asset bundles were designed to separate content delivery from the main game build, enabling modular updates and reducing initial download size. The asynchronous loading and dependency system balance performance and flexibility. Alternatives like embedding all assets in the main build were too rigid and inefficient for large or live-updated games.

┌───────────────┐       ┌───────────────┐
│ Asset Bundle  │──────▶│ Load Async    │
│ File (.unity3d)│       │ (Background) │
└───────────────┘       └───────────────┘
         │                      │
         ▼                      ▼
┌─────────────────┐      ┌───────────────┐
│ Manifest File   │◀─────│ Dependency    │
│ (Bundle Map)    │      │ Resolver     │
└─────────────────┘      └───────────────┘
         │                      │
         ▼                      ▼
┌─────────────────┐      ┌───────────────┐
│ Memory Manager  │◀─────│ Asset Loader  │
│ (Reference Cnt) │      │ (Assets in RAM)│
└─────────────────┘      └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do asset bundles automatically unload assets from memory when no longer used? Commit to yes or no.

Common Belief: Asset bundles unload their assets automatically when you unload the bundle.

Reality: Unloading an asset bundle only frees the bundle file, but assets loaded from it remain in memory until explicitly unloaded or garbage collected.

Why it matters: Assuming automatic unloading leads to memory leaks and increased RAM usage, causing slowdowns or crashes.

Quick: Can you load any asset from an asset bundle without loading its dependencies first? Commit to yes or no.

Common Belief: You can load assets from a bundle without worrying about dependencies; Unity handles it all automatically.

Reality: You must manually load all dependent bundles before loading assets that rely on them, or else assets may be missing or broken.

Why it matters: Ignoring dependencies causes runtime errors and broken visuals or sounds in the game.

Quick: Is it always better to put all assets into one big asset bundle? Commit to yes or no.

Common Belief: One big asset bundle is easier and faster to load than many small bundles.

Reality: Large bundles take longer to download and load, and prevent loading only needed assets, hurting performance and flexibility.

Why it matters: Poor bundling strategy increases load times and memory use, degrading player experience.

Quick: Do asset bundles automatically update on the player's device when you change assets? Commit to yes or no.

Common Belief: Once an asset bundle is downloaded, it updates automatically when you change the assets on the server.

Reality: Asset bundles must have new version hashes and the game must check and download updates explicitly; otherwise, cached bundles remain outdated.

Why it matters: Failing to manage updates causes players to see old content and bugs.

Expert Zone

1

Asset bundle compression formats affect load speed and memory differently; choosing between LZ4 and LZMA impacts runtime performance.

2

Shared assets in multiple bundles require careful versioning to avoid duplication and inconsistent states.

3

The Unity Editor's asset bundle building process can differ from runtime behavior, so testing on target platforms is essential.

When NOT to use

Asset bundles are less suitable for very small games or projects without dynamic content needs. In such cases, embedding assets directly or using Unity Addressables is better for simplicity and automatic management.

Production Patterns

Professionals use asset bundles to deliver downloadable content (DLC), live updates, and platform-specific assets. They combine bundles with caching, version control, and profiling tools to optimize load times and memory usage in large-scale games.

Connections

Content Delivery Networks (CDNs)

Asset bundles are often hosted on CDNs to deliver game content efficiently worldwide.

Understanding CDNs helps optimize asset bundle distribution, reducing latency and improving player download speeds.

Modular Software Design

Asset bundles embody modular design by separating game content into independent packages.

Knowing modular design principles clarifies why separating assets improves maintainability and scalability.

Supply Chain Management

Managing asset bundles and their dependencies is similar to managing parts and suppliers in a supply chain.

Recognizing this connection helps appreciate the importance of dependency tracking and version control in complex systems.

Common Pitfalls

#1 Forgetting to load dependent bundles before loading an asset bundle.

Wrong approach:

var bundle = AssetBundle.LoadFromFile("bundleA");
var asset = bundle.LoadAsset("MyModel");

Correct approach:

var manifestBundle = AssetBundle.LoadFromFile("manifest");
var manifest = manifestBundle.LoadAsset("AssetBundleManifest");
var dependencies = manifest.GetAllDependencies("bundleA");
foreach(var dep in dependencies) {
AssetBundle.LoadFromFile(dep);
}
var bundle = AssetBundle.LoadFromFile("bundleA");
var asset = bundle.LoadAsset("MyModel");

Root cause:

Misunderstanding that asset bundles can have dependencies that must be loaded first.

#2 Not unloading asset bundles and assets after use, causing memory leaks.

Wrong approach:

var bundle = AssetBundle.LoadFromFile("bundleB");
var asset = bundle.LoadAsset("Texture");
// Use asset but never unload
// bundle.Unload(false); // missing

Correct approach:

var bundle = AssetBundle.LoadFromFile("bundleB");
var asset = bundle.LoadAsset("Texture");
// Use asset
bundle.Unload(false); // unload bundle but keep assets
Resources.UnloadUnusedAssets(); // free unused assets

Root cause:

Not understanding Unity's memory management and the need for explicit unload calls.

#3 Packing too many assets into one large bundle causing slow load times.

Wrong approach:

Assigning all game assets to a single asset bundle named "all_assets" and loading it at once.

Correct approach:

Splitting assets into logical bundles like "characters", "environment", and "UI" and loading only needed bundles.

Root cause:

Lack of strategy in asset organization and misunderstanding of load time trade-offs.

Key Takeaways

Asset bundles let you package and load game assets separately to keep your game smaller and faster.

Loading asset bundles is asynchronous and requires managing dependencies to avoid errors.

Optimizing bundle size and caching improves game performance and player experience.

Proper unloading of bundles and assets is essential to prevent memory leaks.

Understanding asset bundles deeply helps build scalable, efficient, and maintainable games.