Asset Bundle Custom Data ​

Intermediate40-60 minutesWindowsNotepad++Unity Editor

Asset bundle custom data is a Unity ScriptableObject that a modder can optionally create inside a master bundle to attach Unturned-specific metadata to the bundle itself. It is a separate concern from the item .asset files and the .dat files that configure individual items. Where an item .asset file defines one item and a .dat file defines the item's gameplay parameters, the asset bundle custom data object defines properties of the bundle as a whole: metadata that the engine reads at bundle load time and that applies to every item served by that bundle.

The single most important property that asset bundle custom data controls is workshop file ownership. The Owner Workshop File Id field prevents an asset bundle from being loaded if the bundle was not downloaded from the Steam Workshop file that the modder designated as the bundle's owner. This is a copy-protection mechanism: it stops a third party from extracting the bundle from a Workshop subscription, republishing it under a different Workshop item, and having the stolen bundle load successfully in the game. The field is simple to configure, but failing to configure it correctly can lock the modder out of their own bundle or, worse, ship a bundle with no copy protection at all.

This article is the 57 Studios™ canonical reference for the asset bundle custom data system. It documents the AssetBundleCustomData Unity ScriptableObject, the Owner Workshop File Id field, the creation workflow in the Unity Editor, the load-time verification that the engine performs, the diagnostic log messages that confirm correct configuration, and the copy-protection model that the field implements. The article is deliberately focused: the AssetBundleCustomData object supports a small number of properties, and the scope of this article is confined to those properties and their use. For the broader master bundle system, bundle building, and bundle loading, see Asset Bundles Reference.

Unity Inspector showing an AssetBundleCustomData ScriptableObject

Documentation source: This article references the official Smartly Dressed Games modding documentation for the AssetBundleCustomData object definition and the workshop file ID verification behaviour. Shipped Unturned game files have been inspected to confirm field behaviour and to provide worked examples of .asset files that interact with the custom data system.

Who this article is for ​

This article is written for Unturned™ mod authors who have a working master bundle, a Unity project with the Unturned modding package imported, and at least one item .asset file configured. The reader should understand the master bundle pipeline per Asset Bundles Reference and should be able to build and export a master bundle per Master Bundle Export. If you have not yet set up a master bundle, start with those articles before returning here. If you are new to Unturned modding and have not yet authored a single item, start with Project Folder Structure and GUIDs.

What you'll learn ​

  • What the AssetBundleCustomData Unity ScriptableObject is and where it lives in the bundle
  • How the Owner Workshop File Id field works and what it protects against
  • How to create the custom data object inside a Unity project
  • How to locate a Steam Workshop file's numeric ID
  • How to confirm that the engine has loaded the custom data at bundle load time
  • The behaviour of the engine when the Owner Workshop File Id check fails
  • How custom data interacts with the bundle's MasterBundle.dat configuration
  • Worked examples from the Unity Editor and from shipped game log output

Background: what asset bundle custom data is ​

Asset bundle custom data is an optional metadata layer that sits at the bundle level, distinct from the per-item metadata in .asset files and English.dat localization files. It is a Unity ScriptableObject of a specific type (AssetBundleCustomData) that must be created in the master bundle's root folder within the Unity project. If the object exists when the bundle is built and exported, the engine reads its properties at bundle load time and applies them to the loading and verification process.

The ScriptableObject is a Unity pattern: a serializable data container that stores configuration values independently of any scene or prefab. Unturned's modding package defines a custom ScriptableObject type called AssetBundleCustomData that the engine knows to look for when loading a master bundle. The engine searches the bundle's root asset folder for an object of this type, and if it finds one, it reads the fields and applies the configured behaviour.

Where the custom data lives in the Unity project ​

The AssetBundleCustomData object must be created in the master bundle's root folder inside the Unity project. The root folder is the folder specified by the Asset_Prefix field in the mod's MasterBundle.dat file. For a mod with Asset_Prefix Assets/MyModMasterBundle, the root folder is Assets/MyModMasterBundle in the Unity Project window. The AssetBundleCustomData object should be created directly in this root folder, not in a subfolder. If the object is placed in a subfolder, the engine may not locate it at load time, and the custom data fields will not be applied.

The flowchart above shows the creation and loading chain for asset bundle custom data. The critical constraint is that the object must be created in the correct folder: the folder whose path matches the Asset_Prefix value in MasterBundle.dat. If the modder creates the object in a different folder or renames the root folder after creating the object, the engine will not find the custom data at load time.

Owner Workshop File Id: workshop copy protection ​

The Owner Workshop File Id field is a uint64 that stores the Steam Workshop file ID of the Workshop item that is the authorized distributor of this bundle. When the engine loads a master bundle that contains an AssetBundleCustomData object with a non-zero Owner Workshop File Id, it checks the source of the bundle. If the bundle was loaded from a Steam Workshop file but the file's ID does not match the stored Owner Workshop File Id, the engine cancels the bundle load.

