Manifest File Reference

Intermediate40-60 minutesWindowsNotepad++Unity Editor

The manifest file (.masterbundle.manifest) is a YAML-like metadata file generated alongside every master bundle that lists all assets contained in the bundle, their paths, and their class type registrations. When the multiplatform option is enabled during export, a manifest file is generated for each target platform. The manifest is invaluable for debugging mods: it confirms that assets were bundled as expected and provides the asset paths used by master bundle pointers.

57 Studios™ has documented the manifest file format through analysis of the core.masterbundle.manifest file and its relationship to the bundle content. This article covers the complete manifest file structure, how to read each section, the relationship between manifest entries and asset loading, and practical use cases for mod authors.

Documentation source: This article is based on analysis of the core.masterbundle.manifest file (approximately 1 MB) and the official SDG documentation on master bundles. The manifest format is specific to Unity AssetBundles version 6.

Who this article is for

This article is written for Unturned™ mod authors who need to debug asset loading issues, verify that their master bundles contain the expected assets, or understand the internal structure of bundle manifests for advanced tooling.

Manifest file structure

The manifest file uses a YAML-like structure organized into several major sections. Each section provides different information about the bundle's contents.

File header

The manifest begins with a header indicating the bundle format and file version:

ManifestFileVersion: 2
BundleName: core.masterbundle
BundleSize: 123456789

Main asset listing

The main section lists every asset in the bundle by its full path within the bundle hierarchy. Each entry includes the asset type and a unique identifier.

Assets:
  - Asset_0:
      Name: Assets/CoreMasterBundle/Items/Guns/Eaglefire/Item.prefab
      AssetType: GameObject
  - Asset_1:
      Name: Assets/CoreMasterBundle/Items/Guns/Eaglefire/Skin_Primary.mat
      AssetType: Material
  - Asset_2:
      Name: Assets/CoreMasterBundle/Effects/Impacts/Impact_Concrete.prefab
      AssetType: GameObject

Class type registry

The class type registry section enumerates every Unity class type that appears in the bundle. Each entry includes the class ID, the class name, and whether it is a MonoBehaviour variant.

ClassTypes:
  - Class_ID: 1
    Class_Name: GameObject
    Is_MonoBehaviour: false
  - Class_ID: 21
    Class_Name: Material
    Is_MonoBehaviour: false
  - Class_ID: 114
    Class_Name: MonoBehaviour
    Is_MonoBehaviour: true

MonoBehaviour variant listing

MonoBehaviour variants are listed separately because they include the script GUID and the assembly-qualified type name. This section is critical for mods that include custom MonoBehaviour scripts.

MonoBehaviourVariants:
  - Script_GUID: a1b2c3d4e5f64a7b8c9d0e1f2a3b4c5d
    Class_Name: MyCustomScript
    Assembly: Assembly-CSharp
    Namespace: MyMod
  - Script_GUID: e5f6a7b8c9d04a7b8c9d0e1f2a3b4c5d
    Class_Name: AnotherScript
    Assembly: Assembly-CSharp
    Namespace: MyMod

Asset dependency listing

Each asset can declare dependencies on other assets within the bundle or in other bundles. Dependencies are listed by asset path.

Dependencies:
  - Asset_0:
      Dependencies:
        - Asset_5
        - Asset_12

Bundle dependencies

If the bundle references assets from other bundles, those bundle-level dependencies are listed at the bottom of the manifest.

BundleDependencies:
  - core.masterbundle
  - textures.masterbundle

How to read a manifest entry

Each manifest entry follows a consistent format:

Asset_N:
    Name: <full-path-within-bundle>
    AssetType: <Unity-class-name>

The Name field is the asset's full path within the bundle, including the Asset_Prefix root. This path is what you use in master bundle pointers when referencing the asset.

The AssetType field tells you the Unity class of the asset. Common types include GameObject (prefabs), Material (materials), Texture2D (textures), AudioClip (audio files), MonoBehaviour (script components), AnimatorController (animation controllers), and Mesh (mesh data).

