Unity Project Overview

Intermediate40-60 minutesWindowsUnity HubUnity Editor

The Unturned™ Unity project is the development environment in which every 57 Studios™ mod author builds, tests, and exports content for the game. Understanding the project's structure, its component directories, its editor preferences, its play-mode configuration, and its continuous integration pipeline is the foundation on which all subsequent mod-development tasks rest. A mod developer who opens the project for the first time without understanding its layout will struggle to locate the files that need editing, will be uncertain where new content should be placed, and will encounter build errors that a structured tour of the project would have prevented.

This article is the structural reference for the Unturned™ Unity project as distributed by Smartly Dressed Games through the public U3-SDK GitHub repository. It covers the project's acquisition via Git clone, its Unity version requirement, its file organization tree, the editor preferences and play mode settings that the SDG development team recommends, the net code generation workflow, and the continuous integration pipeline that builds and tests the project on every commit. The article is written for 57 Studios™ mod developers who have completed the Unity Editor installation and project import procedures and are preparing to begin development work.

The articles that precede this one in the unity-setup section documented the step-by-step procedures for installing the Unity Hub, installing the correct Unity Editor version, creating a new Unity project, importing the Unturned project package, opening and re-opening the project, and waiting for the import phase to complete. This article documents the project that those procedures produce: its shape, its conventions, and the developer-facing subsystems that a mod author interacts with daily.

Documentation source: This article references the official Smartly Dressed Games modding documentation chapter 147 (Unity Project Overview) for the project structure, editor preferences, play mode settings, file organization, net code generation, and continuous integration pipeline sections. The source chapter is reproduced in .wikigen/sdg-sections/147-unity-project-overview.txt and is the binding evidence for every claim in this article that describes the project structure.

Who this article is for

This article is written for two audiences. The first audience is the mod developer who has just completed the Unity Editor installation and project import procedures and is looking at the project for the first time, needing a structured orientation to what each folder contains and what each editor window does. The second audience is the experienced mod developer who has been working in the project for some time and wants a comprehensive reference for the project structure, the build pipeline, and the continuous integration system that underpins the project's development.

Readers who have not yet installed the Unity Editor or imported the Unturned project package should complete the procedures in How to Install Unity Hub, How to Install Unity Editor, How to Create a New Unity Project, and How to Import the Unturned Project Package before returning to this article.

Prerequisites

Before this article applies, confirm the following.

• The Unity Editor is installed at the correct version as documented in How to Install Unity Editor.
• The Unturned project package has been imported into a Unity project following the procedure in How to Import the Unturned Project Package.
• The Unity Editor import phase has completed and the progress bar at the bottom-right of the Editor window has disappeared, as documented in How to Wait for Unity to Finish Importing.
• Steam is installed and running, and Unturned™ is installed through Steam.
• The Unity Editor window is open and displaying the project.

Prerequisites note

The Steam client must be running and Unturned™ must be installed for the project to function correctly in the Editor. The project loads workshop mods and large binary files from the latest official release of the game, which requires the game to be installed and Steam to be running. This is a hard requirement documented by SDG, not a 57 Studios™ convention.

What you'll learn

• How the Unturned™ Unity project is acquired and what the Git repository contains
• The Unity Editor version requirement and how to verify the correct version is installed
• The complete file organization tree of the project and what each top-level directory contains
• The function of the Assets/Game/Sources, Assets/Resources, Assets/Runtime, and Builds directories
• The role of the Assembly-CSharp folder and the newer per-assembly-definition folders
• The function of the NetGen directory and the generated networking code it contains
• How the play mode system works, including the GameStartup.unity scene and the Auto Load Level and Auto Load Mode settings
• The editor preferences that SDG recommends for mod development, including the script-recompilation setting
• The net code generation workflow: opening the Net Gen window, generating RPC code, and ensuring scripts are imported
• The continuous integration pipeline that builds and tests the project on every commit
• How to navigate the project hierarchy and locate specific files and systems
• The troubleshooting steps for common project-level problems

Background: the U3-SDK repository

The Unturned™ Unity project is distributed through a public Git repository maintained by Smartly Dressed Games at https://github.com/SmartlyDressedGames/U3-SDK.git. The repository name stands for "Unturned 3 Software Development Kit," and it contains the complete Unity project for the game, including all source code, all imported game assets, all editor configuration, and all build scripts.

The project is publicly available for anyone to clone, open, and modify. There is no access restriction, no license key, and no approval process. The public availability of the full game source code is one of the distinguishing characteristics of Unturned™ compared to other Unity-based games, and it is the technical foundation on which the entire modding ecosystem is built.

The repository is updated with each new Unturned™ release. Changes committed to the repository reflect the current shipped state of the game. A mod developer who clones the repository after a game update receives source code that matches the latest public build of the game. A mod developer who needs to target an older game version should clone or check out the repository at the tag or commit that corresponds to that version.

The repository is the source of truth

The U3-SDK repository contains the same source code that SDG uses to build the public release of Unturned™. The repository is not a simplified or pared-down version of the project. It is the project. Understanding this distinction matters because it means the project contains every subsystem in the game, including systems that are not directly relevant to modding (dedicated server code, Steam networking, economy integration). The presence of these systems does not mean the mod developer needs to understand them all. The mod developer only needs to understand the subsystems that intersect with the specific mod being developed.

Cloning the repository

