How to Import the Unturned Project Package

The Unturned™ project package is a .unitypackage file shipped by Smartly Dressed Games that contains every authoring tool, sample prefab, and editor script that Unturned mod authors need inside the Unity Editor. Without importing this package, a fresh Unity project cannot build Unturned-compatible asset bundles. Importing it is the step that turns a generic Unity project into an Unturned mod authoring environment for the 57 Studios™ pipeline.

This reference walks through locating the package file on disk, importing it into your Unity project, choosing which items to bring in, and verifying that the import succeeded.

The article is written for beginners who have created a fresh Unity project but have not yet imported the Unturned project package. It assumes the project is open in the correct Editor version and that Unturned is installed through Steam on the same computer.

Prerequisites

Before importing the package, confirm the following.

• The correct Unity Editor version is open with a fresh project (the project you created in the previous article).
• A copy of Unturned is installed through Steam on the computer you are working from. The project package ships inside the Unturned game folder.
• You have at least 1 gigabyte of free disk space inside the project folder. The imported assets occupy several hundred megabytes once Unity processes them.
• The Editor finished any initial asset import from project creation and is no longer showing a progress bar.

Pro tip

Before starting the import, note the current size of your project's Library folder. After import, the folder grows substantially as Unity processes the new assets. The size difference is a useful indirect confirmation that the import completed.

Did you know?

The Unturned project package is updated by Smartly Dressed Games whenever they bump the engine version or add new authoring tools. The package version that ships with your installed Unturned is the package version your mods should be authored against.

What you'll learn

• Where Smartly Dressed Games stores the Unturned project package inside the Unturned game folder.
• How to locate the Unturned game folder through Steam.
• How to use Unity's Custom Package import flow to bring the package into your project.
• How to read the import dialog and decide which items to include.
• What assets the package adds to your project.
• How to verify that the import completed successfully.
• How to re-import the package after a Unturned update.
• How to back up the package file for offline use.

Background

Smartly Dressed Games distributes the Unturned project package as part of the game itself rather than as a separate download. Every Unturned installation includes a Bundles subfolder, and inside that folder is a UnturnedProject.unitypackage file. Whenever the studio releases a major game update, the package updates alongside the game.

This distribution model has two consequences worth understanding. First, the package is always exactly compatible with the Unturned version installed on your computer. Second, updating Unturned through Steam updates the package, so re-importing the package after a major game update is the standard way to keep your mod authoring environment current.

Why the package ships with the game

The decision to ship the project package alongside the game (rather than as a separate download) reflects two practical realities. First, the package and the game are tightly coupled: the package contains editor scripts that reference specific game assets and behaviors, and updating either side without the other risks compatibility breakage. Second, distributing the package through Steam removes a separate download step for modders, which lowers the barrier to entry for new authors.

For Unturned mod authors the practical result is that Steam, not Smartly Dressed Games directly, is your delivery channel for the package. Keep Unturned installed and up-to-date through Steam, and the package follows automatically.

How the import flow works under the hood

When you open a .unitypackage file through Unity's Custom Package import flow, the Editor reads the package's internal tarball, lists the contained assets in the import dialog, and lets you check or uncheck individual assets. On clicking Import, the Editor copies the checked assets into your project's Assets folder, preserving each asset's relative path inside the package.

The Editor also re-creates each asset's .meta file (with the original GUID from the package), so that references between imported assets remain intact. Maintaining the original GUIDs is what allows the imported package to function as a coherent system: editor scripts inside the package reference other assets inside the package by GUID, and the references work because the GUIDs are preserved.

The import flow is the same flow Unity uses for any custom .unitypackage, not just the Unturned one. Asset Store packages, third-party tool packages, and packages exchanged between Unity developers all use the same flow.

Primary content

Step 1: Locate the Unturned game folder

In Steam, navigate to your Library, right-click Unturned, and choose Properties. In the Properties window, select the Installed Files tab. Click the "Browse" button. File Explorer opens directly inside the Unturned game folder.

Alternately, if you know your Steam library path, navigate manually. The default path on Windows is approximately C:\Program Files (x86)\Steam\steamapps\common\Unturned\. Your path may differ if you installed Steam to another drive or used a different Steam library folder.

