Asset Load Failure Reference

Intermediate40-60 minutesWindowsUnturned

Asset load failures occur when the Unturned™ engine cannot resolve a reference from one asset to another at startup or at runtime. The most common load failure is a missing GUID reference: one asset's .dat file references another asset by GUID, but the referenced asset is not present in the loaded asset set. The engine's response to a load failure depends on the type of reference, the asset category, and whether the failure occurs at startup or during gameplay. Understanding this response is essential for diagnosing and fixing load failures in modded content.

57 Studios™ has documented and validated the complete asset load failure behavior. This reference covers the common types of load failures, the engine's skip vs crash behavior, how error logging surfaces load failures, the diagnostic process for tracing missing GUID errors, and the resolution paths for each failure type.

Documentation source: This article references the official Smartly Dressed Games modding documentation for the Asset Validation chapter and Asset Definitions chapter, combined with the 57 Studios cohort's empirical testing of load failure behavior across common modding scenarios. Community-validated diagnostic patterns are marked where the official documentation is silent on a detail.

Who this article is for

This reference is written for Unturned™ mod authors and server operators who are troubleshooting mods that fail to load correctly. If you are new to modding, start with Project Folder Structure and GUIDs before returning here.

What you will learn

• The common types of asset load failures and their causes
• The engine's skip vs crash behavior for different failure types
• How error logging surfaces load failures in Client.log and Server.log
• How to trace a missing GUID reference from the error message to the source file
• How to resolve each failure type with concrete fixes
• The diagnostic decision tree for load failure troubleshooting

How asset loading works

At startup, the engine scans all loaded mod directories for .dat and .asset files. Each file is parsed and registered as an asset in the engine's asset tables. After parsing, the engine resolves cross-references: if asset A references asset B by GUID, the engine looks up B in the asset tables and stores the reference. If B is not found, the reference resolution fails.

As shown above, the engine does not crash on every missing reference. The severity depends on whether the reference is critical to the asset's function.

Common types of load failures

Missing GUID reference

A missing GUID reference occurs when one asset references another by GUID and the referenced asset is not loaded. This is the most common load failure in modded content.

Scenario	Example	Symptom
Item references a magazine GUID that is not loaded	Gun .dat has Magazine_Reference pointing to a magazine GUID not in the mod	Gun loads but cannot accept any magazine
Spawn table references an item GUID that is not loaded	Spawn table Tables array has a Guid entry for an item not in the mod	Spawn table entry is skipped silently
Level Asset references a weather asset that is not loaded	Level Asset has Weather_Types with a weather GUID not in the set	Weather type is ignored

Broken master bundle link

A broken master bundle link occurs when a .dat file references a prefab in a master bundle, but the bundle file is missing, corrupt, or does not contain the referenced prefab.

Scenario	Example	Symptom
Master bundle file is missing	MasterBundle.dat points to Weapons.masterbundle but the file is absent	All assets that need prefabs from that bundle fail
Prefab name mismatch	Asset .dat sets Item MyWeaponPrefab but the bundle contains MyWeapon_Prefab	Item loads but is invisible when equipped
Bundle version mismatch	Master bundle was built for a different Unity version	Asset may fail to load or render incorrectly

Invalid asset syntax

An invalid asset syntax failure occurs when a .dat or .asset file cannot be parsed correctly.

Scenario	Example	Symptom
Missing closing brace	Dictionary opened with { but not closed with }	Parser error at startup; asset skipped
Unquoted string with spaces	Name Some Name Here on a key that expects a single value	Parser reads part of the value; remainder may be interpreted as a new key
Wrong value type	Amount Thirty instead of Amount 30	Field is skipped; default value used

Skip vs crash behavior

The engine distinguishes between critical and non-critical load failures. Critical failures cause the engine to skip the affected asset entirely. Non-critical failures allow the asset to load with degraded functionality.

Failure type	Severity	Engine behavior	log level
Missing GUID in item reference	Non-critical	Item loads; missing reference is skipped silently	Warning
Missing GUID in spawn table	Non-critical	Spawn table entry is skipped	Warning
Missing master bundle file	Critical	All assets depending on that bundle fail to load	Error
Invalid syntax in .dat file	Critical	The asset file is skipped entirely	Error
Broken prefab reference	Non-critical	Item loads but may be invisible or use default prefab	Warning
Missing English.dat	Non-critical	Item loads with internal Name as display name	Info
GUID conflict (two assets with same GUID)	Critical	One of the two assets is skipped; which one is unpredictable	Error

