Unturned Master Bundle Export from Unity

The master bundle is the package Unturned™ loads to access a mod's 3D content. Every prefab, mesh, material, texture, and (typically) audio asset referenced by the mod's items lives in the bundle; the .dat files reference the bundle's contents by name. A correctly built bundle loads in milliseconds; an incorrectly built bundle fails silently and the modder sees a mod that loads with placeholder cubes or with no visible items at all. This article documents the Unity-side workflow that 57 Studios™ and the broader Unturned modding community use to build, locate, and validate master bundles.

The article assumes the modder has Unity installed per Unity Setup and the master bundle tool available per How to Find the Master Bundle Tool. The mod's folder structure should be in place per Project Folder Structure and GUIDs; the bundle this article produces lives in that mod folder's Bundles/ subfolder.

Prerequisites

• Unity editor installed at the version required by the current Unturned build (see Unity Setup).
• Master bundle tool accessible from the Unity menu (see How to Find the Master Bundle Tool).
• A Unity project containing the prefabs, materials, and textures the mod will package.
• The mod's destination folder created per Project Folder Structure and GUIDs.
• Approximately 1 GB of free disk space for the build output and intermediate files.

What you'll learn

• How Unity's BuildAssetBundles API works and what an Unturned master bundle is.
• The naming convention for Unturned master bundles.
• How to set the target platform to StandaloneWindows64 (the platform Unturned requires).
• The trade-offs between LZ4 and LZMA compression and which to choose for an Unturned mod.
• Where Unturned looks for bundles at load time and how the mod's folder structure connects to the in-game asset table.
• How to verify that a bundle was built correctly and loads in the game.
• How to diagnose the most common bundle-related failures.

Background: Unity asset bundles

A Unity asset bundle is a serialized archive of assets that can be loaded by a Unity-built game at runtime. Bundles are the mechanism Unity exposes for downloadable content, expansion packs, and (in Unturned's case) mods. The bundle format is documented in the official Unity manual at docs.unity3d.com/2022.3/Documentation/Manual/AssetBundlesIntro.html; the Unturned-specific conventions are layered on top of that base.

Unturned calls a mod's bundle a "master bundle." The term is a convention rather than a Unity API distinction: a master bundle is a regular Unity asset bundle, built for the platform Unturned runs on, with the naming convention Unturned expects, placed in the folder structure Unturned scans at load time. The master bundle tool in Unity is a small editor script that wraps Unity's BuildAssetBundles API with the Unturned-specific parameters preset.

The sequence diagram above models the data flow from the Unity build through to the running game. The Build step is where the modder's choices about target platform and compression are applied; the file system steps move the bundle from Unity's build output to the mod folder's Bundles/ directory.

The master bundle tool

The master bundle tool is a Unity editor script shipped by Smartly Dressed Games for the modding community. It appears under a menu such as Tools → Unturned → Build Master Bundle once installed. See How to Find the Master Bundle Tool for the install and discovery procedure.

The tool exposes three principal parameters:

Parameter	Required value	Notes
Output path	The mod's Bundles/ folder	The folder created per Project Folder Structure and GUIDs
Target platform	StandaloneWindows64	The platform Unturned ships for; see "Target platform" section below
Compression	LZ4 (recommended) or LZMA	See "Compression" section below

The tool's default values are usually correct for an Unturned mod. The modder needs to verify each parameter against the values above before clicking Build; the most common build failures are caused by an unchanged default that does not match Unturned's expectations.

Naming the bundle

Unturned expects the master bundle to follow a specific naming convention. The convention has two parts: the bundle's internal name (the name Unity records in the bundle's manifest) and the bundle's file name (the name on disk).

Internal name

The internal name is set on each asset in Unity via the AssetBundle assignment in the Inspector. The cohort convention is to use the mod's short name in lower case with no spaces. For a mod called "Example Pistol Mod" the internal bundle name would be examplepistol.

To assign assets to a bundle:

