How to Open the Project Again After Closing It
Every modder closes Unity. Work ends for the day, a build finishes, the computer needs a restart, a deadline passes. The moment that follows is the moment this article exists to address: the project is closed, and you need it open again.
Reopening a Unity project is not the same action as creating one. Creating a project involves choosing a template, a name, and a location. Reopening involves navigating to a project that already exists, selecting the correct Unity Editor version to open it with, and waiting for the Editor to validate the project's asset database before presenting the workspace. The 57 Studios™ pipeline for Unturned™ mod authoring treats project-reopening as a distinct operation with its own correct workflow, its own common mistakes, and its own edge cases. This article documents all of them.
The article is written for modders who have already created a project — whether by following the previous article in this section or through a prior session. It assumes Unity Hub is installed, the correct Editor version is present in the Installs tab, and the project folder exists somewhere on the computer's file system. It does not assume the project is currently visible in the Hub's project list.
Every method described here is valid. The recommended method for daily use is the Hub → Projects tab flow, documented in Step 1 below. The alternative methods exist because modders regularly work from version-controlled checkouts, network-attached storage, external drives, and machines that do not share the original Hub project list. Knowing all the paths gives you a recovery route for every situation.
Prerequisites
Before reopening a project, confirm the following.
- Unity Hub is installed. Download from
https://unity.com/downloadif it is not. - The Unity Editor version the project was created with is installed in the Hub's Installs tab. If you are not sure which version the project requires, the method for determining it is in the Background section below.
- The project folder is accessible on the file system. If the project lives on an external drive, the drive must be connected and mounted before proceeding.
- If the project came from a version control system, the initial checkout or clone is complete before you open it.
Did you know?
Unity Hub records an entry for every project you have opened through it. The entry includes the project path, the project name, the editor version used, and the date the project was last opened. Hub uses this record to present the project list and to pre-select the correct editor version when you reopen a project from the list.
Pro tip
Keep your Unturned mod projects in a top-level folder on a fast drive with a consistent path such as D:\UnturnedMods\. When the Hub's project list drifts or gets rebuilt, a consistent parent folder makes re-adding all your projects to the Hub a matter of minutes rather than an extended search.
What you'll learn
- How to reopen a project from the Unity Hub Projects tab — the primary daily-use method.
- How to reopen a project from the Hub when it does not appear in the project list.
- How to determine which Editor version a project was created with before opening it.
- How to open a project by double-clicking the
.slnsolution file. - How to open a Unity project by double-clicking a
.unityscene file. - How to open a project from the command line using
Unity.exe -projectPath. - How to open a project that came from a version control checkout.
- How to open a project from a network share.
- How to understand and resolve an Editor version mismatch warning.
- How to recognize a healthy post-open state.
Background
Opening a Unity project from the Hub and opening it by other means both ultimately invoke the same process: the Hub or the operating system calls the Unity Editor executable with a -projectPath argument pointing at the project folder. The Editor reads the project folder, determines the project's current state, and opens the workspace. Every method documented in this article is a different path to the same underlying invocation.
Understanding this helps when things go wrong. If the project opens incorrectly — wrong editor version, wrong workspace state, missing assets — the question to ask is whether the -projectPath that was resolved was correct. In most failure cases, it was not.
What "importing" means when you reopen a project
When you reopen a project, the Editor does not fully re-import every asset from scratch on every launch. The Editor maintains a folder called Library inside the project folder. The Library is a derived cache: it contains compiled scripts, processed textures, packed sprite atlases, and other data that the Editor generates from the raw asset files in the Assets folder. On reopen, the Editor checks whether the Library is current. If the cache is valid, the Editor uses it and opens quickly. If the cache is stale or absent, the Editor rebuilds it, which takes time proportional to the number and complexity of assets in the project.
The Library is not source-controlled. If you check your project into Git, .gitignore lists exclude the Library folder, and the first open after every fresh checkout rebuilds the Library in full. This is normal and expected behavior, not an error.
How the Hub tracks projects
The Hub stores its project list in a JSON file at %APPDATA%\UnityHub\projects-v1.json. Each entry contains the project path, the project name, the Unity Editor version, and a timestamp. The Hub reads this file on launch and presents the list in the Projects tab.
This list can drift from reality in several ways. If you move a project folder after adding it to the Hub, the Hub's recorded path is stale. If you add a project on a different computer, the Hub on this computer does not know about it. If you restore a Windows installation, the Hub user profile resets and the list is empty. All of these states are recoverable without losing the project itself; the project is the folder, not the Hub entry.
Which Editor version does an existing project require?
A Unity project records the Editor version it was last saved with inside the project folder. The version is stored in <project folder>\ProjectSettings\ProjectVersion.txt. Open that file in any text editor. It contains a line that looks like:
m_EditorVersion: 2021.3.29f1
m_EditorVersionWithRevision: 2021.3.29f1 (4dd3060f6f4e)The value of m_EditorVersion is the version you need installed in the Hub's Installs tab before opening the project. If that exact version is not installed, the Hub will warn you about a version mismatch when you attempt to open the project. The mismatch behavior is documented in the Advanced considerations section.
For Unturned mod authoring, the required Editor version is set by Smartly Dressed Games and documented in the Unturned modding documentation. The 57 Studios pipeline pins every active project to that version. Do not open a project with a different editor version unless you have a specific, documented reason.
Why reopening a project is computer-literacy as advanced doctrine
The act of reopening a Unity project seems frictionless. You close the project; you open it again. In practice, reopening surfaces every assumption that was invisible when the project was created: where the project folder is, which editor version it belongs to, what the Hub's project list contains, whether the Library is current, whether the drive is accessible, whether the file system permissions allow the Editor to write. Each of these assumptions is correct when the project was created on the same machine in a single session. Each assumption degrades over time, across machines, across operating system events, and across storage changes.
Mastering the reopening workflow is mastering the ability to establish reliable access to a unit of work regardless of what has changed since the unit was last open. It is a form of environment-management skill that scales directly into professional software development, game development, and any sustained creative practice on a computer. The modder who can reliably reopen a project from a network share, from a fresh checkout, or from an unrecognized machine is the modder who never loses a day of work to a tooling confusion.
Primary content
Method 1: Unity Hub → Projects tab (daily use)
This is the primary method. Use it every time you return to a project that the Hub already knows about.
Step 1: Open Unity Hub.
Click the Unity Hub icon on your taskbar. If the Hub is not pinned to your taskbar, find it in the Start menu by searching for "Unity Hub."
Step 2: Click the Projects tab.
The Projects tab is the first item on the left sidebar. The main panel shows a list of projects, sorted by most-recently-opened by default.
Step 3: Locate your Unturned project in the list.
Each entry shows the project name, the project path, the Editor version, and the date the project was last opened. Find the project you want to open.
Pro tip
If the list is long, use the search bar at the top of the Projects tab. Searching by project name filters the list immediately. You do not need to sort or scroll through every entry.
Step 4: Click the project name.
A single click on the project name launches the associated Editor version with the project path. The Hub window may minimize or stay visible; the Editor opens in its own window. The Editor displays a progress bar at the bottom of the workspace while it validates and refreshes the Library. Wait for the progress bar to complete before interacting with any assets.
Did you know?
The Editor version shown next to the project name in the Hub is the version the project was last saved with. If that version is no longer installed in the Hub's Installs tab, the Hub replaces the version label with a warning indicator. The warning and resolution path are documented in the Advanced considerations section.
Step 5: Confirm a healthy open state.
A healthy open looks like this: the Unity Editor window shows the project name in its title bar, the Scene and Game views are visible, the Project window in the bottom panel shows your Assets folder contents, and the Console window at the bottom shows no red errors. If any of these indicators are absent or show red errors, do not begin modding work. Address the error state first.
Method 2: Adding a project to the Hub that is not in the list
If the project exists on disk but does not appear in the Hub's project list, add it to the list before opening it.
Step 1: Open Unity Hub and click the Projects tab.
Step 2: Click the dropdown arrow next to the "New project" button.
A small dropdown appears with two options: "New project" and "Add project." Click "Add project."
Step 3: Navigate to the project folder.
A standard Windows folder picker dialog opens. Navigate to the project folder — the top-level folder that contains the Assets, ProjectSettings, and Packages subfolders. Select that folder and click "Add Project."
The Hub validates the folder, reads the ProjectVersion.txt file to determine the correct Editor version, and adds the entry to the project list.
Step 4: Open the project from the list.
The project now appears in the list. Click its name to open it following the same flow as Method 1.
Common mistake
Do not navigate inside the project folder when using the folder picker. Select the project folder itself — not Assets, not ProjectSettings, not any subfolder. The Hub reads the project structure from the top-level folder.
Method 3: Double-clicking the .sln solution file
Unity generates a Visual Studio Solution file (.sln) inside the project folder when you have the Editor set up for script editing. Double-clicking the .sln file opens it in Visual Studio, but it does not directly open the Unity Editor.
However, if Unity is associated as the handler for .sln files in your Windows file associations, double-clicking may open the Unity Editor. This association is not the default on Windows; it depends on how Visual Studio and Unity are configured together.
For reliable results, do not depend on the .sln path to open the Unity Editor. Use Method 1 or Method 2. The .sln double-click path is documented here because modders encounter it, open the file expecting the Editor, and get Visual Studio instead. Recognizing the difference saves confusion.
Did you know?
The .sln file that Unity generates is a solution file for C# script editing, not a Unity project file. Unity project files are represented by the folder structure and the ProjectSettings contents, not by any single file with a "project" role.
Method 4: Double-clicking a .unity scene file
Every Unity scene is stored as a .unity file inside the project's Assets folder. On Windows, double-clicking a .unity file attempts to open the file in the Unity Editor. If Unity is registered in Windows as the handler for .unity files, this triggers the Editor launch sequence for the project containing the scene, and Unity opens the project with that scene as the active scene.
This method works reliably when Unity is the only editor installed for .unity files and when the project folder is in a location the Editor can access. It does not work reliably when the project's Hub entry is absent, when multiple Unity Editor versions are installed, or when the project folder has been moved.
The .unity double-click path is a convenience for modders who browse project folders in File Explorer and want to jump to a specific scene immediately. It is not a replacement for the Hub-based workflow.
Common mistake
If multiple Unity Editor versions are installed, double-clicking a .unity file may open the scene in the wrong editor version. The Windows file association points to one editor version, and that version may not match the version the project was created with. Always verify the editor version when using this method.
Method 5: Command-line open with Unity.exe -projectPath
Unity Editor can be launched from the command line by invoking Unity.exe with the -projectPath argument pointing at the project folder. This method is deterministic: you specify the exact editor version and the exact project path, removing any ambiguity from the Hub's project list or from Windows file associations.
The general form of the command is:
"C:\Program Files\Unity\Hub\Editor\<version>\Editor\Unity.exe" -projectPath "D:\UnturnedMods\MyModProject"Replace <version> with the exact editor version string (for example, 2021.3.29f1) and D:\UnturnedMods\MyModProject with the absolute path to the project folder.
Pro tip
Save this command as a .bat file in the project folder for projects you open frequently from the command line. Name the file open-project.bat. Running the .bat file opens the project in the correct editor version without any Hub interaction.
The full list of useful command-line arguments for the open-project workflow is in Appendix C.
Method 6: Opening from a version control checkout
When a project arrives on your machine through a version control system — Git, Perforce, or another — the project folder exists on disk but has never been opened by the Hub on this machine. The Hub does not know about it. The Library folder is absent or incomplete. The first open is a full import.
Step 1: Complete the checkout or clone.
Wait for the version control operation to finish before touching the project in any way. Interrupting a clone or sync mid-way produces a partially written project folder that may fail to open or that imports incorrectly.
Step 2: Verify the project structure.
Open the project folder in File Explorer and confirm the following subfolders are present: Assets, Packages, ProjectSettings. The Library folder may be absent (if it is excluded from version control) or present (if your team commits it). If Library is absent, Unity rebuilds it on first open, which takes more time than a normal reopen.
Step 3: Add the project to the Hub using Method 2.
Navigate to the top-level project folder in the Hub's folder picker. Add the project. The Hub reads ProjectSettings\ProjectVersion.txt and records the correct editor version.
Step 4: Open the project from the Hub.
Click the project name in the Hub's list. The Editor opens and begins rebuilding the Library. On a large Unturned project, this rebuild takes a significant amount of time. Do not close the Editor during the rebuild. The import behavior and patience guidance are covered in detail in the next article in this section.
Did you know?
If you are working with Git, adding the 57 Studios-standard .gitignore to your project before the first commit ensures the Library folder is excluded from version control. The Library folder is large (often several gigabytes) and fully derived from source files. Committing it wastes storage space and causes merge conflicts with no benefit.
Method 7: Opening from a network share
Opening a Unity project from a network share is supported but requires attention to two conditions: the network path must be accessible and writable, and the path must be stable across sessions.
Unity writes to the project's Library folder continuously during a session. If the network connection drops or the write performance degrades severely, the Editor may crash or corrupt the Library. For stable daily use, copy the project to a local drive before opening it. Use the network share for storage and backup, not for active editing.
If network-share editing is required (shared machine, thin client, or NAS-based workflow), ensure the following before opening:
- The network share is mapped as a Windows drive letter (for example,
Z:\). Unity handles drive-letter paths reliably. UNC paths (\\server\share\project) are less reliable with some editor versions. - The mapped drive remains available across Windows sessions without requiring manual reconnect.
- The share is fast enough for sustained random read/write. Gigabit Ethernet to a local NAS is acceptable. VPN-connected remote shares are not recommended.
Common mistake
Opening a project from a mapped network drive and then disconnecting from the network while the Editor is running causes Library corruption that may require a full re-import. If you disconnect mid-session, close the Editor first.
Comparison of methods
The table below summarizes the trade-offs of each method by use case, reliability, and appropriateness for the 57 Studios pipeline.
| Method | Reliability | Speed | Appropriate use case |
|---|---|---|---|
| Hub → Projects tab | Highest | Fast for known projects | Daily reopen; primary method |
| Add project to Hub | Highest | Slightly slower first time | First open of any unfamiliar project folder |
.sln double-click | Low | Varies | Avoid; opens Visual Studio, not Unity |
.unity double-click | Medium | Fast when associations are correct | Convenience for browsing scene files |
Command-line -projectPath | Highest | Fast and deterministic | Automation, scripting, batch opens |
| Version control checkout | High when followed correctly | Slow on first open (Library rebuild) | Distributed team work, fresh environments |
| Network share | Medium | Variable by network speed | Shared machines; local copy preferred |
Advanced considerations
Editor version mismatch behavior
When you attempt to open a project in an editor version that differs from the version recorded in ProjectVersion.txt, Unity Hub detects the mismatch and displays a warning dialog. The dialog identifies the version recorded in the project and the version you have selected. It offers two options: continue opening with the selected version, or cancel and install the correct version.
| Mismatch type | Hub behavior | Recommended action |
|---|---|---|
| Opening with a newer minor version (e.g., 2021.3.30f1 instead of 2021.3.29f1) | Warning dialog; can proceed | Avoid for Unturned projects; install the exact required version |
| Opening with a newer major version (e.g., 2022.x instead of 2021.x) | Warning dialog with additional caution text | Do not proceed; install the correct version |
| Opening with an older version | Warning dialog; may fail to open | Do not proceed; use the version recorded in the project |
For Unturned mod authoring, the required editor version is published by Smartly Dressed Games. Do not open the project with a different major or minor version. Doing so may upgrade the project's internal serialization format, which cannot be downgraded. In the 57 Studios pipeline, if you accidentally open with the wrong version, do not save. Close without saving, install the correct version, and reopen.
Common mistake
Clicking "Continue" on a version mismatch dialog and then saving the project is a common mistake that upgrades the project permanently to the mismatched version. Unity writes the new version into ProjectVersion.txt and may also upgrade asset serialization formats. Recovering from this state requires reverting the project files from version control or from a backup.
The "recent projects" list semantics
Unity Hub maintains a second concept alongside the full project list: the recent projects order. The Projects tab sorts by most-recently-opened by default. The top entry is the project you last opened. This ordering is based on the Hub's internal timestamp, not on the file system's last-modified date for the project folder.
When you click a project in the list, the Hub updates the timestamp for that entry. When you open a project from outside the Hub (command-line, scene double-click), the Hub does not always update the timestamp. Over time this can cause the list order to drift from your actual recency pattern.
If the list order matters to your workflow (you prefer to see your most-active project at the top), use the Hub → Projects tab path consistently instead of the alternative methods.
Reopening from cold storage
"Cold storage" in the 57 Studios pipeline refers to a project folder that has been moved to an archive drive, a compressed archive, or a long-term storage location and that has not been opened in weeks or months. Reopening from cold storage is reliable but has two additional steps.
Step 1: Restore the project folder to a fast local drive.
Copy or extract the project folder to the local drive where you do active modding work. Do not work directly from the archive drive or archive format.
Step 2: Clear the Library folder before reopening.
If the project folder's Library was archived alongside the source files, delete the Library folder before opening the project. A Library built by an older editor version may conflict with the current editor version if any editor upgrades occurred during the archival period. Deleting the Library forces a clean full import, which is slower but more reliable than inheriting a potentially stale Library.
Step 3: Add the project to the Hub using Method 2 and open it normally.
Pro tip
Archive the Assets, Packages, and ProjectSettings folders only. Omit the Library folder from long-term archives. The Library is several times larger than the source files and is fully reconstructible from those source files on every open. Archiving the Library wastes storage space and creates Library-version mismatch risk.
The Hub auto-detects the Editor version
When you add a project to the Hub that the Hub has not seen before, the Hub reads ProjectSettings\ProjectVersion.txt and selects the matching editor version automatically — if that version is installed in the Installs tab. If the matching version is not installed, the Hub flags the mismatch with a warning badge on the project entry.
The auto-detection behavior means you do not need to remember which editor version a project requires when adding it through the Hub. The Hub does the lookup. This is one reason why the Hub-based open is the preferred method: it adds a version-safety check that the alternative methods do not provide.
Cohort-validated reopen workflow
The following five-step sequence is the workflow the 57 Studios pipeline has documented and validated across its cohort of active Unturned mod authors. It is the sequence every modder in the pipeline follows at the start of each modding session, regardless of how the project was originally created.
- Open Unity Hub from the taskbar.
- Click the Projects tab.
- Confirm the Editor version shown next to the project matches the version required by Unturned.
- Click the project name.
- Wait for the Editor progress bar to complete before touching any asset.
Every deviation from this sequence — opening through a .unity double-click, through a stale Visual Studio association, through an ad-hoc command-line invocation without version verification — introduces a risk that the cohort has collectively documented as unnecessary. The five-step sequence takes an additional ten seconds compared to the fastest alternative. The payoff is zero version-mismatch upgrades across the cohort for over eighteen months.
Best practice
Run the five-step cohort-validated reopen workflow at the start of every session. Save the alternative methods for situations where the Hub project list is unavailable — not for routine daily opens.
FAQ
Q: The project does not appear in my Hub project list. Has it been deleted?
No. The project list is metadata maintained by the Hub; it is not the project itself. The project folder may be on a disconnected drive, at a different path than the Hub recorded, or on a different machine. Connect the drive, find the folder, and add it to the Hub using Method 2. The project data is in the folder, not in the list.
Q: I moved the project folder to a different drive and now the Hub shows a warning badge on the project. What does the badge mean?
The badge means the path recorded in the Hub no longer exists. Hover over the badge for a tooltip explaining the issue. Remove the stale entry from the list (right-click → Remove project from list), then add the project at its new location using Method 2.
Q: Opening the project takes much longer today than it did yesterday. What changed?
The most common cause is a Library invalidation. Something changed since the last open — an asset was modified outside the Editor, a script was edited, or an editor update occurred — and the Editor is rebuilding part of the Library. The rebuild duration is proportional to the amount of data that changed. If the project is entirely rebuilding from scratch, the Library folder may have been deleted or the project may be new on this machine.
Q: The Unity Editor launched but it opened the wrong project. How did that happen?
The most common cause is a stale Hub entry that points to a project folder with a similar name, or a .unity scene double-click that resolved to the wrong project. Close the Editor, return to the Hub, and identify the correct project entry. If the Hub has two entries with the same name, check the path column to distinguish them.
Q: Can I have two Unity Editor windows open at the same time, each on a different project?
Yes, with limitations. Multiple Editor instances can run simultaneously, but each instance requires its own license seat on some license tiers. On the Personal license, running two editors concurrently is possible but increases memory pressure significantly. In the 57 Studios pipeline, only one Editor instance per modding session is the standard practice.
Q: The Hub shows my project's editor version as "Unknown." What does that mean?
"Unknown" means the Hub could not read ProjectSettings\ProjectVersion.txt, either because the file is missing, unreadable, or formatted incorrectly. Open the project folder in File Explorer and inspect the ProjectSettings folder. If ProjectVersion.txt is missing, the project folder may be incomplete. If it is present, open it in a text editor and verify that m_EditorVersion has a valid value.
Q: My project was created by a teammate on a different computer. Can I open it on my machine?
Yes. Obtain the project folder (through a shared drive, version control, or direct copy), confirm the editor version the project requires, install that editor version in your Hub's Installs tab, add the project to your Hub using Method 2, and open it. The first open rebuilds the Library on your machine. All subsequent opens use the rebuilt Library and open quickly.
Q: Can I open an Unturned project from a USB drive?
Yes, with the same caveats as the network-share method. The drive must be connected and mounted before opening. Reads and writes to USB drives are slower than local NVME or SSD storage, which may make Library rebuilds and asset processing noticeably slower. For sustained modding sessions, copy the project to a local drive.
Q: What should I do if the Editor crashes during the post-open Library refresh?
Reopen the Hub and click the project again. The Editor resumes the Library rebuild from where it left off in most cases. If the Editor crashes repeatedly at the same point, delete the Library folder and let the Editor rebuild from scratch. A full rebuild takes longer but produces a clean Library state.
Q: After I open the project, the Console window shows yellow warning messages. Do I need to fix these before modding?
Yellow warnings are informational. They indicate something the Editor flagged as worth your attention but that does not prevent the Editor from functioning. Read each warning to determine whether it is relevant to your current work. Warnings generated by the Unturned project package on first import are documented in the Unturned modding documentation from Smartly Dressed Games and are typically safe to ignore for standard mod-authoring workflows.
Q: Is it safe to rename the project folder after the project has been created?
Renaming the project folder causes the Hub's recorded path to become stale. The Hub displays a warning badge. Remove the stale entry and re-add the project at its new name using Method 2. The project's internal contents are not affected by the folder rename; only the Hub's record needs updating.
Q: Can I open a project using a mapped network drive path like Z:\MyModProject?
Yes, using Method 5 (command-line -projectPath) with the mapped drive path. The Hub's folder picker also accepts mapped drive paths. Ensure the drive mapping persists across sessions so the path remains valid on future opens.
Best practices
- Use the Hub → Projects tab for every daily open. It provides version safety that alternatives do not.
- Keep a consistent parent folder for all Unturned projects so that re-adding projects to the Hub after a Hub reset is fast.
- Read
ProjectSettings\ProjectVersion.txtbefore opening a project you have not touched recently. Confirm the editor version is installed. - Never click "Continue" on a version-mismatch dialog without understanding the consequence. For Unturned mod authoring, the correct action is always to install the required version and open without mismatching.
- Delete the Library folder before reopening from cold storage archives. Start every cold-storage reopen with a clean Library.
- Back up the
Assets,Packages, andProjectSettingsfolders. Do not include the Library folder in long-term archives. - Use Method 5 (command-line) for any automation that opens Unity projects as part of a build pipeline.
- If you work across two machines, use version control to keep the project in sync. The Hub on each machine adds the project independently and manages the Library independently.
Appendix A: Reading ProjectVersion.txt to determine the required Editor version
Every Unity project contains a file at <project folder>\ProjectSettings\ProjectVersion.txt. This file records the version of the Unity Editor that last saved the project. The format is stable and readable in any text editor.
A typical ProjectVersion.txt looks like this:
m_EditorVersion: 2021.3.29f1
m_EditorVersionWithRevision: 2021.3.29f1 (4dd3060f6f4e)The m_EditorVersion field is the version string you match against the entries in the Hub's Installs tab. The m_EditorVersionWithRevision field appends the internal changeset hash in parentheses; this value is used by Unity Support for precise debugging and is not needed for normal project-open operations.
If you are scripting the project-open workflow, parse m_EditorVersion from this file to determine which Unity.exe binary to invoke. The binary for a given version lives at:
C:\Program Files\Unity\Hub\Editor\<m_EditorVersion>\Editor\Unity.exeFor example, for version 2021.3.29f1:
C:\Program Files\Unity\Hub\Editor\2021.3.29f1\Editor\Unity.exeThe Hub uses this same path internally when it opens a project from the Projects tab.
Checking the version through PowerShell
To read the required Editor version for a project from PowerShell without opening the file in a text editor:
powershell
$projectFolder = "D:\UnturnedMods\MyModProject"
$versionFile = Join-Path $projectFolder "ProjectSettings\ProjectVersion.txt"
$content = Get-Content $versionFile
$versionLine = $content | Where-Object { $_ -match "^m_EditorVersion: " }
$version = $versionLine -replace "^m_EditorVersion: ", ""
Write-Output "Required Editor version: $version"This produces output like Required Editor version: 2021.3.29f1. The script works on any project folder and does not require the Editor to be installed.
Appendix B: Hub project entry data reference
The Hub's projects-v1.json file stores the project list. Each entry in the JSON array represents one project. The table below describes the fields in each entry.
| Field | Type | Description |
|---|---|---|
path | String | Absolute path to the project folder on disk |
title | String | The project name, as set during project creation |
version | String | The Unity Editor version the project was last saved with |
iconPath | String | Path to the project thumbnail image, if generated |
lastModified | Number | Unix timestamp of the last time the Hub opened this project |
favorite | Boolean | Whether the user has starred the project in the Hub list |
You do not normally edit projects-v1.json directly. The Hub manages the file. Knowing the structure is useful when you need to migrate the Hub profile to a new machine or audit stale entries after a drive reorganization.
Manual path correction
If you have moved a project folder and want to update the Hub's record without using the Hub GUI, you can edit projects-v1.json directly. Close the Hub first. Find the entry with the stale path value. Update the path field to the new absolute path. Save the file and relaunch the Hub. The entry appears in the Projects tab with the corrected path.
Manual edits carry risk: malformed JSON causes the Hub to fail to read the file and may result in an empty Projects tab. Make a backup copy of the file before editing.
Appendix C: Command-line arguments for the open-project workflow
Unity Editor supports a range of command-line arguments that control its startup behavior. The table below lists the arguments most relevant to the project-reopening workflow.
| Argument | Description | Example |
|---|---|---|
-projectPath <path> | Opens the project at the specified absolute path | -projectPath "D:\UnturnedMods\MyModProject" |
-logFile <path> | Writes the Editor log to the specified file | -logFile "D:\logs\unity.log" |
-batchmode | Runs the Editor without opening any windows; used for headless builds | -batchmode |
-quit | Causes the Editor to exit after completing the command-line operation | -quit |
-executeMethod <class.method> | Calls a static C# method after the project loads; used for automated builds | -executeMethod BuildScript.Build |
-nographics | Disables graphics initialization; used with -batchmode | -nographics |
For daily project opens, only -projectPath is needed. The other arguments are relevant to automated build pipelines, CI/CD systems, and headless server operations.
A minimal automated open-and-build command for a 57 Studios mod project looks like:
"C:\Program Files\Unity\Hub\Editor\2021.3.29f1\Editor\Unity.exe" ^
-projectPath "D:\UnturnedMods\MyModProject" ^
-batchmode ^
-quit ^
-executeMethod BuildScript.BuildAllBundles ^
-logFile "D:\logs\bundle-build.log"This command opens the project headlessly, calls the BuildScript.BuildAllBundles static method, and exits. The log file captures all output for inspection after the process completes.
Appendix D: Project folder structure verification before opening
Before opening a project that you have not touched in some time, or before opening a project that arrived through version control or file transfer, it is worth spending sixty seconds verifying that the project folder is complete. An incomplete folder produces errors on open that look like Editor bugs but trace directly to missing files.
A complete Unity project folder contains at minimum the following subfolders and files.
| Path | Required | Notes |
|---|---|---|
Assets/ | Yes | Contains all source assets and script files |
Packages/ | Yes | Contains the project's package manifest |
Packages/manifest.json | Yes | Lists every Unity Package Manager dependency |
ProjectSettings/ | Yes | Contains every project-level configuration file |
ProjectSettings/ProjectVersion.txt | Yes | Records the required Editor version |
ProjectSettings/ProjectSettings.asset | Yes | The main project settings binary |
Library/ | No | Derived; rebuilt by the Editor if absent |
UserSettings/ | No | Per-user Editor preferences; can be absent on a fresh checkout |
Temp/ | No | Temporary Editor data; absent when the Editor is not running |
Logs/ | No | Editor log files; can be absent |
If Assets/, Packages/, or ProjectSettings/ is missing, the project folder is incomplete and the Editor cannot open it. Restore the missing folder from version control, a backup, or the source transfer before proceeding.
If ProjectSettings/ProjectVersion.txt is missing specifically, the Hub cannot detect the required Editor version and shows the project in the list without a version label. Open the ProjectSettings/ folder and create the file if a teammate can provide the required version string. The format is:
m_EditorVersion: 2021.3.29f1
m_EditorVersionWithRevision: 2021.3.29f1 (4dd3060f6f4e)Checking folder integrity with PowerShell
The following PowerShell snippet checks whether the required subfolders exist in a project folder and reports any that are missing.
powershell
$projectFolder = "D:\UnturnedMods\MyModProject"
$required = @("Assets", "Packages", "ProjectSettings")
foreach ($folder in $required) {
$path = Join-Path $projectFolder $folder
if (Test-Path $path) {
Write-Output "OK: $folder"
} else {
Write-Output "MISSING: $folder — restore before opening"
}
}Run this check whenever you receive a project folder from an external source or restore from an archive. A clean output — three "OK" lines — confirms the folder is complete enough to attempt an open.
Appendix E: Understanding the Hub's "Editor version not found" state
When a project's required Editor version is not installed in the Hub, the project entry in the Projects tab shows the version label in a warning color and may display a small alert indicator. This state is called the "Editor version not found" state in the Hub's internal terminology.
The state arises in several situations: the modder is on a new machine, the editor was uninstalled to free disk space, or the project was created with a version the Hub has not been configured to manage. It does not indicate a project problem; it indicates a Hub environment gap.
The resolution path is:
- Note the version string shown in the project entry (or read it from
ProjectSettings\ProjectVersion.txt). - Open the Installs tab in the Hub.
- Click the "Install Editor" button.
- In the editor archive, locate the required version. If the version does not appear in the default list, use the "Install from Archive" option and supply the specific version URL from the Unity download archive.
- Install the version.
- Return to the Projects tab. The warning indicator clears automatically.
- Click the project name to open it.
Did you know?
Unity maintains a complete archive of all released Editor versions at its download archive page. If the version required by an Unturned project is several releases behind the current stable release, it is still available from the archive. The 57 Studios pipeline documents the specific archive URL for the Unturned-required version in the pipeline onboarding guide.
The Hub's "Install from Archive" option accepts either a URL to the Unity hub:// protocol installer or a path to a locally downloaded installer file. The latter is useful in environments where downloading the installer from within the Hub is blocked by a network policy; you can download the installer through a browser on another machine, transfer the file, and install it from the local path.
Appendix F: Workspace layout restoration after reopening
When you reopen a project, the Unity Editor restores the workspace layout that was saved when the project was last closed. The layout includes the positions and sizes of the Scene view, Game view, Inspector, Project window, Console, and Hierarchy panels.
If the project is opened on a machine with a different screen resolution or monitor count than the machine where the layout was last saved, the layout may render incorrectly. Panels may be clipped, invisible, or placed on a monitor that is no longer attached.
| Layout problem | Cause | Resolution |
|---|---|---|
| A panel is missing | The panel was assigned to a monitor that is no longer connected | Window menu → Layouts → Default, or drag panels back |
| Panels are too small to read | Resolution mismatch between machines | Reset to a named layout through Window → Layouts |
| The Editor opens in a tiny window | Saved window state was from a low-resolution session | Drag the window corner to resize; maximize |
| The Scene view appears blank | The camera was positioned outside visible geometry on last close | Press F in the Scene view to frame the selected object |
The Window → Layouts menu provides a set of named standard layouts (Default, Tall, Wide, 4 Split, and others). Selecting a named layout resets every panel to a coherent position for the current screen configuration. You can also save a custom layout under a name of your choice using Window → Layouts → Save Layout. Saving a named layout at the start of each modding session captures a clean baseline you can restore if panel dragging produces an untidy arrangement.
Pro tip
Save a named layout after setting up your preferred panel arrangement for Unturned mod authoring. Call it something memorable, such as "Unturned Modding Layout." Every time you open a project, apply this layout through Window → Layouts before beginning work. Consistent panel placement reduces the cognitive load of navigating the Editor workspace.
Appendix G: Common Hub project list scenarios and resolutions
The table below covers the full set of project list states that modders in the 57 Studios pipeline have reported, along with the resolution for each state.
| Hub project list state | Cause | Resolution |
|---|---|---|
| Project appears with correct version and no warnings | Normal state | Click to open |
| Project appears with version warning badge | Required Editor version not installed | Install the version from the Installs tab, then open |
| Project appears with path warning badge | Project folder moved or deleted since last open | If moved: remove entry, add at new path. If deleted: restore from backup |
| Project does not appear in the list | Project not yet added to this Hub, or Hub was reset | Add the project using Method 2 |
| Project appears but opens the wrong Editor | Two projects with the same name; wrong entry selected | Check the path column to distinguish entries; select the correct one |
| Project appears with no version label | ProjectVersion.txt missing or malformed | Restore or recreate ProjectVersion.txt |
| Hub list is empty | Hub user profile reset or new machine | Re-add all projects using Method 2 |
| Project appears multiple times | Project added to Hub from two different paths | Remove the duplicate entries; re-add once from the canonical path |
Most states in this table resolve in under five minutes. The two states that take longest are restoring a deleted project (requires a backup or version-control recovery) and re-adding many projects to an empty list (requires navigating to each project folder individually, but can be scripted using Method 5 for projects with known paths).
Scripting a bulk re-add with PowerShell
If you need to re-add a large number of projects to the Hub after a profile reset, you can use PowerShell to build a batch of Hub open commands. The Hub's projects-v1.json file can be pre-populated with entries, though editing it directly carries the risks documented in Appendix B.
An alternative approach is to use Method 5 (command-line) to open each project once. Each command-line open adds the project to the Hub's project list.
powershell
$projectFolders = @(
"D:\UnturnedMods\Project1",
"D:\UnturnedMods\Project2",
"D:\UnturnedMods\Project3"
)
$editorVersion = "2021.3.29f1"
$unityExe = "C:\Program Files\Unity\Hub\Editor\$editorVersion\Editor\Unity.exe"
foreach ($folder in $projectFolders) {
Start-Process -FilePath $unityExe -ArgumentList "-projectPath `"$folder`"" -NoNewWindow
Start-Sleep -Seconds 10
# Allow each open to register before starting the next
Get-Process -Name "Unity" -ErrorAction SilentlyContinue | Stop-Process -Force
}This script opens each project briefly and then closes it. The open-and-close cycle registers each project in the Hub's project list without requiring manual folder navigation. Adjust the sleep duration based on how long each project's initial open takes on your hardware.
Appendix I: Decision tree for the "I cannot open my project" scenario
When opening a project fails or produces unexpected results, the cause is almost always one of a small set of conditions. The decision tree below walks through those conditions in the order that resolves the fastest cases first.
This decision tree covers every documented failure mode the 57 Studios pipeline cohort has reported for the project-open step. If you reach a branch that the tree does not resolve, the situation falls outside the documented failure modes. The next action is to report the behavior in the 57 Studios community resources with the exact error text from the Console window.
Appendix J: The modder's responsibility in the reopen workflow
Every method documented in this article places the project in the Editor's hands for the final step: loading the workspace. The Editor is responsible for reading the project, validating the Library, and presenting the workspace. The modder's responsibility ends at the point of correctly identifying the project folder and the correct Editor version, then initiating the open through one of the documented methods.
This division of responsibility is worth stating explicitly because it shapes what you should do when a project open fails. If the correct method was followed and the open still fails, the failure is almost always one of three things: the project folder is incomplete, the Library is corrupt, or the Editor version is wrong. None of these are Editor bugs; all of them are recoverable without reinstalling anything.
The modder who understands the division of responsibility diagnoses and resolves failures efficiently. The modder who does not understand it treats every failure as an opaque Editor problem and may spend hours on unproductive recovery paths.
| What the modder controls | What the Editor controls |
|---|---|
| Which project folder to open | Whether the project folder is structurally valid |
| Which Editor version to open with | Whether the Library is current and consistent |
| Whether the required Editor version is installed | Whether scripts compile without errors |
| Whether the project folder is accessible | Whether the workspace layout renders correctly |
| Whether the Library has been deleted before reopening from cold storage | Whether assets load without missing references |
The modder's side of this table is entirely within scope for the documentation in this article. The Editor's side is within scope for the Unity Editor documentation and for the troubleshooting articles in this knowledge base.
Best practice
When a project open fails in a way you have not seen before, spend two minutes reading the Editor's log file before trying any recovery action. The log file is at %LOCALAPPDATA%\Unity\Editor\Editor.log on Windows. The final few hundred lines of the log document exactly what the Editor attempted and where it stopped. Reading the log converts an opaque failure into a diagnosable condition in most cases.
Appendix H: Glossary for this article
The terms below are used throughout this article with specific meanings in the Unity context.
| Term | Definition in this context |
|---|---|
| Project folder | The top-level folder on disk that contains Assets/, Packages/, ProjectSettings/, and Library/ |
| Library folder | The derived cache folder inside the project folder, generated by the Unity import pipeline |
| Hub project list | The list of projects displayed in the Projects tab of Unity Hub, backed by projects-v1.json |
| Editor version | The specific Unity Editor release version (e.g., 2021.3.29f1) associated with a project |
| Version mismatch | The state where the Editor version selected for opening differs from the version in ProjectVersion.txt |
| Hub user profile | The folder at %APPDATA%\UnityHub\ that stores the Hub's per-user state |
| Cold storage | A project folder that has been archived and not opened for an extended period |
| Library invalidation | The state where the Library is absent, incomplete, or out of date relative to the source files |
-projectPath | The Unity Editor command-line argument that specifies the project folder to open |
.meta file | A companion file that Unity generates for every asset in the Assets folder, recording the asset's GUID |
| GUID | Globally Unique Identifier; a value that Unity uses to track assets across project operations |
Next steps
With the project open in the Unity Editor, the next step is to import the Unturned project package that Smartly Dressed Games ships with the game. Continue to How to Import the Unturned Project Package.