Master Bundle Pointer Type Reference ​

Intermediate10-15 minutesCross-platformNotepad++

Every 3D model, material, texture, audio clip, and particle effect that a mod item displays in-game lives inside a Unity master bundle. The .dat and .asset files that define the mod's items, NPCs, vehicles, and effects do not embed the 3D content directly; they reference it by path, using a master bundle pointer. A master bundle pointer identifies a Unity asset , a prefab, a material, a PNG texture, or an OGG audio clip , by specifying which master bundle contains it and where within that bundle's asset hierarchy the file resides.

57 Studios™ has documented and validated the full master bundle pointer specification across the Unturned™ modding community. This article covers the three master bundle pointer syntaxes , the explicit .asset-file format, the inline format, and the bundle-prefixed inline format , the MasterBundle.dat configuration file that controls bundle naming and asset path resolution, the default master bundle convention, the full resolution chain from pointer field to loaded Unity asset, and the relationship between master bundle pointers and .asset files. Worked examples drawn from shipped game files, a complete diagnostic table, and a template for MasterBundle.dat configuration are included.

Diagram of a master bundle pointer referencing a Unity prefab inside a master bundle file

Documentation source: This article references the official Smartly Dressed Games modding documentation for the master bundle pointer specification, the MasterBundle.dat field definitions, and the resolution chain. Community-validated notes are marked where the official documentation is silent on a detail.

Who this article is for ​

This article is written for Unturned™ mod authors who are working with .asset files that reference Unity prefabs, materials, textures, or audio clips inside master bundles, and for mod authors who need to understand how the game resolves a pointer field into a loaded Unity asset at runtime. The article assumes familiarity with the Unity asset bundle workflow, the master bundle export process, and the mod folder structure conventions. If you are new to Unturned™ modding, start with Master Bundle Export and Project Folder Structure and GUIDs before returning here.

What you'll learn ​

  • The definition of a master bundle pointer and how it differs from an asset pointer
  • The three syntaxes for master bundle pointers: the explicit .asset-file format, the inline format, and the bundle-prefixed inline format
  • The structure and purpose of the MasterBundle.dat configuration file
  • How Asset_Bundle_Name and Asset_Prefix control bundle identification and path resolution
  • The full resolution chain from a master bundle pointer field to a loaded Unity asset
  • When to use the default master bundle versus a named master bundle
  • The Asset_Bundle_Version field and its significance for Unity version compatibility
  • Worked examples drawn from shipped Unturned™ files

Background: the master bundle system ​