The protection model is straightforward: a bundle author sets Owner Workshop File Id to the ID of their Workshop item. When a player subscribes to that Workshop item, the bundle is downloaded to the player's Workshop content folder. When the engine loads the bundle from that folder, it knows the Workshop file ID of the item that provided the bundle, and it compares that ID to the Owner Workshop File Id stored in the bundle's custom data. If the IDs match, the bundle loads. If the IDs do not match, the bundle does not load.

What the field protects against ​

The Owner Workshop File Id field protects against a specific form of content theft: extracting a master bundle from one Workshop item and republishing it as part of a different Workshop item. Without this protection, a bad actor could subscribe to a mod, copy the .masterbundle file from the Workshop content folder, create a new Workshop item that includes the stolen bundle, and publish it. Players who subscribe to the stolen Workshop item would load the stolen bundle without any indication that the content was authored by a different modder.

With Owner Workshop File Id configured, the stolen bundle would fail to load when the engine detects that it was loaded from a Workshop file whose ID does not match the stored owner ID. The stolen Workshop item would appear to install correctly (the files would download) but the bundled assets would not load in the game. The thief cannot modify the stored Owner Workshop File Id because it is baked into the compiled bundle binary; altering it would require rebuilding the bundle in Unity, which the thief cannot do without the modder's original Unity project.

Scope of the protection

The Owner Workshop File Id field protects against Workshop-to-Workshop redistribution. It does not protect against a player who manually copies the bundle file into their local mod folder for personal use, nor does it protect against a player who extracts individual models or textures from the bundle using third-party tools. The protection is specific to the Workshop ecosystem: it prevents a stolen bundle from loading when the engine knows the bundle came from a Workshop file with a different ID.

Finding a Workshop file's ID ​

A Steam Workshop file's numeric ID is visible in the URL of the file's Workshop page. The URL follows the pattern:

https://steamcommunity.com/sharedfiles/filedetails/?id=<numeric ID>

The numeric ID appears after ?id= in the URL. For example, if the Workshop item's page URL is https://steamcommunity.com/sharedfiles/filedetails/?id=1234567890, the Workshop file ID is 1234567890. This is the value that should be entered into the Owner Workshop File Id field.

The Workshop file ID is not the same as the Workshop item's title or the modder's Steam profile ID. It is a unique integer assigned by Steam when the Workshop item is first created. The ID does not change when the item is updated. A modder who plans to set Owner Workshop File Id should create the Workshop item (even as a hidden draft) before configuring the custom data object, so that the file ID is known at the time of configuration.

What happens when the Workshop file ID is not known at build time ​

A common scenario: the modder is building the master bundle before creating the Workshop item. The Workshop file ID is not yet known because the item has not been created on Steam. In this scenario, the modder has two options:

  1. Leave Owner Workshop File Id at 0 (the default). Build and export the bundle, create the Workshop item, obtain the file ID, return to the Unity project, set the Owner Workshop File Id field, rebuild the bundle, and upload the rebuilt bundle as the first update to the Workshop item. The initial Workshop upload does not include the protection; the first update adds it. The brief window between initial upload and first update is unprotected, but for a new mod that has no subscribers and no visibility, this window is effectively risk-free.

  2. Create the Workshop item as a hidden draft first. Use the Steam Workshop web interface to create the item, set its visibility to "hidden," obtain the file ID from the draft's URL, set the Owner Workshop File Id field before the first bundle build, and upload the already-protected bundle as the initial Workshop file. This approach ensures the protection is in place from the first public moment of the mod's existence.

The cohort recommendation is option 2 for mods that the modder intends to distribute publicly. The extra step of creating a hidden Workshop draft before the first build is a small overhead that eliminates the unprotected window entirely.

The Workshop ecosystem and copy protection ​

The Steam Workshop is the primary distribution channel for Unturned mods. When a player subscribes to a Workshop item, Steam downloads the item's files to a content folder under Steam\steamapps\workshop\content\304930\<Workshop File ID>\. Unturned scans this directory alongside its own Bundles\ directory for mod content. Each Workshop subscription is isolated in its own folder, named by the Workshop file ID.

This folder-based isolation is what makes the Owner Workshop File Id protection work. When the engine loads a .masterbundle file from a Workshop content folder, it knows the Workshop file ID from the folder name. It compares that ID to the Owner Workshop File Id baked into the bundle. A bundle that was extracted from one Workshop item and placed in a different Workshop item's folder will trigger a mismatch: the folder's ID does not match the bundle's stored owner ID, and the bundle load is cancelled.

What copy protection does not cover ​

The Owner Workshop File Id field is a specific defence against a specific attack. It does not provide general-purpose digital rights management. Understanding the limits of the protection is as important as understanding what it covers.