1. In the Project window, select the prefab, mesh, material, or other asset.
2. At the bottom of the Inspector, find the "AssetBundle" dropdown.
3. Click the dropdown, select "New," and type the mod's short name.
4. Repeat for every asset that should be packed into the bundle.

Once assigned, the asset appears in the bundle list at the bottom of the Inspector and will be packaged when the bundle is built.

File name

The file name on disk is the internal name followed by .unity3d. The example mod above would produce examplepistol.unity3d in the build output folder. The file extension is fixed by Unity's build pipeline; the modder cannot change it.

Common mistake

Building the bundle into a folder that does not match the mod's expected folder structure. The bundle file must be at <mod folder>/Bundles/<bundlename>.unity3d for Unturned to find it. A bundle built into Unity's project folder (the default Unity output location) will not be discovered by Unturned until the modder manually copies it into place.

Target platform

Unity supports building bundles for many platforms. Unturned runs on Windows 64-bit, so the bundle must be built for the StandaloneWindows64 target. A bundle built for any other target will not load.

Setting the target

The target platform is set in Unity's File → Build Settings dialog before the bundle build runs. The cohort procedure:

1. Open File → Build Settings.
2. In the Platform list, click "PC, Mac & Linux Standalone."
3. Confirm that "Target Platform" in the right panel is set to "Windows" and "Architecture" is set to "Intel 64-bit."
4. If the platform is not yet active, click "Switch Platform" and wait for Unity to re-import the project for the new target. The switch can take several minutes on large projects.
5. Close the Build Settings dialog.

The target platform is also exposed as a parameter on the master bundle tool. The tool should be set to StandaloneWindows64; if it offers a different default, change it before building.

Critical warning

Bundles built for the wrong target platform are the single most common cause of "my mod loads but no items appear in the game" reports across the cohort. Unity does not warn the modder when a bundle is built for the wrong target; the build succeeds, the bundle file is created, and Unturned silently fails to load it. Always confirm the target platform before every build.

Why other platforms do not work

Target	Result in Unturned
StandaloneWindows64	Loads correctly
StandaloneWindows (32-bit)	Does not load; Unturned is 64-bit only
StandaloneOSX	Does not load on Windows hosts
StandaloneLinux64	Does not load on Windows hosts
Android	Does not load; bundle format is incompatible
iOS	Does not load
WebGL	Does not load
Server (any)	Does not load on standard Unturned

The platform incompatibility is structural: each Unity target produces bundles in a format the matching runtime knows how to read. The Unturned runtime is built for StandaloneWindows64, so only StandaloneWindows64 bundles are compatible.

Compression

Unity offers three compression options for asset bundles: no compression (uncompressed), LZ4, and LZMA. The choice affects build time, file size, and runtime load behaviour.

Comparison

Compression	Build time	File size	Load time	Random access
Uncompressed	Fastest	Largest (1.0x baseline)	Fastest at load	Yes
LZ4 (chunk-based)	Fast	Medium (≈0.7x baseline)	Fast at load	Yes
LZMA (stream-based)	Slowest	Smallest (≈0.4x baseline)	Slow at first access	No (requires full decompress)

LZ4's "chunk-based" property means Unity can decompress and access individual assets in the bundle without decompressing the whole archive. LZMA's "stream-based" property requires the entire archive to be decompressed before any asset can be accessed. For an Unturned mod that loads at game startup and may use only some of its assets in a given session, LZ4 produces faster runtime behaviour at a modest file size penalty.

Recommendation

The cohort's default recommendation is LZ4. The slight file-size penalty (a ~75 MB LZ4 bundle becomes a ~45 MB LZMA bundle) is more than offset by the runtime advantage for mods that load on every game start. LZMA is appropriate only for very large mods (over 500 MB raw) where the file-size reduction is significant for Workshop bandwidth, and the modder accepts the slower first-load behaviour.

Uncompressed bundles are appropriate for development builds where build time matters more than file size; the modder switches to LZ4 before publishing the mod to the Workshop.

Pro tip