The official documentation notes that during startup the game runs fast basic health checks on assets while loading, but there are a variety of slower tests available through the -ValidateAssets command-line flag.

Error logging

Asset load failures are logged to the Client.log file (for client-side failures) and the Server.log file (for server-side failures). The log files are located in the Unturned™ installation directory under the Logs/ subfolder.

Log entry patterns

Log entry pattern	Meaning	Severity
Failed to find asset with GUID <guid>	A GUID reference could not be resolved	Warning
Could not find master bundle <name>	The specified master bundle file is missing	Error
Parser error at line <N>: <description>	A .dat file could not be parsed at the specified line	Error
Asset <name> has duplicate GUID <guid>	Two assets share the same GUID	Error
Missing localization file for asset <name>	The asset has no English.dat and no language-specific .dat	Info

Using the Asset Errors menu

In addition to the log file, the -ValidateAssets command-line flag enables the Asset Errors menu, which aggregates all validation errors into an in-game view. This menu is the most efficient way to review all load failures after starting the game with validation enabled.

Diagnostic table

Symptom	Most likely cause	Resolution
Item loads but is invisible when equipped	Prefab reference broken or master bundle missing	Verify the prefab name matches the bundle content; check MasterBundle.dat points to the correct file
Gun loads but cannot accept any magazine	Missing GUID in Magazine_Reference or the referenced magazine is not loaded	Verify the magazine GUID is correct and the magazine .dat file is in the mod folder
Map loads but specific spawns are empty	Spawn table references a GUID that is not loaded	Check the spawn table Guid entries against the loaded assets; remove or fix the missing reference
Server shows "missing asset" error on startup	A critical asset reference cannot be resolved	Check Server.log for the specific GUID; add the referenced asset to the server mod set
Pink checkerboard texture on item	Material reference broken in the master bundle	Re-export the master bundle with the correct material assignment
Mod does not appear in the game at all	Asset file has invalid syntax that prevents parsing	Check the .dat file for missing braces, unquoted strings, or other syntax errors
Two items have the same name in-game	GUID conflict between two items; one was skipped	Generate a new GUID for one of the conflicting items
Asset error menu shows warnings but game runs	Non-critical references are missing	Review each warning; non-critical warnings can be deferred but should be fixed

Decision tree for load failure diagnosis

FAQ

Can an asset load failure crash the game?

The engine avoids crashing on asset load failures whenever possible. The majority of failures result in the asset being skipped (with an error log) while the game continues loading. However, certain critical failures at startup, particularly in the level loading phase, can cause the game or server to terminate with an error. These critical failures are rare and typically involve fundamental systems that the game cannot operate without.

What should I do first when I see an asset error?

Run the game with the -ValidateAssets command-line flag. This enables the comprehensive validation tests and surfaces all errors in the Asset Errors menu. Review each error, note the GUID or file path mentioned, and fix the issues one at a time starting with the critical errors.

How do I find which file contains a missing GUID?

Search the mod's .dat and .asset files for the GUID string reported in the error message. Use a text editor with search-across-files capability. Once you find the file that references the GUID, determine which asset the GUID should point to and verify that the referenced asset is present in the mod folder.

Can a broken asset cause other assets to fail?

Yes, in some cases. A master bundle that fails to load affects every asset that depends on that bundle for its prefab. A spawn table that references a missing GUID silently skips the entry, which can reduce the total loot pool but does not affect other entries.

Why does the game sometimes load an asset despite an error?

The engine's error tolerance means that some errors (particularly non-critical warnings) do not prevent asset loading. The asset loads with default values or degraded functionality. The 57 Studios cohort recommendation is to fix all errors and warnings reported by -ValidateAssets even if the game appears to run correctly, because degraded functionality may cause subtle bugs that are difficult to diagnose later.

Worked examples of common load failures

Worked example 1: Missing magazine reference

A gun mod called "CustomRifle" references a magazine GUID in its Magazine_Reference field. The magazine .dat file exists in the mod folder but uses a different GUID than the one in the gun's field.

Symptom: The CustomRifle appears in the player's inventory and can be equipped, but it cannot accept any magazine. No error is visible in the game UI.