The project is acquired with a single Git command. Open a command prompt or PowerShell window, navigate to the desired project location, and run:

git clone https://github.com/SmartlyDressedGames/U3-SDK.git

The clone operation downloads the entire repository, including all source files, all asset files, and the full Git history. The download size is substantial (several gigabytes) because the repository contains the complete game asset corpus. The clone operation should be performed on a development workstation with at least 10 GB of free disk space and a reliable internet connection.

For mod developers who do not have the Git CLI installed, the repository can also be downloaded as a ZIP archive from the GitHub repository page, though this approach does not include the Git history and prevents updating the project through Git pull operations. The cohort recommendation is to install Git and clone the repository properly, both because future project updates are simpler through Git and because the build pipeline scripts expect the Git repository structure to be present.

The flowchart above shows the acquisition and update cycle. The initial clone is a one-time operation. Subsequent updates (when SDG releases a new game version) are performed with git pull in the local clone directory, followed by re-opening the project in Unity to allow the Editor to re-import any changed assets.

Unity version requirement

The project requires a specific version of the Unity Editor. The required version is documented in the file ProjectSettings/ProjectVersion.txt, which is included in the repository. Before opening the project for the first time, the mod developer should open this file and confirm that the installed Unity Editor version matches the version recorded there.

The file ProjectSettings/ProjectVersion.txt contains a single line indicating the Unity Editor version that the project was authored with. The format is a standard Unity project version string. Opening the project in a different Unity Editor version may result in asset import errors, script compilation failures, or runtime exceptions that do not occur with the correct version.

The cohort recommendation is to install the exact Unity Editor version recorded in ProjectSettings/ProjectVersion.txt, not a "close enough" version. The Unity Editor's platform-specific compilation, shader compilation, and asset import pipeline are sensitive to version differences, and using a different version introduces failure modes that are difficult to diagnose because they manifest at runtime rather than during import.

Unity version mismatch is the most common first-time project error

Opening the Unturned™ project in a Unity Editor version that does not match the version recorded in ProjectSettings/ProjectVersion.txt is the single most common cause of first-open failures. Symptoms include unable-to-compile script errors, pink materials indicating shader compilation failure, missing prefabs, and scenes that fail to load. If the project does not open cleanly, check the Unity Editor version against ProjectSettings/ProjectVersion.txt before investigating any other cause.

File organization

The project's file organization mirrors the structure that SDG uses internally. Understanding this structure is the prerequisite to finding specific files quickly and to knowing where new content should be placed. The project root contains several top-level directories, each with a specific role in the development and build workflow.

The project root

The project root is the folder containing the cloned Git repository. It contains all Unity project files and all build pipeline scripts. The principal subdirectories are:

U3-SDK/
├── Assets/                    ← Unity project assets (source, runtime, resources)
├── Packages/                  ← Unity Package Manager manifest and dependencies
├── ProjectSettings/           ← Unity Editor project configuration files
├── Builds/                    ← Exported Unity players (build output)
├── Build_Scripts/             ← Jenkins CI pipeline scripts
└── JenkinsBootstrapper/       ← CI bootstrapper source code

Assets directory structure

The Assets/ directory is the core of the Unity project. Every file that the Unity Editor loads, compiles, or processes lives under this directory. The principal subdirectories within Assets/ are:

