Why use Addressables?

Have you ever wanted to create a mobile game that performs well on almost any device? What about adding downloadable content (DLC) or having holiday-themed content for your game? This is where the Addressables system can help.

Unity's Addressables system is a dynamic asset management solution that provides your users with only the assets they need, when they need them. It also helps you organize your assets to be built into AssetBundles from within the Unity Editor while you're developing your game, and its runtime API lets you load and unload assets dynamically while users are playing your game.

You can choose to either ship all your assets with your game, or host them on a remote content delivery network (CDN) such as Unity's Cloud Content Delivery. The actual location of your assets are abstracted by their address — a string that you assign.

Unlike legacy Unity solutions, the Addressables system provides one consistent methodology for you to organize and deliver your assets.

In this tutorial, you will learn about Unity's approach to dynamic asset management and why the Addressables system may be a valuable addition to your project. You'll also learn more about this course, so that you'll be ready to begin working with the Addressables system.

Get started with Addressables is an Intermediate level course.

To complete this course, you'll need experience programming in Unity. In addition to all the concepts covered in the Junior Programmer pathway, it will be useful to know about event handlers and building asynchronous methods. We'll provide resources to help you learn these additional concepts in case you need them.

We also recommend that you complete the Creative Core pathway, or gain similar experience, to become familiar with all of the types of assets within Unity for which you can apply the Addressables system.

Dynamic asset management systems help you improve the performance of your game by allowing you to determine when, and from where, assets are loaded in and out of memory during runtime.

Throughout the Unity engine’s history there have been several ways to manage assets in memory. The Addressables system was designed to replace or improve upon legacy systems that have either been deprecated or are inadequate for a project that has progressed beyond a basic prototype. In this course, you'll be updating a game that uses some of these legacy approaches to use the Addressables system instead.

Here's a review of various approaches to asset management that Unity engine provides or has provided in the past.

Direct references

When you drag an asset into a scene or onto a component through the Inspector window of the Editor, you're making a direct reference to that asset. When you build your application, these assets are saved in a separate file associated with your scene. When your application is running on a user's device and the scene is loaded, the Unity Player loads the entire asset file into memory before the scene, ensuring that the scene has access to everything it directly references.

If you use only direct references in your game, then your approach to asset management is not dynamic. Loading and unloading the scene is the only control offered. You run the risk of building a game with a large build size that performs slowly, especially on devices with less memory such as mobile.

Resources folder

The Resources folder and the Resources API provided a simple way to manage assets in memory. In the project folder structure of older Unity projects, you might see one or more Resources folders containing assets. During the Player build process, the Editor finds the assets in any folders named Resources and bundles them into a serialized file, with metadata and indexing information, that's packaged with your application. The Resources API allows you to write scripts to load and unload the assets in folders named Resources.

The Resources system has several disadvantages over newer systems. It doesn't allow for a fine-grained approach to memory management, it slows down startup time, and it can bloat the size of your built application. Moreover, it doesn't support delivery of content from a CDN.

AssetBundle system

The AssetBundle system organizes assets into containers called AssetBundles. Like the Resources folder, the AssetBundle system creates sets of assets into separate files. Unlike Resources folders, AssetBundles can be stored locally with the Player or remotely in the cloud.

The AssetBundles system, through its API, minimizes the impact on network and system resources. It does this by allowing you to download the bundles on an as-needed basis, so that you can add DLC and post-release content updates. For example, you can deliver new content for your players to view, earn, or purchase, without requiring them to download a new version of your game. Once bundles are downloaded, AssetBundles API provides a way to load and unload assets from bundles.

Although it is a fully bespoke system, AssetBundles has limitations that have required developers to implement their own solutions:

• The AssetBundles system is an API that can only be used in scripts. There is a limited user interface for defining AssetBundles in the Unity Editor, but building AssetBundles requires scripting.
• The AssetBundles API by itself does not keep track of asset dependencies between AssetBundles. For example, if you want to load a prefab from AssetBundle A, you will need to locate any of its dependencies such as meshes, materials, and textures that may be located in other AssetBundles, and ensure those dependent AssetBundles are loaded at runtime before you attempt to load the prefab.
• Memory allocation and deallocation is direct and manual, so it's possible to unload an asset from an AssetBundle while other code still depends on that asset, potentially resulting in missing content issues or memory leakage. This can become problematic in code that creates race conditions, and requires fortifying your code against these problems.
• AssetBundles runtime API is not aware whether you put your built bundles locally or remotely. This requires you to keep track of the location of that AssetBundle, whether it's on a web server or on disk.

Addressables

The Addressables system is built on top of the AssetBundles API to give you a user interface in the Unity Editor, and to automate processes that before could only be managed manually in scripts. With the Addressables system, you can organize your assets in the Unity Editor, and let the system handle dependencies, asset locations, and memory allocation and deallocation.

Once an asset is addressable, it has an address that you can reference in your scripts, rather than by its file name or bundle location. Although that might sound simple, addresses enable the Addressables system to automate a lot of the details.

Here are more reasons why you should use the Addressables system in your application:

Flexibility

The Addressables system gives you the flexibility to specify where an asset is hosted. You can install assets so that they exist alongside your application on disk or download them on demand from a remote web server. You can then change where a specific asset exists, such as from local to remote, or from a monolithic bundle to more granular bundles, all without needing to rewrite code.

Dependency management

The Addressables system automatically loads all dependencies of any assets you load so that all meshes, shaders, animations, and other dependent assets load before the asset requested loads. For example, if you request to load a character, the system will automatically load the character's meshes, materials, and animations, and the materials' textures and shaders as well.

Memory management

The Addressables system automates much of the drudge work of memory management. As you load assets into and out of your game in scripts, the system keeps track of memory allocation. You can also use the system's robust profiler to further improve the memory efficiency of your game.

Efficient content packing

Because the Addressables system maps complex dependency chains, it helps you pack assets efficiently, even if you move or rename assets. You can choose how granular you want your assets to be at a location, favoring packing them separately or grouped together, and can easily prepare assets for both local and remote deployment to support on-demand or downloadable content (DLC), which can reduce application sizes.

Cloud build and content delivery

The Addressables system has been integrated into Unity Gaming Services (UGS), specifically Cloud Content Delivery and Cloud Build, giving you end-to-end services for live game updates and building your applications in the cloud.

Scriptable Build Pipeline

The Addressables system uses the Scriptable Build Pipeline (SBP), which is more robust than the legacy AssetBundle build pipeline. You can use the pre-defined build flows or, if you want to use a more advanced method, create your own using the divided-up APIs.

Localization

The system is also integrated with Unity’s Localization package so that you can use various languages in your projects.

In this course, Get started with Addressables, you'll learn the following:

• The basics of the user interface of the Addressables system
• Various ways to make assets addressable and load them in scripts
• How Unity builds applications with addressable assets and how to organize your projects to prepare for these builds effectively
• Options for hosting your addressable assets to get the benefits you need from the system

In the tutorials that follow, you'll learn the basics of the Addressables system by working with our starter project, a game called Loady Dungeons. Loady Dungeons was developed using direct references and the legacy Resources system. Throughout the tutorials, you’re going to update it to use the Addressables system, and learn all about addressable assets along the way.

Whether you're an indie game developer who wants to gain more traction on mobile platforms, or a member of a large production team with complex live content delivery needs, the Addressables system will help you make your game leaner and faster, while automating many runtime asset management tasks.

Next, it's time to get started in Unity. You'll explore Loady Dungeons and begin making assets addressable.