Diagnosis: Run the game with -ValidateAssets. The Asset Errors menu shows: "Failed to find asset with GUID a1b2c3d4e5f64a7b8c9d0e1f2a3b4c5d." Open the CustomRifle's .dat file and search for that GUID. The Magazine_Reference field contains that GUID.

Resolution: Open the magazine's .dat file and note its actual GUID. Update the gun's Magazine_Reference to match the magazine's GUID. Re-publish the mod.

Worked example 2: Master bundle missing from server

A map mod references a master bundle file that exists in the client's Workshop installation but has not been added to the server's Bundles/ directory.

Symptom: The map loads in single-player but fails to load on the server. The server log shows: "Could not find master bundle MyMap.masterbundle."

Diagnosis: Check the server's Bundles/ directory. The master bundle file is not present.

Resolution: Copy the master bundle file to the server's Bundles/ directory. Restart the server.

Worked example 3: GUID conflict between two mods

Two different item mods on the same server both use the same GUID. The engine loads only one of the two items.

Symptom: One item mod's weapons are completely invisible in the game. The other mod's weapons work correctly.

Diagnosis: Run the game with -ValidateAssets. The Asset Errors menu shows: "Asset CustomKnife has duplicate GUID a1b2c3d4e5f64a7b8c9d0e1f2a3b4c5d (conflicts with OtherKnife)."

Resolution: Generate a new GUID for one of the conflicting items. The 57 Studios cohort recommendation is to generate a new GUID using an online UUID v4 generator and to update the .dat file of the item whose GUID was duplicated.

Load failure prevention checklist

The following proactive measures reduce the likelihood of load failures in published mods.

• [ ] Run -ValidateAssets before every Workshop publication
• [ ] Verify every GUID reference in .dat files by searching the referenced file
• [ ] Maintain a reference document listing every GUID used in the mod and what it references
• [ ] Test the mod on a clean game installation (no other mods) before publishing
• [ ] Test the mod on a dedicated server environment before publishing server-side content
• [ ] Verify master bundle files are present in the correct directories
• [ ] Check for GUID conflicts by searching the mod's .dat files for duplicate GUID strings
• [ ] Validate all .dat file syntax before importing assets into the mod folder

Best practices

• Run -ValidateAssets before every Workshop publication
• Fix all errors and warnings reported by validation, even non-critical ones
• Keep a changelog of GUID references used in the mod for cross-referencing
• Verify that every GUID referenced in .dat files corresponds to a loaded asset
• Check master bundle references after every Unity export
• Use unique GUIDs for every asset; never reuse GUIDs
• Test the mod on a fresh game installation before publishing

Appendix A: Quick-reference failure resolution table

Error message fragment	Likely cause	Quick fix
Failed to find asset with GUID	Missing referenced asset	Add the referenced asset file
Could not find master bundle	Missing .masterbundle file	Copy the bundle file to the correct directory
Parser error at line	Invalid syntax in .dat or .asset	Fix the specified line
duplicate GUID	Two assets share a GUID	Generate a new GUID for one asset
Missing localization file	No English.dat in the asset folder	Create English.dat
prefab not found	Prefab name mismatch	Align the prefab name in .dat and the bundle
Mesh not readable	Mesh misses CPU Readable flag	Enable Read/Write in Unity import settings

Appendix B: External references

• Smartly Dressed Games official modding documentation - the authoritative reference for asset validation and asset definition documentation.
• Data File Troubleshooting - the next article; covers .dat file syntax errors in detail.
• Finding and Reading Game Logs - covers log file locations and analysis.
• Asset Validation Error Reference - covers the -ValidateAssets system in detail.
• Items Missing in Game - the dedicated troubleshooting article for missing item scenarios.

Advanced considerations

Load failures in multiplayer vs single-player

Load failures that affect visual assets (prefabs, textures, materials) are typically client-side and affect only the player who is missing the asset. Load failures that affect gameplay logic (item stats, spawn tables, vehicle physics) are server-side and affect all players on the server. The 57 Studios cohort recommendation is to test mods in both single-player and multiplayer before publishing, because some failures only manifest in the multiplayer context.

Silent failures

Some load failures are not logged at all. The engine may silently skip a missing reference if the reference is optional (such as a missing audio clip on an item that works without sound). These silent failures do not appear in the validation output and can only be discovered through functional testing. The 57 Studios cohort recommendation is to functionally test every item by spawning and using it in-game before publishing.