Step 2: Open the Bundles folder

Inside the Unturned game folder, locate the folder named Bundles. Open it. You will see a number of subfolders that hold the game's runtime asset bundles, and at the top level you will see a file named UnturnedProject.unitypackage.

Common mistake

Do not edit, rename, or remove any files inside the Unturned game folder. The folder is managed by Steam, and changes will be reverted or flagged on the next game integrity check. You are only locating the package file; you will copy it implicitly through the import flow.

Step 3: Switch to the Unity Editor

Switch focus to your open Unity Editor window. The project you created in the previous article should still be open, displaying the default empty scene.

Step 4: Open the Custom Package import dialog

In the Unity menu bar at the top of the Editor window, click Assets, then hover Import Package, then click "Custom Package." A file picker dialog opens.

Step 5: Browse to the package file

In the file picker, navigate to the Bundles folder you located in Step 2. Select UnturnedProject.unitypackage and click Open.

Unity reads the package file, which takes 10 to 30 seconds. When the read completes, Unity opens the Import Unity Package dialog. This dialog lists every asset contained in the package as a checkbox tree.

Step 6: Choose which items to import

The Import Unity Package dialog displays a hierarchical list of every asset in the package. Each asset has a checkbox.

For a first-time import, leave every checkbox enabled. The default selection includes every asset that the package author intended you to import. Selectively disabling items only matters if you are re-importing an updated package and want to preserve local customizations to specific files.

Best practice

Take a moment to scan the asset tree before clicking Import. You will see folder names that reveal the package's structure: SDG, Plugins, Scripts, Editor, Examples. Reading the tree once before clicking Import gives you a mental map of what is about to land in your project.

Step 7: Click Import

Click the Import button in the bottom-right corner of the dialog. Unity begins copying the package contents into your project's Assets folder and processing each asset.

Processing takes 1 to 5 minutes depending on your machine. A progress bar appears in the bottom-right corner of the Editor window showing the current operation. The Editor may appear unresponsive while large assets are imported; this is normal.

Step 8: Verify the import

When processing completes, the Project window inside the Editor (typically docked at the bottom of the layout) shows new top-level folders that did not exist before. The exact folder names depend on the current version of the package, but you will typically see folders such as the following.

