Asset Validation Rules

Intermediate40-60 minutesWindowsNotepad++Unity Editor

Every asset the Unturned™ game loads, every .dat file, .asset file, Unity prefab, texture, mesh, and audio clip, passes through a validation system that checks for structural integrity, performance problems, and configuration errors. The validation system runs in two tiers: fast basic health checks that execute during every game startup, and slower comprehensive tests that execute when the -ValidateAssets command-line flag is passed to the game executable. A modder who runs validation before publishing catches mesh defects, missing materials, oversized textures, and reference errors before they reach players; a modder who skips validation ships bugs that the validation system was designed to catch.

This article is the 57 Studios™ canonical reference for the Unturned™ asset validation system. It documents every validation rule the game enforces, the diagnostic severity classification, the validation timing (at load time versus at runtime versus on-demand with -ValidateAssets), the required fields per asset type, the GUID uniqueness requirement, the reference integrity checks, the bundle path validation, the English.dat presence rules, and a comprehensive diagnostic table that maps every validation failure to its symptom, cause, and resolution.

Documentation source: This article references the official Smartly Dressed Games modding documentation for the asset validation specification and the -ValidateAssets command-line flag behavior.

Who this article is for

This article is written for Unturned™ mod authors who have completed at least one item or vehicle mod and are preparing it for publication to the Steam Workshop. It presupposes that the reader has read the Data File Format Reference and the Asset Definitions Reference and understands the syntax grammar and asset structure those articles document. If you are new to Unturned™ modding, publish your first mod before returning here, validation is a pre-publication step, not a getting-started step.

What you'll learn

• The two validation tiers: basic health checks at every startup, and comprehensive checks with the -ValidateAssets flag
• Every documented validation rule: navmesh readability, mesh readability, missing meshes, vertex count limits, missing materials, material count limits, texture readability, texture NPOT dimensions, and audio sample analysis
• The GUID uniqueness requirement and how duplicate GUIDs are detected
• Required field verification: which fields must be present for each asset type
• Type correctness validation: how the parser handles type-mismatched field values
• Reference integrity: how the game verifies that GUID references resolve to existing assets
• Bundle path validity: how the game checks that the bundle an asset references exists and is loadable
• English.dat presence rules: when the game requires a localization file and when it does not
• Validation timing: which checks run at load time versus at runtime versus on demand
• Error severity classification: how the game categorizes validation failures
• A diagnostic table mapping every validation failure to its symptom, cause, and resolution

Background: the two-tier validation system

The Unturned™ asset validation system is designed to catch problems at the earliest possible moment, during development and testing, before a mod reaches players. The system is organized into two tiers that trade speed for thoroughness.

Tier 1: startup health checks

During every game startup, as assets are loaded from the Bundles directory, the game runs a set of fast basic health checks on each asset. These checks are designed to complete within the normal startup time budget, they add negligible overhead to the loading process. Startup checks cover structural integrity: does the asset have a valid GUID and Type, can the referenced bundle be found, does the English.dat file exist where expected. Assets that fail a startup check are logged to Client.log and may be excluded from the loaded asset set, resulting in the item not appearing in-game.

Startup checks are always active. There is no flag to disable them, and there is no flag to make them more thorough. They represent the minimum validation bar every asset must pass to function in the game.

Tier 2: comprehensive validation with -ValidateAssets

When the game executable is launched with the -ValidateAssets command-line flag, a second tier of slower, more thorough checks executes. These checks inspect the Unity content that the asset references, meshes, textures, materials, audio clips, and report performance problems, missing or malconfigured content, and content that violates the asset authoring guidelines. The results are logged to Client.log and displayed in the Asset Errors menu, accessible from the game's main menu.

The -ValidateAssets flag adds measurable time to the startup sequence because it loads and inspects every mesh, texture, and material referenced by every asset. The time cost is proportional to the number and complexity of the assets being validated. For a typical mod project with dozens of items, the additional startup time is on the order of seconds; for a full map mod with thousands of assets, it can add minutes.

Unturned.exe -ValidateAssets

Pro tip

Run -ValidateAssets as the final step before publishing any mod. The flag catches defects that are invisible during normal single-player testing, a missing material on a rarely-seen LOD mesh, a texture with non-power-of-two dimensions that causes GPU sampling artifacts, a mesh with an unusually high vertex count that degrades server performance. These defects do not cause a visible error during gameplay but negatively affect the player experience and can generate bug reports after publication.

Startup validation: basic health checks

The following checks execute during every game startup on every loaded asset. These checks are the minimum bar; an asset that fails any of them will either not load or will load with degraded functionality.

GUID uniqueness

The game enforces that every loaded asset has a unique GUID. If two assets share the same GUID, the later-loaded asset overwrites the earlier one in the engine's internal registry. The game logs a warning when a GUID collision is detected during loading, but the startup continues, the overwritten asset is simply gone, and any references to its GUID resolve to the overwriting asset instead.

The GUID uniqueness check operates globally across all asset categories. A GUID collision between an item asset and a tag asset is treated the same as a collision between two item assets: the later-loaded asset wins.