Use uncompressed bundles during development to minimize the build-iterate cycle. A 50 MB raw mod that takes 90 seconds to build with LZ4 builds in 12 seconds with no compression. Switch to LZ4 only for the final pre-publish build.

Setting compression in the master bundle tool

The master bundle tool exposes the compression option as a dropdown or as boolean flags ("Chunk Based Compression," "Uncompressed Asset Bundle"). The cohort mapping:

Tool setting	Result
Neither flag set	LZMA
"Chunk Based Compression" enabled	LZ4 (recommended)
"Uncompressed Asset Bundle" enabled	Uncompressed
Both flags enabled	Tool behaviour is undefined; do not set both

The flags map directly to Unity's BuildAssetBundleOptions enum: ChunkBasedCompression and UncompressedAssetBundle. The cohort recommendation is to set ChunkBasedCompression only.

Build procedure

The full procedure to build a master bundle:

1. Open the Unity project containing the mod's prefabs.
2. Assign every asset that should be packaged to the bundle. Select each asset in the Project window, find the AssetBundle dropdown at the bottom of the Inspector, and assign the asset to the mod's bundle. Materials, textures, and meshes referenced by assigned prefabs are pulled in automatically.
3. Switch the build target to StandaloneWindows64. File → Build Settings → PC, Mac & Linux Standalone → Switch Platform.
4. Open the master bundle tool. Tools → Unturned → Build Master Bundle (or the equivalent menu path for the installed tool version).
5. Set the output path to the mod's Bundles/ folder. The tool will append the bundle's file name automatically.
6. Set the target platform to StandaloneWindows64. Confirm even if the tool's default already shows this value.
7. Set compression to LZ4 (Chunk Based Compression enabled).
8. Click Build. The build takes between five seconds and ten minutes depending on the bundle's raw asset size.
9. Read the Unity console. A successful build logs "AssetBundle build complete" with the output path. A failed build logs an error; common errors are documented in the "Troubleshooting" section below.
10. Confirm the file exists at <mod folder>/Bundles/<bundlename>.unity3d.

Where Unturned looks for bundles

Unturned searches three locations for mod bundles at startup:

Location	Purpose
<Unturned install>/Bundles/	Vanilla content; modders should not write here
<Unturned install>/Sandbox/ or local mod folders	Local mods not yet published to the Workshop
Steam Workshop content folder	Workshop subscriptions, managed by Steam

For a local mod under development, the bundle path the game scans is the mod's own Bundles/ subfolder, when the mod folder is dropped into one of Unturned's recognized mod locations. The exact local mod location depends on the Unturned version; recent versions accept mods in Sandbox/ or in a configured workshop folder.

The cohort's recommendation is to develop the mod in C:\Project Folder\MyMod\ (outside the Unturned install) and to symlink or copy the mod folder into the game's recognized mod location when testing. This keeps the source-controlled mod folder separate from the game's runtime layout.

Bundle validation

After the build completes, the modder should verify the bundle before assuming it works.

Step 1: Confirm the file exists

Open File Explorer and navigate to <mod folder>/Bundles/. The file <bundlename>.unity3d should exist with a non-zero size. A file size of zero indicates the build produced no output and the build log probably contains errors.

A PowerShell one-liner:

Get-Item "C:\Project Folder\MyMod\Bundles\mymod.unity3d" |
  Select-Object Name, Length, LastWriteTime

The output shows the file name, size in bytes, and the time of the last write. A recent timestamp and a non-zero size are the minimum signs of a successful build.

Step 2: Inspect the manifest

Unity writes a .manifest file alongside the bundle, with the same base name. The manifest is a text file listing the assets included in the bundle. Open the manifest in Notepad++ (see Notepad++) and confirm that the expected assets appear.

ManifestFileVersion: 0
CRC: 1234567890
Hashes:
  AssetFileHash:
    serializedVersion: 2
    Hash: abcdef0123456789...
Assets:
- Assets/Models/MyPistol.prefab
- Assets/Materials/MyPistolMat.mat
- Assets/Textures/MyPistolDiff.png