Practical use cases

Confirming assets are in the bundle

After exporting a master bundle, open the manifest file and search for the expected asset paths. If an asset that was supposed to be included is not listed, the export configuration may have missed it.

Debugging master bundle pointers

When a master bundle pointer reference fails at runtime, compare the AssetPath value in the .dat file against the Name values in the manifest. The path must match exactly, including the Asset_Prefix prefix.

Identifying class types

When creating assets that require specific Unity component types, use the manifest's class type registry to confirm that those component types are available in the bundle.

Tracking bundle size

The BundleSize field in the file header reports the total bundle size in bytes. Compare this value across exports to track how changes affect bundle size.

Manifest file format reference

Section	Description	Required
ManifestFileVersion	Format version identifier	Yes
BundleName	Name of the master bundle file	Yes
BundleSize	Total bundle size in bytes	Yes
Assets	List of all assets in the bundle with paths and types	Yes
ClassTypes	Registry of Unity class types used in the bundle	Yes
MonoBehaviourVariants	List of MonoBehaviour variants with script GUIDs	Conditional
Dependencies	Per-asset dependency list	Conditional
BundleDependencies	Cross-bundle dependency list	Conditional

Diagnostic table

Symptom	Most likely cause	Resolution
Asset path in .dat does not match manifest	Typo in the asset path or Asset_Prefix mismatch	Compare the .dat path against the manifest entry
Asset not listed in manifest	Asset was not included in the export	Re-export with the asset's directory selected
MonoBehaviour variant not found	Script GUID in the manifest does not match the compiled script	Rebuild the script assembly and re-export
Bundle dependency missing	A referenced asset is in a different bundle that is not loaded	Include the dependency bundle in the mod distribution
Manifest file not generated	Multiplatform toggle was not enabled	Re-export with multiplatform enabled
Bundle size unexpectedly large	Unintended assets included in the export	Review the export directory selection
Class type not recognized	The Unity class is not registered in the bundle's scope	Verify the component is properly set up in Unity

Best practices

• Always inspect the manifest file after exporting to confirm the expected assets are included.
• Use the manifest as a reference when configuring master bundle pointers.
• Keep the manifest file with the bundle distribution for debugging purposes.
• Compare manifest files across export versions to track content changes.
• Use the MonoBehaviourVariants section to verify custom script correctness.

Frequently asked questions

Can I edit the manifest file?

The manifest is a generated file. Editing it does not change the contents of the master bundle. The manifest is informative only; the actual bundle content is determined by the export process.

Do I need to distribute the manifest with my mod?

The manifest is not required for the bundle to load. It is a debugging aid. However, including the manifest helps other mod authors understand your bundle's content when they need to create master bundle pointers that reference your assets.

What does the BundleSize field represent?

BundleSize is the total size of the master bundle file in bytes, as reported at the time of export. This value is useful for tracking how changes to the project affect the bundle's file size.

How are asset dependencies tracked in the manifest?

Each asset entry in the Assets section can have a Dependencies sub-section that lists other assets by their index (e.g., Asset_5, Asset_12). These are assets within the same bundle that the entry references. The dependency graph helps the engine determine loading order.

What is the difference between ClassTypes and MonoBehaviourVariants?

ClassTypes lists every Unity class that appears anywhere in the bundle (GameObject, Material, Texture2D, etc.). MonoBehaviourVariants specifically lists MonoBehaviour subclasses, which have a script GUID that identifies the compiled C# script. MonoBehaviour entries include the assembly name and namespace.

How do I find the path for a master bundle pointer using the manifest?

Search the manifest for the asset name. Copy the Name value exactly as it appears. Use that value as the AssetPath in your master bundle pointer. The path includes the Asset_Prefix root.

Can the manifest tell me if an asset bundle was corrupted?