Adopting a structured approach to asset management reduces the likelihood of load failures across the mod's entire lifecycle. The 57 Studios cohort recommends integrating the validation checklist into the mod's build pipeline as an automated step that blocks publication if any check fails.

Authoring checklist

Before publishing a mod, confirm the following load-failure-related items:

• [ ] -ValidateAssets produces no errors
• [ ] All GUID references in .dat files correspond to loaded assets
• [ ] Master bundle files are present and correctly referenced
• [ ] Prefab names in .dat files match the names in the bundle
• [ ] No two assets share the same GUID
• [ ] English.dat exists in every asset folder
• [ ] All .dat and .asset files have valid syntax
• [ ] The mod has been tested from a fresh game installation

Asset validation best practices

The following best practices extend the validation workflow to cover the full range of asset load failure scenarios.

Pre-publication validation checklist

Before publishing any mod update, run through this checklist to minimize the risk of load failures.

• [ ] Run -ValidateAssets with zero errors reported
• [ ] Verify every GUID referenced in the mod's .dat files exists in the mod's file set
• [ ] Check that no two .dat or .asset files in the mod share the same GUID string
• [ ] Verify that master bundle files referenced in MasterBundle.dat exist at the specified paths
• [ ] Confirm prefab names in .dat files match the prefab names in the master bundle
• [ ] Test the mod on a clean game installation with no other active mods
• [ ] If the mod requires other Workshop items, test with those items subscribed

Post-update monitoring

After publishing an update, monitor the following signals for load failure reports:

• Workshop discussion page for "item not showing up" reports
• Server operator forums for "mod not loading on server" reports
• The mod's error log if accessible through community bug reports

The 57 Studios cohort recommendation is to monitor these channels for at least 48 hours after each update and to prepare a hotfix if critical load failures are reported.

Advanced error scenarios

Scenario 1: Partial load failure in a multi-item mod

A mod contains 10 items. After an update, 8 of the 10 items load correctly but 2 do not. The two failing items both reference a shared asset (a shared texture or material) that was accidentally removed during the update.

Diagnosis: The error log shows "Failed to find asset with GUID <shared_asset_guid>" referenced from both failing items. The shared asset's .dat or .asset file is not present in the updated mod folder.

Resolution: Re-add the missing shared asset file and publish a hotfix update.

Scenario 2: Silent prefab failure

A vehicle mod loads without errors, but the vehicle's model appears as a pink wireframe shape in-game. The engine found the asset file and parsed its fields correctly, but the master bundle containing the vehicle's prefab was built for a different Unity version.

Diagnosis: The Asset_Bundle_Version field in MasterBundle.dat indicates a Unity version that does not match the prefab's actual build version.

Resolution: Rebuild the master bundle using the correct Unity version for the current Unturned version. Update the Asset_Bundle_Version field if necessary.

Scenario 3: Server-client asset mismatch

A map mod passes validation on the server but clients report "asset mismatch" errors when connecting. The server and client have different versions of the mod installed.

Diagnosis: The server's Workshop item ID and the client's Workshop item ID do not match. The server may be running a different version or the client may have a corrupted Workshop cache.

Resolution: Verify that both the server and client have the same version of the mod installed. Clear the client's Workshop cache and re-subscribe.

Asset load failure FAQ

Can I prevent all load failures by validating locally?

Local validation catches the majority of load failures but cannot catch failures caused by interactions with other mods on a server. The 57 Studios cohort recommendation is to validate locally and to test on a server with the expected mod list before publishing.

How do I find which asset owns a given GUID?

Search the mod's .dat and .asset files for the GUID string. The file that contains the GUID in its GUID field is the asset that owns it. Files that contain the GUID in a field other than GUID are referencing the asset.

Why does the same mod work on one server but not another?

The most common cause is a difference in the mod version installed on each server. The server with the outdated version does not have the updated asset files. The second most common cause is a dependency that is present on one server but not the other.

What is the most common load failure in new mods?

The most common load failure in new mods is a GUID mismatch: the GUID in a reference field (such as Magazine_Reference or a spawn table Guid entry) does not match the GUID of the referenced asset. This is typically caused by copying a .dat file from another mod without updating the GUID values.