A manifest that lists no assets indicates that no assets were assigned to the bundle in Unity. The fix is to return to the Unity project, assign assets to the bundle (Step 2 of the build procedure), and rebuild.

Step 3: Launch Unturned and confirm the items appear

Place the mod folder in Unturned's recognized mod location (either by copy or by symlink), launch Unturned, and load a world. Use the in-game /give command with the item's ID to spawn the item:

/give Self 32000

The item should appear in the player's inventory with the correct icon and, when equipped, with the correct 3D model. If the icon appears but the model is a default placeholder (a white sphere or an "X" shape), the bundle was built but the prefab reference in the .dat file is incorrect; see the "Troubleshooting" section.

Pro tip

Use a fresh single-player save for bundle testing. Spawning items in a save that has been played for hours risks corrupting the save if the mod has errors. A throwaway save makes the test cycle fast and removes the data-loss risk.

Troubleshooting

The bundle file is not created

The most common cause is that no assets are assigned to the bundle. Confirm the AssetBundle dropdown in the Inspector for each asset shows the bundle's name. The build script will report "No assets to build" or similar in the Unity console.

A second cause is that the output path is not writable. Confirm the modder has write permission on the mod folder; antivirus or restrictive folder permissions can intercept the write.

The bundle file is created but Unturned does not load it

The most common cause is the wrong target platform. Open the Unity Build Settings and confirm the target is StandaloneWindows64. Rebuild after fixing the target.