Unturned™ loads 3D content from Unity asset bundles , archived collections of prefabs, meshes, materials, textures, audio clips, and other Unity assets that the game loads at runtime. Each mod ships at least one master bundle (the *.unity3d file in the mod's Bundles/ folder) containing the mod's visual and audio content. The .dat and .asset files that define the mod's gameplay objects reference the bundle's contents by path, using master bundle pointers.

The master bundle pointer is the mechanism that connects the data-definition layer (the .dat and .asset text files) to the visual-presentation layer (the Unity assets inside the bundle). Without a correctly authored master bundle pointer, a mod item has no visible model in the game world , it exists as a data entry in the asset table but appears as a placeholder or invisible object when equipped, placed, or dropped.

The flowchart above shows the three pointer formats converging on the same resolution output: a full path within the correct master bundle that the Unity asset-bundle loader can resolve into a loaded asset. The MasterBundle.dat file controls the mapping from bundle name to bundle file and from relative asset path to the full path prefix within the Unity project.

MasterBundle.dat configuration ​

The MasterBundle.dat file is the top-level configuration file for a mod's master bundle. It sits in the mod's Bundles/ folder (at Bundles/MasterBundle.dat) and defines three essential fields that the master bundle pointer resolution system uses.

MasterBundle.dat field reference ​

FieldTypeRequiredExamplePurpose
Asset_Bundle_NamestringYescore.masterbundleThe file name of the asset bundle exported from Unity. This is the value that master bundle pointers use in their MasterBundle field to identify which bundle to load. The name should match the actual .unity3d file name in the Bundles/ folder (without the extension).
Asset_PrefixstringYesAssets/CoreMasterBundleThe file path prefix within the Unity project that is prepended to relative asset paths in master bundle pointers. All AssetPath values in master bundle pointers are relative to this prefix.
Asset_Bundle_Versionuint8Yes6The Unity asset bundle version. This field tells the game which compression format and asset serialization version the bundle uses. See the version table below.

Asset_Bundle_Version values ​

ValueUnity versionNotes
2Unity 2017 LTSLegacy version; not recommended for new mods
3Unity 2018 and 2019 LTSOlder versions have shader consolidation enabled for backward compatibility
4Unity 2020 LTS2019 did not need its own version; 2020 introduces a new format
5Unity 2021 LTSUpdated asset serialization
6Unity 2022 LTSCurrent version; recommended for all new mod content

The Asset_Bundle_Version field must match the Unity Editor version used to build the bundle. A version mismatch produces a bundle that the game cannot load , the binary format of the serialized assets differs between Unity major versions, and the game's asset-bundle loader rejects version-mismatched bundles. The current recommended value for new mods is 6 (Unity 2022 LTS).

MasterBundle.dat file format ​

The MasterBundle.dat file uses standard Unturned™ .dat file syntax. Fields are key-value pairs separated by whitespace. Comments are prefixed with // and are ignored by the parser.

Asset_Bundle_Name core.masterbundle

// Path to the asset bundle within Unity.
// Unity subfolders should match 1:1 with dat subfolders.
Asset_Prefix Assets/CoreMasterBundle

// Version 6 is Unity 2022 LTS.
Asset_Bundle_Version 6

The shipped vanilla MasterBundle.dat file (from Bundles/MasterBundle.dat in the Unturned™ installation) uses the name core.masterbundle and the prefix Assets/CoreMasterBundle. Mod authors define their own bundle name and prefix to avoid collision with the vanilla master bundle.

Configuring MasterBundle.dat for a mod ​

For a custom mod with its own master bundle, the recommended MasterBundle.dat configuration is:

Asset_Bundle_Name MyModMasterBundle
Asset_Prefix Assets/MyMod
Asset_Bundle_Version 6

Where:

  • Asset_Bundle_Name matches the file name of the .unity3d file in the mod's Bundles/ folder (e.g., MyModMasterBundle.unity3d would correspond to Asset_Bundle_Name MyModMasterBundle).
  • Asset_Prefix matches the Unity project folder that contains the mod's assets (e.g., if the mod's prefabs are in Assets/MyMod/Items/Guns/MyGun.prefab, the Asset_Prefix should be Assets/MyMod).
  • Asset_Bundle_Version matches the Unity Editor version used for the project.

Master bundle pointer syntaxes ​

The master bundle pointer has three formats, all appearing in .asset files. The choice of format depends on whether the pointer references the default master bundle or a named master bundle, and on the author's preference for compactness versus explicitness.

Explicit .asset file format ​

The explicit format uses two named sub-fields within a brace-delimited block: MasterBundle and AssetPath.

"MyMasterBundlePtr"
{
    "MasterBundle" "core.masterbundle"
    "AssetPath" "Level/Carepackage.prefab"
}