Directory	Purpose	Directly relevant to modding?
Assets/Game/Sources/	Source files (.blend, .fbx) for Unity assets exported in the asset bundle	Yes, for asset authors
Assets/Resources/	Unity assets loaded by the Resources class at runtime	No (avoid introducing new files here)
Assets/Runtime/	All player code (C# scripts, assembly definitions)	Yes, for script authors

Assets/Game/Sources

This directory contains the source files for all game assets that are exported in asset bundles. The term "source files" in this context refers to the authoring formats: .blend files for Blender-authored 3D models, .fbx files for imported 3D models, texture source files, and any other file that is processed into a Unity-native format and then packaged into an asset bundle.

The files in Assets/Game/Sources are not loaded directly at runtime. They are the source from which Unity creates the imported assets that live elsewhere in the project. Mod developers who are authoring new 3D models or textures place their source files here (or in a parallel directory structure for mod-specific content) and let Unity import them into the engine's native formats.

Assets/Resources

The Assets/Resources/ directory is a special Unity directory. Any asset placed in a folder named Resources (at any depth) can be loaded at runtime using the Resources.Load API without being referenced directly in a scene or prefab. The Unturned™ project uses this directory for assets that are loaded dynamically rather than through direct references.

Do not introduce new files to Assets/Resources

The SDG documentation explicitly recommends against introducing new files to this folder "if possible." The reason is that every file in Resources is included in the build regardless of whether it is actually used, which increases build size and load time. For mod-specific assets, use the standard mod asset pipeline (master bundle packaging) rather than placing files in Resources/.

Assets/Runtime

The Assets/Runtime/ directory is the heart of the project. It contains all player-side code: every C# script that defines game behavior, every assembly definition that controls how scripts are compiled into assemblies, and every supporting file that the code references.

The principal subdirectory within Assets/Runtime/ is Assembly-CSharp/. This folder contains the majority of the game's C# code, compiled into the Assembly-CSharp.dll assembly. The name "Assembly-CSharp" is a Unity convention inherited from early Unity versions, and the SDG documentation notes that renaming it would break script references in asset bundles (as of 2024-10-18) because asset bundles store the assembly name alongside the script GUID.

Newer game features introduced after the project was established have their own folders per assembly definition rather than being added to the monolithic Assembly-CSharp/ folder. These per-assembly folders sit alongside Assembly-CSharp/ under Assets/Runtime/ and contain a .asmdef file that declares the assembly, its dependencies, and its platform targets.

The Assets/Runtime/Assembly-CSharp/NetGen/ subdirectory contains all generated networking code. The networking code is auto-generated from the RPC (Remote Procedure Call) annotations in the source code and is committed to Git to make the first-run process smoother for new developers. The generation process is described in the Net Code section of this article.

The Builds directory

The Builds/ directory at the project root contains exported Unity players: the compiled, standalone executable builds of the game. This directory is populated by the build pipeline and is not part of the Assets directory tree. Mod developers who are not building the game from source do not need to interact with this directory.

ProjectSettings directory

The ProjectSettings/ directory contains configuration files that the Unity Editor reads on project open and writes during project configuration changes. These files define the editor version requirement (ProjectVersion.txt), the input manager configuration, the tag and layer manager, the physics settings, the graphics settings, the quality settings, and many other project-wide configurations.

The file ProjectSettings/ProjectVersion.txt is the most important file in this directory for mod developers because it records the Unity Editor version that the project was authored against. Opening this file before opening the project for the first time prevents the version-mismatch problem described earlier in this article.

Packages directory

The Packages/ directory contains the Unity Package Manager manifest (manifest.json) and a lock file that records the resolved package versions. The manifest lists the Unity packages that the project depends on, including the package name, the version constraint, and (for packages not sourced from the Unity registry) the repository URL or local path. The lock file pins each package to a specific version so that every developer who opens the project gets the same package set.

Mod developers generally do not need to modify the Packages/manifest.json file unless they are adding a new Unity package dependency to the project. Adding a new package dependency should be done with caution because it introduces a new requirement that every mod developer who opens the project must satisfy.

The diagram above shows the hierarchical structure of the project's principal directories. The Assets/Runtime/ branch is the one most relevant to mod developers who are writing custom scripts or modifying game behavior.

Getting started: opening the project in the Editor

After cloning the repository, the mod developer opens the project in the Unity Editor and performs the first-run steps that configure the project for local development.

Verifying the Unity Editor version

Before opening the project, open ProjectSettings/ProjectVersion.txt and confirm the Unity Editor version recorded there. If the installed Unity Editor version does not match, install the correct version following the procedure in How to Install Unity Editor.

Opening the project

Open Unity Hub, click "Open," navigate to the cloned repository folder, and select it. Unity Hub detects the project and adds it to the project list. Click the project to open it. The first open triggers the asset import process documented in How to Wait for Unity to Finish Importing.

Steam requirement

The project loads workshop mods and large binary files from the latest official release of the game installed through Steam. Steam must be running, and Unturned™ must be installed for the project to function correctly. If Steam is not running when the project is opened, the Editor may display missing-asset errors or fail to load certain scenes.

Running the game in the Editor

To run the game from within the Unity Editor, open the GameStartup.unity scene (located in the project's scene list) and click the Play button at the top of the Editor window. The game launches in the Game view within the Editor, connected to a local single-player server.

The GameStartup.unity scene is the entry point for the game when running in the Editor. It initializes the game's subsystems, loads the menu, and transitions into gameplay when the player starts or joins a game. Running the game in the Editor is the standard workflow for testing script changes, verifying asset modifications, and debugging runtime behavior.

The Hierarchy window consideration

The SDG documentation includes a specific recommendation about the Unity Editor's Hierarchy window. Unturned's scenes contain mostly top-level game objects for optimization purposes, and the sheer number of these objects slows down the Hierarchy window significantly when it is open. SDG recommends closing the Hierarchy window except when it is needed for a specific editing task.

Hierarchy window performance

The Hierarchy window performance problem is a consequence of the project's architecture: top-level game objects are used for optimization (fewer parent-child traversal steps at runtime), but the cost is paid in the Editor where the Hierarchy window must render every top-level object. Closing the Hierarchy window during play mode testing is a simple way to recover Editor performance without any adverse effect on the game's runtime behavior.

Editor preferences

The SDG documentation recommends specific Unity Editor preferences for mod development. These preferences are set once and persist across project sessions.

Script changes while playing

Unturned™ does not support hot-reloading. If a mod developer modifies code while the game is running in the Editor, Unity's default behavior is to recompile the scripts, which destroys the current play session state and restarts the game. The cycle of modifying code, recompiling, and losing the test state is inefficient and frustrating.

SDG recommends changing the Editor preference "Script Changes While Playing" to "Recompile After Finished Playing." This setting prevents Unity from recompiling scripts while the game is running, which means:

• The mod developer can modify code at any time without disrupting the current play session.
• The modified code does not take effect until the play session ends and is restarted.
• The mod developer completes the play session, makes all desired code changes, then restarts to test the changes.

To set this preference: open the Unity Editor, navigate to Edit > Preferences > General, locate the "Script Changes While Playing" dropdown, and select "Recompile After Finished Playing."

Why hot-reloading is not supported

Hot-reloading (applying code changes without restarting the play session) is a feature that some Unity projects implement through custom tooling, but the Unturned™ project's architecture (particularly the networking layer and the server-authoritative game state) makes hot-reloading impractical. The server and client share game state that is initialized at session start, and modifying the code that defines that state mid-session would require re-initializing the state, which is functionally equivalent to restarting the session.

Play mode settings

The project includes a custom editor window accessible from Window > Unturned > Editor Settings. This window provides options that are otherwise specified on the command-line when launching a standalone build. The play mode settings allow the mod developer to configure the Editor's play mode behavior to bypass the menu and jump directly into a specific level.

Auto Load Level and Auto Load Mode

The Auto Load Level and Auto Load Mode settings control whether the game automatically loads a specific level when the play mode starts, bypassing the menu sequence.

• Auto Load Level: Set to a level's folder name to load that level automatically on play. For example, setting this to PEI loads the Prince Edward Island map immediately when the game starts in the Editor.
• Auto Load Mode: Controls the game mode for the auto-loaded level. Options include singleplayer and the level editor. Setting this to the level editor opens the specified level in the Unturned™ level editor rather than in play mode.

When both settings are configured, clicking Play opens the specified level directly, skipping the main menu, the loading screen, and the mode selection. This is the recommended workflow for mod developers who are iterating on a specific map or testing a specific level repeatedly, because the time saved by skipping the menu sequence accumulates across dozens of test cycles.

Glazier

The Glazier setting overrides the default Glazier configuration. Glazier is Unturned's UI framework, and this setting allows the mod developer to specify a custom Glazier configuration for testing UI changes. For the majority of mod development tasks, the default Glazier setting is correct and should not be changed.

The complete file organization tree

The table below provides an expanded reference for every principal directory in the project, its purpose, its relationship to the modding workflow, and whether a mod developer should modify its contents.

Directory	Path	Purpose	Modify?	Notes
Project root	/	Git repository root	No	Contains the top-level Unity project structure
Assets	Assets/	All Unity project content	Yes	Primary working directory for mod developers
Game Sources	Assets/Game/Sources/	Authoring files for game assets	Yes, for new assets	Source .blend and .fbx files
Resources	Assets/Resources/	Dynamically loaded Unity assets	No (avoid)	Do not introduce new files
Runtime	Assets/Runtime/	All C# game code	Yes, for script authors	Primary location of game logic
Assembly-CSharp	Assets/Runtime/Assembly-CSharp/	Main game code assembly	Yes	Most game code lives here
NetGen	Assets/Runtime/Assembly-CSharp/NetGen/	Generated networking code	No	Auto-generated, committed to Git
Per-assembly folders	Assets/Runtime/<Feature>/	Newer feature-specific code	Yes	Each has its own .asmdef
Packages	Packages/	Unity Package Manager manifest	Rarely	Contains manifest.json
ProjectSettings	ProjectSettings/	Unity Editor configuration	Indirectly	Editor writes to these files
ProjectVersion	ProjectSettings/ProjectVersion.txt	Unity Editor version	Read only	Check version before opening
Builds	Builds/	Exported Unity players	No	Build pipeline output
Build Scripts	Build_Scripts/	Jenkins CI pipeline scripts	No	CI configuration
JenkinsBootstrapper	JenkinsBootstrapper/	CI bootstrapper source	No	Builds the CI launcher

The "Modify?" column above indicates whether a mod developer should edit files in that directory. Directories marked "No" should not be modified. Directories marked "Indirectly" are modified by the Unity Editor when the developer changes project settings through the Editor UI, not by direct file editing. Directories marked "Rarely" should only be modified when the developer has a specific reason to add or change a package dependency.

Moving between the Unity project and the Bundles tree

The Unity project and the Bundles/ directory tree described in Project Folder Structure and GUIDs are two distinct file structures that serve complementary roles in the mod development workflow. Understanding how they relate is essential for a mod developer who builds content in the Unity project and then deploys it through the Bundles tree.

The Unity project is the development environment. It contains all source files, all game code, and all editor configuration. When a mod developer authors a new item (a 3D model, a configuration file, a prefab), the development work happens in the Unity project. The Unity project is the "workshop" in which the developer builds and tests content.

The Bundles tree is the deployment structure. The master bundle that a mod ships to Steam Workshop is a .unity3d file built from the Unity project and placed in a specific folder under Workshop/Content/304930/<modID>/Bundles/. The .dat configuration files and English.dat localization files live adjacent to the bundle in the Items/ subdirectory.

The flowchart shows the deployment path for a new mod item. The Unity project produces the master bundle. The .dat files are authored outside the Unity project. Both are placed in the mod's Workshop directory structure. The mod is then tested locally or submitted to Steam Workshop.

The Unity project is not the mod

A common first-time misconception is that the Unity project itself is the mod. It is not. The Unity project is the development environment. The mod is the set of files (master bundle, .dat files, English.dat files, preview image) that are placed in the Workshop directory and distributed to players. Keeping the Unity project clean and organized is a development discipline; the mod's Workshop directory structure is a separate concern with its own organization conventions.

Navigational conventions

Navigating a Unity project of the scale and complexity of the Unturned™ project requires familiarity with several Editor conventions that experienced developers use to locate files quickly.

The Project window search bar

The search bar at the top of the Unity Editor's Project window accepts partial file names, type filters, and label filters. Typing GameStartup into the search bar returns the GameStartup.unity scene. Typing t:script filters the Project window to show only script files. Typing l:Player filters to show only files with the "Player" label.

The cohort recommendation for mod developers who need to find a specific file in the large project hierarchy is to use the search bar before browsing. The search bar is faster than navigating the folder tree, and the type and label filters narrow the result set to the exact category of file the developer is looking for.

The Hierarchy window search bar

The Hierarchy window includes a search bar that functions identically to the Project window search bar. Typing a game object name or component type into the Hierarchy search bar filters the displayed game objects to those matching the search term. For the Unturned™ project, with its many top-level game objects, the Hierarchy search bar is the practical way to locate a specific object without scanning the entire hierarchy manually.

The Console window

The Console window (Window > General > Console) displays log messages, warnings, and errors from the Unity Editor, the C# scripts, and the game runtime. During development, the Console window is the primary feedback channel for script compilation errors, asset import warnings, and runtime exceptions. A mod developer who encounters unexpected behavior should check the Console window before investigating any other cause.

Net code generation

Unturned™ is a networked game. Most gameplay systems require remote procedure calls (RPCs) to function correctly across the client-server boundary. Even single-player mode is implemented as a one-player server: the same networking code runs in single-player as in multiplayer, with the client and server communicating through local channels rather than over a network socket.

The RPC code that handles client-server communication is auto-generated from annotations in the C# source code. The generation process scans the source for RPC annotations, produces the corresponding networking stubs, and writes them into the Assets/Runtime/Assembly-CSharp/NetGen/ directory. The generated code is committed to Git so that a developer who clones the repository for the first time does not need to run the generation step before the project will compile.

When to run net code generation

The net code generation step is required in two scenarios:

1. After changing an existing RPC signature. If a mod developer modifies the parameters or return type of an existing RPC-annotated method, the generated networking code must be re-generated to reflect the new signature.
2. After adding a new RPC-annotated method. If a mod developer adds a new method with an RPC annotation, the generation step must be run to produce the networking stub for the new method.

For mod development work that does not touch RPC-annotated code (the vast majority of asset authoring and configuration work), the net code generation step does not need to be run.

Running the net code generation

The generation interface is accessed through the Unity Editor menu:

1. Open Window > Unturned > Net Gen.
2. In the Net Gen window, click "Generate."
3. After generation completes, tab out of the Unity Editor window and then tab back in. This ensures that Unity detects the newly generated script files and imports them.

The "tab out and back in" step is documented by SDG as necessary because Unity does not always detect script file changes that are written by an editor window within the same Editor session. The tab-out-and-back-in action forces Unity to refresh its asset database, which triggers the import of the newly generated scripts.

Missing net code generation after RPC changes

Failing to run the net code generation step after modifying an RPC-annotated method produces compilation errors referencing missing methods that appear in the generated code stubs. The missing methods are the ones the generation step would have produced. If compilation errors appear after modifying a method that has an RPC annotation, run the Net Gen window before investigating any other cause.

Continuous integration

Smartly Dressed Games uses a continuous integration (CI) pipeline to build the project and run tests on every commit. The pipeline is implemented with Jenkins, a CI server that monitors the repository for new commits, checks out the latest code, builds the Unity project, runs the test suite, and optionally uploads the build to a Steam branch for internal testing.

At the time of the documentation source (2024-10-18), the Jenkins server is locally hosted at SDG and is not accessible over the internet. This means only SDG can trigger the CI pipeline; community contributors and mod developers cannot access the Jenkins server or view its build results.

The Jenkins pipeline script

The CI pipeline is defined in Build_Scripts/Jenkinsfile.txt, a Jenkins Pipeline script that describes the build stages: checkout, build, test, and optionally upload. The script is written in the Jenkins Pipeline DSL and references the JenkinsBootstrapper utility to launch the correct Unity Editor version.

The JenkinsBootstrapper

The Jenkins bootstrapper is a utility that locates the correct Unity Editor installation on the build machine and launches it with the arguments needed to perform a command-line build. The bootstrapper source code is in the JenkinsBootstrapper/ directory, and the compiled executable is Build_Scripts/JenkinsBootstrapper.exe.

The bootstrapper expects Unity to be installed in one of three standard locations:

• C:\UnityEditors
• C:\Unity Editors
• C:\Program Files\Unity\Hub\Editor

The SDG documentation notes that the development and build processes are "very Windows-centric," and the bootstrapper reflects this by searching only Windows-typical Unity installation paths.

What the CI pipeline means for mod developers

The CI pipeline is an SDG internal system that mod developers do not interact with directly. Its existence is documented here because:

• It explains why the Build_Scripts/ and JenkinsBootstrapper/ directories exist in the project.
• It establishes that SDG builds and tests the project on every commit, which is an indicator of the project's engineering rigor.
• It provides context for the Build_Scripts/Jenkinsfile.txt file, which a mod developer might encounter while browsing the project directory tree and wonder about.

A mod developer who wants to set up a CI pipeline for their own mod project would follow a different pattern (typically a GitHub Actions workflow rather than a locally hosted Jenkins server), and the SDG Jenkins configuration is not directly applicable to mod CI pipelines.

Troubleshooting

The SDG documentation recommends checking Unity's log files as the first step in troubleshooting project-level problems. The log files record every action the Unity Editor performs, including asset imports, script compilations, shader compilations, and any errors or warnings that occur during these operations.

Locating the log files

On Windows, the Unity Editor log files are stored in a standard location that varies slightly by Unity version. The U3-SDK project includes a shortcut to the most recent log file, named Unity Editor.log, in the project root. The project also includes a shortcut to the containing folder, named UnityEditor Logs Folder. These shortcuts are convenience links created during the project's initial setup and allow the mod developer to open the log files without navigating through the Windows file system to the Unity log directory.

Alternatively, the log files can be accessed directly through the Unity Editor: open the Console window (Window > General > Console), click the three-dot menu in the upper-right corner, and select "Open Editor Log."

Common project-level problems and resolutions

Symptom	Most likely cause	Resolution
Project fails to compile on first open	Unity Editor version mismatch	Check ProjectSettings/ProjectVersion.txt against installed Unity version
Pink materials on game objects	Shader compilation failure or missing shader	Re-import the project assets; check the Console for shader errors
Missing prefabs in scenes	Asset import incomplete	Allow the import process to complete fully; check the progress bar
NullReferenceException on play	Required game data not loaded (Steam not running, Unturned not installed)	Ensure Steam is running and Unturned is installed
Hierarchy window is extremely slow	Many top-level game objects in active scene	Close the Hierarchy window except when needed for editing
Script compilation takes minutes	First-time compilation of large project	Wait for compilation to complete; subsequent compilations are faster
Generated networking code produces errors	NetGen code is stale after RPC changes	Run Window > Unturned > Net Gen > Generate
Project window search returns nothing	Search filter active from previous session	Clear the Project window search bar
Scene does not load on Play	GameStartup.unity not open in the Editor	Open GameStartup.unity and click Play
Play mode starts at menu despite Auto Load settings	Auto Load Level not set or set incorrectly	Check Window > Unturned > Editor Settings > Auto Load Level

Diagnostic scenarios

The scenarios below describe representative project-level problems that mod developers encounter and the documented resolution paths for each.

Scenario 1: The project that opens but nothing works

A mod developer clones the repository, opens the project in Unity, waits for the import to complete, and opens GameStartup.unity. The scene loads, but clicking Play produces a cascade of NullReferenceException errors in the Console and the game fails to start.

The most likely cause is that Steam is not running or Unturned is not installed. The project loads workshop mods and large binary files from the installed game directory, and if the game is not present, those files are missing. The fix is to install Unturned™ through Steam, launch the game once to ensure it initializes, and then restart the Unity Editor.

Scenario 2: The project that fails to compile after a Git pull

A mod developer pulls the latest changes from the U3-SDK repository and re-opens the project. The project fails to compile with errors referencing missing methods, missing types, or changed method signatures.

The most likely cause is that the pulled changes included modifications to RPC-annotated methods, and the NetGen code is now out of date. The fix is to open Window > Unturned > Net Gen, click Generate, tab out and back in, and allow Unity to recompile.

Scenario 3: The project that builds incorrectly after a Unity version upgrade

A mod developer upgrades the Unity Editor to a newer version and opens the project. The import completes successfully and the scripts compile, but asset bundles built from the project fail to load in the game.

The most likely cause is that the Unity version used to build the bundles does not match the game's Unity version. Asset bundle compatibility is sensitive to Unity version differences. The fix is to revert to the Unity Editor version recorded in ProjectSettings/ProjectVersion.txt and rebuild the bundles.

Best practices

• Check ProjectSettings/ProjectVersion.txt before opening the project for the first time and after every Unity Hub update. The version recorded there is the authoritative version requirement.
• Ensure Steam is running and Unturned™ is installed before opening the project. The project depends on files from the installed game.
• Set "Script Changes While Playing" to "Recompile After Finished Playing" in Edit > Preferences > General. This prevents mid-play-session script recompilation.
• Close the Hierarchy window during play mode testing. The window's performance cost is substantial in the Unturned™ project.
• Use the Project window search bar before browsing. The search bar is faster than tree navigation for the project's scale.
• Run Window > Unturned > Net Gen > Generate after any change to RPC-annotated code, then tab out and back in to force asset re-import.
• Keep the Unity project clean: do not add mod-specific content to Assets/Resources/. Use the standard mod asset pipeline instead.
• Compile and test in the Editor before building a master bundle for Steam Workshop. A script error caught in the Editor is a minute lost; a script error caught by a Workshop downloader is a reputation lost.
• If the project produces unexpected compilation errors after a Git pull, run the Net Gen step before investigating other causes.
• Bookmark the Unity Editor.log shortcut in the project root for quick access to diagnostic information when problems occur.

Frequently asked questions

What is the difference between the Unity project and a mod project?

The Unity project is the development environment containing the full Unturned™ game source code. A mod project is a set of files (master bundle, .dat configurations, localization) that are placed in the Workshop directory structure and distributed to players. The Unity project produces the master bundle; the mod project is the complete set of files that constitute a distributable mod. They are separate concepts with separate file structures.

Do I need to clone the entire repository, or can I download just the parts I need?

The entire repository must be cloned because the Unity project's files reference each other through GUIDs, and a partial clone would produce broken GUID references that prevent the project from opening. The Git clone downloads the full repository, including the Git history. The complete download size is several gigabytes. If bandwidth is a constraint, consider using git clone --depth 1 for a shallow clone that excludes the history.

Why can't I rename the Assembly-CSharp folder?

Renaming the folder would change the assembly name that is baked into every asset bundle that references scripts from that assembly. The asset bundles in the installed game (and in every mod that references game scripts) would fail to resolve their script references. As of 2024-10-18, SDG has determined that the breakage outweighs the benefit of a more descriptive assembly name. The folder name is effectively a frozen convention.

Can I add my own code to the project?

Yes. Mod developers routinely add custom C# scripts to the project for testing or for producing custom game behavior. New scripts should be placed in a dedicated folder (preferably with its own assembly definition) rather than added to the monolithic Assembly-CSharp/ folder, because the monolithic assembly is the one most affected by upstream changes from SDG. A custom assembly is isolated from upstream changes and easier to maintain across project updates.

What happens if I modify the contents of Assets/Resources/?

The file will be included in the next build of the game. If the file is large, the build size increases. If the file conflicts with an existing resource, the conflict may cause runtime errors. SDG recommends avoiding the introduction of new files to Assets/Resources/ "if possible." For mod-specific assets, use the standard mod asset pipeline.

How do I update the project when SDG releases a new game version?

Navigate to the cloned repository directory in a command prompt or PowerShell window and run git pull. The pull downloads the changes committed by SDG since the last pull. After the pull completes, re-open the project in Unity and allow the import process to complete. The NetGen code is committed to the repository and should not need to be re-generated after a pull unless the pulled changes directly modified RPC-annotated code that your own modifications also touch.

Can I run the CI pipeline on my own machine?

The CI pipeline is SDG-internal and not accessible to community developers. However, a mod developer who wants to set up CI for their own mod project can use GitHub Actions (free for public repositories) to build Unity projects. The SDG Jenkins configuration is Windows-specific and not directly transferable to GitHub Actions, but the concept (build on commit, run tests, optionally deploy) is the same.

Why is the Unity project so large?

The project contains the complete game asset corpus: every model, texture, audio clip, animation, and prefab in Unturned™. These assets are needed for the Editor to correctly render scenes, preview prefabs, and build asset bundles. The project size is an unavoidable consequence of the project containing the full game source, and it should be expected on a development workstation with adequate storage.

How do I find where a specific game feature is implemented?

Use the Project window search bar with the feature's known terms. Search for a class name, a field name, a menu item text, or a scene name. The search bar's type filter (t:script for C# scripts, t:scene for scenes, t:prefab for prefabs) narrows the search to the relevant asset type. If the search does not find the feature, check the Assembly-CSharp/ folder's subdirectories, which organize code by system (networking, vehicles, items, UI, etc.).

Can I delete the Builds/ folder to save space?

Yes. The Builds/ folder contains exported Unity players from previous builds and is not needed for development. Deleting it frees disk space. The folder will be recreated the next time the project is built from source. Most mod developers do not build the game from source and can safely delete the Builds/ folder entirely.

What is the Glazier setting in Editor Settings?

Glazier is Unturned's UI rendering framework. The Glazier setting in Window > Unturned > Editor Settings overrides the default Glazier configuration for testing custom UI implementations. The default setting is correct for the vast majority of mod development work and should not be changed unless the mod developer is specifically testing a custom UI system.

Can I open multiple scenes simultaneously?

Yes. Unity supports multi-scene editing. However, the Unturned™ project's scene structure (predominantly top-level game objects for optimization) makes multi-scene editing in the Hierarchy window impractical because the combined object count overwhelms the Hierarchy window's rendering. The cohort recommendation is to work in one scene at a time and close additional scenes before opening a new one.

Why are there two shortcuts for Unity Editor.log in the project root?

The shortcuts Unity Editor.log and UnityEditor Logs Folder are Windows shortcut files (.lnk) placed in the project root by SDG as a convenience for developers who need to access the log files quickly. The .log shortcut opens the most recent log file directly. The Logs Folder shortcut opens the containing folder, which contains all archived log files. The shortcuts exist because the Unity log directory path is long and varies by Unity version, making it tedious to navigate to manually.

What happens to my custom scripts when I pull an update from the U3-SDK repository?

The git pull operation merges upstream changes into the local clone. If the mod developer's custom scripts are in files that do not conflict with any file that SDG modified since the last pull, the merge completes cleanly and the custom scripts are unaffected. If SDG modified a file that the mod developer also modified, Git produces a merge conflict that must be resolved manually. The cohort recommendation is to keep custom scripts in separate assembly definition folders (which SDG is unlikely to modify) and to commit all custom work to a separate branch before pulling upstream changes.

How do I know if a directory is safe to delete from the project?

Directories that contain only build output (Builds/) are safe to delete and will be regenerated by the build pipeline. Directories that contain generated code that is committed to the repository (NetGen/) should not be deleted because deleting them removes code that is tracked in version control. Directories that contain project configuration (ProjectSettings/, Packages/) must not be deleted because the project cannot open without them. Directories that contain source assets (Assets/Game/Sources/, Assets/Runtime/) must not be deleted because they contain the content the project needs to function. The safe-to-delete directories are limited to Builds/ and any user-created temporary directories that were never committed to the repository.

What is the purpose of the asset companion files that appear alongside every asset?

Unity asset companion files are YAML-format files that the Editor generates for every asset in the project. Each companion file contains a GUID that uniquely identifies the asset, the asset's import settings, and any asset-specific metadata. The GUID in the companion file is the identifier that other assets use to reference this asset. Without the companion file, all references to the asset break because the GUID is lost. These companion files must be committed to version control alongside their corresponding assets and must never be deleted or manually edited unless the developer understands the consequences of GUID changes.

Can I use the project without Steam if I only need to work on asset bundles?

No. The project loads workshop mods and large binary files from the installed game directory, and those files are only present if Unturned™ is installed through Steam. If the game is not installed, the binary files are missing and the project cannot function correctly. This is a hard requirement of the project, not a preference or a convenience. Steam must be running, and the game must be installed, before opening the project.

Appendix A: Project directory quick-reference card

Directory	Path	Function	Mod developer interaction
Project root	/	Git repository root	Clone, pull
Assets	Assets/	Unity project content	Primary working directory
Game Sources	Assets/Game/Sources/	Asset authoring files	Place new .blend and .fbx files here
Resources	Assets/Resources/	Runtime-loaded assets	Do not add new files
Runtime (main)	Assets/Runtime/	Game code	Read, modify for script changes
Assembly-CSharp	Assets/Runtime/Assembly-CSharp/	Main code assembly	Modify for script changes
NetGen	.../Assembly-CSharp/NetGen/	Generated networking code	Regenerate after RPC changes
Packages	Packages/	Unity Package Manager	Modify manifest only when adding dependencies
ProjectSettings	ProjectSettings/	Editor configuration	Read ProjectVersion.txt
Builds	Builds/	Exported players	Can be deleted to free space
Build Scripts	Build_Scripts/	Jenkins CI scripts	Not modified by mod developers
JenkinsBootstrapper	JenkinsBootstrapper/	CI bootstrapper	Not modified by mod developers

Appendix B: Editor preference and window reference

Setting or window	Location	Recommended value
Script Changes While Playing	Edit > Preferences > General	Recompile After Finished Playing
Auto Load Level	Window > Unturned > Editor Settings	Level folder name (e.g., PEI)
Auto Load Mode	Window > Unturned > Editor Settings	Singleplayer or Level Editor
Glazier	Window > Unturned > Editor Settings	Default (do not change without specific reason)
Net Gen	Window > Unturned > Net Gen	Click "Generate" after RPC changes
Console	Window > General > Console	Open during development for error feedback
Hierarchy window	Default Editor layout	Close during play mode for performance
Project window	Default Editor layout	Use search bar before browsing

Appendix C: Net code generation procedure

The procedure below is the documented workflow for running the net code generation step after modifying RPC-annotated code.

1. Make the desired changes to RPC-annotated C# methods in the Assets/Runtime/ directory.
2. Open the Net Gen window: Window > Unturned > Net Gen.
3. Click the "Generate" button in the Net Gen window. The window displays progress as the generation runs.
4. When generation completes, click outside the Unity Editor window (on the desktop, on another application window) to shift focus away from the Editor.
5. Click back inside the Unity Editor window. Unity detects the newly generated script files and begins importing them. Wait for the import progress bar to disappear.
6. Verify that the project compiles without errors. Open the Console window (Window > General > Console) and confirm no compilation errors related to networking code appear.

Appendix D: External references

Resource	URL	Notes
Smartly Dressed Games modding documentation	https://docs.smartlydressedgames.com/en/stable/	Official SDG field and system reference; chapter 147 covers the Unity project overview
U3-SDK GitHub repository	https://github.com/SmartlyDressedGames/U3-SDK	The public repository containing the complete Unturned Unity project
Unturned on Steam	https://store.steampowered.com/app/304930/Unturned/	Game page; must be installed for the project to function
Unity Editor documentation	https://docs.unity3d.com/Manual/	Official Unity Editor manual
Jenkins documentation	https://www.jenkins.io/doc/	CI server documentation (SDG-internal)
Project Folder Structure and GUIDs	/items/project-folder-structure-and-guids	The Bundles tree structure that mod content deploys into
How to Create a New Unity Project	/unity-setup/how-to-create-a-new-unity-project	The procedure for creating a fresh Unity project
How to Import the Unturned Project Package	/unity-setup/how-to-import-the-unturned-project-package	The procedure for importing Unturned assets
How to Wait for Unity to Finish Importing	/unity-setup/how-to-wait-for-unity-to-finish-importing	The previous article in this section
Upgrading Unity Version	/unity-setup/upgrading-unity-version	The next article in this section

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Covers project acquisition, file organization, editor preferences, play mode settings, net code generation, CI pipeline, and troubleshooting.

Appendix E: Compatibility matrix of project versions and Unity versions

Unity Editor version	Project version indicator	Game version indicator	Notes
Recorded in ProjectSettings/ProjectVersion.txt	Commit hash in U3-SDK repository	Steam build ID	All three should match for a given snapshot
Version mismatch	Compilation errors, shader errors, asset import failures	-	Most common first-open failure mode
Correct version	Project opens cleanly, compiles, plays	-	Verify against ProjectVersion.txt before opening

Cross-references

• How to Wait for Unity to Finish Importing, the previous article in this section; documents the import phase that follows project opening.
• Upgrading Unity Version, the next article in this section; documents the procedure for upgrading the Unity Editor version.
• How to Create a New Unity Project, the procedure for creating a fresh Unity project before importing Unturned assets.
• How to Import the Unturned Project Package, the procedure for importing the Unturned project package into a Unity project.
• How to Install Unity Editor, the procedure for installing the correct Unity Editor version.
• Project Folder Structure and GUIDs, the Bundles tree structure that mod content deploys into; the complementary structure to the Unity project.
• Smartly Dressed Games modding documentation, the official SDG documentation; chapter 147 covers the Unity project overview.
• Unturned on Steam, the game must be installed for the project to function.