A second cause is the bundle file in the wrong folder. The bundle must be at <mod folder>/Bundles/<bundlename>.unity3d. A bundle in a different location (Unity's default output, a sibling folder) will not be discovered.

A third cause is a malformed .dat file pointing at the bundle. Confirm the .dat file's Bundle or Prefab fields reference the bundle's internal name (no .unity3d extension).

The item loads but appears as a placeholder

The bundle loaded successfully but the prefab reference is wrong. Open the item's .dat file in Notepad++ and confirm the prefab name matches an asset packaged in the bundle (visible in the .manifest file).

The build fails with a "BuildPipeline" error

Unity's build pipeline can fail for many reasons; the error message in the Unity console identifies the cause. Common cases:

Error	Cause	Resolution
"Asset not found"	An asset assigned to the bundle has been deleted	Remove the dead reference and rebuild
"Cannot find target platform"	The chosen platform module is not installed	Install the Windows Build Support module via Unity Hub
"Out of memory"	The Unity editor ran out of memory	Restart Unity and rebuild
"Compilation failed"	A C# script in the project has a syntax error	Resolve the script error before building
"Missing prefab reference"	A prefab references a missing asset	Open the prefab, locate the missing reference, replace or remove

Common mistake

Ignoring Unity console warnings during the build. The console may report dozens of warnings (deprecated APIs, suboptimal asset settings) that do not prevent the build. The cohort recommendation is to scan the warnings for any mention of the mod's bundle or its assets; a warning about an asset in the bundle often becomes a runtime failure even when the build succeeds.

Advanced considerations

Bundle splitting

Very large mods can be split across multiple bundles to allow Unity to load assets on demand. The split is achieved by assigning different assets to different bundle names in the Inspector. Each bundle produces a separate .unity3d file in the output folder, and the modder's .dat files must reference the correct bundle for each asset.

Bundle splitting is rarely worth the complexity for an Unturned mod. The cohort recommendation is one bundle per mod up to approximately 100 MB; mods larger than that should consider splitting only if load times become a problem.

Bundle dependencies

A prefab in one bundle can reference a material or texture in another bundle. Unity's build pipeline handles the dependency by storing a reference in the dependent bundle's manifest. At load time, Unturned must load all dependent bundles before the referencing prefab can be instantiated.

Bundle dependencies are a frequent source of mod load failures. The cohort recommendation is to keep every asset a prefab depends on inside the same bundle as the prefab itself.

Incremental builds

Unity supports incremental bundle builds: assets that have not changed since the last build are not re-packaged. The incremental cache lives in the project's Library/ folder; deleting the Library forces a full rebuild.

For day-to-day development, leave the Library in place and rely on incremental builds. Before a pre-publish build, delete the Library to force a clean rebuild from scratch; this guarantees the published bundle reflects the current state of every asset.

Bundle versioning

Each rebuilt bundle produces a different CRC (cyclic redundancy check), even if the assets are unchanged. This is a Unity artifact and does not indicate a problem with the build. The CRC is used by Unity to detect bundle changes between builds; Unturned does not check the CRC at load time.

Workshop publishing impact

The bundle is the principal payload uploaded to the Steam Workshop when the mod is published (see the Publishing section). The bundle's file size directly affects upload time and the bandwidth consumed by every subscriber. The cohort recommendation is to use LZ4 compression and to remove unused assets from the bundle before publishing; a 200 MB bundle with 100 MB of unused assets wastes 100 MB of Workshop bandwidth on every subscription.

Animation packaging in bundles

Animation clips and animator controllers are packaged in the same bundle as the prefab they animate. See Animations Export Blender to Unity for the Blender-side export and the Unity-side import that produces the animation assets.

Audio packaging in bundles

Audio assets can be packaged in the bundle alongside the prefab that references them, or stored as separate files in the mod's Sounds/ folder. See Audio Packaging for Unturned for the audio format requirements and the cohort recommendation.

Frequently asked questions

My Unturned master bundle is not loading. What do I check first?

Confirm the target platform was set to StandaloneWindows64 before the build. The wrong target platform is the single most common cause of a bundle that builds successfully but does not load. Re-check Unity's Build Settings and rebuild.

What name should I give my Unturned master bundle?

The cohort convention is the mod's short name in lower case with no spaces. For a mod called "Example Pistol Mod" the bundle name is examplepistol. The file name on disk becomes examplepistol.unity3d.

Should I use LZ4 or LZMA compression for an Unturned bundle?

LZ4 is the cohort recommendation. It produces a slightly larger file than LZMA but loads faster at runtime, which matters more for an Unturned mod that loads on every game start. Use LZMA only for very large mods (over 500 MB raw) where the file-size reduction is significant.

Where does the Unturned master bundle go on disk?

The bundle must be at <mod folder>/Bundles/<bundlename>.unity3d. The mod folder is the top-level folder created per Project Folder Structure and GUIDs; the Bundles/ subfolder is created by the modder before the build.

How do I verify the bundle actually contains my assets?

Open the .manifest file that Unity writes alongside the bundle. The manifest lists every asset packaged in the bundle. If the expected asset does not appear, the asset was not assigned to the bundle in Unity's Inspector.

Can I rebuild the bundle while Unturned is running?

No. Unturned holds the bundle file open during play. Rebuilding the bundle while the game is running either fails (Windows reports the file is in use) or succeeds and the running game does not see the change. The cohort workflow is: close Unturned, rebuild, launch Unturned.

Does the bundle work on Linux or macOS servers?

Bundles built for StandaloneWindows64 work only on Windows. Servers running Unturned on Linux require bundles built for StandaloneLinux64; servers on macOS require StandaloneOSX. The cohort's recommendation for cross-platform mod distribution is to build separate bundles for each platform the mod must support, and to use platform-specific naming to keep them straight.

Why does my bundle build take so long?

Bundle build time scales with the raw asset size and the chosen compression. A 50 MB mod with LZMA can take five minutes to build; the same mod with LZ4 takes one minute; with no compression, twelve seconds. For development iteration, use no compression and switch to LZ4 only for the final build.

Can two mods share a single bundle file?

Technically yes — multiple mods can reference assets in the same bundle — but the practice is discouraged. The cohort recommendation is one bundle per mod, because shared bundles couple the lifecycle of multiple mods and create cross-mod failure modes that are difficult to diagnose.

What is the .manifest file for?

The .manifest file is a Unity-generated text file that lists the assets packaged in the bundle, the bundle's CRC, and the bundle's dependencies. Unturned does not read the manifest at runtime; it is purely a development aid. The modder can leave the manifest alongside the bundle or delete it before publishing.

How big can my bundle be?

There is no hard limit on bundle size that Unturned enforces, but practical limits apply. Bundles over 1 GB take many minutes to load and may exceed Steam Workshop upload limits. The cohort recommendation is to keep bundles under 200 MB; mods larger than that should consider splitting (see "Advanced considerations").

What happens if I forget to set the target platform?

Unity falls back to the active build target, which is whatever the modder last selected in File → Build Settings. If the modder has been doing Android or iOS work recently, the bundle will be built for that platform and will not load in Unturned. Always confirm the target platform in the master bundle tool before each build.

Build output inspection: a closer look

After a successful build, Unity writes several files to the output folder. Understanding each file's purpose helps the modder diagnose build issues and confirm that the build produced the expected output.

Files produced by a master bundle build

File	Purpose	Required for Unturned?
<bundlename>.unity3d	The bundle binary; contains the packaged assets	Yes
<bundlename>.unity3d.manifest	Text manifest listing assets and dependencies	No (development aid)
<bundlename> (no extension)	Unity's parent manifest for the build folder	No
<bundlename>.manifest	Parent manifest text file	No

Only the .unity3d file is required at runtime. The manifest files are written by Unity for the asset bundle pipeline's own bookkeeping and can be deleted before publishing the mod, though leaving them in place does no harm.

Reading the manifest

The .manifest file is YAML-formatted text. A typical manifest:

ManifestFileVersion: 0
CRC: 2547839125
Hashes:
  AssetFileHash:
    serializedVersion: 2
    Hash: 8f3a2b1c5d9e4f7a6b8c1d2e3f4a5b6c
  TypeTreeHash:
    serializedVersion: 2
    Hash: 1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d
HashAppended: 0
ClassTypes:
- Class: 1
  Script: {instanceID: 0}
- Class: 4
  Script: {instanceID: 0}
- Class: 21
  Script: {instanceID: 0}
Assets:
- Assets/Prefabs/MyPistol.prefab
- Assets/Materials/MyPistolMat.mat
- Assets/Textures/MyPistolDiff.png
- Assets/Sounds/MyPistolFire.wav
Dependencies: []

The fields the modder typically cares about are CRC (changes on every build), Assets (the list of packaged assets), and Dependencies (other bundles this bundle depends on; should be empty for a self-contained mod).

Did you know?

Unity computes the bundle's CRC by hashing every asset's serialized representation. Two bundles built from identical inputs on different machines may produce different CRCs because of platform-specific serialization differences (line endings, file timestamps embedded in metadata). The CRC is not a reliable cross-machine identity check; the assets list in the manifest is.

A worked build example

The example below shows a full build cycle for a small Unturned mod. The mod contains a single pistol with a prefab, a material, two textures, and a fire sound.

Starting state

Unity Project: ExamplePistolUnity/
├── Assets/
│   ├── Prefabs/
│   │   └── MyPistol.prefab
│   ├── Materials/
│   │   └── MyPistolMat.mat
│   ├── Textures/
│   │   ├── MyPistolDiff.png
│   │   └── MyPistolNorm.png
│   └── Sounds/
│       └── MyPistolFire.wav
└── (Unity project metadata)

Mod Destination: C:\Project Folder\ExamplePistolMod\
├── Bundles/                  <-- empty, awaiting bundle
├── Items/
│   └── MyPistol/
│       ├── MyPistol.dat
│       ├── English.dat
│       └── Icon.png
└── meta.dat

Build steps for the example

1. Open the Unity project ExamplePistolUnity/.
2. Select MyPistol.prefab in the Project window. In the Inspector's AssetBundle dropdown, create and assign the bundle name examplepistol.
3. Confirm that the material and textures referenced by the prefab inherit into the bundle automatically (visible in the AssetBundle browser).
4. Switch the build target to StandaloneWindows64 via File → Build Settings.
5. Open Tools → Unturned → Build Master Bundle.
6. Set the output path to C:\Project Folder\ExamplePistolMod\Bundles\.
7. Enable Chunk Based Compression (LZ4).
8. Click Build.
9. Wait approximately 25 seconds for the build to complete.
10. Confirm C:\Project Folder\ExamplePistolMod\Bundles\examplepistol.unity3d exists at approximately 2 MB.

Verifying the example

Get-Item "C:\Project Folder\ExamplePistolMod\Bundles\examplepistol.unity3d" |
  Select-Object Name, Length, LastWriteTime

Expected output:

Name                   Length LastWriteTime
----                   ------ -------------
examplepistol.unity3d 2073600 5/18/2026 2:34:12 PM

A file size of 2 MB for a small mod with one prefab, one material, two textures, and one short audio file is reasonable. A file size of zero or a few hundred bytes indicates the build failed silently; rebuild after confirming the AssetBundle assignment in the Inspector.

Build automation

Modders who iterate frequently can automate the build using Unity's command-line interface. The pattern is:

& "C:\Program Files\Unity\Hub\Editor\2021.3.29f1\Editor\Unity.exe" `
  -batchmode -quit `
  -projectPath "C:\Project Folder\ExamplePistolUnity" `
  -executeMethod BuildScript.BuildMasterBundle `
  -logFile "C:\Project Folder\ExamplePistolUnity\build.log"

The BuildScript.BuildMasterBundle method is a static C# method the modder writes in an Editor/ script. The method calls Unity's BuildPipeline.BuildAssetBundles with the desired parameters and exits the editor.

The command-line build is useful for continuous integration or for modders who rebuild after every code change. The cohort recommendation is to add the command to a PowerShell script in the mod folder so the build can be triggered with a single command.

Pro tip

Pipe the Unity log file to PowerShell after the command completes to surface build results in the terminal:

Get-Content "C:\Project Folder\ExamplePistolUnity\build.log" -Tail 50

The last 50 lines of the log typically contain the build summary, including the bundle path and any errors.

Best practices

• Confirm the target platform is StandaloneWindows64 before every build.
• Use LZ4 compression for production builds; use no compression for development iteration.
• One bundle per mod for mods under 100 MB; split only when load times become a problem.
• Keep every asset a prefab depends on inside the same bundle as the prefab itself.
• Delete the Unity Library/ folder before the final pre-publish build to guarantee a clean rebuild.
• Inspect the .manifest file to confirm the expected assets are packaged before launching the game.
• Use a fresh single-player save for bundle testing to avoid corrupting a long-running save.
• Document the bundle's internal name in the mod's README so the modder remembers it across project sessions.

Cross-references

• Project Folder Structure and GUIDs — the folder layout the bundle's output path depends on.
• Audio Packaging for Unturned — the audio format requirements for assets packaged alongside the bundle.
• How to Find the Master Bundle Tool — the procedure for locating the master bundle tool in Unity.
• Unity Setup — the Unity install prerequisites the build pipeline depends on.
• Notepad++ — the text editor used to inspect the .manifest file and the .dat files that reference the bundle.
• Unity manual: Asset Bundles — the upstream Unity documentation for the asset bundle system.

Document history

Version	Date	Notes
1.0	2024-07-08	Initial publication. Build procedure and target platform documentation.
1.1	2024-10-21	Added LZ4 vs LZMA comparison and recommendation.
1.2	2025-02-19	Added validation section and PowerShell verification snippets.
2.0	2025-05-18	Major revision. Added Mermaid diagrams, expanded troubleshooting, advanced considerations section.

Closing note

The master bundle is the bridge between the Unity-side asset authoring environment and the Unturned-side runtime. A bundle built with the correct target platform, the correct compression, and the correct internal name loads silently and correctly; a bundle with any of those wrong fails silently and the modder spends hours diagnosing a mod that "loads but doesn't work." The validation procedure documented in this article catches the common failure modes at build time and saves the modder from runtime debugging.

Next steps

Continue to Audio Packaging for Unturned for the audio format requirements and Unity import settings that audio assets must match before they can be packaged in the bundle. Return to Items for the section overview.