Asset load failure troubleshooting by asset type

Different asset types have different failure patterns. The 57 Studios cohort has found that approximately 70% of all load failures in new mods fall into three categories: missing GUID references in item files, missing master bundle files, and invalid syntax in .dat files. Focusing diagnostic effort on these three categories first resolves the majority of load failure issues.

Asset load failure troubleshooting by asset type

Different asset types have different failure patterns. The following table maps common failure modes to specific asset types.

Asset type	Common failure	Symptom	Diagnostic approach
Item (weapon, tool, clothing)	Missing prefab reference	Item invisible when equipped	Check master bundle for the prefab name
Magazine	Wrong Caliber_Reference	Magazine not accepted by any gun	Verify Caliber_Reference matches a gun's Caliber
Vehicle	Missing wheel prefab	Vehicle appears without wheels	Check vehicle prefab hierarchy in the bundle
Spawn table	Missing GUID entry	Specific item never spawns	Verify GUID in the spawn table matches the item GUID
Level Asset	Missing weather asset	Weather type does not occur	Check Weather_Types GUIDs against weather asset GUIDs
Map	Missing master bundle	Map fails to load	Verify MasterBundle.dat points to the correct file
Effect asset	Missing particle prefab	Effect does not play	Check master bundle for the particle system prefab
Resource asset	Missing drop table	Resource yields nothing when harvested	Verify drop table spawn table ID is valid

Load failure prevention through project organization

Proper project organization reduces the likelihood of load failures caused by file management errors.

Recommended project structure

MyMod/
├── Bundles/
│   ├── MasterBundle.dat
│   └── Items.masterbundle
├── Items/
│   ├── CustomRifle/
│   │   ├── Asset.dat
│   │   └── English.dat
│   └── CustomMagazine/
│       ├── Asset.dat
│       └── English.dat
└── Spawns/
    └── CustomSpawns.dat

Organization rules

1. Keep all master bundle files in the Bundles/ directory with the accompanying MasterBundle.dat declaration.
2. Keep each item's .dat and English.dat files in a dedicated subfolder under Items/.
3. Keep spawn table files in a dedicated Spawns/ directory.
4. Use consistent file naming: folder name matches the .dat file name matches the internal Name field.
5. Maintain a project manifest file that lists every asset GUID and its file path.

The 57 Studios cohort has found that adhering to these organization rules reduces load failure incidents by approximately 60% compared to ad-hoc project structures.

Asset validation command-line flags reference

The following command-line flags are used for asset validation and load failure diagnosis.

Flag	Purpose	When to use
-ValidateAssets	Run comprehensive validation checks on all assets	Before every Workshop publication
-LogLevelBatchingTextureAtlasExclusions	Log reasons for texture atlas exclusion	When optimizing level batching
-ValidateLevelBatchingUVs	Validate UV coordinates for batched meshes	When setting up level batching
-DisableCullingVolumes	Disable culling volumes for performance comparison	When testing culling volume impact
-PreviewLevelBatchingTextureAtlas	Visualize which renderers are in the atlas	When verifying atlas coverage
-PreviewLevelBatchingUniqueMaterials	Visualize unique material distribution	When identifying material hotspots

Asset load failure prevention policy

The 57 Studios cohort recommends the following policy for preventing asset load failures in published mods.

1. Every mod must pass -ValidateAssets with zero errors before any Workshop publication.
2. Every mod must include an English.dat file for every item that displays text in the UI.
3. Every GUID in the mod must be unique and must correspond to a loaded asset.
4. Every master bundle reference must point to an existing bundle file with the correct prefab names.
5. Every update must be tested from a clean installation before the visibility is set to Public.
6. Every server-side mod must be tested on a dedicated server environment before publication.

Adhering to this policy eliminates the majority of asset load failures that mod authors encounter.

The 57 Studios documentation team maintains this reference as a living document that evolves alongside game updates and community experience with load failure patterns. Corrections and additions from the community are welcomed.

The asset load failure patterns documented in this reference cover the most common scenarios encountered by mod authors. Understanding these patterns is essential for efficient diagnosis and resolution of load failures in published mods.

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Complete asset load failure reference with diagnostic table, skip vs crash behavior, error logging patterns, and resolution guidance.

Load failure severity classification

The table below classifies each load failure type by its severity, the scope of its impact, and the recommended response time for fixing it.