ScenarioProtected?Notes
Subscriber extracts the bundle and uses it in a local mod folderNoLocal folders bypass the check
Subscriber extracts individual models or textures with third-party toolsNoThe protection operates at the bundle load level, not the individual asset level
Another modder rebuilds the bundle in Unity (requires the original Unity project)YesThe rebuilt bundle would have a different Owner Workshop File Id, but the modder needs the source project
Another modder republishes the raw bundle under a different Workshop itemYesThe stolen bundle's stored ID does not match the new Workshop item's ID
Modder publishes a mod and then loses access to the Workshop accountNoThe protection does not prevent the legitimate owner from being locked out

The protection is a Workshop-to-Workshop redistribution barrier. It is effective against the specific threat model of content theft through Workshop republication. It does not, and cannot, protect against a determined attacker with the technical skill to extract individual assets or to reverse-engineer the bundle format.

The relationship between Steam accounts and Owner Workshop File Id ​

The Owner Workshop File Id field stores a Workshop file ID, not a Steam account ID. A Workshop file is associated with a Steam account (the account that created it), but the custom data field references the file, not the account. If a modder transfers a Workshop item to a different Steam account (through Steam's item transfer process, where available), the Workshop file ID remains the same, and the Owner Workshop File Id does not need to be updated. If a modder creates a new Workshop item under a new Steam account, the new item has a new file ID, and the Owner Workshop File Id must be updated to match.

How the engine discovers and reads AssetBundleCustomData ​

The engine's discovery process for the AssetBundleCustomData object is a specific sequence that runs once per bundle load. Understanding this sequence helps diagnose cases where the custom data is configured but not found.

The flowchart above shows the discovery and verification chain. The critical detail is that the engine searches by ScriptableObject type, not by filename. The modder can name the AssetBundleCustomData object anything; the engine will find it as long as it is in the correct folder in the Unity project and the correct bundle. The engine does not search subfolders; it searches only the root folder path that matches Asset_Prefix. If the object is placed in Assets/MyModMasterBundle/Subfolder/CustomData.asset, the engine will not find it, even though it is in a subfolder of the correct root.

How to create and configure AssetBundleCustomData ​

The creation and configuration procedure has five steps, all performed inside the Unity Editor with the Unturned modding package imported.

Step 1: Locate the master bundle root folder ​

In the Unity Project window, navigate to the folder that matches the Asset_Prefix value in the mod's MasterBundle.dat. For a typical mod project, this is a folder directly under Assets/ with a name that identifies the mod, such as Assets/MyItemPackMasterBundle. If the modder is unsure of the root folder path, open MasterBundle.dat in Notepad++ and read the Asset_Prefix value: the part after Assets/ is the folder name to find in the Project window.

Step 2: Create the AssetBundleCustomData object ​

Right-click inside the root folder in the Project window and navigate the context menu:

Create > Unturned > Asset Bundle Custom Data

Selecting this option creates a new AssetBundleCustomData object in the root folder. The default name is something like NewAssetBundleCustomData; rename it to a descriptive name such as MyModCustomData. The name does not affect the engine's behaviour (the engine searches by type, not by name), but a descriptive name helps the modder identify the object in the Project window.

Step 3: Set the Owner Workshop File Id field ​

With the AssetBundleCustomData object selected in the Project window, view the Inspector window. The Inspector shows the object's configurable properties. For the current AssetBundleCustomData type, the only configurable property is Owner Workshop File Id. Enter the Workshop file's numeric ID into this field.

The field accepts a uint64 value. Enter the Workshop file ID as a plain integer without commas, spaces, or formatting characters. For example, enter 1234567890, not 1,234,567,890.

Step 4: Verify the object is included in the bundle ​

With the AssetBundleCustomData object still selected, confirm in the Inspector that the object is assigned to the correct asset bundle. The asset bundle assignment dropdown is at the bottom of the Inspector window. The bundle name should match the bundle name assigned to the other assets in the mod. If the custom data object is not assigned to any bundle, it will not be included in the exported .masterbundle file, and the engine will not find it at load time.

Step 5: Build, export, and verify ​

Build and export the master bundle using the master bundle tool per the workflow documented in Asset Bundles Reference. After export, copy the bundle and MasterBundle.dat to the mod's test folder, launch Unturned in single-player, and check the game's log file for the diagnostic message that confirms the custom data was loaded.

Diagnostic log messages ​

The engine writes log messages at bundle load time that confirm whether the custom data was found and loaded. These messages are the primary diagnostic tool for verifying that the AssetBundleCustomData object is configured correctly.

The success message follows the pattern:

Loaded (bundle name) custom data from (path)

For example, a successfully loaded custom data object for a bundle named MyItemPack.masterbundle might produce:

Loaded MyItemPack.masterbundle custom data from Assets/MyItemPackMasterBundle/MyModCustomData.asset

The "not found" message (when the bundle contains no custom data object) follows the pattern:

Tried loading (bundle name) optional custom data from (path)

For example:

Tried loading MyItemPack.masterbundle optional custom data from Assets/MyItemPackMasterBundle

The distinction between the two messages is important for diagnosis. The "Loaded" message confirms that the object was found and its fields were read. The "Tried loading" message means the engine looked for the object but did not find one; this is normal behaviour for bundles that do not include custom data and is not an error. If the modder expected custom data to load and sees the "Tried loading" message instead, the likely causes are: the AssetBundleCustomData object was placed in the wrong folder, the object was not assigned to the asset bundle, or the object was not included in the exported bundle (check the manifest file).

Pro tip

The log file is located at Unturned_Data/output_log.txt in the Unturned installation directory (Windows standalone client). On Steam, the log can also be accessed by adding the launch option -logfile and checking the generated file in the Unturned installation directory. The log file is overwritten on each game launch, so inspect it immediately after testing.

Owner Workshop File Id verification behaviour at load time ​

When the engine loads a master bundle that contains an AssetBundleCustomData object with a non-zero Owner Workshop File Id, it performs the following verification steps:

  1. The engine determines the load source of the bundle. Is the bundle being loaded from a Steam Workshop content folder, or from a local mod folder?
  2. If the bundle is loaded from a local mod folder (not a Workshop subscription), the verification is skipped. The Owner Workshop File Id field is not checked for locally installed mods because there is no Workshop file ID associated with the load source. This means a modder can test a bundle with Owner Workshop File Id configured on a local installation without requiring the Workshop item to be published.
  3. If the bundle is loaded from a Steam Workshop content folder, the engine reads the Workshop file ID of the item that provided the bundle.
  4. The engine compares the source Workshop file ID to the Owner Workshop File Id stored in the custom data. If the values match, the bundle loads normally. If the values do not match, the engine cancels the bundle load and writes a diagnostic message to the log.

The verification is performed once, at bundle load time, before any item from the bundle is loaded. If the verification fails, every item that depends on the bundle fails to load (because the bundle itself was not loaded). The failure is not reported to the player through an in-game popup or error message; the only visible symptom is that items from the bundle appear with placeholder meshes or are invisible. The log file is the sole source of diagnostic information about a failed verification.

The zero-value behaviour ​

An Owner Workshop File Id of 0 (the default value for an unconfigured field) means "no owner restriction." A bundle with Owner Workshop File Id 0 will load from any Workshop file, from any local folder, with no verification. This is the appropriate setting for bundles that are in active development (where the Workshop file ID is not yet known) and for bundles that the modder does not intend to protect (public-domain mods, open-source mod projects, mods distributed outside the Workshop ecosystem).

Setting Owner Workshop File Id to 0 after it has been set to a non-zero value permanently removes the copy protection. The cohort recommendation is to set Owner Workshop File Id to the Workshop file ID as early as practical in the mod's public lifecycle and to never set it back to 0 after the mod is published.

Interaction with MasterBundle.dat and the broader bundle system ​

The AssetBundleCustomData object is an independent layer from the MasterBundle.dat declaration file. The MasterBundle.dat file tells the engine that a master bundle exists, what it is named, what its Unity asset prefix is, and what version it uses. The AssetBundleCustomData object tells the engine what Workshop file owns the bundle. The two files work together but are configured separately: MasterBundle.dat is a plain text file in the mod's file hierarchy; AssetBundleCustomData is a Unity ScriptableObject baked into the compiled bundle.

The AssetBundleCustomData object must be created in the Unity project, assigned to the asset bundle, and exported as part of the .masterbundle file. It does not exist as a separate file in the mod's folder structure after export; it is embedded inside the .masterbundle binary. The MasterBundle.dat file, by contrast, is a separate text file that sits alongside the .masterbundle file in the mod's folder structure. Both must be present and correctly configured for a mod that uses copy protection.

The flowchart above shows the relationship between the on-disk files and the internal bundle structure. The MasterBundle.dat file and the .masterbundle file are separate files in the mod folder. The AssetBundleCustomData object lives inside the .masterbundle file, alongside the prefabs and materials. The engine reads the MasterBundle.dat to locate the bundle, loads the bundle, and then scans the bundle's contents for an AssetBundleCustomData object.

Worked example: configuring Workshop copy protection ​

This worked example walks through the complete process of configuring Workshop copy protection for a hypothetical mod called "Custom Rifle Pack." The mod has a Unity project with a master bundle root folder at Assets/CustomRiflePackMasterBundle. The modder has created the Workshop item and obtained the file ID 2945678901.

Step 1: Verify the root folder ​

Open the Unity project. In the Project window, navigate to Assets/CustomRiflePackMasterBundle. Confirm that this folder contains the mod's prefab subfolders (Guns/, Magazines/, etc.) and that it matches the Asset_Prefix value in the mod's MasterBundle.dat.

Step 2: Create the AssetBundleCustomData object ​

Right-click Assets/CustomRiflePackMasterBundle in the Project window. Select Create > Unturned > Asset Bundle Custom Data. A new object appears. Rename it from the default name to CustomRiflePackCustomData.

Step 3: Configure the field ​

Select CustomRiflePackCustomData in the Project window. In the Inspector, the Owner Workshop File Id field is visible. Enter 2945678901. Press Enter to confirm the value.

Step 4: Assign to the asset bundle ​

At the bottom of the Inspector, locate the asset bundle assignment dropdown. Select the bundle name that matches the mod's bundle (e.g., customriflepack). Confirm that the bundle name is the same name assigned to the prefabs and other assets in the project.

Step 5: Export the bundle ​

Open Window > Unturned > Master Bundle Tool. Confirm that the customriflepack bundle is checked as a master bundle. Set the export destination to the mod's Bundles\ folder. Enable the multiplatform toggle. Click Export.

Step 6: Verify the log output ​

Copy the exported bundle files and the MasterBundle.dat to the mod's test folder. Launch Unturned in single-player. After the game loads, quit and open the output log file. Search for the string "custom data." Confirm that the log contains a line matching:

Loaded customriflepack.masterbundle custom data from Assets/CustomRiflePackMasterBundle/CustomRiflePackCustomData.asset

If the log shows this line, the custom data object was found and loaded. The copy protection is active.

Worked example: verifying that copy protection blocks unauthorized loading ​

This worked example demonstrates how to confirm that the Owner Workshop File Id protection is working as intended. The test requires the Workshop item to be published (or at least uploaded as a hidden draft) so that a Workshop file ID is associated with the bundle.

Step 1: Publish the mod with Owner Workshop File Id configured ​

Upload the mod to the Steam Workshop with the Owner Workshop File Id field set to the Workshop item's file ID. The uploaded bundle contains the custom data object with the correct owner ID.

Step 2: Subscribe to the Workshop item ​

On the same machine (or a different machine, if available), subscribe to the Workshop item through the Steam client. Allow the Workshop content to download.

Step 3: Locate the downloaded bundle ​

Navigate to the Steam Workshop content folder for Unturned, typically at:

Steam\steamapps\workshop\content\304930\<Workshop File ID>\

Open the folder corresponding to the Workshop file ID. Confirm that the .masterbundle file is present.

Step 4: Create a test mod that references the stolen bundle ​

Create a new, empty mod in the local Workshop\Content\304930\ folder. Copy the stolen .masterbundle file into this folder. Copy the MasterBundle.dat from the downloaded Workshop folder. Rename the MasterBundle.dat's Asset_Bundle_Name to match the copied .masterbundle filename if necessary. The test mod now has a copy of the bundle that was downloaded from the Workshop, but the bundle is being loaded from a local folder with no Workshop file ID association.

Step 5: Test loading the stolen bundle ​

Launch Unturned in single-player. The bundle should load successfully from the local mod folder because the engine skips the Owner Workshop File Id check for local installations. The protection does not block local loading.

Step 6: Simulate Workshop-to-Workshop theft ​

To fully simulate the theft scenario, the thief would need to create a new Workshop item (with a different file ID) containing the stolen bundle. Subscribing to that stolen item would cause the engine to load the bundle from a Workshop content folder. The engine would detect that the Workshop file ID of the stolen item does not match the Owner Workshop File Id stored in the bundle, and the bundle load would be cancelled. The modder who originally authored the bundle can verify this by checking that the stolen Workshop item's subscribers report missing assets in the game.

Best practices ​

  • Create the AssetBundleCustomData object in the master bundle's root folder, not in a subfolder. The engine expects the object at the root level.
  • Obtain the Workshop file ID before configuring the Owner Workshop File Id field. Create the Workshop item as a hidden draft if the file ID is not yet known.
  • Verify the log output after every bundle export that includes custom data. The "Loaded ... custom data from ..." message confirms correct configuration.
  • Never set Owner Workshop File Id back to 0 after the mod is published. Doing so permanently removes the copy protection.
  • Confirm that the AssetBundleCustomData object is assigned to the same asset bundle as the mod's other assets. An unassigned object is not included in the export.
  • Check the bundle manifest file after export to confirm that the custom data object appears in the asset list. If it is absent, reassign the bundle name and rebuild.
  • Document the Owner Workshop File Id value in the mod's project notes. If the Unity project is lost and recreated, the same file ID must be used to rebuild a protected bundle that is compatible with the existing Workshop item.

Frequently asked questions ​

What is the AssetBundleCustomData ScriptableObject? ​

It is a Unity ScriptableObject type defined by the Unturned modding package. When created inside a master bundle's root folder and included in the exported bundle, the engine reads its properties at bundle load time and applies the configured behaviour. Currently, the only configured property is Owner Workshop File Id, which provides Workshop copy protection.

Does every master bundle need an AssetBundleCustomData object? ​

No. The AssetBundleCustomData object is optional. A bundle without custom data loads and functions normally; the engine simply logs the "Tried loading ... optional custom data from ..." message and proceeds. If the modder does not need Workshop copy protection (because the mod is for personal use, local-only distribution, or open-source collaboration), the custom data object can be omitted entirely.

What happens if I set Owner Workshop File Id to the wrong value? ​

If the Owner Workshop File Id does not match the actual Workshop file ID of the item that distributes the bundle, the bundle will fail to load for any player who subscribes through the Workshop. The bundle loads correctly during local testing (because the check is skipped for local installations) but fails when Workshop subscribers try to use the mod. The fix is to correct the Owner Workshop File Id field in the Unity project, rebuild the bundle, and upload the corrected bundle as an update to the Workshop item.

Can I set Owner Workshop File Id for a mod distributed outside the Steam Workshop? ​

Yes, but the field will have no effect. The Owner Workshop File Id check is only performed when the engine knows that the bundle was loaded from a Steam Workshop content folder. Bundles distributed outside the Workshop (direct download, third-party mod sites, local installation) are loaded without the Workshop file ID check. Setting Owner Workshop File Id on a non-Workshop mod is harmless but unnecessary.

Can multiple Workshop items share the same Owner Workshop File Id? ​

No. Only one Workshop item should set its Owner Workshop File Id to match its own file ID. If two different Workshop items distribute the same bundle with the same Owner Workshop File Id, one of them will fail the check (the one whose file ID does not match the stored value). The cohort recommendation is one Workshop item per bundle, with the bundle's Owner Workshop File Id matching that item's file ID.

How do I remove copy protection from a published mod? ​

Rebuild the bundle with Owner Workshop File Id set to 0 (the default), export the bundle, and upload the rebuilt bundle as an update to the Workshop item. The updated bundle will load from any source without verification. Note that removing copy protection is irreversible for the bundles already downloaded by subscribers: once the unprotected bundle is published, anyone can copy it and republish it. Only remove copy protection if you genuinely intend the bundle to be freely redistributable.

Does the Owner Workshop File Id field protect individual assets within the bundle? ​

No. The field protects the bundle as a whole from being loaded from an unauthorized Workshop item. It does not protect individual models, textures, or prefabs from being extracted from the bundle using third-party asset-extraction tools. The protection is at the bundle load level, not at the individual asset level. Modders who require stronger asset protection should consider additional measures such as custom shader watermarking or server-side asset validation, which are beyond the scope of the AssetBundleCustomData system.

What happens if I move my mod to a different Workshop item? ​

If a modder decides to republish a mod under a new Workshop item (for example, after changing the mod's branding or scope), the Owner Workshop File Id field must be updated to match the new Workshop item's file ID. Rebuild the bundle with the updated value and upload the rebuilt bundle to the new Workshop item. Subscribers to the old Workshop item will continue to receive the old bundle, which remains protected by its own Owner Workshop File Id pointing to the old item's file ID.

How do I know if my bundle loaded with the custom data applied? ​

Check the game's output log file for the diagnostic message. The log file is at Unturned_Data/output_log.txt in the Unturned installation directory. Search for the string "custom data." If the log contains "Loaded (bundle name) custom data from (path)," the custom data was found and applied. If the log contains "Tried loading (bundle name) optional custom data from (path)," the custom data was not found. The presence of the "Loaded" message is the definitive confirmation.

Can I include other custom data fields beyond Owner Workshop File Id? ​

The AssetBundleCustomData ScriptableObject type is defined by the Unturned modding package and currently exposes only the Owner Workshop File Id field. The engine reads only the fields that the ScriptableObject type defines. Custom fields added by the modder to a subclass of AssetBundleCustomData would not be recognized by the engine. If additional custom data fields are needed, they must be implemented by the engine side, which is outside the scope of mod development.

How do I find my Workshop file ID if the item is not published yet? ​

Create the Workshop item as a hidden draft. In the Steam client, navigate to Unturned in your Library, click the Workshop link, and use the "Create a new Workshop item" option. Set the visibility to "Hidden" during creation. After creation, the draft item has a Workshop page with a URL that includes its file ID. This file ID is permanent and will not change when the item is published. Use this ID for the Owner Workshop File Id field. When the mod is ready for release, change the Workshop item's visibility from "Hidden" to "Public."

What happens if I change my Workshop item's file ID? ​

Steam Workshop file IDs do not change. A Workshop item's file ID is assigned at creation and is permanent for the lifetime of the item. There is no operation that changes a Workshop item's file ID. If a modder creates a new Workshop item to replace an old one (rather than updating the existing item), the new item has a new file ID, and the Owner Workshop File Id must be updated in the Unity project to match the new ID.

Does the Owner Workshop File Id check affect Workshop item updates? ​

No. The Owner Workshop File Id check is performed at bundle load time, not at Workshop item download time. When a modder uploads an updated bundle to an existing Workshop item, the Workshop item's file ID does not change. Subscribers download the updated bundle into the same Workshop content folder (named with the same file ID). The engine loads the updated bundle from that folder, compares the stored Owner Workshop File Id to the folder's ID, and finds a match because the Workshop item's file ID has not changed. Updates to a Workshop item do not affect the copy protection.

How do I verify that the copy protection is working before publishing? ​

The most reliable pre-publication verification is to check the game's output log file after loading the mod in a local single-player session. The log should contain the "Loaded ... custom data from ..." message. This confirms that the AssetBundleCustomData object is present in the bundle, the engine found it, and the Owner Workshop File Id field was read. The log message does not confirm that the ID is correct (that requires a Workshop subscription test after publication), but it confirms that the custom data infrastructure is functioning.

Can I use Owner Workshop File Id with a bundle distributed outside the Workshop? ​

Technically yes, but it serves no purpose. The verification is only performed when the engine knows the bundle came from a Workshop subscription. A bundle downloaded manually, distributed through a third-party site, or installed from a local folder bypasses the check. Setting Owner Workshop File Id on a non-Workshop bundle has no effect. If the modder later decides to distribute the bundle through the Workshop, the field should be set before the Workshop upload.

What is the difference between a Workshop file ID and a Steam App ID? ​

A Workshop file ID (also called a published file ID) identifies a specific item within a game's Steam Workshop. It is a unique number assigned by Steam when the Workshop item is created. An App ID (or Steam App ID) identifies a game or application on Steam; Unturned's App ID is 304930. The Owner Workshop File Id field expects a Workshop file ID (identifying the mod's Workshop item), not a Steam App ID. Entering 304930 (the Unturned App ID) would not provide any protection and would prevent the bundle from loading for Workshop subscribers because the Workshop content folder's ID would never match the Unturned App ID.

Can I protect multiple bundles in the same Workshop item with one custom data object? ​

Each master bundle that needs Workshop copy protection must have its own AssetBundleCustomData object, created in its own root folder inside the Unity project and exported as part of that specific bundle. A single AssetBundleCustomData object in one bundle does not protect other bundles in the same Workshop item. If a Workshop item distributes three master bundles (a core bundle, a map bundle, and an audio bundle), and the modder wants all three protected, each bundle needs its own AssetBundleCustomData object with the same Owner Workshop File Id (since all three bundles are distributed through the same Workshop item). The custom data object must be placed in each bundle's respective root folder in the Unity project.

Advanced considerations ​

Custom data and bundle updating ​

When a modder updates a published Workshop item by rebuilding and re-uploading the bundle, the AssetBundleCustomData object is rebuilt as part of the bundle. If the Owner Workshop File Id field was set correctly in the original build and is not changed, the rebuilt bundle carries the same value and the protection continues. If the modder accidentally clears the field or sets it to a different value, the updated bundle's protection is broken (cleared to 0) or points to the wrong Workshop item (set to a different ID). The cohort recommendation is to keep the AssetBundleCustomData object as a permanent, unchanging asset in the Unity project, never deleting or resetting it, so that every bundle build includes the correct Owner Workshop File Id.

Custom data in multi-bundle mod projects ​

A mod project that uses multiple master bundles (per the strategy documented in Asset Bundles Reference) can include an AssetBundleCustomData object in each bundle, or in only the primary bundle, or in none. The decision depends on the distribution model:

  • If all bundles are distributed through a single Workshop item, only the primary bundle needs the Owner Workshop File Id field set. The other bundles are protected by association: they are only useful when the primary bundle is loaded, and the primary bundle's copy protection prevents unauthorized use of the entire mod.
  • If each bundle is distributed through a different Workshop item, each bundle should have its own AssetBundleCustomData object with its own Owner Workshop File Id matching its respective Workshop item.
  • If some bundles are distributed through the Workshop and others are only used locally (development-only bundles), only the Workshop-distributed bundles need the custom data.

Custom data and dedicated servers ​

On a dedicated server, the engine loads master bundles for server-side validation (checking that client bundles match the server's bundles). The Owner Workshop File Id check is not relevant on the server side because the server loads bundles from a local file path, not from a Workshop subscription. The server's bundles can have any Owner Workshop File Id value (or none) without affecting server operation. The copy protection applies only on the client side, where bundles are loaded from Workshop subscriptions.

Diagnosing "Tried loading ... optional custom data" when you expected "Loaded" ​

The most common diagnostic scenario: the modder created an AssetBundleCustomData object, configured it, exported the bundle, and tested in-game, but the log shows "Tried loading ... optional custom data" instead of the expected "Loaded" message. The causes, in order of likelihood:

  1. The object was placed in the wrong folder. Confirm that the folder containing the object exactly matches the Asset_Prefix value in MasterBundle.dat. Even a character-case difference can cause a miss on case-sensitive platforms.
  2. The object was not assigned to the asset bundle. Select the object in the Project window and confirm the asset bundle assignment dropdown in the Inspector is set to the correct bundle name.
  3. The object was excluded from the export by a Unity build setting. Check the bundle manifest file after export; if the custom data object's path does not appear in the manifest, it was not included in the build.
  4. The MasterBundle.dat Asset_Prefix value includes a trailing slash or an extra path segment that does not match the Unity folder structure. The prefix must be the exact folder path, no trailing slash.

Custom data and the Unity build cache ​

Unity caches asset bundle builds to accelerate incremental rebuilds. The build cache stores previously built asset data and reuses it when assets have not changed. In rare cases, the build cache can become stale: Unity reports a successful build, but the exported .masterbundle file does not contain the latest version of an asset, including the AssetBundleCustomData object. If the modder has confirmed that the object is correctly placed, assigned, and configured, but the log still shows "Tried loading ... optional custom data," the build cache may be the cause.

To clear the Unity build cache, delete the contents of the Library/ folder in the Unity project directory and perform a full rebuild. The full rebuild regenerates every asset from source, including the custom data object. The rebuilt bundle should contain the object. This is a rare failure mode (the build cache is generally reliable) but is worth knowing about when every other diagnostic step has been exhausted.

Custom data across Unity project transfers ​

If a Unity project is transferred to a different machine (a new workstation, a collaborator's machine), the AssetBundleCustomData object travels with the project in the Assets/ folder. The Owner Workshop File Id value is preserved because it is stored in the .asset metadata file. No reconfiguration is needed after project transfer, provided the Unity project folder structure is preserved. However, after transfer, the modder should perform a full bundle rebuild (not an incremental build) and verify the log output to confirm that the custom data object is still present and correctly configured in the exported bundle.

Appendix A: AssetBundleCustomData field quick reference ​

FieldTypeRequiredDefaultPurpose
Owner Workshop File Iduint64No0The Steam Workshop file ID of the Workshop item authorized to distribute this bundle. When non-zero, the engine verifies that the bundle was loaded from a Workshop subscription whose file ID matches.

Appendix B: Creation workflow quick reference ​

StepActionLocation
1Locate master bundle root folderUnity Project window; folder matching Asset_Prefix
2Create AssetBundleCustomData objectRight-click root folder > Create > Unturned > Asset Bundle Custom Data
3Set Owner Workshop File IdInspector window; enter Workshop file ID as plain integer
4Assign to asset bundleInspector window; asset bundle dropdown at bottom
5Build and export master bundleWindow > Unturned > Master Bundle Tool
6Verify in log fileUnturned output log; search for "custom data"

Appendix C: Diagnostic log message reference ​

Log message patternMeaningAction
Loaded (bundle name) custom data from (path)Custom data found and loaded successfullyNone; configuration is correct
Tried loading (bundle name) optional custom data from (path)Custom data not found in bundleExpected for bundles without custom data; for bundles that should have it, check object placement and bundle assignment
No "custom data" message at allBundle may not have loaded at allCheck MasterBundle.dat configuration, bundle file presence, and log for load errors

Appendix D: External references ​

Document history ​

VersionDateAuthorNotes
1.02026-07-2657 StudiosInitial publication. Complete asset bundle custom data reference: AssetBundleCustomData ScriptableObject, Owner Workshop File Id field, creation workflow, copy protection model, diagnostic log messages, worked examples.

Authoring checklist ​

Before publishing a mod that uses asset bundle custom data, confirm the following:

  • [ ] AssetBundleCustomData object is created in the master bundle root folder (matching Asset_Prefix)
  • [ ] Owner Workshop File Id is set to the correct Workshop file ID (or left at 0 if copy protection is not desired)
  • [ ] The custom data object is assigned to the correct asset bundle in the Inspector
  • [ ] The bundle manifest file includes the custom data object's path after export
  • [ ] The game log file shows "Loaded ... custom data from ..." after testing in single-player
  • [ ] The Workshop item's file ID matches the Owner Workshop File Id value before the bundle is uploaded publicly
  • [ ] The custom data object is retained in the Unity project and not deleted or reset between builds

Cross-references ​

57 Studios logo with slogan

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

Learn

Getting StartedSteam SetupInstalling Unturned

Explore

ItemsSelf-HostingTroubleshootingHome

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

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