No. The manifest is a text file generated during export. It does not contain checksums or integrity data for individual assets. Bundle integrity is verified through the .hash file, which is a separate file.

Appendix A: Example manifest entry

Assets:
  - Asset_0:
      Name: Assets/CoreMasterBundle/Items/Guns/Eaglefire/Item.prefab
      AssetType: GameObject
  - Asset_1:
      Name: Assets/CoreMasterBundle/Items/Guns/Eaglefire/Skin_Primary.mat
      AssetType: Material
  - Asset_2:
      Name: Assets/CoreMasterBundle/Items/Guns/Eaglefire/Skin_Secondary_6.mat
      AssetType: Material
  - Asset_3:
      Name: Assets/CoreMasterBundle/Effects/Impacts/Impact_Concrete.prefab
      AssetType: GameObject

Appendix B: External references

• Smartly Dressed Games official modding documentation - the official field reference.
• Unturned on Steam - the Unturned store page.
• Master Bundle Internal Structure - the previous article.
• Modding Workflow: End-to-End - the next article.
• Master Bundle Export - the companion export workflow article.

Using the manifest for mod development

The manifest file is a valuable tool throughout the mod development lifecycle, not just at the final export stage.

Development phase

During development, use the manifest to confirm that newly added assets are being included in the bundle. If a new prefab or texture does not appear in the manifest after export, the asset was not selected for bundling in the Unity Editor.

Debugging phase

When a mod asset fails to load at runtime, compare the asset path in the .dat file's master bundle pointer against the paths listed in the manifest. The path must match exactly, including the Asset_Prefix prefix.

Release phase

Before distributing a mod, inspect the manifest to confirm that no unintended assets are included in the bundle. Remove any development-only assets (test textures, placeholder models, debug scripts) from the bundle before release.

Update phase

When releasing an update, compare the manifest of the new export against the previous version's manifest to confirm that the expected assets changed and that no assets were accidentally omitted.

Frequently asked questions (continued)

Can I use the manifest to determine the Asset_Prefix?

Yes. Look at the common prefix shared by all asset paths in the Assets section. That common prefix is the Asset_Prefix that was set in the MasterBundle.dat at export time. For example, if all paths start with Assets/CoreMasterBundle/, then Asset_Prefix was Assets/CoreMasterBundle.

What does it mean if an asset's AssetType is "MonoBehaviour"?

MonoBehaviour entries indicate that the asset contains a script component. The MonoBehaviourVariants section provides the specific script GUID, class name, assembly, and namespace. This is important for custom script mods.

How do I verify that a specific asset is in the bundle?

Search the manifest file for the asset's expected path. If the path is found, the asset is in the bundle. If the path is not found, the asset may have been exported under a different name or may not have been selected for bundling.

Does the manifest file affect game performance?

No. The manifest file is not loaded by the game engine at runtime. It is a development-time artifact generated for debugging purposes. It has no impact on game performance or memory usage.

Can I manually add entries to the manifest?

Adding entries to the manifest does not add assets to the bundle. The manifest is a reporting artifact, not a configuration file. Assets must be added through the Unity export process.

Testing manifest file accuracy

To verify that a manifest file accurately represents the bundle contents, compare the manifest's asset listing against the assets that actually load in-game.

Step 1: Export the bundle

Export the master bundle with the multiplatform option enabled to generate the manifest file.

Step 2: Inspect the manifest

Open the manifest file and note the total number of assets listed, the asset paths, and the asset types.

Step 3: Cross-reference with .dat files

For each .dat file that uses a master bundle pointer, confirm that the AssetPath value appears in the manifest.

Step 4: In-game verification

Launch the game and confirm that every asset listed in the manifest is loadable and renders correctly.

Glossary

Term	Definition
Manifest file	A YAML-like text file listing all assets in a master bundle with paths and types.
Asset listing	The section of the manifest enumerating every asset by path and Unity class type.
Class type registry	A section listing every Unity class that appears in the bundle with class IDs.
MonoBehaviour variant	A section listing scripted components with their GUID, assembly, and namespace.
Bundle dependency	A reference from this bundle to another bundle that provides required assets.
Asset path	The full path of an asset within the bundle, including the Asset_Prefix prefix.