Assets/
├── Scenes/
│   └── SampleScene.unity
├── SDG/
│   ├── Editor/
│   │   └── (Master Bundle Tool scripts and menu integration)
│   ├── Plugins/
│   │   └── (managed DLLs for editor-side support)
│   ├── Scripts/
│   │   └── (C# scripts that define Unturned asset behaviors)
│   ├── Examples/
│   │   └── (sample prefabs for guns, items, vehicles, etc.)
│   └── Resources/
│       └── (shared materials, textures, and shaders)

Additionally, the Unity menu bar at the top of the Editor now displays a new top-level menu (commonly named to reflect the asset bundle tooling) that did not exist before the import. This menu is the entry point for the Master Bundle Tool, which is covered in the next article.

Step 9: Confirm a healthy idle state

A healthy idle state after import looks like this.

• The Project window shows the SDG folder at the top level of Assets.
• The Console window shows no errors (warnings are acceptable).
• The Unity menu bar shows a new menu entry related to the Master Bundle Tool.
• The project's Library folder is larger than it was before the import.
• The Editor is no longer showing a progress bar.

If any of these indicators are off, repeat the relevant step or use the recovery procedures in the appendices below.

Comparison

The table below summarizes the asset categories the package typically adds and what each is used for.

Category	Folder	Purpose	Modify after import?
Editor scripts	SDG/Editor	Adds menu items and Master Bundle Tool to the Editor	No; treat as read-only
Managed plugins	SDG/Plugins	Compiled DLLs that the editor scripts depend on	No; treat as read-only
Runtime scripts	SDG/Scripts	C# definitions for Unturned asset components	No; treat as read-only
Example prefabs	SDG/Examples	Reference samples for guns, items, vehicles, structures	Yes; copy and modify in your own folder
Shared resources	SDG/Resources	Shared materials, textures, and shaders	No; create your own resources alongside
Scenes	Scenes	Default and sample scenes	Yes; create your own scenes

Imported package footprint

The disk footprint added by the package import is documented in the table below.

Component	Disk footprint (approximate)
Editor scripts and tooling	5-15 MB
Managed plugin DLLs	10-30 MB
Runtime scripts	5-15 MB
Example prefabs and supporting assets	50-150 MB
Shared resources (materials, textures, shaders)	50-100 MB
Total typical import	100-300 MB on disk in Assets, plus 200-500 MB in Library

The exact figures vary by Unturned version. Plan for around 500 MB total project growth after a fresh import.

Decision flowchart

Re-import decision tree

After a Unturned update, you may need to re-import the package. The diagram below shows the decision tree for re-imports.

Advanced considerations

When Smartly Dressed Games releases a major Unturned update, the project package may change. To bring those changes into an existing mod project, repeat this import flow. Unity detects the existing files and shows them in the import dialog with their previous state. Items you have not modified will overwrite cleanly. Items you have modified will display a small warning indicator; review those carefully before reimporting them.

For modders who maintain many projects, consider keeping a backup copy of the UnturnedProject.unitypackage file outside the Steam folder. If you ever need to re-import the package while Unturned is mid-update on another machine, the backup ensures a consistent authoring environment.

Did you know?

The .unitypackage format is a tarball of asset files plus their metadata. Unity can import the same package into many projects, and the same assets can coexist with other imported packages as long as their internal paths do not collide.

Critical warning

Never import a .unitypackage file from an untrusted source. Custom Unity packages can include editor scripts that run automatically inside your Editor, which means a malicious package can take destructive actions on your project or computer. Only import packages from sources you trust, such as Smartly Dressed Games for Unturned authoring.

Backing up the package file

To back up the package file, close the Editor, open File Explorer, navigate to the Unturned Bundles folder, and copy UnturnedProject.unitypackage to a backup location outside the Steam folder. The backup is a static file; it does not need to be updated unless Unturned updates.

A reasonable backup location is D:\UnturnedMods\Backups\UnturnedProject_<gameversion>.unitypackage. Including the Unturned version in the filename helps when you maintain backups across multiple Unturned versions.

Pro tip

Keep two backups: one for the current Unturned version and one for the previous version. If a Unturned update introduces a regression that affects your mods, the previous-version backup lets you continue authoring against the old environment while Smartly Dressed Games resolves the regression.

Multiple computers

Modders who work on multiple computers need the package available on each computer. Two approaches work.

Approach	When to use
Install Unturned through Steam on each computer	Easiest; works as long as Steam is signed in on each computer
Carry a backup of the .unitypackage file	Useful when one of the computers does not run Steam (e.g., a build server)

The Steam-on-each-computer approach is the cohort default. The backup approach is the fallback for unusual configurations.

FAQ

Q: I cannot find the Bundles folder inside my Unturned installation. Where is it?

Some Steam installations place the game files inside a different library folder. In Steam, right-click Unturned, choose Properties, open the Installed Files tab, and click Browse. The Browse button always opens directly into the correct folder.

Q: The import dialog shows hundreds of files. Do I need to read each one?

No. For a first-time import, leave every box checked and click Import. The package author has already curated the contents.

Q: After import, my Editor became sluggish. Is this normal?

The first time Unity processes the imported assets, the Editor is busy importing textures, compiling shaders, and indexing scripts. Performance returns to normal once processing completes. Allow up to ten minutes on slower machines.

Q: Can I move the SDG folder to a different location inside Assets?

The package's editor scripts use relative paths internally. Moving the SDG folder breaks those paths and prevents the Master Bundle Tool from working. Leave the folder where the import places it.

Q: I see compilation errors in the Console after import. What now?

Compilation errors after a fresh import usually trace to a Unity version mismatch (the package was authored against a different Unity version than the one you have installed). Verify your Editor version against the Smartly Dressed Games documentation. If the version matches, the errors are unusual; report them on the Unturned modding forums for follow-up.

Q: Can I uncheck specific files during import to keep my custom changes?

Yes. On a re-import, uncheck the boxes for files where you have local changes you want to preserve. The Editor will leave those files alone and import only the checked files. Be deliberate: leaving an editor script out of a re-import can produce inconsistent behavior if the script depends on other re-imported files.

Q: The Editor crashed during import. What happened?

Editor crashes during package import are rare but possible if the project's Library folder is corrupted before the import. Close the Editor, delete the Library folder, reopen the project (which forces a Library regeneration), and retry the import. If the crash persists, file a Unity bug report with the Editor's crash log attached.

Q: How do I re-import the package after a Unturned update?

Repeat the same import flow described in the article. The Editor will detect existing files and show a re-import dialog that lets you accept the package's version of each file or keep your local version. For most files, accept the package version.

Q: Can two mod projects share a single imported package?

No. Each project has its own Assets folder, and the package needs to be imported into each project's Assets folder independently. Projects that share assets do so by referencing assets from each project's local Assets folder, not by sharing a single Assets folder across projects.

Q: I imported the wrong package by accident. How do I undo?

If the project is fresh, the easiest recovery is to delete the project and create a new one. If the project has work you want to preserve, close the Editor, manually delete the wrongly-imported folders from the Assets folder, reopen the project, and re-import the correct package.

Best practices

• Always import the package that ships with your installed Unturned version.
• Leave every checkbox enabled on first-time import.
• Treat the imported SDG folder as read-only; do not edit files inside it.
• Keep a backup of the .unitypackage file outside the Steam folder for redundancy.
• Repeat the import flow after Unturned major updates to keep your authoring environment current.
• Verify a healthy idle state after import before starting to author content.
• Document the Unturned version you imported the package from in your project notes.
• Avoid importing other .unitypackage files from untrusted sources into the same project.

Appendix A: The SDG folder in detail

The SDG folder is the top-level folder the package adds to the Assets folder. Inside it, the package organizes its contents into several subfolders. The table below documents the typical subfolders and their purposes.

Subfolder	Typical contents	Purpose
SDG/Editor/	Editor-only C# scripts	Adds menu items and Master Bundle Tool integration
SDG/Plugins/	Compiled managed DLLs	Provides reusable Editor-side libraries
SDG/Scripts/	Runtime C# scripts	Defines Unturned asset components
SDG/Examples/	Sample prefabs and supporting assets	Reference content for new modders
SDG/Resources/	Shared materials, textures, shaders	Reusable resources for mod content
SDG/Editor Default Resources/	Editor-only icons and assets	UI assets for the Master Bundle Tool

The exact subfolder set varies with the Unturned version, but the categories above are stable across versions. Treat the entire SDG folder as read-only; the package will overwrite local changes on re-import.

Editor scripts vs runtime scripts

The package contains two categories of C# scripts: Editor scripts and runtime scripts.

• Editor scripts live in SDG/Editor/ and are compiled into an Editor-only assembly. They run inside the Editor process during authoring but are not included in built bundles.
• Runtime scripts live in SDG/Scripts/ and are compiled into a runtime assembly. They define Unturned asset components and are included in built bundles where appropriate.

The distinction matters because Editor scripts can reference Editor-only Unity APIs that are not available at runtime. If you ever read the package's source code, you will see attributes like [CustomEditor] and [MenuItem] on Editor scripts; runtime scripts do not use those.

Did you know?

The Editor-vs-runtime split is enforced by Unity's assembly compilation. Files inside a folder named Editor (anywhere in the Assets folder) compile into the Editor assembly. Files outside Editor folders compile into the runtime assembly. The Unturned package follows this convention strictly.

Appendix B: Common compilation errors after import

Occasionally a fresh import produces compilation errors visible in the Console window. The table below documents the most common error patterns and their resolutions.

Error pattern	Likely cause	Resolution
"The type or namespace <name> could not be found"	Missing Unity package or wrong Editor version	Verify Editor version matches the documentation
"Assembly with name <name> already exists"	Two copies of the same DLL in the project	Remove the duplicate DLL from Assets
"Method <name> not found"	Editor version mismatch between package and Editor	Reinstall the correct Editor version
"Plugin not supported on current platform"	A plugin requires a build target that is not installed	Add the missing Build Support module to the Editor
"Script class cannot be found" on a prefab	A C# script the prefab references was not imported	Re-import the package with the script checked

The vast majority of compilation errors trace to Editor version mismatch. Verify the Editor version first; resolving the mismatch resolves most errors.

Appendix C: How the Master Bundle Tool relates to the imported package

The Master Bundle Tool is the menu-driven utility that compiles your assets into the bundle format Unturned loads at runtime. The tool is implemented as Editor scripts inside the imported SDG/Editor/ folder. When the Editor loads those scripts, the tool's [MenuItem] attributes register a new menu in the Editor's menu bar.

This means the Master Bundle Tool only exists after the package is imported. Before the import, the menu bar does not show the tool. After a successful import, the tool's menu appears and is ready to use.

The next article in the section walks through locating the Master Bundle Tool's menu, understanding what each option does, and performing a first test build. This article is the prerequisite for that one.

Pro tip

After completing the import in this article, look at the Editor's menu bar. The new menu entry that appeared is the entry point for the Master Bundle Tool. The next article documents exactly what the entry is named and how to use it.

Appendix D: A timeline view of the import flow

For readers who learn well from a timeline, the diagram below maps the entire import flow from first click in the Editor menu to a healthy idle state.

Appendix E: A summary of the article

This article walked through every step of importing the Unturned project package into a fresh Unity project. The high-level flow is:

1. Locate the Unturned game folder through Steam Properties.
2. Open the Bundles subfolder and find UnturnedProject.unitypackage.
3. Switch to the Unity Editor.
4. Choose Assets > Import Package > Custom Package.
5. Select the package file in the file picker.
6. Leave all checkboxes enabled in the import dialog.
7. Click Import.
8. Wait for the Editor to process the assets.
9. Verify the SDG folder and the new menu entry are present.

The next article walks through locating the Master Bundle Tool's menu entry that the package added to the Editor's menu bar.

Appendix F: Cohort observations on first-time package imports

Across the 57 Studios pipeline, the package import step is the third most reliable step in the Unity Setup section, after Hub install and Editor install. The first-attempt success rate sits near 92 percent, with the remaining 8 percent of cases tracing to a small set of documented causes.

Cause	Frequency in cohort	Resolution
Editor version mismatch with the package	About half of failures	Reinstall the correct Editor version
Project located in a cloud-synced folder	About one quarter of failures	Move the project to a non-synced location
Disk space ran out during import	About one eighth of failures	Free disk space and retry
Antivirus blocked the import	About one tenth of failures	Add the project folder to the antivirus exclusion list
Other	Remainder	Inspect the Editor crash log and the Console window

The Editor version mismatch is the most common cause and also the most preventable. Cross-checking the Editor version against the documentation before the import flow eliminates the bulk of failures.

Appendix G: Re-importing after a Unturned update

When Smartly Dressed Games releases a Unturned update, the package may change. The recommended re-import procedure is:

1. Close the Editor on all mod projects.
2. Back up each project's folder before the update.
3. Allow Steam to update Unturned.
4. Note the new Unturned version.
5. Open one mod project at a time. Allow the Editor to recompile any scripts.
6. Choose Assets > Import Package > Custom Package and select the updated UnturnedProject.unitypackage file.
7. Inspect the import dialog. Files marked as modified have changed in the new package.
8. Accept the package version for files you have not modified locally.
9. For files you have modified locally, decide per file whether to accept the package version or keep your local version.
10. Click Import and wait for processing.
11. Verify the Editor still loads the project correctly and the Master Bundle Tool menu is still present.
12. Build a test bundle to confirm the toolchain still works end to end.

Repeat the procedure for each mod project that imports the Unturned package. The procedure is deliberate; rushing it has historically been the largest source of post-update mod-build outages in the cohort.

Common mistake

Re-importing the package into a project that has not been backed up first is a common mistake. The re-import overwrites files, and any unsaved local customizations are lost. Always back up before re-importing.

Appendix H: A note on package versions and Unturned versions

The Unturned project package is versioned implicitly through the Unturned game version. There is no separate package version number visible in the Editor. To know which package version you have imported, refer to the Unturned game version that was installed when you imported.

A cohort convention is to record the Unturned version in the project's notes or README file. A typical entry might read:

Project: BlazetailRifleSet
Unturned package imported from: Unturned 3.24.2.3
Imported on: 2026-04-15
Editor version: 2021.3.29f1

The record helps when troubleshooting a project that is several months old and the cohort has moved on to newer Unturned versions.

Appendix I: The .unitypackage format explained

The .unitypackage format is Unity's standard archive format for distributing assets. Internally, a .unitypackage file is a gzip-compressed tarball that contains a directory per asset. Each per-asset directory holds the asset's binary contents, the asset's .meta file (which carries the GUID and import settings), and a pathname file that records the asset's path inside the receiving project.

When Unity imports a .unitypackage, it reads the tarball, iterates over the per-asset directories, and for each one decides where to place the asset based on the pathname file. The receiving project's existing files at the target paths are either overwritten (if the boxes are checked in the import dialog) or left alone (if the boxes are unchecked).

For Unturned mod authors, the format is a useful piece of background knowledge. It explains why the Unturned project package can carry editor scripts, runtime scripts, materials, prefabs, and DLLs in a single file: all of them are just per-asset directories inside the tarball.

Why Unity uses .unitypackage instead of a folder

Unity could distribute assets as folders that you simply copy into your project. The .unitypackage format adds two advantages over that approach.

Advantage	Explanation
Single-file distribution	One file is easier to download, back up, and version than a folder tree
GUID preservation	The format records each asset's GUID, so references between assets survive the import

The GUID preservation property is the more important of the two. Unity references assets by GUID internally, not by path. If you copied a folder of assets without preserving GUIDs, every cross-asset reference would break.

Appendix J: A short note on the Editor's asset import pipeline

When Unity imports an asset (whether from a .unitypackage or from a file you drop into the Assets folder), it runs the asset through its asset import pipeline. The pipeline performs format-specific processing:

• Textures are decompressed, resized, and re-compressed into the target platform's texture format.
• Models are parsed and converted into Unity's internal mesh format.
• Audio files are decoded and re-encoded into the target platform's audio format.
• Scripts are passed to the C# compiler.
• Shaders are compiled into the target platform's shader format.

The pipeline is what makes the Editor responsive at runtime: by pre-processing assets into the target format, the Editor can load and use them quickly during authoring. The Library folder is where the pre-processed forms are cached.

The first import of the Unturned project package triggers the import pipeline for every asset in the package. This is why the import takes several minutes; the Editor is doing real work to pre-process every asset.

Did you know?

The asset import pipeline runs in a background thread in modern Unity versions, which is why the Editor remains somewhat responsive during a large import. Older Unity versions ran the pipeline on the main thread and would freeze during large imports.

Appendix K: Inspecting the package contents before importing

If you want to inspect the package contents before clicking Import, the Editor's import dialog provides a tree view of every asset. You can browse the tree, expand subfolders, and read the names of each asset.

For a more detailed inspection (file sizes, last-modified dates), you would need to extract the .unitypackage file manually. The format is a gzip-compressed tarball, so any standard tar extractor can open it. Extracting reveals the per-asset directories described in Appendix I.

Most modders do not need to inspect the package contents in detail. The import dialog's tree view is sufficient for sanity-checking that the import is about to bring in the expected content.

Appendix L: A note on imported example prefabs

The SDG/Examples/ folder contains sample prefabs that demonstrate Unturned-specific authoring patterns. The examples typically include:

• A sample gun prefab showing the component layout for a firearm.
• A sample item prefab showing the layout for a consumable or piece of equipment.
• A sample vehicle prefab showing the layout for a drivable vehicle.
• A sample structure prefab showing the layout for placeable building pieces.
• A sample clothing prefab showing the layout for wearable items.

These prefabs are reference content. The recommended workflow is to copy a sample prefab into your own Mods/<ModName>/Prefabs/ folder, rename it, and modify the copy. Do not modify the originals in place; the next package re-import will overwrite your changes.

Pro tip

Studying the example prefabs is the fastest way to learn Unturned's authoring conventions. Open each example prefab in the Inspector, examine the component stack, and note the names and configurations. The example prefabs encode many small details that would otherwise need to be discovered through trial and error.

Appendix M: A glossary of import-related terminology

The terms below appear throughout this article and are worth defining once.

Term	Definition
Package	A .unitypackage file containing reusable assets
Custom Package	The Unity import flow for .unitypackage files (as opposed to Asset Store packages)
Import dialog	The Editor dialog that lists package contents and lets you check or uncheck items
Asset	A single file in the Assets folder (script, prefab, material, texture, sound, etc.)
GUID	A globally unique identifier Unity assigns to each asset; used for cross-asset references
.meta file	The Unity-specific metadata file that sits alongside each asset and records its GUID and import settings
Library folder	The per-project cache where the Editor stores pre-processed asset data
Asset import pipeline	The set of importers that process raw asset files into the Editor's internal formats
SDG folder	The top-level folder the Unturned project package creates in the Assets folder
Master Bundle Tool	The Unturned-specific tool added by the imported package; covered in the next article

The glossary is reproduced and expanded in later articles in the section as new terms become relevant.

Appendix N: A final reminder on package source trust

The article above repeatedly emphasizes that you should only import packages from trusted sources. The reason is worth restating in detail.

A .unitypackage file can contain editor scripts that run automatically inside your Editor as soon as they compile. Editor scripts have access to the full Editor API, which means they can:

• Read and write any file in your project.
• Modify any project setting.
• Delete files anywhere in your Assets folder.
• Make HTTP requests to remote servers.
• Read environment variables and system information.

A malicious package can take destructive actions on your project (deleting your work) or on your computer (reading credentials from environment variables, exfiltrating data over HTTP). Importing a package from an untrusted source is functionally equivalent to running an unknown executable on your computer.

The Unturned project package from Smartly Dressed Games is trustworthy because:

• It is distributed by the studio that developed Unturned, through Steam's signed-update channel.
• It has been imported by the entire Unturned modding community for years without incident.
• The source code of the package's editor scripts is available for inspection inside the package.

Other .unitypackage files you encounter (from random Discord servers, untrusted websites, or unknown contributors) do not enjoy the same trust position. Treat them with the same caution you would treat a random executable.

Critical warning

Never import a .unitypackage file from an untrusted source into a project that contains work you cannot afford to lose. If you must inspect an untrusted package, do so in a throwaway project on a sandboxed machine.

Appendix O: A second visual reference of the imported folder structure

The Project window inside the Editor displays the imported folder structure once the import completes. The diagram below documents the canonical layout for a fresh import.

Assets/
├── Mods/                          (created later by you for your own mods)
├── Scenes/
│   └── SampleScene.unity
└── SDG/                           (imported by the Unturned project package)
    ├── Editor/
    │   ├── (Editor scripts)
    │   ├── (Master Bundle Tool integration)
    │   └── Editor Default Resources/
    │       └── (UI icons and assets for the tool)
    ├── Examples/
    │   ├── Guns/
    │   ├── Items/
    │   ├── Vehicles/
    │   ├── Structures/
    │   └── Clothing/
    ├── Plugins/
    │   ├── SDG.Unturned.dll
    │   ├── SDG.NetTransport.dll
    │   └── (other managed plugin DLLs)
    ├── Resources/
    │   ├── Materials/
    │   ├── Shaders/
    │   └── Textures/
    └── Scripts/
        ├── Animals/
        ├── Effects/
        ├── Items/
        ├── Resources/
        ├── Structures/
        ├── Vehicles/
        └── (other runtime script folders)

The exact folder set varies by Unturned version. The diagram above documents the typical layout in recent versions.

Appendix P: A short reflection on the importance of this step

The package import step is, in some ways, the most consequential step in the entire Unity Setup section. Before the import, your Unity project is a generic empty project that could be the start of any Unity work. After the import, the project is specifically an Unturned mod authoring environment.

The transformation is one-directional in practice. Once a project has the Unturned package imported, removing the package cleanly is difficult; the editor scripts have registered menus, the runtime scripts have registered assemblies, and the example prefabs reference each other through GUIDs that other projects do not have.

This is fine. The recommendation is to create dedicated Unturned mod projects rather than retrofit existing general Unity projects. The package import is a once-per-project commitment, and the package re-import is the ongoing maintenance step.

Pro tip

If you ever want to experiment with non-Unturned Unity work, create a separate project for that work. Keep your Unturned mod projects dedicated to Unturned. The separation simplifies maintenance and keeps each project's purpose clear.

Appendix Q: A long-form note on the relationship with Steam

Steam is the delivery channel for the Unturned project package, and the relationship between Steam and your Unity authoring environment is worth thinking about deliberately.

Steam manages the Unturned game folder on your computer. The game folder contains the Bundles subfolder, and the Bundles subfolder contains UnturnedProject.unitypackage. The path from Steam to the package file is:

Steam Library Folder
└── steamapps
    └── common
        └── Unturned
            └── Bundles
                └── UnturnedProject.unitypackage

The path can be longer if you use a non-default Steam library folder, but the structure is consistent. The UnturnedProject.unitypackage file is always inside the Bundles subfolder of the Unturned game folder.

When Steam updates Unturned, it may update the .unitypackage file. The update happens automatically; Steam does not notify you that the package has changed. The first hint that the package has changed is when you try to build a bundle in the Editor and the build behaves differently from before.

The cohort convention is to check the .unitypackage file's last-modified date after each Steam update and re-import the package into your projects if the date has changed. The check takes a few seconds and prevents post-update surprises.

Pro tip

Right-click the UnturnedProject.unitypackage file in File Explorer, choose Properties, and look at the Modified date. Compare it to the date you last imported the package into your active mod project. A newer date means the package has changed.

Appendix R: A long-form note on the relationship with Tebex

Tebex is the commerce platform where many Unturned mod authors sell their mods to players. The relationship between Tebex and the package import is indirect but worth noting.

The bundles that the Master Bundle Tool produces (covered in the next article) are the products that authors distribute through Tebex. The bundles are downstream of the package import: the import provides the editor scripts that the Master Bundle Tool uses, the Master Bundle Tool produces the bundles, and Tebex distributes the bundles to players.

A successful import in this article is a necessary precursor to a successful Master Bundle Tool build, which is in turn a necessary precursor to a successful Tebex distribution. The chain is:

Package import -> Master Bundle Tool -> Built bundle -> Tebex distribution -> Player install

For 57 Studios authors who sell mods through Tebex, the import step is the foundation of the entire distribution chain. A careful import pays off in fewer Tebex-side support tickets weeks later.

Appendix S: A note on import determinism

The import flow is deterministic: importing the same .unitypackage into the same project twice produces the same result. This determinism is the property that makes re-imports safe; you can re-import the same package multiple times without producing different outcomes.

The determinism breaks down only if files on disk have been modified between imports. If you have manually edited a file inside the SDG folder, a subsequent re-import will detect the modification and either overwrite the local changes (if the box is checked) or leave them alone (if the box is unchecked). Either choice is deterministic given the inputs.

For Unturned mod authors the practical implication is that you should not modify files inside the SDG folder. The folder is the package's territory; your authoring belongs in your own folders alongside the SDG folder. Following this convention keeps re-imports straightforward.

Appendix T: A wrap-up reflection

The package import step is one of the smaller articles in the Unity Setup section in terms of clicks required (open a menu, pick a file, click Import), but it is one of the more conceptually important steps because it transforms the project from generic Unity into Unturned-specific. The article above spends extra attention on the surrounding concepts (the .unitypackage format, the asset import pipeline, the GUID system, the relationship with Steam and Tebex) because understanding those concepts pays off in the troubleshooting that occasionally follows.

A modder who reads this article in full will understand not just how to click through the import dialog but also what the import is doing, why the imported folder structure looks the way it does, and how to recognize and recover from the failure modes the cohort has documented. The next article will use that foundation to introduce the Master Bundle Tool itself.

Next steps

With the Unturned project package imported and the SDG folder visible in your project, the next step is to locate the Master Bundle Tool menu entry that the package added. Continue to How to Find the Master Bundle Tool.