Items Missing in Game

A modder publishes an Unturned™ mod, joins a local game with the mod loaded, and goes to test the new items. The mod is enumerated in the game log. The bundle has loaded. But the items themselves are not available: /giveitem does not autocomplete the item name, the admin item spawn menu does not list the item, or /giveitem <id> returns "Invalid ID." The mod loaded, but the items did not.

The mod-loaded-but-items-missing pattern is a distinct troubleshooting scenario from a complete mod-load failure. The mod's meta.dat, bundle, and folder structure are all valid; the game has read them. The failure is in the item-level validation: a per-item field is missing, malformed, or conflicting with another asset. Identifying which item the failure applies to and which field is the cause is the central diagnostic task.

This article documents the eight most common causes of an Unturned item that does not appear in-game despite the mod loading successfully, identifies the symptom that points at each cause, and provides a resolution. The article assumes the modder has already confirmed the mod loads (per Mod Not Loading); items missing in a mod that does not load is a different problem and should be diagnosed there first.

Prerequisites

• The mod loads successfully (confirmed via Player.log — the mod's folder is enumerated and the bundle is read without error). If not, return to Mod Not Loading.
• Unturned installed and launchable.
• Admin access in the in-game console for testing item spawn commands.
• File Explorer access to the mod's output folder.
• Notepad++ or another text editor installed for inspecting .dat files.
• A backup of the mod's source folder before making changes.

What you'll learn

• How to confirm an item has been registered by Unturned.
• How to distinguish a missing item from a mis-named item.
• The required fields for an item's .dat file and the symptoms of each missing field.
• How to read the bundle inspector output to confirm prefab references are resolvable.
• How to verify that English.dat provides the autocomplete strings for the item.
• How to identify ID-range conflicts that cause the modder's item to be silently overridden.
• How to diagnose broken icon textures that make the item appear in inventory but with a missing icon.
• The cohort-validated test procedure for new item additions.

Background: how Unturned registers an item

Unturned's item registration is a multi-stage process. Each stage can fail silently, with the result that the item is not available in-game even though prior stages succeeded.

1. File enumeration: the game reads every .dat file in the mod's folder tree.
2. Asset type identification: the game reads the Type field in each .dat file. If the field is absent or invalid, the asset is skipped.
3. GUID validation: the game reads the GUID field. If absent or duplicate, the asset is skipped or overrides another asset.
4. ID validation: the game reads the ID field. If absent or in the reserved range, the asset is skipped or overrides a vanilla asset.
5. Required-field validation: the game checks for type-specific required fields (e.g., items require Rarity, weapons require Range, vehicles require Engine). If a required field is absent or invalid, the asset is skipped.
6. Prefab reference resolution: the game resolves the asset's references to bundle prefabs. If a referenced prefab is missing from the bundle, the asset is skipped or loads with a placeholder.
7. Display string lookup: the game reads English.dat (or the relevant language file) for the asset's display name and description. If missing, the asset loads with the raw ID as its name.
8. Asset database registration: the asset is added to the in-game database, available for spawn commands, admin panels, and inventory.

A failure at stages 1-6 produces a missing item. A failure at stage 7 produces an item whose name appears as a raw ID. A failure at stage 8 does not occur in practice; if stages 1-7 succeed, stage 8 succeeds.

Where to find the diagnostic information

The two diagnostic sources for items missing in-game are the Unturned Player.log and the in-game console.

Player.log

The Player.log records every asset registration attempt and the result. On Windows the log is at:

%LOCALAPPDATA%Low\Smartly Dressed Games\Unturned\Player.log

Search the log for the mod's folder name to find the registration entries. Each item produces a log line like "Registered item <name> with ID <id> and GUID <guid>," or an error line indicating the registration failed.

In-game console

The in-game console (accessed by pressing F1 in single-player or via the admin panel on a server) accepts diagnostic commands:

Command	Use
/giveitem <id>	Spawn an item by ID. "Invalid ID" indicates the ID is not registered.
/giveitem <name>	Spawn an item by name. Failure indicates English.dat is not providing the name.
/help	Lists registered commands; useful for confirming the mod's custom commands.
/listadminitems	(Admin only) lists every registered item. Useful for confirming an item is registered under a different ID than expected.

Did you know?

The in-game console's /giveitem command performs both an ID lookup and a name lookup. Pass an integer to look up by ID; pass a string to look up by name. The same command serves both diagnostic paths.

The eight causes

The table below summarises the eight causes documented in this article. Each row links the symptom to the cause and the resolution method.

Cause	Typical symptom	Resolution
1. ID in reserved range	Item overrides vanilla item or is overridden	Method 1
2. GUID typo in .dat	Item not registered; log shows GUID parse error	Method 2
3. Missing required field (Type, Rarity)	Item not registered; log shows field error	Method 3
4. Bundle missing referenced prefab	Item not registered; log shows reference error	Method 4
5. English.dat missing for this item	Item registered but shows raw ID as name	Method 5
6. Broken icon texture	Item appears in inventory with missing icon	Method 6
7. Item shadowed by load order	Item registered then immediately overwritten	Method 7
8. Item type incompatible with command	Item registered but not spawnable via /giveitem	Method 8

Diagnostic flow

Cause and remedy reference

Cause 1: ID in reserved range

Symptom: The item registered (Player.log shows the registration), but /giveitem <id> returns a vanilla item instead of the modder's item, or vice versa. The item ID is below 2000.

Root cause: Smartly Dressed Games reserves the ID range 0-2000 for vanilla Unturned content. Mod items with IDs in that range collide with vanilla items at lookup time. Which item wins depends on load order, which is not deterministic.

Why it happens: The modder did not know about the reserved range, or copied an ID from a tutorial that used reserved-range examples.

Fix:

1. Open the item's .dat file in Notepad++.
2. Locate the ID line.
3. Change the ID to a number above 2000. The cohort-recommended range for new mods is 50000+ to avoid collision with both vanilla and other major modders.
4. Update any references to the item's ID in other .dat files in the same mod.
5. Update any English.dat references if applicable.
6. Restart Unturned.
7. Test with /giveitem <new-id>. The modder's item should appear.

Prevention: The cohort recommendation is to reserve an ID range for each mod project at the start of development. The cohort maintains a public ID registry that lets modders claim ranges to avoid cross-mod collisions. See Project Folder Structure and GUIDs for the cohort's ID-allocation guidance.

Cause 2: GUID typo in .dat

Symptom: Player.log shows a "GUID parse error" or "Invalid GUID format" against the item's .dat file. The item does not register. /giveitem <id> returns "Invalid ID."

Root cause: The GUID field in the .dat file must be a valid GUID in the standard 8-4-4-4-12 hexadecimal format (e.g., aabbccdd-1234-5678-9abc-1234567890ab). A GUID with an extra character, a missing dash, or a non-hex character fails to parse.

Why it happens: The modder hand-typed the GUID and made a typo. Or the modder pasted a GUID with extraneous whitespace or a wrapping quote character.

Fix:

1. Open the item's .dat file in Notepad++.
2. Locate the GUID line.
3. Confirm the GUID is in the format xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx where every x is a hexadecimal digit (0-9 or a-f).
4. If the GUID is malformed, replace it with a freshly generated GUID. On Windows in PowerShell: [guid]::NewGuid().ToString().
5. Save the file (ANSI encoding — see How to Save a .dat File with Correct Encoding).
6. Restart Unturned and verify the item registers.

Prevention: Generate GUIDs programmatically rather than hand-typing them. The PowerShell [guid]::NewGuid().ToString() command is the cohort-recommended source.

Cause 3: Missing required field (Type, Rarity)

Symptom: Player.log shows "Could not register asset: missing required field <field>." The item does not register.

Root cause: Every Unturned asset type has a set of required fields in its .dat file. An asset with a missing required field is rejected at registration time.

Why it happens: The modder created the .dat file from scratch without consulting the field list for the asset type, or copied an old .dat from a previous Unturned release in which the field was not required.

The common required fields:

Asset type	Required fields
Item (generic)	Type, ID, GUID, Rarity
Weapon	Type, ID, GUID, Rarity, Range, Damage
Magazine	Type, ID, GUID, Rarity, Capacity
Attachment	Type, ID, GUID, Rarity, Caliber
Clothing	Type, ID, GUID, Rarity, Armor
Consumable	Type, ID, GUID, Rarity, Food, Water, Health
Vehicle	Type, ID, GUID, Engine, Wheels
Structure	Type, ID, GUID, Resource

Fix:

1. Read the Player.log to identify the missing field.
2. Consult the Smartly Dressed Games Modding Documentation for the asset type's full required-field list.
3. Add the missing field to the .dat file.
4. Restart Unturned and verify the item registers.

Prevention: The cohort recommendation is to use templates for each asset type, with every required field pre-populated. The 57 Studios cohort maintains a public template repository for the principal asset types.

Cause 4: Bundle missing referenced prefab

Symptom: Player.log shows "Could not resolve prefab reference <guid>" against the item's .dat file. The item does not register, or it registers as a placeholder with no visual representation.

Root cause: The .dat file references a prefab GUID that the bundle does not contain. The reference points at a prefab that was either never added to the bundle or was removed in a recent bundle rebuild.

Why it happens: The modder forgot to include the prefab in the bundle's include list. Or the prefab was deleted from the Unity project but the .dat file still references it. Or the prefab was renamed and the bundle now contains the renamed version under a different GUID.

Fix:

1. Open the Unity project.
2. Locate the prefab the .dat file references. Read the prefab's .meta file to confirm its current GUID.
3. Compare the GUID in .meta with the GUID in the .dat. If they differ, update the .dat to use the current GUID.
4. Open the bundle build configuration and confirm the prefab is in the include list.
5. Rebuild the bundle.
6. Copy the new bundle into the mod's output folder.
7. Restart Unturned and verify the item registers.

Prevention: The cohort recommendation is to use a bundle-validation script that compares every GUID referenced in the mod's .dat files against the GUIDs present in the bundle. The script catches missing references before they ship.

Pro tip

The bundle file can be inspected with Unity's AssetBundleBrowser package or with any third-party bundle inspector. The inspector lists every prefab in the bundle with its GUID. Comparing the inspector's list against the .dat references is the most reliable way to confirm references resolve.

Cause 5: English.dat missing for this item

Symptom: The item registers (Player.log shows the registration). /giveitem <id> works. The item appears in the player's inventory. The item's name displays as the raw numeric ID (e.g., "50001" instead of "Steel Sword"). The description is empty.

Root cause: Unturned reads display strings from English.dat (or the relevant language file) in the same folder as the item's .dat file. If English.dat is absent, the item registers without display strings and falls back to the raw ID.

Why it happens: The modder created the item's .dat file but did not create the matching English.dat. Or the English.dat was renamed, deleted, or placed in the wrong folder.

Fix:

1. Locate the item's folder under the mod's Bundles directory.
2. Confirm the folder contains both <ItemName>.dat and English.dat.
3. If English.dat is missing, create it. The minimum content is:

   Name <Display Name>
   Description <Description text>

4. Save the file with ANSI encoding.
5. Restart Unturned and verify the item displays its name correctly.

Prevention: Generate English.dat programmatically from the same source data that generates the item's .dat file. See Cause 2 in Mod Not Loading for the cohort's English.dat template approach.

Cause 6: Broken icon texture

Symptom: The item registers and appears in the player's inventory. The item slot shows a placeholder icon (typically a pink-and-black checkered texture or a generic question mark). The item is otherwise fully functional.

Root cause: The item's icon texture is missing from the bundle, the texture reference in the .dat file is incorrect, or the texture's import settings in Unity produced a corrupted texture.

Why it happens: The modder forgot to assign an icon texture in the Unity project. Or the texture was assigned but did not get included in the bundle. Or the texture import settings are incompatible with Unturned's icon rendering (e.g., the texture is not flagged as a Sprite).

Fix:

1. Open the Unity project.
2. Locate the prefab that represents the item.
3. Confirm the prefab has an icon Sprite assigned. The Sprite should be a 512x512 PNG with transparency.
4. Confirm the Sprite is included in the bundle's include list.
5. Open the Sprite asset's import settings. Confirm "Texture Type" is "Sprite (2D and UI)."
6. Rebuild the bundle.
7. Copy the new bundle into the mod's output folder.
8. Restart Unturned and verify the icon now appears.

Prevention: The cohort recommendation is to use a Sprite Atlas for all of a mod's icons. The atlas consolidates icons into a single texture and reduces the per-item bundle overhead. The atlas also makes it easier to verify every icon is included.

See My PNG Has a Checkered Background for the transparency-related variant of this failure.

Cause 7: Item shadowed by load order

Symptom: Player.log shows the item registered, then immediately shows "Overwriting existing asset with GUID <guid>" or "Replacing item ID <id> with new definition." The item is registered but the in-game lookup returns a different definition than expected.

Root cause: Another mod or vanilla content has registered an item with the same GUID or ID after the modder's item. The later registration replaces the earlier one.

Why it happens: A GUID or ID collision (see Causes 1 and 2 in this article, and GUID Conflicts Between Mods). The load order favours the other mod or vanilla content.

Fix:

1. Read the Player.log to identify the conflicting mod or content.
2. Decide which of the conflicting assets should win. The cohort recommendation is for the modder's mod to change its GUID and ID, leaving vanilla and previously published mods unchanged.
3. Open the item's .dat file in Notepad++.
4. Change the GUID and ID to unique values.
5. Restart Unturned and verify the item now wins the lookup.

Prevention: See GUID Conflicts Between Mods for the cohort's GUID-uniqueness validation workflow.

Cause 8: Item type incompatible with command

Symptom: The item registers and appears in the admin item list. /giveitem <id> returns "This command does not support assets of type <type>" or a similar error.

Root cause: The /giveitem command supports only certain asset types (items, magazines, attachments). Vehicles, structures, animals, and some other types are spawned with different commands.

The asset-type-to-command map:

Asset type	Spawn command
Item (weapons, consumables, clothing, etc.)	/giveitem <id> or /giveitem <name>
Vehicle	/vehicle <id> or /vehicle <name>
Structure / barricade	/barricade <id>
Animal	/animal <id>
Resource	/resource <id>

Fix:

1. Identify the asset type in the item's .dat file (the Type field).
2. Use the spawn command appropriate for that type.

This is the only cause in the table that is not a defect in the mod; it is a usage error. The "fix" is for the modder (or the player) to use the correct command.

Cause-by-symptom lookup

Symptom	Most likely causes
/giveitem returns "Invalid ID"	1, 2, 3, 4, 7
Item appears with raw ID as name	5
Item appears with missing icon	6
/giveitem returns wrong item	1, 7
Player.log shows GUID parse error	2
Player.log shows missing field error	3
Player.log shows prefab reference error	4
Player.log shows overwriting message	7
/giveitem rejects the asset type	8

Method comparison

Method	Time required	Risk level	Frequency in cohort survey
1. Move ID out of reserved range	5-15 minutes	Medium	Very high
2. Fix GUID typo	2 minutes	Low	Medium
3. Add missing required field	5 minutes	Low	High
4. Re-link bundle prefab references	10-30 minutes	Medium	Medium
5. Add English.dat	5 minutes	Low	Very high
6. Fix icon texture	10-30 minutes	Low	Medium
7. Resolve load-order shadowing	5-15 minutes	Medium	Medium
8. Use correct spawn command	1 minute	Low	Low

Advanced considerations

Confirming an item registered

The most reliable way to confirm an item has registered is to read the Player.log for the registration message. The message is typically of the form:

Loaded item Steel Sword for ID 50001 / GUID aabbccdd-1234-5678-9abc-1234567890ab

If the registration message is present, the item is registered. If it is absent, the item failed at some stage before registration; consult the surrounding log lines for the cause.

Using /listadminitems for verification

The admin command /listadminitems lists every registered item. The command's output is long (thousands of lines for a heavily modded install) but searchable. Filtering the output for the modder's ID range confirms exactly which of the modder's items are registered.

English.dat field reference

The English.dat file supports more fields than Name and Description. The full field set:

Field	Purpose
Name	Display name (required for /giveitem autocomplete)
Description	Inventory tooltip text
Char	Single-character abbreviation for compact UI displays
Rich Description	Rich-text variant with formatting tags (optional)

The cohort recommendation is to populate at least Name and Description for every item. The other fields are optional and rarely needed.

Icon dimensions and format

Unturned expects item icons in specific dimensions. The cohort-validated icon parameters:

Icon size	Pixel dimensions	Use
Inventory slot 1x1	512x512	Items occupying one inventory slot
Inventory slot 1x2	512x1024	Items occupying two vertical slots
Inventory slot 2x1	1024x512	Items occupying two horizontal slots
Inventory slot 2x2	1024x1024	Large items
Inventory slot 3x2	1536x1024	Long firearms

The icon should be a PNG with transparency on a transparent background. Format details are in My PNG Has a Checkered Background.

Bundle inspector tools

Unity's AssetBundleBrowser is the cohort-recommended bundle inspector. The package is installed via the Unity Package Manager:

1. Open Window → Package Manager.
2. Click the "+" button → "Add package from git URL."
3. Enter https://github.com/Unity-Technologies/AssetBundles-Browser.git.
4. Click Add.

After install, the inspector is available under Window → AssetBundle Browser. The inspector lists every bundle in the project with its contents, dependencies, and size.

Per-item debug logging

For items whose registration is failing in a way the Player.log does not document clearly, add a temporary debug-log statement to the item's load code (if the mod has custom code). The statement should write to the Unturned log via UnturnedLog.info(...). The log statement confirms whether the load code reached a specific point, which narrows the diagnosis.

Did you know?

The cohort survey found that approximately 79 percent of items-missing failures resolve within 15 minutes when the modder reads the Player.log registration messages first. The remaining 21 percent take longer because the underlying cause is in a less visible place (bundle prefab references, icon import settings, asset type / command mismatch).

Frequently asked questions

My item is in the .dat file but /giveitem says "Invalid ID." What's wrong?

The item failed to register. Read the Player.log for the registration attempt. The most common causes are: the ID is in the reserved range (Cause 1), the GUID has a typo (Cause 2), a required field is missing (Cause 3), or a bundle prefab reference cannot resolve (Cause 4). The log indicates which stage failed.

Why does my item show up with a number instead of its name?

Cause 5: English.dat is missing or in the wrong location. Unturned reads display strings from English.dat in the same folder as the item's .dat file. If the language file is absent, the item registers without display strings and falls back to the raw ID. The fix is to create or restore English.dat with the Name and Description fields.

My item works but the icon is a pink-and-black checkered texture. What's wrong?

Cause 6: the icon texture is missing from the bundle. The pink-and-black checker is Unity's default placeholder for a missing material or texture. The fix is to confirm the icon Sprite is assigned to the prefab, the Sprite is included in the bundle, and the texture import settings flag it as a Sprite (2D and UI). For the related transparency variant, see My PNG Has a Checkered Background.

What is the difference between an item's ID and its GUID?

The ID is a small integer (typically 5 digits for mod items) used for the in-game spawn commands and for save-file references. The GUID is a globally unique identifier in the standard 8-4-4-4-12 hex format used for cross-mod asset references and bundle resolution. Both must be unique across loaded content, but they serve different roles: the ID is for human use (short and easy to type), the GUID is for machine use (collision-resistant and bundle-stable).

My item appears in /listadminitems but /giveitem doesn't work. What's wrong?

Cause 8: the item's asset type does not support /giveitem. Vehicles use /vehicle, structures use /barricade, animals use /animal. Check the Type field in the .dat file and use the appropriate spawn command.

How do I know which fields are required for my item type?

Consult the Smartly Dressed Games Modding Documentation for the asset type's required-field list. The cohort also maintains type templates with every required field pre-populated; using a template prevents Cause 3 entirely.

Can I publish an item without an English.dat?

Yes, technically. The item will load and be spawnable by ID. The item's name will appear as the raw ID. The cohort recommendation is to never publish without an English.dat; the raw-ID display is visually broken from the player's perspective and reduces the perceived quality of the mod.

How many items can a single mod have?

There is no documented hard limit. The cohort has published mods with several hundred items in a single mod. The practical limit is bundle size (Unturned takes longer to load large bundles) and modder maintenance (more items means more potential failure points).

What does "Could not resolve prefab reference" mean specifically?

The .dat file references a prefab GUID that the bundle does not contain. The bundle was built without the referenced prefab, or the prefab's GUID has changed since the .dat file was last updated. The fix is to confirm the prefab is in the bundle's include list and that its current GUID matches the .dat reference.

How do I generate a GUID on Linux or Mac?

On Linux: uuidgen in any shell. On Mac: uuidgen in Terminal. Both commands emit a GUID in the standard format. The result is interchangeable with the PowerShell GUID on Windows; all three platforms produce GUIDs in the same format.

Why does my new item replace a vanilla item?

Cause 1: the item's ID is in the vanilla reserved range (0-2000). The modder's item is overwriting the vanilla definition (or being overwritten by it, depending on load order). The fix is to move the modder's ID above 2000.

Can I use the same icon for multiple items?

Yes. Each item's prefab references the icon Sprite by reference; multiple prefabs can reference the same Sprite. The bundle includes the Sprite once and the prefabs share the reference.

What if my Player.log doesn't show my mod at all?

The mod did not load. This is the case in Mod Not Loading, not this article. Return to the previous article to diagnose the load failure first.

Best practices

• Confirm the mod loads (Player.log shows enumeration) before diagnosing items missing.
• Read Player.log registration messages for every item before testing in-game.
• Use type templates for every new item; never start a .dat from a blank file.
• Generate GUIDs programmatically (PowerShell, uuidgen) rather than hand-typing.
• Reserve an ID range for each mod project; document the range in the README.
• Verify every item has an English.dat before publishing.
• Inspect bundles with AssetBundleBrowser before publishing to confirm every referenced prefab is present.
• Use Sprite Atlases for icons to simplify bundle management.

Cross-references

• Mod Not Loading — the previous article in the troubleshooting section. Diagnose mod-load failures there first; items missing assumes the mod loads.
• GUID Conflicts Between Mods — the next article. Cross-mod GUID conflicts produce the load-order shadowing of Cause 7.
• Unity Compiler Errors — compile errors that prevent the mod from being built at all.
• My PNG Has a Checkered Background — the icon transparency failure mode related to Cause 6.
• Project Folder Structure and GUIDs — the folder layout, ID-range allocation, and GUID-uniqueness guidance.
• Master Bundle Export — the bundle-export workflow.
• How to Save a .dat File with Correct Encoding — encoding guidance that prevents some .dat parse failures.
• Installing Mods — the installation workflow from the player's perspective.
• Publishing — the publishing workflow.
• Unity Asset Bundles Intro — Unity's official asset-bundle documentation.
• Smartly Dressed Games Modding Documentation — the official Unturned modding documentation, including the canonical required-field lists.
• Unturned on Steam — the game itself.

Appendix A: required field reference

The table below lists the required fields for the principal Unturned asset types. The list is sourced from the Smartly Dressed Games modding documentation as of the most recent Unturned release. Modders should consult the official documentation for the most current list.

Asset type	Required fields
Item	Type, ID, GUID, Rarity
Gun	Type, ID, GUID, Rarity, Range, Damage_Player, Damage_Zombie, Player_Damage, Zombie_Damage
Magazine	Type, ID, GUID, Rarity, Capacity, Caliber
Sight	Type, ID, GUID, Rarity, Caliber
Tactical	Type, ID, GUID, Rarity, Caliber
Grip	Type, ID, GUID, Rarity, Caliber
Barrel	Type, ID, GUID, Rarity, Caliber
Hat	Type, ID, GUID, Rarity, Armor
Shirt	Type, ID, GUID, Rarity, Armor
Pants	Type, ID, GUID, Rarity, Armor
Backpack	Type, ID, GUID, Rarity, Width_X, Height_Y
Vest	Type, ID, GUID, Rarity, Armor
Mask	Type, ID, GUID, Rarity
Food	Type, ID, GUID, Rarity, Food, Water, Health
Water	Type, ID, GUID, Rarity, Water
Medical	Type, ID, GUID, Rarity, Health
Vehicle	Type, ID, GUID, Engine, Wheels
Structure	Type, ID, GUID, Resource
Barricade	Type, ID, GUID
Animal	Type, ID, GUID, Behaviour

Appendix B: cohort case studies

Case study 1: the reserved-ID weapon

A mid-tenure cohort member published a sword mod and used ID 1234 because the number was easy to remember. In-game, /giveitem 1234 returned the vanilla Police Baton. The cohort diagnosis was Cause 1: ID 1234 is in the vanilla reserved range.

The fix was to renumber the sword to ID 50001 and republish. The cohort recommendation that resulted from the case study is to claim an ID range from the cohort registry before starting any new mod, and to use the bottom of the claimed range for the first item.

Case study 2: the GUID with extra whitespace

A new cohort member generated a GUID via PowerShell, copied the result into the .dat file, and accidentally included a trailing newline. The Unturned parser rejected the GUID with "Invalid GUID format." The Player.log showed the parse error but the modder did not check the log; they spent an hour wondering why the item did not register.

The fix was Method 2: remove the trailing newline. The cohort recommendation that resulted from the case study is to teach new cohort members to read Player.log as the first diagnostic step, before any other troubleshooting.

Case study 3: the missing Rarity field

A long-tenure cohort member migrated a legacy mod to a newer Unturned release. The legacy mod's items did not have the Rarity field, which was optional in the older Unturned release but became required in the newer release. The migrated items did not register.

The fix was Method 3: add Rarity Common to every item's .dat file. The cohort recommendation that resulted from the case study is to read the Unturned release notes after every Unturned update and to update mods against new required fields.

Case study 4: the prefab GUID that drifted

A mid-tenure cohort member rebuilt a complex mod after reorganising the Unity project's folder structure. Some prefabs got new GUIDs during the reorganisation (Unity should have preserved the GUIDs, but did not for prefabs that crossed an .asmdef boundary). The bundle still contained the prefabs but under their new GUIDs. The .dat files referenced the old GUIDs.

The fix was Method 4: update the .dat files to reference the new GUIDs. The cohort recommendation that resulted from the case study is to avoid reorganising the Unity project's folder structure once the project has shipped, or to validate every GUID reference after any reorganisation.

Case study 5: the icon without alpha channel

A new cohort member created icon textures in Photoshop and exported them as JPEGs because JPEG files are smaller. Unturned displayed the icons with the JPEG's background colour visible instead of transparent. The cohort diagnosis was that JPEG does not support an alpha channel; Unturned cannot display the icon with transparency.

The fix was to re-export the icons as PNG with transparent backgrounds. The cohort recommendation that resulted from the case study is to use PNG exclusively for icon textures. JPEG is acceptable for environmental textures (terrain, building exteriors) but not for icons.

Appendix C: pre-publish item validation checklist

The cohort's pre-publish item validation runs before every mod release. The checklist takes approximately 30 seconds per item and catches the causes documented in this article.

Step	Check	Pass criteria
1	ID above 2000	Yes
2	ID unique within mod	Yes, confirmed by registry script
3	GUID in standard format	Matches xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx pattern
4	GUID unique within mod	Yes, confirmed by registry script
5	Type field present	Yes
6	Type-specific required fields present	Yes, per Appendix A
7	English.dat present in same folder	Yes
8	English.dat has Name and Description	Yes
9	English.dat encoded as ANSI	Yes
10	Item .dat encoded as ANSI	Yes
11	Icon Sprite assigned to prefab	Yes
12	Icon dimensions match slot size	Yes, per icon table
13	Prefab included in bundle	Yes, confirmed by bundle inspector
14	All prefab GUIDs in .dat resolve in bundle	Yes
15	Test load in local install	Item registers and spawns

A modder who runs the checklist for every item before publishing reduces the rate of post-release items-missing failures to approximately 3 percent in the cohort survey data, compared to approximately 27 percent for releases without the checklist.

Closing note

Items missing in-game is the second-highest-volume troubleshooting category in the 57 Studios cohort survey, accounting for approximately 24 percent of all troubleshooting requests across the 2024 and 2025 cohort years. The eight-cause framework documented in this article covers the overwhelming majority of cohort-reported items-missing failures.

A modder who internalises the diagnostic flow and the cause-by-symptom lookup can typically resolve an items-missing failure within ten to twenty minutes from the first symptom. The pre-publish validation checklist in Appendix C is the cohort's strongest defensive practice; the 30-second-per-item cost catches almost every items-missing cause before it reaches subscribers.

The combination of Mod Not Loading (for whole-mod failures), this article (for whole-item failures), and GUID Conflicts Between Mods (for cross-mod conflicts) covers the cohort's complete troubleshooting flow for mod-load and item-registration issues.

Next steps

If the items missing failure traces to a GUID collision with another mod, continue to GUID Conflicts Between Mods. Return to the section overview at Troubleshooting for a list of all articles in this section.