This is the most explicit and readable format. The MasterBundle field names the bundle file (matching the Asset_Bundle_Name value in that bundle's MasterBundle.dat). The AssetPath field specifies the relative path to the Unity asset within the bundle, relative to the Asset_Prefix configured in the bundle's MasterBundle.dat.

At resolution time, the game:

  1. Reads the MasterBundle value to identify which bundle to load.
  2. Reads the Asset_Prefix from that bundle's MasterBundle.dat.
  3. Concatenates the Asset_Prefix with the AssetPath to form the full Unity project path.
  4. Loads the bundle and retrieves the asset at the resolved path.

The explicit format is the recommended format for new mod content because it is self-documenting , a reader can determine which bundle and which path a pointer references without consulting the MasterBundle.dat configuration.

Inline format (default master bundle) ​

The inline format specifies only the relative asset path, without naming a master bundle. The game interprets the pointer as referencing the default master bundle for the context in which the pointer appears.

"MyMasterBundlePtr" "path/to/file.extension"

The inline format is compact but depends on the context's default master bundle. If the default master bundle is not configured or does not contain the referenced asset, the pointer fails to resolve. The inline format is most commonly seen in vanilla .asset files where every pointer references core.masterbundle and specifying the bundle name on every pointer would be redundant.

Prefixed inline format ​

The prefixed inline format combines the bundle name and the asset path into a single string separated by a colon:

"MyMasterBundlePtr" "core.masterbundle:path/to/file.extension"

The bundle name precedes the colon; the relative asset path follows the colon. The game splits the string at the first colon, uses the left portion as the MasterBundle value, and uses the right portion as the AssetPath value. The prefixed inline format is a compact alternative to the explicit format that does not depend on the context's default master bundle.

When to use each format

  • Use the explicit format for new mod content. It is the most readable and the most self-documenting.
  • Use the inline format only when every pointer in the .asset file references the same master bundle and that bundle is the default for the file's context. Mod content that relies on the inline format is harder to debug because the bundle name is implicit.
  • Use the prefixed inline format as a compact alternative to the explicit format when the pointer block would otherwise contain only two fields. The prefixed inline format is a single line; the explicit format is four lines (field name, open brace, two sub-fields, close brace). For .asset files with many pointers, the line-count difference is meaningful.

The resolution chain ​

The full resolution chain for a master bundle pointer involves four configuration sources and three processing steps. Understanding the chain is essential for diagnosing pointer-resolution failures.

The flowchart shows that the resolution chain has two independent halves: the bundle identification (which .unity3d file to load) and the path construction (where within that bundle's hierarchy the asset lives). Both halves must resolve correctly for the pointer to produce a valid loaded asset. A failure in either half produces an unresolved pointer.

Step 1: bundle identification ​

The game reads the MasterBundle value from the pointer (for explicit and prefixed inline formats) or uses the context's default master bundle (for the inline format). It then locates the MasterBundle.dat file associated with that bundle name and reads the Asset_Bundle_Name field. The Asset_Bundle_Name value identifies the .unity3d file to load. The game loads that file from the mod's Bundles/ folder.

Step 2: path construction ​

The game reads the Asset_Prefix from the same MasterBundle.dat file and concatenates it with the AssetPath from the pointer. The result is a full Unity project path of the form Assets/ProjectFolder/Subfolder/File.extension. This is the path that the Unity asset-bundle loader uses to locate the asset within the loaded bundle.

Step 3: asset retrieval ​

The game queries the loaded bundle for the asset at the constructed full path. If the asset exists in the bundle, the pointer resolves; the asset is returned and assigned to the referencing asset's field. If the asset does not exist, the pointer is unresolved and the asset type's fallback behavior applies.

Relationship to .asset files ​

Master bundle pointers appear in .asset files, not in .dat files. The .asset file format is the configuration format for asset types that reference Unity content: airdrop definitions, foliage definitions, landscape material definitions, effect definitions, and other asset types that need to reference specific prefabs, materials, or textures within a master bundle.

The .asset file is a text file that uses a C-like block syntax with quoted string keys and values. The master bundle pointer syntax is one of several pointer types that can appear in an .asset file; asset pointers (GUID-based references) and master bundle pointers (path-based references) coexist in the same file and are distinguished by their field structure , asset pointers use a GUID sub-field, while master bundle pointers use a MasterBundle and AssetPath sub-field pair.

.asset file structure ​

An .asset file contains a header block (identifying the asset's GUID and type) followed by the asset body (containing the asset's fields). Master bundle pointers appear in the asset body.

Metadata
{
    GUID 229440c249dc490ba26ce71e8a59d5c6
    Type SDG.Unturned.AirdropAsset, Assembly-CSharp, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
}
Asset
{
    Landed_Barricade
    {
        GUID fe71781c60314468b22c6b0642a51cd9
    }
    Carepackage_Prefab
    {
        MasterBundle core.masterbundle
        AssetPath Level/Carepackage.prefab
    }
}

In the example above, drawn from the shipped vanilla DefaultAirdrop.asset file, the Metadata block identifies the asset by GUID and type. The Asset block contains two fields: Landed_Barricade (an asset pointer, resolving to a barricade by GUID) and Carepackage_Prefab (a master bundle pointer, resolving to a Unity prefab by bundle name and path). The two pointer types coexist in the same .asset file and are distinguished by their internal field structure.

Worked examples ​

Example 1: explicit format master bundle pointer ​

From the shipped vanilla DefaultAirdrop.asset file:

Carepackage_Prefab
{
    MasterBundle core.masterbundle
    AssetPath Level/Carepackage.prefab
}

The pointer references the Unity prefab Carepackage.prefab located at the relative path Level/Carepackage.prefab within the master bundle named core.masterbundle. At resolution time, the game reads the MasterBundle.dat for core.masterbundle (finding Asset_Bundle_Name core.masterbundle and Asset_Prefix Assets/CoreMasterBundle), constructs the full path Assets/CoreMasterBundle/Level/Carepackage.prefab, loads the core.masterbundle.unity3d bundle file, and retrieves the prefab at that path.

Example 2: inline format master bundle pointer ​

"MyItemPrefab" "Items/Guns/MyRifle.prefab"

The inline format specifies only the relative path. The game uses the default master bundle for the file's context. If the default master bundle's MasterBundle.dat has Asset_Prefix Assets/CoreMasterBundle, the full resolved path is Assets/CoreMasterBundle/Items/Guns/MyRifle.prefab.

Example 3: prefixed inline format master bundle pointer ​

"MyVehiclePrefab" "my_vehicle_mod.masterbundle:Vehicles/MyTruck.prefab"

The prefixed inline format identifies the bundle (my_vehicle_mod.masterbundle) and the path (Vehicles/MyTruck.prefab) in a single colon-delimited string. The game splits the string, looks up the MasterBundle.dat for my_vehicle_mod.masterbundle, and constructs the full path from the prefix and the relative path.

Example 4: material pointer ​

"MyMaterial"
{
    MasterBundle core.masterbundle
    AssetPath Materials/MyCustomMaterial.mat
}

The pointer references a Unity material asset (.mat file) inside the master bundle. Material pointers are used when an asset needs to override the default material with a custom one , for example, an effect that uses a custom particle material, or a landscape definition that references a custom terrain material.

Example 5: audio clip pointer ​

"MyAudio"
{
    MasterBundle core.masterbundle
    AssetPath Audio/MySound.ogg
}

The pointer references an OGG audio clip inside the master bundle. Audio pointers are used when an asset (typically an effect or a weapon) needs to reference a custom audio file for playback at runtime.

Example 6: texture pointer ​

"MyTexture"
{
    MasterBundle core.masterbundle
    AssetPath Textures/MyIcon.png
}

The pointer references a PNG texture inside the master bundle. Texture pointers are used when an asset needs to reference a specific texture for UI rendering , for example, a custom inventory icon or a map icon.

Frequently asked questions ​

What is the difference between a master bundle pointer and an asset pointer? ​

A master bundle pointer references a Unity asset (prefab, material, texture, audio clip) by its file path within a master bundle. An asset pointer references another Unturned™ gameplay asset (item, NPC, quest, barricade) by its GUID. Master bundle pointers resolve against Unity's asset-bundle loader; asset pointers resolve against the game's internal asset table. Both pointer types appear in .asset files and are distinguished by their internal field structure (MasterBundle/AssetPath for master bundle pointers, GUID for asset pointers).

Can a master bundle pointer reference an asset in a different mod's bundle? ​

The game does not directly support cross-mod master bundle references in the base modding system. Each mod loads its own master bundle; a pointer in Mod A's .asset file that names Mod B's bundle will only resolve if Mod B's bundle is loaded , but the base modding system does not guarantee cross-mod bundle loading order or discovery. If cross-mod prefab sharing is required, the recommended approach is to bundle the shared assets in each dependent mod's own master bundle, or to use a shared-asset mod that both dependent mods declare as a dependency.

Do I need a MasterBundle.dat file for every master bundle? ​

Yes. Every master bundle that is referenced by a master bundle pointer must have a MasterBundle.dat file in the same Bundles/ folder as the .unity3d file. The MasterBundle.dat defines the Asset_Bundle_Name (how pointers identify this bundle), the Asset_Prefix (the path prefix for relative asset paths), and the Asset_Bundle_Version (the Unity version of the bundle). Without this file, pointers that reference the bundle cannot resolve the bundle name to a .unity3d file.

What is the default master bundle? ​

The default master bundle is the bundle that is used when a master bundle pointer uses the inline format (no MasterBundle field). The default master bundle for a given asset depends on the asset's context. For vanilla assets, the default is core.masterbundle , the main Unturned™ content bundle. For mod assets, the default is typically the mod's own master bundle, as configured in the mod's MasterBundle.dat. The exact default behavior is context-dependent and is documented per asset type in the asset-specific reference articles.

What file extensions can master bundle pointers reference? ​

Master bundle pointers can reference any asset type that Unity's asset-bundle system supports. The most common extensions in Unturned™ modding are:

ExtensionAsset typeTypical use
.prefabUnity prefabItem models, NPC character models, vehicle models
.matUnity materialCustom materials for effects, landscapes
.pngTexture (PNG)Inventory icons, UI elements
.oggAudio clip (Ogg Vorbis)Custom sounds, ambient audio, weapon audio
.mp3Audio clip (MP3)Less common; .ogg is the recommended audio format
.controllerAnimator controllerAnimation state machines for items and NPCs
.animAnimation clipIndividual animation sequences

What happens when a master bundle pointer is unresolved? ​

The fallback behavior for an unresolved master bundle pointer depends on the asset type that holds the pointer. An item with an unresolved prefab pointer loads as a data entry but has no visible model , it appears as nothing when held, dropped, or equipped in the inventory, or sometimes as a placeholder cube. An airdrop with an unresolved care-package prefab deploys but the container model is missing. An effect with an unresolved audio pointer plays silently. In all cases, the game does not log a warning or display an error; the visual or audio component is simply absent. This is the same silent-failure pattern as unresolved asset pointers.

How do I verify that a master bundle pointer resolves correctly? ​

Spawn the item or trigger the effect in single-player and visually confirm that the model appears, the texture renders, or the audio plays. For item prefabs: spawn the item with @give <ID>, equip it, and confirm the model is visible and correctly scaled. For effects: trigger the effect through the game mechanic that produces it. For audio: play the sound and confirm it is audible. Visual inspection of the rendered output is the only reliable verification method for master bundle pointers , there is no log output or diagnostic panel that reports pointer resolution status.

Can I use forward slashes in AssetPath values? ​

Yes. AssetPath values use forward slashes (/) as path separators, consistent with Unity's internal path convention. Backslashes are not recognized as path separators by Unity's asset-bundle loader and produce unresolved pointers. The forward-slash convention applies regardless of the host operating system's native path separator.

Can AssetPath reference a file at the root of the bundle's Asset_Prefix? ​

Yes. If the target asset is at the root of the Asset_Prefix directory, the AssetPath value is just the file name and extension. For example, if Asset_Prefix is Assets/MyMod and the prefab is at Assets/MyMod/MyItem.prefab, the AssetPath value is MyItem.prefab with no directory prefix.

How does Asset_Bundle_Version affect mod compatibility? ​

The Asset_Bundle_Version field declares which Unity version's serialization format the bundle uses. A bundle built with Unity 2022 LTS should have Asset_Bundle_Version 6. If the value is incorrect , e.g., Asset_Bundle_Version 3 on a Unity 2022 bundle , the game may attempt to load the bundle using an incompatible binary format reader, producing a load failure or corrupted asset data. Always set Asset_Bundle_Version to match the Unity Editor version used for the project. The version mapping is documented in the MasterBundle.dat field reference earlier in this article.

Best practices ​

  • Use the explicit format for master bundle pointers in new mod content. It is self-documenting and does not depend on context-specific default bundle assumptions.
  • Choose a unique Asset_Bundle_Name for each mod to avoid collision with vanilla bundles and other mod bundles. The vanilla master bundle is named core.masterbundle; do not reuse this name.
  • Match Asset_Prefix to the Unity project folder structure. If the mod's assets are in Assets/MyMod/Items/, set Asset_Prefix Assets/MyMod and reference sub-items with AssetPath Items/MyGun.prefab.
  • Set Asset_Bundle_Version to the correct value for your Unity Editor version. The current recommended value is 6 for Unity 2022 LTS.
  • Use forward slashes in AssetPath values, not backslashes. Forward slashes are Unity's internal path convention and are required by the asset-bundle loader.
  • Verify every master bundle pointer by spawning the item or triggering the effect in single-player and visually confirming the model or effect renders.
  • Maintain one MasterBundle.dat per master bundle. A mod with multiple bundles needs one MasterBundle.dat per .unity3d file, each in the bundle's subfolder.
  • Comment the MasterBundle.dat file with the Unity project path structure. Comments help future contributors understand the path mapping without opening the Unity project.
  • Test the mod with a clean Unturned™ installation (no other mods loaded) to confirm that all master bundle pointers resolve from the mod's own bundle without unexpected dependencies on other loaded bundles.

Diagnostic table ​

SymptomMost likely causeResolution
Item has no visible model when equippedMaster bundle pointer unresolved , prefab not found in bundleVerify AssetPath matches the prefab's path in the Unity project, relative to Asset_Prefix
Item appears as a placeholder cube or pink rectangleMaster bundle pointer or material pointer unresolvedVerify the prefab path and the material assignment in Unity; rebuild the bundle
Bundle fails to load at allAsset_Bundle_Name mismatch between MasterBundle.dat and the .unity3d file name, or Asset_Bundle_Version incorrectConfirm the bundle file name matches Asset_Bundle_Name and the version matches the Unity Editor version
Effect has no soundAudio pointer unresolved or audio file not included in bundleConfirm the OGG file is in the bundle and the AssetPath references it correctly
Custom inventory icon is missingTexture pointer unresolved or icon texture not included in bundleConfirm the PNG file is in the bundle and the pointer references it
Prefab loads but has wrong scale or offsetPrefab transform values are non-identity in UnitySet the root prefab transform to position (0,0,0), rotation (0,0,0), scale (1,1,1) in Unity before building the bundle
Bundle loads but asset not found at pathAssetPath uses wrong directory separator or misspelled directory nameUse forward slashes; verify the directory structure in the Unity project matches the AssetPath value
Explicit format pointer fails but inline worksMasterBundle value does not match any MasterBundle.dat's Asset_Bundle_NameConfirm the MasterBundle field value exactly matches the Asset_Bundle_Name in the bundle's MasterBundle.dat
Prefixed inline format pointer failsColon-separated string is malformed or bundle name does not existConfirm the format is BundleName:RelativePath with no spaces around the colon
Bundle loads on developer's machine but not on other machinesAsset_Bundle_Version does not match the actual bundle formatVerify the Unity Editor version used to build the bundle and set Asset_Bundle_Version accordingly

Appendix A: Master bundle pointer quick-reference card ​

FormatSyntaxUse case
Explicit"FieldName" { "MasterBundle" "bundle.name" "AssetPath" "path/to/file.ext" }Recommended for all new mod content
Inline"FieldName" "path/to/file.ext"When every pointer references the default master bundle
Prefixed inline"FieldName" "bundle.name:path/to/file.ext"Compact alternative to explicit format for single-bundle references

Appendix B: MasterBundle.dat template ​

Copy this template for a new mod's MasterBundle.dat file. Replace the placeholder values with the mod-specific bundle name, asset prefix, and Unity version.

Asset_Bundle_Name MyModMasterBundle

// Path to the asset bundle within Unity.
// Unity subfolders should match 1:1 with dat subfolders.
Asset_Prefix Assets/MyMod

// Version 2 is Unity 2017 LTS.
// Version 3 is Unity 2018 and 2019 LTS.
// Version 4 is Unity 2020 LTS.
// Version 5 is Unity 2021 LTS.
// Version 6 is Unity 2022 LTS.
Asset_Bundle_Version 6

Appendix C: External references ​

Cross-references ​

Appendix D: Multiple master bundles in a single mod ​

A mod is not limited to a single master bundle. Large mods with substantial 3D content , map mods, vehicle packs with many variants, item packs with hundreds of items , often benefit from splitting their assets across multiple bundles. Each bundle has its own MasterBundle.dat and its own .unity3d file. Pointers reference the correct bundle by using the explicit or prefixed inline format with the appropriate bundle name.

Multi-bundle folder structure ​

MyLargeMod/
└── Bundles/
    ├── MasterBundle.dat               ← default bundle config
    ├── MyLargeModCore.unity3d          ← core bundle (shared assets)
    ├── MasterBundle_Guns.dat           ← guns bundle config
    ├── MyLargeModGuns.unity3d          ← guns prefab bundle
    ├── MasterBundle_Vehicles.dat       ← vehicles bundle config
    └── MyLargeModVehicles.unity3d      ← vehicles prefab bundle

Each bundle's MasterBundle.dat uses a distinct Asset_Bundle_Name and typically a distinct Asset_Prefix sub-folder within the Unity project:

# MasterBundle_Guns.dat
Asset_Bundle_Name MyLargeModGuns
Asset_Prefix Assets/MyLargeMod/Guns
Asset_Bundle_Version 6

Pointers in the mod's .asset files then reference the correct bundle explicitly:

"GunPrefab"
{
    MasterBundle MyLargeModGuns
    AssetPath Rifles/MyRifle.prefab
}
"VehiclePrefab"
{
    MasterBundle MyLargeModVehicles
    AssetPath Trucks/MyTruck.prefab
}

Multi-bundle considerations ​

  • Each additional bundle increases the mod's download size by the bundle's compressed size. A bundle with a single small prefab adds more file-overhead bytes than content bytes; consolidating small assets into fewer bundles is more efficient.
  • The game loads each referenced bundle when the first pointer to it is resolved. Loading many small bundles at startup increases the mod's load time compared to loading one larger bundle. The performance difference is typically negligible for mods with up to approximately five bundles.
  • Assets in different bundles cannot directly reference each other at the Unity level (a prefab in bundle A cannot contain a material from bundle B through Unity's asset-reference system). All cross-bundle asset relationships must be managed at the .dat/.asset file level through master bundle pointers.

Appendix E: Diagnosing master bundle pointer failures in the Unity Editor ​

Before the bundle is even loaded by Unturned™, the modder can verify that the bundle contains the expected assets using the Unity Editor's asset-bundle inspection tools. The diagnostic workflow below catches most master bundle pointer failures before the bundle reaches the game.

Workflow step 1: verify assets are assigned to the correct bundle ​

In the Unity Editor, select each asset that should be in the bundle. In the Inspector, expand the asset-bundle assignment dropdown at the bottom of the Inspector window. Confirm that the asset is assigned to the correct bundle name (the name that will become the .unity3d file name). An asset that is not assigned to any bundle, or is assigned to the wrong bundle, will not be present in the built bundle file.

Workflow step 2: build the bundle and check the manifest ​

After building the bundles, Unity generates a .manifest file alongside each .unity3d bundle file. The manifest is a text file that lists every asset included in the bundle, with its full Unity project path. Open the manifest file in a text editor and search for the AssetPath value used in the mod's master bundle pointers. If the asset does not appear in the manifest, the pointer will not resolve at runtime.

Workflow step 3: confirm Asset_Prefix matches the manifest paths ​

The paths in the manifest are relative to the Unity project root (they start with Assets/). The Asset_Prefix in MasterBundle.dat must match the directory prefix of the assets in the manifest. If the manifest shows Assets/MyMod/Items/Guns/MyRifle.prefab and Asset_Prefix is set to Assets/WrongFolder, the resolved path will be Assets/WrongFolder/Items/Guns/MyRifle.prefab, which does not exist in the bundle.

Workflow step 4: test load the bundle in a minimal Unturned session ​

Copy the built bundle and MasterBundle.dat to the mod's Bundles/ folder, launch Unturned™ in single-player with only the current mod loaded, and spawn the item or trigger the effect. Visual confirmation that the model appears is the definitive test that every pointer in the chain resolved correctly.

Document history ​

VersionDateAuthorNotes
1.02026-07-2657 StudiosInitial publication. Complete master bundle pointer specification, all three syntaxes, MasterBundle.dat field reference, resolution chain documentation, worked examples, diagnostic table, multi-bundle configuration, Unity Editor diagnostic workflow, template appendices.
57 Studios logo with slogan

Beginner-friendly guides for Unturned modding, tools, publishing, server operations, and troubleshooting.

Learn

Getting StartedSteam SetupInstalling Unturned

Explore

ItemsSelf-HostingTroubleshootingHome

Built for Unturned creators, server staff, and 57 Studios™ contributors.

Copyright © 57 Studios™. All rights reserved. 57 Studios™, its branding, guides, and associated original content are protected by applicable copyright and trademark law.