For a complete diagnostic guide on GUID collision failures, see GUID Conflicts Between Mods.

Required identity fields

Every asset must carry a GUID field and a Type field. An asset definition file that is missing either field is logged as an error and the asset is not loaded. The GUID field must contain a non-empty value; an empty GUID field at the root level triggers the auto-generation behavior documented in the Asset Definitions Reference, but an empty GUID inside a Metadata block produces an asset with no GUID, which causes reference-resolution failures for any other asset that references it.

Required body fields per asset type

Each asset type has a set of fields that must be present for the asset to function correctly. Fields that are not present default to the C# type's default value, which may produce an asset that loads but behaves incorrectly.

Asset type	Required fields	Consequence of missing field
All item types	ID	Item cannot be spawned via console; cross-references by ID fail
Type Gun	Caliber	Gun cannot accept any magazine; effectively non-functional
Type Magazine	Caliber_Reference, Amount	Magazine cannot be loaded into any gun or has zero rounds
Type Melee	None explicitly required beyond identity	All damage fields default to 0; weapon deals no damage
Type Vehicle	ID	Vehicle cannot be spawned; cross-references fail
All assets	GUID, Type	Asset not loaded

Reference integrity at load time

At load time, the game performs basic reference validation: it checks that every ID-based cross-reference (a gun's Magazine field, a vehicle's Tire field) points to an asset that exists in the loaded set. References that cannot be resolved are logged as warnings. The referenced field is set to its default value (typically 0), and the asset loads without that cross-reference.

Reference type	Field example	Validation behavior
Within-category ID reference	Magazine 108	Verified against loaded asset IDs in the same category
Cross-category GUID reference	CategoryTag "732ee6ffeb18418985cf4f9fde33dd11"	Verified against loaded asset GUIDs globally
Legacy ID redirector reference	@give 4 with redirector AssetCategory Item	Verified through the redirector chain

Bundle path validity

The game checks that the bundle an asset references, whether through the master bundle hierarchy, a Master_Bundle_Override, or a same-name .unity3d file, exists and is loadable. An asset whose bundle cannot be found is logged as an error. The asset definition loads (the game has the text data), but the asset's prefab, textures, and audio are not available, resulting in an invisible or silent entity in-game.

English.dat presence

Each asset looks for a localization .dat file in the same directory, named for the current language (e.g., English.dat, French.dat, German.dat). If no English.dat file is present, the game falls back to an empty display name and description for English-language players. The absence of English.dat is not logged as an error at startup (because the game cannot know whether the omission is intentional), but it produces an item whose name displays as a blank string in the inventory.

The game's localization lookup follows the current language setting. If the player's language is French, the game looks for French.dat first; if that file is not present, it falls back to English.dat; if neither is present, the item has no display name. The cohort recommendation is to always provide at least an English.dat file, and to provide localized .dat files for every language the mod targets.

Comprehensive validation: -ValidateAssets checks

The following checks execute only when the -ValidateAssets command-line flag is active. They inspect the Unity content that the asset references and report performance, configuration, and optimization issues.

Navmesh readable check