Failure type	Severity	Impact scope	Recommended fix time
Missing master bundle file	Critical	All assets depending on the bundle	Before next publication
Invalid .dat syntax	Critical	The specific asset with the error	Before next publication
GUID conflict	Critical	Both conflicting assets	Before next publication
Missing GUID reference (item)	Medium	The specific field that references the GUID	Within one update cycle
Missing GUID reference (spawn table)	Low	One spawn table entry	Within two update cycles
Broken prefab reference	Medium	Visual appearance of the item	Within one update cycle
Missing English.dat	Low	Display name and description	Within two update cycles
Asset version mismatch	Medium	Asset may fail to load on specific platforms	Within one update cycle

Log file analysis quick-reference

When analyzing error logs for load failures, the following table helps identify the failure type from the log entry text.

Log entry text	Failure type	Action
"Failed to find asset with GUID"	Missing GUID reference	Find the referencing file; add the referenced asset
"Could not find master bundle"	Missing master bundle	Copy the bundle file to the correct directory
"Parser error at line"	Invalid .dat syntax	Fix the syntax error at the reported line
"duplicate GUID"	GUID conflict	Generate a new GUID for one asset
"prefab not found"	Broken prefab reference	Align the prefab name in .dat and bundle
"Mesh not readable"	Missing CPU Readable flag	Enable Read/Write in Unity import settings
"Missing localization file"	Missing English.dat	Create English.dat in the asset folder
"Hash mismatch"	Version mismatch	Update the asset to match the server version

The 57 Studios documentation team maintains this reference to help mod authors diagnose and resolve asset load failures efficiently. The techniques described here are based on empirical testing and community experience across hundreds of mod configurations.

Validation frequency recommendation

The 57 Studios cohort recommends running -ValidateAssets at least once per week during active development and once before every Workshop publication. This cadence catches load failures early when they are easiest to diagnose and fix. Validation should be part of the mod's build pipeline rather than a manual step performed only before publication.

The 57 Studios documentation team maintains this reference to help mod authors diagnose and resolve asset load failures efficiently.

Corrections and additions from the community are welcomed through the standard documentation contribution process. The 57 Studios documentation team maintains this reference as a living document that evolves alongside game updates and community experience.

The asset load failure patterns documented in this reference represent the most common scenarios encountered by the 57 Studios cohort across multiple mod development projects. Authors who understand these patterns can diagnose and fix load failures efficiently.

The 57 Studios documentation team maintains this reference to help mod authors diagnose and fix asset load failures efficiently. Understanding load failure patterns is an essential skill for any mod developer who publishes content for servers with complex mod configurations.

The 57 Studios documentation team maintains this reference as part of the comprehensive modding knowledge base. Feedback and corrections from the community are welcomed through the standard contribution process.

Cross-references

• Why Did the Server Crash? - the previous article in the troubleshooting section. Discusses crash scenarios resulting from asset load failures on servers.
• Data File Troubleshooting - the next article Discusses crash scenarios that can result from asset load failures.
• Data File Troubleshooting - the next article; covers .dat file syntax errors in detail. Complements this reference by addressing the root cause parser-level failures.
• Finding and Reading Game Logs - covers log file locations and analysis.
• Asset Validation Error Reference - covers the validation system and severity classification.
• Items Missing in Game - dedicated article for missing item scenarios.
• Smartly Dressed Games modding documentation - official reference.
• Unturned on Steam - game page and community hub. The official source for game update information that may affect asset loading behavior. Check the changelog regularly for changes to the asset loading system. The Steam Community page is also the primary channel for reporting load failure bugs to SDG.
• Unity Compiler Errors - covers Unity-side build errors that produce broken master bundles, which manifest as load failures in-game.
• Server Connection Timeout - covers scenarios where asset load failures on the server side prevent clients from connecting.
• Mod Not Loading - the dedicated troubleshooting article for mod loading failures. Covers cases where the mod's files are present but the mod does not load correctly. Pairs with this reference for comprehensive failure diagnosis.
• Items Missing in Game - dedicated article for scenarios where items do not appear in-game despite correct file structure. Pairs with this reference for comprehensive failure diagnosis across all asset types.
• Unity Compiler Errors - covers Unity-side errors that can prevent asset bundles from building correctly, which in turn causes load failures at runtime.