Authoring checklist

• [ ] Manifest file is inspected after each export
• [ ] Asset paths in .dat files match manifest entries
• [ ] MonoBehaviour variants are correctly listed (if using custom scripts)
• [ ] Bundle dependencies are accounted for in the mod distribution
• [ ] Manifest is included in the mod documentation package

Manifest file in the development workflow

The manifest file serves different purposes at each stage of the mod development lifecycle.

During asset authoring

While authoring assets in the Unity Editor, the manifest does not yet exist. It is generated during the export phase. The manifest confirms that the assets you configured for bundling are actually included in the output.

During export verification

After exporting the master bundle, immediately inspect the manifest to verify that all expected assets are present. If an asset is missing, return to the Unity Editor and correct the asset bundle assignment.

During debugging

When an asset fails to load at runtime, the manifest is the first diagnostic tool. Compare the AssetPath in the .dat file's master bundle pointer against the paths in the manifest. A mismatch of even one character will cause the asset to fail to load.

During distribution

Before distributing a mod, inspect the manifest for any unintended assets. Development-only assets (test models, placeholder textures, debug scripts) should be removed from the bundle before distribution.

During updates

When releasing an update, compare the new manifest against the previous version. This reveals which assets changed, which were added, and which were removed.

Advanced manifest analysis techniques

Asset count trending

Track the total number of assets in the manifest across export versions. A sudden increase may indicate that unintended assets were included. A sudden decrease may indicate that intended assets were missed.

Asset type distribution

Analyze the distribution of AssetType values in the manifest. A healthy mod bundle typically has a mix of GameObject, Material, Texture2D, AudioClip, and AnimatorController entries. A bundle with only GameObject entries may be missing its material dependencies.

Dependency graph analysis

The Dependencies section of the manifest shows which assets depend on which other assets. A circular dependency (Asset A depends on Asset B which depends on Asset A) may cause loading issues.

Manifest file design patterns

The full-inventory pattern

Before distribution, print the manifest and check off each asset against the mod's asset inventory list. This ensures nothing was missed during export.

The diff-based debugging pattern

Keep copies of manifest files from previous exports. When a bug appears in a new version, diff the new manifest against the old one to identify which asset changes may have caused the bug.

The master bundle pointer verification pattern

For each .dat file that uses a master bundle pointer, create a line in a tracking document that maps the .dat file's AssetPath to the manifest entry. This ensures every pointer resolves correctly.

Common manifest file errors

Manifest symptom	Meaning	Action
Asset path ends with ".prefab" but is type "Material"	Asset was misconfigured in the Unity project	Re-check the asset's export settings
MonoBehaviour variant lists wrong assembly	Script reference is broken	Rebuild the script assembly
Bundle dependency lists nonexistent bundle	Bundle references an unloaded bundle	Include the dependency bundle
Asset count is zero	Export failed or no assets were selected for bundling	Re-configure asset bundle assignments
BundleSize is suspiciously small	Only metadata was exported; core assets may be missing	Re-export with correct asset selection

Performance implications of manifest content

The manifest file itself does not affect game performance because it is not loaded at runtime. However, the content described by the manifest does affect performance.

Bundle size and load time

A manifest listing many large assets indicates a large bundle that will take longer to load. The BundleSize field gives the total bundle size in bytes.

Asset type performance characteristics

Asset type	Memory impact	Load time impact
GameObject (prefab)	Medium (mesh + materials)	Low
Texture2D	High (depends on resolution)	Medium
AudioClip	Medium (depends on length and format)	Low
Material	Low	Low
AnimatorController	Low	Low
Mesh	High (vertex count dependent)	Medium

Frequently asked questions (continued)

Can the manifest help me find unused assets?

