Introduction to runtime asset management

Unity provides the following ways to load and manage the assets in your project at runtime:

Direct references: Unity loads all assets into memory before loading a sceneA Scene contains the environments and menus of your game. Think of each unique Scene file as a unique level. In each Scene, you place your environments, obstacles, and decorations, essentially designing and building your game in pieces. More info
See in Glossary.
The Resources system: Use the Resources API to load and unload assets originating from the Resources folders in your project.
The AssetBundle system: Use the AssetBundle API to organize assets into AssetBundles which you can store remotely and download on demand.
The Addressables package: Built on top of the AssetBundle API, it automates a lot of the manual processes that the AssetBundle system has, and provides a Unity Editor interface.
ECS content management system: If you use the Entities package in your project, then it has its own content management system.

Direct references

Direct reference asset management is the default way of managing assets at runtime in Unity. Whenever you drag an asset into a scene or onto a component through the InspectorA Unity window that displays information about the currently selected GameObject, asset or project settings, allowing you to inspect and edit the values. More info
See in Glossary window of the Editor, you create a direct reference to that asset. When you build your application, Unity saves any referenced assets in a separate file associated with the scenes in your project.

When your application runs on the target device, Unity loads the entire asset file into memory before loading a scene. This approach isn’t dynamic and you can only load or unload a scene. If your project only uses direct references to load assets, then it can lead to slow load times, especially on devices with less memory.

Resources system

The Resources system provides a simple way of managing assets in memory. To use the Resources system, you create a folder called Resources in your project and add assets to it. During the build process, Unity finds the assets in the Resources folder and bundles them into a serialized file with metadata and indexing information. You can then use the Resources API to load and unload the assets in your application.

The Resources system has the following limitations:

Assets in Resources folders are always included in the player build, even if they’re not referenced by anything.
If you need to make changes to the assets in your project, you need to rebuild and redeploy your entire application, whereas AssetBundles and Addressables allow you to create incremental content updates.
It doesn’t support content delivery from a remote server.
You can’t control its memory management.
If you have a lot of assets in the Resources folder, then building and starting your application can take a long time.
If your code loads an asset by string, but that asset is missing, then Unity doesn’t detect this missing data at build time, and becomes a runtime error, so you need to manually track which assets are needed.

It’s an ideal system for prototyping, or for smaller projects which need assets throughout the lifetime of the application. For more information, refer to Use AssetBundles to load assets at runtime.

AssetBundle system

Use the AssetBundle system to organize assets into separate container files called AssetBundles. You can store AssetBundle files in your project files, or remotely in the cloud.

The AssetBundle API minimizes the impact on network and system resources by allowing you to download AssetBundles on demand. You can use this on-demand behavior to add DLC and post-release content updates to your application. For example, you can deliver new content for your game without requiring users to download a new version of your game. The AssetBundle API then provides a way to load and unload assets from downloaded bundles.

The AssetBundle system has the following limitations:

You can only use AssetBundles in scriptsA piece of code that allows you to create your own Components, trigger game events, modify Component properties over time and respond to user input in any way you like. More info
See in Glossary, and there’s no Editor interface to build AssetBundles with.
The AssetBundle API doesn’t keep track of asset dependencies. For example, if you want to load a prefabAn asset type that allows you to store a GameObject complete with components and properties. The prefab acts as a template from which you can create new object instances in the scene. More info
See in Glossary from an AssetBundle, you need to manually load the AssetBundles, and any AssetBundle that the AssetBundle depends on, before loading the prefab. Safely unloading AssetBundles often requires writing a reference counting system. For more information, refer to Handling dependencies between AssetBundles.
You need to manually allocate and deallocate memory, so you might create memory leaks or missing content by unloading assets from an AssetBundle that other code relies on.
The AssetBundle API isn’t aware of whether an AssetBundle is hosted locally or remotely, so you need to keep track of the ___location of all the AssetBundles in your project.

For more information, refer to Introduction to AssetBundles.

Addressables package

The Addressables package provides a user interface in the Unity Editor to manage and organize the assets in your project. It’s built on top of the AssetBundle API and automatically manages dependencies, asset locations, and memory allocation, which you otherwise have to handle manually in the AssetBundle system. The Addressables package aims to remove the limitations of the Resources and AssetBundle system to make it easier to manage assets on demand.

Once you have made an asset Addressable, you can reference it by address in your code, rather than by its file name or AssetBundle ___location, which means you can change the ___location of an asset without needing to rewrite any code. For more information, refer to Addressables overview

ECS content management system

The Entities package has its own content management system, where you use weak references to assets to load them at runtime. You can also create content archives to deliver content to an application. For more information, refer to Introduction to content management.

Additional resources

Managing assets at runtime

Use the Resources system to load assets at runtime