Object navmeshes (navigation meshes used by the game's Recast pathfinding system to generate the level navmesh) should have the CPU Readable flag enabled in Unity. If the CPU Readable flag is disabled, Recast cannot read the mesh data from the CPU side and cannot generate the level navmesh. The validation check finds object navmeshes with the CPU Readable flag disabled and logs them.

The impact of a missing navmesh readable flag is silent and severe: AI entities (zombies, animals) cannot navigate around or through the object, and pathfinding through the level is broken. This check applies primarily to map objects and barricades that define the walkable surface; it does not apply to weapon prefabs or attachment models.

Mesh readable check

Most non-navmesh meshes do not need the CPU Readable flag enabled in Unity. Keeping the flag enabled causes the mesh data to be duplicated in RAM, one copy on the GPU for rendering and one copy on the CPU, which is unnecessary for most meshes. The validation check finds non-navmesh meshes with the CPU Readable flag enabled and recommends disabling it. This is a recommendation, not a hard error, because the core game content itself has many cases that still need cleanup.

Missing meshes

Mesh filters without a mesh assigned, and mesh renderers without a mesh filter, are detected and logged. A mesh filter with no mesh reference means the renderer has nothing to render, the object is invisible at that mesh slot. A mesh renderer with no mesh filter means the renderer has no source of vertex data and cannot render anything. Both conditions produce invisible or partially invisible entities.

Mesh vertex count limits

Meshes with unusually high numbers of vertices are flagged for optimization. The recommended vertex count thresholds differ between render meshes and collider meshes:

Mesh type	Recommended maximum vertices	Rationale
Render mesh	Higher threshold	Rendering complex meshes is GPU-optimized
Collider mesh	Lower threshold	Collision detection against complex meshes is slower than rendering complex meshes

The typical optimization for a high-vertex-count mesh is to remove unused faces and vertices. Many meshes imported from 3D modelling tools carry internal geometry, hidden faces, and sub-mesh detail that is not visible in the game and should be removed before export.

Missing materials

Renderers without materials are detected and logged. A renderer with no material renders with the default Unity material (typically magenta/pink), which produces the "pink item" appearance in-game. The validation check catches materials that were not assigned in Unity before the bundle was built, which is a common authoring mistake when creating new prefabs from imported 3D models.

One exception to this check is "DepthMask" renderers, which are set by the game for specific rendering passes and whose material is managed by the engine at runtime.

Material count limits

Renderers with high numbers of materials are flagged for optimization. Each individual material on a renderer requires a separate draw call, and excessive draw calls degrade rendering performance. The recommended practice is to have one material for each render type on an object, a material for the opaque surfaces and, if needed, a material for the transparent surfaces.

Material count	Recommendation
1-2	Normal; no action needed
3-5	Acceptable; consider consolidation if performance is a concern
6+	Flagged; consolidate materials where possible

The cohort practice is to keep material counts on item prefabs to two or fewer (one opaque, one transparent if needed). High material counts are more common on map objects and structures than on individual items.

Texture readable check

Most textures do not need the CPU Readable flag enabled in Unity. Disabling the flag means a copy of the texture is not kept in RAM, reducing the game's memory footprint. One documented exception is shirt and pants textures, which are layered on the CPU and require the CPU Readable flag to be enabled.

The validation check finds textures with the CPU Readable flag enabled and recommends disabling it for textures that do not need it. This check is a recommendation; the game functions correctly with readable textures, but the memory cost accumulates across many textures.

Texture NPOT check

Most textures should have power-of-two dimensions, dimensions that are powers of two on each axis, such as 1 x 2, 4 x 4, 64 x 32, 256 x 256, 1024 x 512, and so on. GPUs are best equipped for drawing textures at these resolutions, and non-power-of-two (NPOT) textures can cause sampling artifacts, increased memory usage, and degraded rendering performance.

Texture dimension	Power of two?	Recommendation
1024 x 1024	Yes	Optimal; standard for item textures
2048 x 1024	Yes	Acceptable for large object textures
500 x 500	No	Flagged; resize to 512 x 512
750 x 350	No	Flagged; resize to nearest power-of-two pair

Unity provides import options for scaling textures up or down to the nearest power of two. The cohort recommendation is to author textures at power-of-two dimensions from the start rather than relying on Unity's import-time scaling.

Audio sample check

Long audio clips with high sample frequencies are flagged for inspection. The check finds audio clips that are unusually large for their purpose, a short sound effect (a gunshot, a footstep) encoded as a long high-fidelity clip, for example. The check does not enforce a hard limit; it surfaces clips for the modder to review and decide whether the file size is justified.

Audio characteristic	When flagged	Typical cause
Long duration + high sample rate	File size disproportionate to use case	Full song encoded as a sound effect
High sample rate for simple effect	Unnecessary fidelity for a short clip	48 kHz sample rate for a 0.1-second click
Extremely long clip	Large file in the bundle	Unintended long recording or silence at end of clip

Validation timing: when each check runs

Understanding when each validation check executes helps the modder plan the testing workflow. Some checks run at load time (during every game startup), some at runtime (when the asset is first used), and some only on demand (with the -ValidateAssets flag).

Check	Timing	Scope
GUID uniqueness	Load time	All assets
Required identity fields	Load time	All assets
Required body fields	Load time	Per asset type
Reference integrity (ID)	Load time	Within-category references
Reference integrity (GUID)	Runtime	Cross-category references (resolved when first accessed)
Bundle path validity	Load time	All assets with bundle references
English.dat presence	Load time (fallback, not error)	All assets
Navmesh readable	-ValidateAssets only	Object navmeshes
Mesh readable	-ValidateAssets only	Non-navmesh meshes
Missing meshes	-ValidateAssets only	All mesh-referencing assets
Mesh vertex counts	-ValidateAssets only	All meshes
Missing materials	-ValidateAssets only	All renderers
Material counts	-ValidateAssets only	All renderers
Texture readable	-ValidateAssets only	All textures
Texture NPOT	-ValidateAssets only	All textures
Audio samples	-ValidateAssets only	All audio clips

Did you know?

GUID-based cross-category references are validated at runtime, not at load time. The game does not eagerly resolve every GUID reference during startup because the full set of loaded assets may not be complete until all mods have finished loading. Instead, a GUID reference is resolved the first time it is accessed, when a blueprint is opened, when a crafting recipe is checked, or when a redirector is followed. This means a broken GUID reference may not produce an error at startup but will fail silently when the player attempts to use the feature that depends on it.

Error severity classification

The validation system classifies each finding into one of three severity levels. The severity determines whether the finding blocks the asset from loading, whether it is logged as an error or a warning, and whether it appears in the Asset Errors menu.

Severity	Classification	Load behavior	Logged as	Example
Error	Asset cannot function correctly	Asset may be excluded from the loaded set	Error in Client.log	Missing GUID or Type field; duplicate GUID
Warning	Asset loads but has a performance or correctness issue	Asset loads and functions	Warning in Client.log	High vertex count; missing material; NPOT texture
Info	Informational finding; no functional impact	Normal operation	Informational entry	Non-critical mesh readable flag

The Asset Errors menu, accessible from the game's main menu, displays errors and warnings from the most recent validation run. The menu groups findings by asset and by check type, allowing the modder to triage issues systematically.

Diagnostic table: validation failures and resolutions

The following table documents every validation failure the system can detect, the symptom the modder observes, the most likely cause, and the recommended resolution.

Validation failure	Symptom	Cause	Resolution
Duplicate GUID	Item overwrites or is overwritten by another item	Two assets share the same GUID	Generate a fresh GUID for one of the assets; ensure uniqueness across all mod files
Missing GUID	Asset does not load	GUID field absent or empty inside Metadata block	Add a non-empty GUID field at the root level
Missing Type	Asset does not load	Type field absent from asset definition	Add the appropriate Type field
Missing ID	Item cannot be spawned via @give	ID field absent from item asset	Add a unique ID in the 50,000+ range
Unresolved magazine ID reference	Gun accepts no magazine; cannot fire	Gun's Magazine field references an ID that does not exist	Verify the magazine asset's ID; confirm the magazine is in the loaded mod set
Bundle not found	Item is invisible in-game; prefab does not load	Master bundle missing, Master_Bundle_Override incorrect, or bundle file not in expected location	Verify the bundle file exists; check the master bundle hierarchy; confirm Master_Bundle_Override spelling
Missing English.dat	Item has no display name in inventory	English.dat file not present in the asset's folder	Create English.dat with Name and Description fields in the asset's folder
Navmesh not readable	AI cannot navigate through/around object	Navmesh mesh has CPU Readable flag disabled in Unity	Enable the CPU Readable flag on the navmesh in Unity; rebuild the bundle
Mesh missing	Part of the model is invisible	Mesh filter has no mesh assigned, or mesh renderer has no mesh filter	Assign the mesh to the mesh filter in Unity; rebuild the bundle
High vertex count on render mesh	Rendering performance degradation	Mesh contains excessive vertices, often from high-detail imports	Remove unused faces and vertices in the 3D modelling tool; re-export; rebuild bundle
High vertex count on collider	Collision detection performance degradation	Collider mesh is too complex for efficient collision calculations	Simplify the collider mesh or use a primitive collider instead of a mesh collider
Missing material	Item or part of item renders pink/magenta	Renderer has no material assigned in Unity	Assign the material to the renderer in Unity; rebuild the bundle
High material count	Excessive draw calls; rendering performance degradation	Renderer has many separate materials	Consolidate materials; merge texture atlases; reduce to 1-2 materials per object
Texture CPU readable enabled unnecessarily	Increased RAM usage	Texture has CPU Readable flag enabled but does not need it	Disable the CPU Readable flag on the texture in Unity; rebuild the bundle
Texture NPOT dimensions	GPU sampling artifacts; increased memory usage	Texture dimensions are not powers of two	Resize the texture to power-of-two dimensions in the image editor or use Unity's import scaling
Long/high-freq audio clip	Large bundle file size; increased memory usage	Audio clip is longer or higher quality than needed for its use case	Trim silence from clip ends; reduce sample rate for short effects; compress appropriately
Reference to nonexistent GUID	Feature that uses the reference silently does nothing	GUID in CategoryTag, Effect, or other GUID field does not resolve to any loaded asset	Verify the GUID spelling; confirm the referenced asset is loaded; check for GUID collision
Legacy ID redirector chain broken	@give <ID> does not spawn the expected item	Redirector's TargetAsset points to a nonexistent GUID	Verify the redirector's TargetAsset GUID; confirm the target asset is loaded
Incorrect Asset_Bundle_Version	Shader artifacts or rendering errors after game update	Bundle was built with an older Unity version than what the game currently uses	Rebuild the bundle with the current Unity version; update Asset_Bundle_Version to match
Bypass_ID_Limit missing	Item with ID > 2000 does not load	Bypass_ID_Limit True field not present	Add Bypass_ID_Limit True to the asset definition

Cross-reference validation in detail

The reference integrity system validates two categories of cross-references: within-category ID references and cross-category GUID references.

Within-category ID references

ID-based references link assets within the same category. A gun references its default magazine by the magazine's ID; a vehicle references its tire model by the tire asset's ID. These references are validated at load time because the full set of assets in a category is known as soon as that category finishes loading.

The validation check verifies that the referenced ID exists in the loaded set. If it does not, the reference field is set to 0 (the default) and a warning is logged. The asset loads without that cross-reference, the gun has no default magazine, the vehicle has no default tire.

Cross-category GUID references

GUID-based references link assets across categories. A blueprint's CategoryTag field references a tag asset by GUID; a crafting recipe's Effect field references an effect asset by GUID. These references are resolved at runtime, when the player opens the crafting menu or triggers the effect.

The validation check (when -ValidateAssets is active) verifies that every GUID referenced in a field typed as a GUID reference resolves to a loaded asset. Unresolved references are logged as warnings. At runtime, an unresolved GUID reference produces no visible error, the referenced entity is simply absent, and the feature that depends on it does nothing.

Reference field	Reference type	Target category	Validation timing
Magazine	ID	Item (Magazine)	Load time
Sight	ID	Item (Sight attachment)	Load time
Caliber_Reference	ID	Item (linked by value, not by asset ID)	Load time
CategoryTag	GUID	Tag	Runtime (GUID resolution)
Effect	GUID	Effect	Runtime
TargetAsset	GUID	Any (redirector target)	Runtime
Landed_Barricade > GUID	GUID	Barricade	Runtime

Frequently asked questions

How do I run the -ValidateAssets check?

Launch the Unturned™ executable from the command line or from a shortcut with the -ValidateAssets flag appended. The full command is:

"C:\Program Files (x86)\Steam\steamapps\common\Unturned\Unturned.exe" -ValidateAssets

The game will start normally but execute the comprehensive validation checks during the loading sequence. Results are written to Client.log in the Unturned™ installation directory and displayed in the Asset Errors menu on the main menu.

Where do I find the Asset Errors menu?

The Asset Errors menu is accessible from the Unturned™ main menu. It displays the errors and warnings from the most recent validation run, grouped by asset and by check type. The menu is only populated when validation has been run, either during startup with -ValidateAssets or during normal loading when startup checks detect errors.

What is the Client.log file and where is it?

Client.log is the game's client-side log file, located in the Unturned™ installation directory alongside the game executable. Every validation finding, errors, warnings, and informational messages, is written to this file during loading. The file is a plain-text log that can be opened in any text editor. The log includes timestamps, severity levels, and the specific asset and field that triggered each finding.

Do validation errors prevent the game from loading?

Most validation errors do not prevent the game from loading. The game loads as many assets as possible and logs the errors for the modder to review. Only structural errors that prevent the asset from being understood at all, a missing GUID or Type field, a completely unparseable file, cause the asset to be excluded from the loaded set. All other validation failures produce warnings or informational entries, and the asset loads with the best-effort fallback behavior.

Can I run validation on a specific mod only, rather than on every loaded asset?

The -ValidateAssets flag validates every asset loaded by the game, vanilla content and mod content alike. There is no built-in mechanism to scope validation to a specific mod. The cohort practice is to run validation in an environment that loads only the mod being tested (a clean single-player session with no other mods active) and to focus on the findings that reference the mod's assets by name or GUID.

How do I check if a texture is a power-of-two size?

Open the texture file in any image editor or in File Explorer's Properties dialog. The width and height dimensions should each be a power of two: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, or 4096. The two dimensions do not need to be equal, 1024 x 512 is a valid power-of-two pair. Common non-power-of-two dimensions come from authoring a texture at an arbitrary resolution (e.g., 500 x 500) rather than at a standard power-of-two size.

What is the difference between a mesh collider and a primitive collider for validation purposes?

A mesh collider uses the exact vertex geometry of a mesh for collision detection, every vertex and face contributes to the collision shape. A primitive collider (box, sphere, capsule) uses a simple geometric shape that approximates the object's volume. Mesh colliders are more accurate but significantly slower for collision detection. The validation system flags high-vertex-count mesh colliders and recommends either simplifying the mesh or replacing it with a primitive collider.

Does the validation system check for correct C# type mapping of .dat fields?

No. The validation system does not verify that .dat field values match the expected C# types of the asset class properties. Type coercion, parsing a string value into an int, float, bool, or enum, is performed by the parser at load time, and invalid values are silently coerced to defaults. The validation system's role is to check Unity content (meshes, textures, materials, audio), not to type-check .dat field values. Modders should verify field types against the type-specific article for each asset type.

What happens if I ship a mod with validation warnings?

The mod will load and function. Validation warnings indicate performance issues, optimization opportunities, or potential problems, not functional defects. A mod with warnings is publishable, the warnings advise the modder about improvements, but the game does not block the mod from loading or functioning. The cohort recommendation is to resolve all errors and to review all warnings before publication, addressing those that affect the player experience.

Can I automate validation as part of a build pipeline?

Yes. Launching Unturned.exe -ValidateAssets from a script, waiting for the loading sequence to complete, and then parsing Client.log for error and warning entries is a viable automated-validation strategy. The log format is consistent across runs, and the asset names and GUIDs in the log entries are stable identifiers that can be matched against the mod project's asset set. The cohort practice for 57 Studios™ mod projects is to run validation as the final step in the build-and-publish pipeline, blocking publication if errors are present.

Best practices

• Run -ValidateAssets as the final step before publishing any mod to the Steam Workshop.
• Resolve every validation error before publication, errors indicate functional defects that will affect players.
• Review every validation warning and resolve those that affect the player experience (missing materials, high vertex counts, NPOT textures).
• Run validation in a clean single-player environment with no other mods active to isolate your mod's findings.
• Check Client.log after every validation run and keep a copy for reference during the fix cycle.
• Generate a fresh GUID for every asset and never reuse GUIDs, GUID collisions are among the hardest-to-diagnose validation failures.
• Add Bypass_ID_Limit True to every item asset with an ID above 2,000.
• Enable the CPU Readable flag on object navmeshes and disable it on all other meshes.
• Author textures at power-of-two dimensions from the start, resizing after the fact can introduce scaling artifacts.
• Keep material counts to two or fewer per renderer, consolidate materials and merge textures into atlases where possible.
• Always provide an English.dat file in every asset folder, even if the item's display name is obvious.

Appendix A: Validation checklist for mod publication

Use this checklist before publishing any mod to the Steam Workshop. Every item on this list should be confirmed before the mod ships.

• [ ] Run -ValidateAssets on the final mod build and review every finding in Client.log.
• [ ] Resolve all validation errors. No errors in the log.
• [ ] Review all validation warnings. Address those that affect gameplay, appearance, or performance.
• [ ] Confirm every asset has a unique GUID. No two assets share a GUID.
• [ ] Confirm every asset has a valid Type field.
• [ ] Confirm every item asset has a unique ID in the 50,000+ range and Bypass_ID_Limit True.
• [ ] Confirm every asset folder contains an English.dat file with Name and Description fields.
• [ ] Confirm the master bundle (MasterBundle.dat and .masterbundle file) is present and correctly configured.
• [ ] Confirm all magazine-caliber linkages between guns and magazines resolve correctly.
• [ ] Confirm all mesh renderers have materials assigned (no pink/magenta items).
• [ ] Confirm all textures are power-of-two dimensions.
• [ ] Confirm the CPU Readable flag is disabled on all textures (except shirts and pants) and all meshes (except navmeshes).
• [ ] Test in single-player: spawn every item, equip it, use it. Confirm every field behaves as intended.

Appendix B: Command-line validation reference

Unturned.exe -ValidateAssets

Launches Unturned with comprehensive asset validation.
Validation findings are written to Client.log and the Asset Errors menu.

Typical usage:
  1. Copy the mod's Bundles/ and Items/ folders into the game directory
  2. Launch with -ValidateAssets
  3. Wait for the main menu to appear
  4. Open Client.log in a text editor
  5. Search for your mod's asset names or GUIDs
  6. Review and resolve every finding

Appendix C: Asset Errors menu navigation

Main Menu → Asset Errors

Displays findings from the most recent validation run.
Grouped by:
  - Asset (by name and GUID)
  - Check type (navmesh, mesh, material, texture, audio)

Each finding shows:
  - Severity (error, warning, info)
  - The specific mesh, texture, or material that triggered the check
  - A brief description of the issue

Use the menu to triage issues by asset and by severity.

Worked example: a validation run on a new item mod

The following scenario traces the validation workflow for a typical item mod, a single custom melee weapon, through the full startup-plus-ValidateAssets pipeline. The scenario is composed from documented patterns observed across the cohort's mod-testing workflow.

Step 1: startup checks

The mod author launches Unturned™ without the -ValidateAssets flag to test the mod in single-player. The startup loading sequence processes the mod's .dat file and logs the following:

[INFO] Loaded asset: CustomKnife (GUID b3c4d5e6f7084a9b1c2d3e4f5a6b7c8d)
[INFO] English.dat found: Items/CustomKnife/English.dat
[INFO] MasterBundle.dat found: Bundles/MasterBundle.dat
[INFO] Asset bundle loaded: core.masterbundle

No errors or warnings. The startup checks confirm that the asset has a valid GUID and Type, that the English.dat file is present, and that the master bundle is reachable. The mod author proceeds to in-game testing and confirms that the weapon spawns, equips, and deals damage correctly.

Step 2: comprehensive validation

Before publishing, the mod author runs Unturned.exe -ValidateAssets and reviews Client.log. The comprehensive checks reveal two findings that the startup checks did not catch:

[WARN] CustomKnife: Mesh 'Blade' has 12400 vertices (recommended limit: 8000).
[WARN] CustomKnife: Texture 'CustomKnife_Albedo' is 1026x1024, non-power-of-two dimension (1026).

The vertex count warning indicates that the blade mesh, imported from a high-detail modelling session, carries more vertices than the recommendation. The NPOT warning indicates that the texture's width is 1026 pixels instead of 1024, a two-pixel discrepancy introduced during export from the image editor.

Step 3: resolution

The mod author addresses both findings:

1. Vertex count: The blade mesh is re-imported into the 3D modelling tool. Internal geometry, hidden backfaces from the blade's tang construction, and sub-millimeter bevel detail are removed. The optimized mesh has 4,200 vertices and re-exports correctly. The bundle is rebuilt.

2. Texture NPOT: The texture is reopened in the image editor and resized from 1026x1024 to 1024x1024 using a canvas crop (not a scale, scaling would introduce interpolation artifacts). The resized texture is re-imported into Unity. The bundle is rebuilt.

Step 4: re-validation

The mod author re-runs -ValidateAssets. The Client.log now shows:

[INFO] Loaded asset: CustomKnife (GUID b3c4d5e6f7084a9b1c2d3e4f5a6b7c8d)
[INFO] English.dat found: Items/CustomKnife/English.dat
[INFO] MasterBundle.dat found: Bundles/MasterBundle.dat
[INFO] Asset bundle loaded: core.masterbundle

No warnings. The mod passes validation and is ready for publication.

Validation pipeline flowchart

The following flowchart shows the complete validation pipeline from asset loading through to the final pass/fail report that the modder reviews before publication.

As shown in the flowchart above, the validation system operates as a two-stage pipeline. Tier 1 runs unconditionally on every startup and determines whether each asset can load at all. Tier 2 runs only when the modder explicitly requests it and provides the detailed performance and optimization feedback that drives pre-publication cleanup.

Validation checks by asset type

Different asset types are subject to different subsets of the comprehensive validation checks. An item weapon prefab is checked for mesh, material, and texture issues; a map object is also checked for navmesh readability. The following table maps each asset type to the validation checks that apply to it.

Asset type	Startup checks	Mesh checks	Material checks	Texture checks	Audio checks	Navmesh checks
Item (Melee, Gun, Magazine, Clothing, etc.)	GUID, Type, ID, English.dat	Vertex count, missing mesh	Missing material, material count	NPOT, readable flag	Audio sample	-
Vehicle	GUID, Type, ID, English.dat	Vertex count, missing mesh	Missing material, material count	NPOT, readable flag	Audio sample	-
Animal	GUID, Type, ID, English.dat	Vertex count, missing mesh	Missing material, material count	NPOT, readable flag	Audio sample	-
Object (map object)	GUID, Type, English.dat	Vertex count, missing mesh	Missing material, material count	NPOT, readable flag	Audio sample	Navmesh readable
Barricade	GUID, Type, ID, English.dat	Vertex count, missing mesh	Missing material, material count	NPOT, readable flag	-	Navmesh readable (if walkable)
Structure	GUID, Type, ID, English.dat	Vertex count, missing mesh	Missing material, material count	NPOT, readable flag	-	Navmesh readable (if walkable)
Resource	GUID, Type, ID, English.dat	Vertex count, missing mesh	Missing material, material count	NPOT, readable flag	-	-
Effect	GUID, Type, English.dat	-	-	NPOT, readable flag	Audio sample	-
Tag	GUID, Type	-	-	-	-	-
Redirector	GUID, Type, TargetAsset	-	-	-	-	-

The table shows that tag and redirector assets, which have no Unity bundle content, are subject only to the startup identity checks. Map objects and barricades carry the largest validation surface because they interact with the AI navigation system in addition to the rendering system.

Common failure-mode scenarios

The following scenarios document failure modes that recur across the cohort's mod-testing experience. Each scenario is a composite of documented patterns; the resolution path is validated against the validation rules documented in this article.

Scenario 1: the invisible weapon

A mod author publishes a new melee weapon to the Steam Workshop and receives a player report that the weapon is invisible when equipped. The .dat file is present and correctly authored; the mod loads without startup errors; the weapon can be spawned with @give and appears in the player's inventory. But when equipped, no model appears in the player's hands.

The validation investigation reveals that the master bundle MasterBundle.dat is not reachable through the hierarchy search. The mod author placed the MasterBundle.dat file in the mod's root Bundles/ directory, but the asset's folder is nested several levels deeper, and the distance between them causes the upward hierarchy search to terminate at a higher-level Bundles/ directory that contains a different MasterBundle.dat. The fix is to add Master_Bundle_Override <bundle-name> to the asset's .dat file, which bypasses the hierarchy search and points directly to the correct bundle.

Scenario 2: the pink magazine

A mod author publishes a custom magazine for an existing rifle mod and receives reports that the magazine model renders solid pink/magenta when held in the player's hands. The magazine functions correctly, it loads into the gun, the correct round count is displayed, and firing works, but the visual is wrong.

The validation investigation reveals that the magazine's prefab in the master bundle has a mesh renderer component but no material assigned. The missing-material check (a Tier 2 comprehensive validation check) would have caught this, but the mod author did not run -ValidateAssets before publication. The fix is to assign the material in Unity, rebuild the bundle, and republish.

Scenario 3: the enormous texture

A mod author receives a community report that a custom vehicle mod causes the game's memory usage to spike when the vehicle is in view. FPS drops measurably for players near the vehicle. The vehicle's visual quality is otherwise good, no pink materials, no invisible parts.

The validation investigation reveals that the vehicle's body texture is 4096x4096 pixels (a 4K texture) but the vehicle's body mesh is simple enough that the texture resolution is far higher than necessary. The texture readable flag is also enabled, causing a 64 MB copy of the texture to reside in system RAM in addition to the GPU copy. The fix is to reduce the texture to 2048x2048 (a quarter of the memory footprint), disable the CPU Readable flag, rebuild the bundle, and republish.

Scenario 4: the silent gunfire

A mod author publishes a custom rifle and receives reports that the gun makes no sound when fired. The rifle's model is visible, the firing animation plays, projectiles are spawned and deal damage, but there is no audio. The mod author confirms that the audio clip exists in the master bundle and that the gun's .dat file includes the correct audio field values.

The validation investigation reveals that the audio clip is encoded at 96 kHz with a 32-bit sample depth, formats that the Unturned™ audio system does not support. The parser loads the audio field correctly, but the runtime audio system cannot decode the clip and falls back to silence. The audio sample check in Tier 2 validation would have flagged this clip as unusually large for a gunfire effect. The fix is to re-encode the audio clip at 44.1 kHz, 16-bit, mono, in a supported format, rebuild the bundle, and republish.

Validation severity decision matrix

When the modder reviews validation findings, each finding must be classified as "must fix before publication", "should fix before publication", or "can ship with this finding". The following matrix provides the cohort-validated decision guidance.

Validation finding	Severity	Fix before publication?	Rationale
Missing GUID or Type	Error	Yes, must fix	Asset will not load
Duplicate GUID	Error	Yes, must fix	One asset overwrites the other
Missing ID	Error	Yes, must fix	Item cannot be spawned or referenced
Bundle not reachable	Error	Yes, must fix	Item is invisible; no model loads
Missing material	Warning	Yes, should fix	Pink/magenta rendering is a visible defect
Missing mesh	Warning	Yes, should fix	Missing geometry is a visible defect
Navmesh not readable	Warning	Yes, should fix for map objects	AI pathfinding breaks through affected area
High vertex count (render mesh, 2x+ over limit)	Warning	Yes, should fix	Performance impact on lower-end hardware
High vertex count (render mesh, 1-2x over limit)	Warning	Consider fixing	Minor performance impact
High vertex count (collider mesh)	Warning	Yes, should fix	Server-side collision cost affects all players
High material count (6+)	Warning	Yes, should fix	Excessive draw calls
High material count (3-5)	Warning	Consider fixing	Modest draw-call impact
Texture NPOT	Warning	Yes, should fix	GPU sampling artifacts; avoidable defect
Texture readable flag enabled unnecessarily	Warning	Consider fixing	RAM cost accumulates; fix for large textures
Audio clip unusually large	Warning	Consider fixing	Bundle size; fix for clips over 1 MB
Missing English.dat	Info (not an error)	Yes, should fix	Item has no display name; visible to players
CPU Readable on non-navmesh mesh	Info	Optional	RAM cost; low priority

Appendix D: Texture dimension reference for common mod asset types

The following table provides the cohort-recommended texture dimensions for common mod asset categories. Authoring textures at these dimensions from the start avoids NPOT validation findings.

Asset type	Recommended albedo texture	Recommended normal map	Notes
Small item (knife, pistol magazine)	512 x 512	512 x 512	Low screen footprint
Medium item (rifle, SMG)	1024 x 1024	1024 x 1024	Standard for most weapon mods
Large item (LMG, sniper rifle)	2048 x 1024	2048 x 1024	Rectangular UV layout common for long weapons
Small vehicle part (wheel)	512 x 512	512 x 512	Reused across multiple instances
Vehicle body	2048 x 2048	2048 x 2048	Largest screen footprint in the vehicle category
Map object (small, e.g., crate)	512 x 512	512 x 512	Viewed from variable distances
Map object (large, e.g., building)	2048 x 2048	2048 x 2048	May use multiple materials; one texture per material
UI element (icon, HUD)	256 x 256 or 512 x 512	Not typically needed	Power-of-two requirement still applies
Clothing (shirt, pants)	1024 x 1024	512 x 512	CPU Readable flag must be enabled for clothing textures

Cross-references

• Data File Format Reference, the syntax grammar for .dat and .asset files; every validation check assumes the file parses correctly.
• Asset Definitions Reference, the asset structure reference; documents the GUID, Type, and bundle-linkage fields that the validation system checks.
• Asset Bundle Custom Data, the next article; covers how individual .asset files specify bundle content overrides.
• Item Asset Anatomy, the shared field reference for all item types; lists the required fields per type.
• Master Bundle Export from Unity, the bundling workflow; the validation system checks the output of this workflow.
• GUID Conflicts Between Mods, diagnostic guide for the most common validation failure.
• Smartly Dressed Games modding documentation, the official specification for asset validation and the -ValidateAssets flag.
• Unturned on Steam, the Unturned™ store page; game updates may add or modify validation rules.

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Complete validation rules reference sourced from official SDG documentation.

Glossary

Term	Definition
Asset Errors menu	The in-game menu that displays findings from the most recent validation run
Client.log	The game's client-side log file, located in the Unturned™ installation directory
CPU Readable	A Unity import flag that keeps a copy of mesh or texture data in system RAM for CPU access
DepthMask	A special renderer type managed by the game engine for specific rendering passes
Draw call	A single instruction from the CPU to the GPU to render a batch of geometry with a specific material
LOD	Level of Detail, a lower-polygon version of a mesh used when the object is distant from the camera
Material count	The number of separate materials assigned to a renderer
Navmesh	Navigation mesh, a simplified representation of walkable surfaces used by AI pathfinding
NPOT	Non-Power-Of-Two, texture dimensions that are not powers of two on one or both axes
Recast	The pathfinding library Unturned™ uses to generate level navigation meshes
Reference integrity	The property that every ID and GUID cross-reference resolves to an existing asset
Startup checks	Validation checks that execute during every game startup
Tier 1 / Tier 2	The two validation tiers: fast startup checks and comprehensive -ValidateAssets checks
Vertex count	The number of vertex points in a mesh; higher counts increase rendering and collision cost
-ValidateAssets	The command-line flag that enables comprehensive asset validation