# AssetBundle

> API for accessing the content of AssetBundle files.

## Definition

* **Type:** Class
* **Namespace:** [UnityEngine](/engine/6000.7/script-reference/unityengine.md)
* **Assembly:** UnityEngine.AssetBundleModule
* **Inherits from:** [Object](/engine/6000.7/script-reference/unityengine/object.md)

```csharp
public class AssetBundle : Object
```

## Remarks

This class exposes an API, via static methods, for loading and managing AssetBundles.

This same class offers non-static methods and properties that expose the contents of a specific loaded AssetBundle, including the ability to load an Asset from within an AssetBundle.

Create AssetBundles by calling [BuildPipeline.BuildAssetBundles](/engine/6000.7/script-reference/unityeditor/buildpipeline/buildassetbundles.md) or using the [Addressables package](http://docs.unity3d.com/Packages/com.unity.addressables@latest/index.html). The build process generates one or more AssetBundle files, and each AssetBundle file contains a serialized instance of this class.

**Scenes inside AssetBundles**

* An AssetBundle can contain scenes or assets, but not a mix of both types.

* [AssetBundle.LoadAsset](/engine/6000.7/script-reference/unityengine/assetbundle/loadasset.md), and the other Load methods, do not support loading scenes from AssetBundles.

* Scenes can be loaded from AssetBundles using the [SceneManager](/engine/6000.7/script-reference/unityengine/scenemanagement/scenemanager.md).  When running in the Player, or Play mode in the Editor, first load the AssetBundle containing scenes.  Then call [SceneManager.LoadScene](/engine/6000.7/script-reference/unityengine/scenemanagement/scenemanager/loadscene.md) or [SceneManager.LoadSceneAsync](/engine/6000.7/script-reference/unityengine/scenemanagement/scenemanager/loadsceneasync.md) with the scene path or name.

* When the Editor is in Edit mode, it does not support loading scenes from AssetBundles. Calls to [EditorSceneManager.OpenScene](/engine/6000.7/script-reference/unityeditor/scenemanagement/editorscenemanager/openscene.md) with the path of a scene inside a loaded AssetBundle fail and log an error stating that the scene file is not found.

Additional Resources: [Intro to AssetBundles](/engine/6000.7/manual/assets-and-media/assets-managing-runtime/assetbundles-section/asset-bundles-intro.md), [UnityWebRequestAssetBundle.GetAssetBundle](/engine/6000.7/script-reference/unityengine/networking/unitywebrequestassetbundle/getassetbundle.md), [BuildPipeline.BuildAssetBundles](/engine/6000.7/script-reference/unityeditor/buildpipeline/buildassetbundles.md)

## Examples

```csharp
using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

public class SampleBehaviour : MonoBehaviour
{
    IEnumerator Start()
    {
        var uwr = UnityWebRequestAssetBundle.GetAssetBundle("https://myserver/myBundle.unity3d");
        yield return uwr.SendWebRequest();

        // Get an asset from the bundle and instantiate it.
        AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(uwr);
        var loadAsset = bundle.LoadAssetAsync<GameObject>("Assets/Players/MainPlayer.prefab");
        yield return loadAsset;

        Instantiate(loadAsset.asset);

        bundle.Unload(true);
    }
}
```

```csharp
 //This example shows how to build a scene into an AssetBundle, and then build a Player with that AssetBundle included.
 //When the Player starts it loads the scene and then unloads after a few seconds.
 //
 //To try this example:
 // - Save it into a file, for example "Assets/AssetBundleSceneLoader.cs".  The source file name needs to match the name of the MonoBehaviour.
 // - From the Editor Menu select "Example" / "Scene in AssetBundle Example".
 //
 //It is also possible to try it in Play mode in the Editor:
 // - Run the menu at least once to create the scenes and AssetBundle
 // - Open "Assets/Scenes/StartingScene.unity"
 // - Enter Play mode

using System.IO;
using System.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;

#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.Build.Reporting;
using UnityEditor.SceneManagement;
#endif

public class Constants
{
    // Scene in the project that is intended for an AssetBundle
    public static readonly string SceneForAssetBundle = "Assets/Scenes/SceneForBundle.unity";

    // Scene for the Player build that contains the "AssetBundleSceneLoader" MonoBehaviour
    public static readonly string StartingSceneForPlayer = "Assets/Scenes/StartingScene.unity";

    // Note: AssetBundles are always created lower case
    public static readonly string AssetBundleFileName = "scenebundle";

    // Path for AssetBundle (relative to the StreamingAsset location)
    public static readonly string AssetBundlePath = "/AssetBundles";

    // Output directory for the player build (Relative to project and not inside Assets)
    public static readonly string PlayerBuildPath = "PlayerBuild";

    // Name of the player executable inside PlayerBuildPath
    public static readonly string PlayerExecutable = "PlayerBuild";
}

#if UNITY_EDITOR
 // Note: Typically this would be in its own source file, in an Editor-only assembly.
public class BuildBundleWithScene
{
    [MenuItem("Example/Scene in AssetBundle Example")]
    public static void BuildAssetBundle()
    {
        // Location inside StreamingAssets so the AssetBundle content is included in the Player
        string AssetBundleBuildPath = Application.streamingAssetsPath + Constants.AssetBundlePath;

        // Create the content expected by this example
        CreateStartingScene();
        CreateSceneForAssetBundle();

        var buildTargetPlatform = EditorUserBuildSettings.activeBuildTarget;

        if (!Directory.Exists(AssetBundleBuildPath))
            Directory.CreateDirectory(AssetBundleBuildPath);

        // Define an AssetBundle containing the Scene
        var bundleContents = new AssetBundleBuild[]
        {
            new AssetBundleBuild()
            {
                assetBundleName = Constants.AssetBundleFileName,
                assetNames = new string[]
                {
                    Constants.SceneForAssetBundle
                }
            }
        };

        var buildAssetBundlesParameters = new BuildAssetBundlesParameters()
        {
            targetPlatform = buildTargetPlatform,
            bundleDefinitions = bundleContents,
            outputPath = AssetBundleBuildPath
        };
        BuildPipeline.BuildAssetBundles(buildAssetBundlesParameters);

        var buildReport = BuildReport.GetLatestReport();
        if (buildReport.summary.result != BuildResult.Succeeded)
        {
            Debug.Log("AssetBundle Build failed.");
            return;
        }

        // Perform a Player build.  It will include the content of the
        // StreamingAssets folder.
        if (!Directory.Exists(Constants.PlayerBuildPath))
            Directory.CreateDirectory(Constants.PlayerBuildPath);

        var buildOutput = Constants.PlayerBuildPath + "/" + Constants.PlayerExecutable;
        if (buildTargetPlatform == BuildTarget.StandaloneWindows64)
            buildOutput += ".exe";

        var buildPlayerParameters = new BuildPlayerOptions()
        {
            scenes = new string[] { Constants.StartingSceneForPlayer },
            target = buildTargetPlatform,
            locationPathName = buildOutput,
            options = BuildOptions.Development | BuildOptions.AutoRunPlayer,
            assetBundleManifestPath = AssetBundleBuildPath + "/AssetBundles.manifest"
        };

        if (buildTargetPlatform == BuildTarget.StandaloneWindows64)
            buildPlayerParameters.locationPathName += ".exe";

        var playerBuildReport = BuildPipeline.BuildPlayer(buildPlayerParameters);
        if (playerBuildReport.summary.result != BuildResult.Succeeded)
        {
            Debug.Log($"Player Build failed. {playerBuildReport.SummarizeErrors()}");
            return;
        }
    }

    static void CreateStartingScene()
    {
        var startingScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
        var go = new GameObject();
        go.AddComponent<AssetBundleSceneLoader>();
        GameObject.CreatePrimitive(PrimitiveType.Sphere);
        EditorSceneManager.SaveScene(startingScene, Constants.StartingSceneForPlayer);
    }

    static void CreateSceneForAssetBundle()
    {
        var scene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
        GameObject.CreatePrimitive(PrimitiveType.Cube);
        EditorSceneManager.SaveScene(scene, Constants.SceneForAssetBundle);
    }
}
#endif

 // MonoBehaviour that is included in the starting scene.
public class AssetBundleSceneLoader : MonoBehaviour
{
    AssetBundle sceneBundle = null;
    bool sceneLoaded = false;

    // Triggered when the scene containing this MonoBehaviour is loaded
    void Start()
    {
        StartCoroutine(LoadAssetBundleAndScene());
        StartCoroutine(CleanupAfterDelay());
    }

    IEnumerator LoadAssetBundleAndScene()
    {
        // Determine the path to the AssetBundle.
        // Application.streamingAssetsPath is used so that this works in both the Player and Play mode in the Editor.
        string AssetBundleBuildPath = Application.streamingAssetsPath + Constants.AssetBundlePath;
        var bundlePath = AssetBundleBuildPath + "/" + Constants.AssetBundleFileName;

        var op = AssetBundle.LoadFromFileAsync(bundlePath);
        yield return op;

        sceneBundle = op.assetBundle;
        if (sceneBundle == null)
        {
            Debug.LogError("Failed to load AssetBundle: " + Constants.AssetBundleFileName);
        }
        else
        {
            var sceneLoadOp = SceneManager.LoadSceneAsync(Constants.SceneForAssetBundle, LoadSceneMode.Additive);

            if (sceneLoadOp == null)
                Debug.Log($"Failed to load {Constants.SceneForAssetBundle}");
            else
            {
                yield return sceneLoadOp;
                Scene sceneLookup = SceneManager.GetSceneByPath(Constants.SceneForAssetBundle);

                //Will report "Finished loading SceneForBundle (index -1)."
                Debug.Log($"Finished loading {sceneLookup.name} (index {sceneLookup.buildIndex}).");
                sceneLoaded = true;
            }
        }
    }

    IEnumerator CleanupAfterDelay()
    {
        yield return new WaitForSeconds(3.0f);

        if (sceneLoaded)
            yield return SceneManager.UnloadSceneAsync(Constants.SceneForAssetBundle);
        sceneLoaded = false;

        if (sceneBundle != null)
            yield return sceneBundle.UnloadAsync(true);
        sceneBundle = null;

        Debug.Log("Finished unloading Content");
    }
}
```

## Properties

| Property                                                                                                            | Description                                               |
| ------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
| [isStreamedSceneAssetBundle](/engine/6000.7/script-reference/unityengine/assetbundle/isstreamedsceneassetbundle.md) | Return true if the AssetBundle contains Unity Scene files |

## Static Properties

| Property                                                                                    | Description                                                                      |
| ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| [memoryBudgetKB](/engine/6000.7/script-reference/unityengine/assetbundle/memorybudgetkb.md) | Controls the size of the shared AssetBundle loading cache. Default value is 1MB. |

## Methods

| Method                                                                                                                | Description                                                     |
| --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- |
| [Contains](/engine/6000.7/script-reference/unityengine/assetbundle/contains.md)                                       | Check if an AssetBundle contains a specific object.             |
| [GetAllAssetNames](/engine/6000.7/script-reference/unityengine/assetbundle/getallassetnames.md)                       | Return all Asset names in the AssetBundle.                      |
| [GetAllScenePaths](/engine/6000.7/script-reference/unityengine/assetbundle/getallscenepaths.md)                       | Return all the names of Scenes in the AssetBundle.              |
| [LoadAllAssets](/engine/6000.7/script-reference/unityengine/assetbundle/loadallassets.md)                             | Loads all Assets contained in the AssetBundle synchronously.    |
| [LoadAllAssetsAsync](/engine/6000.7/script-reference/unityengine/assetbundle/loadallassetsasync.md)                   | Loads all Assets contained in the AssetBundle asynchronously.   |
| [LoadAsset](/engine/6000.7/script-reference/unityengine/assetbundle/loadasset.md)                                     | Synchronously loads an Asset from the AssetBundle.              |
| [LoadAssetAsync](/engine/6000.7/script-reference/unityengine/assetbundle/loadassetasync.md)                           | Asynchronously loads an Asset from the bundle.                  |
| [LoadAssetWithSubAssets](/engine/6000.7/script-reference/unityengine/assetbundle/loadassetwithsubassets.md)           | Loads Asset and sub Assets from the AssetBundle synchronously.  |
| [LoadAssetWithSubAssetsAsync](/engine/6000.7/script-reference/unityengine/assetbundle/loadassetwithsubassetsasync.md) | Loads Asset and sub Assets from the AssetBundle asynchronously. |
| [Unload](/engine/6000.7/script-reference/unityengine/assetbundle/unload.md)                                           | Unloads an AssetBundle freeing its data.                        |
| [UnloadAsync](/engine/6000.7/script-reference/unityengine/assetbundle/unloadasync.md)                                 | Unloads assets in the bundle.                                   |

## Static Methods

| Method                                                                                                              | Description                                                                                                                                                        |
| ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [GetAllLoadedAssetBundles](/engine/6000.7/script-reference/unityengine/assetbundle/getallloadedassetbundles.md)     | Get an enumeration of all the currently loaded AssetBundles.                                                                                                       |
| [LoadFromFile](/engine/6000.7/script-reference/unityengine/assetbundle/loadfromfile.md)                             | Synchronously loads an AssetBundle from a file on disk.                                                                                                            |
| [LoadFromFileAsync](/engine/6000.7/script-reference/unityengine/assetbundle/loadfromfileasync.md)                   | Asynchronously loads an AssetBundle from a file on disk.                                                                                                           |
| [LoadFromMemory](/engine/6000.7/script-reference/unityengine/assetbundle/loadfrommemory.md)                         | Synchronously load an AssetBundle from a memory region.                                                                                                            |
| [LoadFromMemoryAsync](/engine/6000.7/script-reference/unityengine/assetbundle/loadfrommemoryasync.md)               | Asynchronously load an AssetBundle from a memory region.                                                                                                           |
| [LoadFromStream](/engine/6000.7/script-reference/unityengine/assetbundle/loadfromstream.md)                         | Synchronously loads an AssetBundle from a managed Stream.                                                                                                          |
| [LoadFromStreamAsync](/engine/6000.7/script-reference/unityengine/assetbundle/loadfromstreamasync.md)               | Asynchronously loads an AssetBundle from a managed Stream.                                                                                                         |
| [RecompressAssetBundleAsync](/engine/6000.7/script-reference/unityengine/assetbundle/recompressassetbundleasync.md) | Asynchronously recompress a downloaded/stored AssetBundle from one [BuildCompression](/engine/6000.7/script-reference/unityengine/buildcompression.md) to another. |
| [UnloadAllAssetBundles](/engine/6000.7/script-reference/unityengine/assetbundle/unloadallassetbundles.md)           | Unloads all currently loaded AssetBundles.                                                                                                                         |

## Inheritance

**Inherited Members:**

* [Object.GetEntityId()](/engine/6000.7/script-reference/unityengine/object/getentityid.md)
* [Object.GetHashCode()](/engine/6000.7/script-reference/unityengine/object/gethashcode.md)
* [Object.InstantiateAsync\<T>(T)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, Transform)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, Vector3, Quaternion)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, Transform, Vector3, Quaternion)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, Transform)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, Vector3, Quaternion)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, ReadOnlySpan\<Vector3>, ReadOnlySpan\<Quaternion>)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, Transform, Vector3, Quaternion)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, Transform, Vector3, Quaternion, CancellationToken)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, Transform, ReadOnlySpan\<Vector3>, ReadOnlySpan\<Quaternion>)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, Transform, ReadOnlySpan\<Vector3>, ReadOnlySpan\<Quaternion>, CancellationToken)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, InstantiateParameters, CancellationToken)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, InstantiateParameters, CancellationToken)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, Vector3, Quaternion, InstantiateParameters, CancellationToken)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, Vector3, Quaternion, InstantiateParameters, CancellationToken)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.InstantiateAsync\<T>(T, int, ReadOnlySpan\<Vector3>, ReadOnlySpan\<Quaternion>, InstantiateParameters, CancellationToken)](/engine/6000.7/script-reference/unityengine/object/instantiateasync.md)
* [Object.Instantiate(Object, Vector3, Quaternion)](/engine/6000.7/script-reference/unityengine/object/instantiate.md#instantiate\(object-vector3-quaternion\))
* [Object.Instantiate(Object, Vector3, Quaternion, Transform)](/engine/6000.7/script-reference/unityengine/object/instantiate.md#instantiate\(object-vector3-quaternion-transform\))
* [Object.Instantiate(Object)](/engine/6000.7/script-reference/unityengine/object/instantiate.md#instantiate\(object\))
* [Object.Instantiate(Object, Scene)](/engine/6000.7/script-reference/unityengine/object/instantiate.md#instantiate\(object-scene\))
* [Object.Instantiate\<T>(T, InstantiateParameters)](/engine/6000.7/script-reference/unityengine/object/instantiate.md)
* [Object.Instantiate\<T>(T, Vector3, Quaternion, InstantiateParameters)](/engine/6000.7/script-reference/unityengine/object/instantiate.md)
* [Object.Instantiate(Object, Transform)](/engine/6000.7/script-reference/unityengine/object/instantiate.md#instantiate\(object-transform\))
* [Object.Instantiate(Object, Transform, bool)](/engine/6000.7/script-reference/unityengine/object/instantiate.md#instantiate\(object-transform-bool\))
* [Object.Instantiate\<T>(T)](/engine/6000.7/script-reference/unityengine/object/instantiate.md)
* [Object.Instantiate\<T>(T, Vector3, Quaternion)](/engine/6000.7/script-reference/unityengine/object/instantiate.md)
* [Object.Instantiate\<T>(T, Vector3, Quaternion, Transform)](/engine/6000.7/script-reference/unityengine/object/instantiate.md)
* [Object.Instantiate\<T>(T, Transform)](/engine/6000.7/script-reference/unityengine/object/instantiate.md)
* [Object.Instantiate\<T>(T, Transform, bool)](/engine/6000.7/script-reference/unityengine/object/instantiate.md)
* [Object.Destroy(Object, float)](/engine/6000.7/script-reference/unityengine/object/destroy.md)
* [Object.DestroyImmediate(Object, bool)](/engine/6000.7/script-reference/unityengine/object/destroyimmediate.md)
* [Object.FindObjectsByType(Type)](/engine/6000.7/script-reference/unityengine/object/findobjectsbytype.md#findobjectsbytype\(type\))
* [Object.FindObjectsByType(Type, FindObjectsInactive)](/engine/6000.7/script-reference/unityengine/object/findobjectsbytype.md#findobjectsbytype\(type-findobjectsinactive\))
* [Object.DontDestroyOnLoad(Object)](/engine/6000.7/script-reference/unityengine/object/dontdestroyonload.md)
* [Object.FindAnyObjectByType\<T>()](/engine/6000.7/script-reference/unityengine/object/findanyobjectbytype.md#findanyobjectbytypet\(\))
* [Object.FindAnyObjectByType\<T>(FindObjectsInactive)](/engine/6000.7/script-reference/unityengine/object/findanyobjectbytype.md#findanyobjectbytypet\(findobjectsinactive\))
* [Object.FindObjectsByType\<T>()](/engine/6000.7/script-reference/unityengine/object/findobjectsbytype.md#findobjectsbytypet\(\))
* [Object.FindObjectsByType\<T>(FindObjectsInactive)](/engine/6000.7/script-reference/unityengine/object/findobjectsbytype.md#findobjectsbytypet\(findobjectsinactive\))
* [Object.FindAnyObjectByType(Type)](/engine/6000.7/script-reference/unityengine/object/findanyobjectbytype.md#findanyobjectbytype\(type\))
* [Object.FindAnyObjectByType(Type, FindObjectsInactive)](/engine/6000.7/script-reference/unityengine/object/findanyobjectbytype.md#findanyobjectbytype\(type-findobjectsinactive\))
* [Object.ToString()](/engine/6000.7/script-reference/unityengine/object/tostring.md)
* [Object.name](/engine/6000.7/script-reference/unityengine/object/name.md)
* [Object.hideFlags](/engine/6000.7/script-reference/unityengine/object/hideflags.md)

### Operators

| Operator                                                                           | Description                                                             |
| ---------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
| [operator ==](/engine/6000.7/script-reference/unityengine/object/op-equality.md)   | Compares two object references to see if they refer to the same object. |
| [bool](/engine/6000.7/script-reference/unityengine/object/op-implicit.md)          | Determines whether the object exists.                                   |
| [operator !=](/engine/6000.7/script-reference/unityengine/object/op-inequality.md) | Compares if two objects refer to a different object.                    |