Yes. If an asset appears in the manifest but no .dat file references it through a master bundle pointer, the asset is loaded into memory but never used. Remove unused assets from the bundle to reduce bundle size and memory usage.

How do I read a manifest entry for a texture?

Look for entries with AssetType: Texture2D. The Name field gives the texture's path within the bundle. The manifest does not include texture resolution or format information; that is determined by the Unity import settings used during export.

What does it mean if an asset has no dependencies?

Assets with no dependencies are self-contained. A simple Material that references no textures and uses a built-in shader may have zero dependencies. Most GameObjects have dependencies on their Material and Mesh assets.

Can I compare manifests across different mods?

Yes, but the comparison is only meaningful if the mods share the same Asset_Prefix structure. Comparing manifests across different mods can still reveal naming convention differences and organizational patterns.

Is the manifest file required for Workshop submission?

No. The manifest is a debugging artifact. It is not required for Workshop submission. However, including the manifest in the mod's documentation is a helpful practice for other mod authors who need to reference asset paths.

Quick reference

This article provides a comprehensive reference for the topics covered. Key concepts include understanding the field types, required vs optional fields, default values, and how fields interact with each other. Always cross-reference field values against the official SDG documentation and test changes in both single-player and multiplayer environments before publishing.

Article purpose

This article serves as the authoritative reference for the manifest file format used by Unturned master bundles. The manifest is a generated artifact that lists all assets in a bundle with their paths and Unity class types. Understanding the manifest helps mod authors debug asset loading issues and verify that their bundles contain the expected assets before distribution.

This article completes the manifest file reference for the Unturned master bundle system.

Cross-references

• Master Bundle Internal Structure - the previous article.
• Modding Workflow: End-to-End - the next article.
• Master Bundle Export - export workflow.
• Asset Bundles Reference - bundle system fundamentals.

Manifest file multi-mod management

When managing multiple mods that each have their own master bundles, the manifest files can help track which assets are in which bundle.

Cross-reference matrix

Create a spreadsheet that maps each asset path to the mod it belongs to and the manifest it appears in. This prevents confusion when debugging asset loading issues across multiple mods.

Shared asset identification

If the same asset path appears in manifests from two different mods, the later-loading mod's asset takes precedence. This may be intentional (an override) or accidental (a naming collision).

Bundle size budgeting

Sum the BundleSize values across all manifests to determine the total disk space consumed by all master bundles. Use this data to make informed decisions about which assets belong in which bundle.

Manifest file authoring checklist

Before finalizing a mod distribution, confirm the following manifest-related items:

• [ ] Manifest file exists and is non-empty
• [ ] All expected asset paths are listed
• [ ] No unintended assets are listed
• [ ] Asset paths in .dat files match manifest paths exactly
• [ ] MonoBehaviour variants are correctly listed for scripted assets
• [ ] Bundle dependencies are noted for multi-bundle setups
• [ ] Manifest is archived with the release version

Manifest file automation

For mod authors who frequently export bundles, automating manifest inspection can save time.

Automated path verification

Write a script that reads each .dat file's master bundle pointer AssetPath values and checks them against the manifest. Any path not found in the manifest is flagged for investigation.

Automated asset count validation

Track the expected asset count for the mod. After each export, compare the actual asset count in the manifest against the expected count. A mismatch triggers an alert.

Automated manifest archiving

Configure the export process to automatically archive the manifest file with a version number in the filename. This creates a historical record of how the bundle content changed across versions.

Manifest file troubleshooting quick reference

Check	Manifest section to inspect
Asset exists in bundle?	Assets section - search by path
Asset type correct?	Assets section - check AssetType field
Script component correct?	MonoBehaviourVariants section
Bundle dependencies correct?	BundleDependencies section
Asset dependencies correct?	Dependencies section for the asset
Total bundle size?	BundleSize field in header

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Complete manifest file format reference, section descriptions, practical use cases, diagnostic table.