How to Create a New Folder

A folder is a container in the Windows file system that holds files and other folders. Without folders, every file on your computer would sit in a single flat list at the root of each drive, and finding anything would be impossible. For Unturned™ mod developers, folder structure is the scaffolding around which every project is organized. A well-structured project folder lets you locate any asset in seconds. A poorly structured one wastes hours every week to confusion and duplication.

This article covers the three methods for creating folders in Windows File Explorer, the naming conventions that work well for mod projects, the appropriate depth of folder nesting, and a recommended folder structure for a 57 Studios™ Unturned mod project. By the end you will be able to scaffold a new project folder structure in under a minute.

Prerequisites

You should have File Explorer open and configured to show extensions and hidden items. If you have not yet completed this configuration, read How to View File Extensions and How to View Hidden Files. You should also be comfortable with navigating and renaming.

What you will learn

• Three methods for creating folders
• Naming conventions that work well for mod projects
• Appropriate folder depth and the diminishing returns of deep nesting
• A recommended structure for an Unturned™ mod project
• How to scaffold multiple folders at once with PowerShell
• How to recover when you accidentally created a folder in the wrong location
• How folder structure affects build performance and tool integration
• How to migrate existing projects to a better folder structure
• How professional modders evolve folder structure across a project's lifetime
• How to verify a scaffolded folder structure matches the project specification

What folder creation actually does

Creating a folder adds a new directory entry to the file system. The entry holds the folder's name, its creation timestamp, and a pointer to the (initially empty) list of child entries. No bytes are written to disk beyond the directory metadata.

The metadata-only nature of folder creation means it is fast and atomic. A new folder is fully created at the file-system level before File Explorer enters rename mode. The rename mode that follows is a UI convenience to let you give the folder its proper name immediately.

Did you know?

A newly created empty folder consumes approximately 4 KB of space on NTFS (the minimum cluster size). Even a folder containing zero files occupies space on disk. For projects with thousands of small folders, this overhead compounds. A project with 5,000 empty subfolders consumes roughly 20 MB before any files are added.

Method 1: Ctrl + Shift + N keyboard shortcut

The keyboard shortcut is the fastest folder creation method.

1. Navigate to the location where you want to create the new folder.
2. Click an empty area inside the folder, or click the file list, to ensure the focus is on the folder contents and not the navigation pane.
3. Press Ctrl + Shift + N.
4. A new folder appears with the default name New folder selected for editing.
5. Type the desired name and press Enter.

The new folder is created and immediately enters rename mode so you can name it without an extra step. If you press Enter without typing, the folder is created with the literal name "New folder", which you can rename later with F2.

Pro tip

Practice Ctrl + Shift + N until it is automatic. This shortcut is one of the most useful in all of Windows because folder creation is so frequent in mod work. Within a week of building the habit, your folder structure speed will more than double.

Pro tip

After creating one folder with Ctrl + Shift + N and naming it, press Ctrl + Shift + N again immediately. A second new folder is created at the same level. You can scaffold a flat set of sibling folders rapidly using only this shortcut and the typed name for each.

Method 2: Right-click → New → Folder

The right-click context menu provides a visible alternative.

1. Right-click an empty area inside the destination folder.
2. Hover over New in the context menu.
3. A submenu appears listing folder and several file types.
4. Click Folder at the top of the submenu.
5. The new folder appears with the default name selected for editing.
6. Type the desired name and press Enter.

This method is slower than the keyboard shortcut but is reliable when you do not remember the shortcut. The New submenu is also useful when you want to create other file types directly, such as a Text Document or a Bitmap image.

Common mistake

Right-clicking a file instead of empty space changes the context menu and removes the New submenu. Always right-click empty space when creating a folder. If the new submenu does not appear, you clicked an existing item by mistake.

Common mistake

The New submenu's contents vary depending on installed applications. Photoshop adds Photoshop Document, Office adds Word and Excel documents. The Folder entry is always present at the top of the submenu, but its position relative to other entries varies.

Method 3: Ribbon or command bar New folder button

The ribbon and command bar expose New folder as a toolbar button.

Windows 10:

1. Click the Home tab in the ribbon.
2. Click New folder in the New group.

Windows 11:

1. Click the + New button at the top left of the command bar.
2. Choose Folder from the dropdown.

The new folder appears and enters rename mode.

Comparison of folder creation methods

Method	Speed	Skill level	Best context
Ctrl + Shift + N	Fastest	Beginner	Any time
Right-click → New → Folder	Medium	Beginner	Mouse already in hand
Ribbon or command bar	Slow	Beginner	Learning the interface

Method usage among professional modders

Ctrl + Shift + N dominates folder creation in interactive workflows. The 16 percent share for PowerShell scaffolding reflects the dominant role of scripted folder creation in project setup: modders rarely scaffold a new project's entire folder tree one folder at a time, preferring a single PowerShell command that creates all needed folders in one execution.

Naming conventions for mod project folders

A consistent naming convention reduces friction across the entire project. The four common conventions are:

Convention	Example	When to use
PascalCase	ItemTextures	Code-adjacent folders matching C# class names
snake_case	item_textures	Cross-platform compatibility, Linux-adjacent work
kebab-case	item-textures	Web-adjacent assets
Title Case	Item Textures	Top-level project folders, user-facing names

For Unturned™ mod projects, the most common convention is Title Case at the top of a project hierarchy and PascalCase for folders that map to asset categories. Spaces in folder names are allowed but require quoting in PowerShell paths, so technical folders often avoid them.

Best practice

Pick a convention before starting your project and document it in a README.txt at the project root. Stick to it strictly. Mixed conventions look messy and slow you down because you have to remember which folder uses which style.

Best practice

For folders that will be referenced by scripts, prefer convention styles without spaces or special characters. PowerShell and command-line tools handle paths with spaces correctly when paths are quoted, but the quoting is friction that compounds across many scripts.

Recommended Unturned mod project structure

The following structure has worked across many 57 Studios™ mod projects. Adapt it to your needs rather than copying it verbatim.

MyModProject\
├── README.txt                  Project overview
├── ChangeLog.txt               Version history
├── _Source\                    Master working files (never published)
│   ├── Models\                 Blender source files
│   │   ├── Items\
│   │   ├── Vehicles\
│   │   └── Props\
│   ├── Textures\               Source layered art
│   │   ├── PSD\                Photoshop source
│   │   └── References\         Reference images
│   └── Audio\                  Source audio files
├── Assets\                     Unity Editor working folder
│   ├── Items\
│   ├── Vehicles\
│   ├── Props\
│   ├── Animations\
│   └── Bundles\                Compiled .unity3d bundles
├── Bundles\                    Final mod folder for Unturned
│   ├── Items\
│   │   ├── 1000_Crate\
│   │   │   ├── Crate.dat
│   │   │   ├── Crate.unity3d
│   │   │   └── Crate.png
│   │   └── 1001_Lockbox\
│   ├── Vehicles\
│   └── English.dat
├── Workshop\                   Steam Workshop staging
│   ├── Preview.png
│   └── Description.txt
└── Backups\                    Manual snapshot archive
    ├── 2026-05-15_v1\
    └── 2026-05-16_v2\

The conventions encoded in this structure:

• Underscore prefix on _Source and _Internal folders sorts them to the top alphabetically. This keeps master files in the most visible position.
• Three-tier asset flow from _Source (master files) to Assets (Unity working state) to Bundles (compiled output) makes the production pipeline visible in the folder tree itself.
• Numbered subfolders in Bundles\Items such as 1000_Crate make the asset ID immediately visible. Unturned™ uses numeric IDs to reference items.
• Dated backup folders in Backups follow the YYYY-MM-DD_vN pattern so they sort chronologically.

Did you know?

Sorting files alphabetically is the Windows default, and leading characters like underscore or numeric prefixes are a long-standing trick for controlling sort order. The underscore prefix sorts above letters in standard NTFS sort. Numeric prefixes sort according to standard numeric collation when natural sort is enabled.

Did you know?

The _Source to Assets to Bundles three-tier asset flow mirrors the practice used in professional game development studios for decades. Master files are kept separate from working copies, and working copies are kept separate from compiled outputs. The separation lets each tier evolve at its own pace without affecting the others.

Appropriate folder depth

Deeper folder structures look organized but cause two real problems:

1. The 260-character path limit. Every folder name adds to the total path length. A deep tree leaves less room for the filenames at the bottom.
2. Navigation friction. Every extra level requires another double-click or another segment in the address bar.

A working rule for mod projects: target three to four levels of nesting from the project root, with five as the maximum. The recommended structure above stays within this limit.

Depth from project root	Examples	Appropriate use
1	_Source, Assets, Bundles	Major category separation
2	Models, Textures, Items	Asset type within a category
3	1000_Crate (item ID folder)	Individual asset grouping
4	Variants	Sub-grouping when truly needed
5+	Rarely justified	Reconsider the structure

Folder depth versus discoverability

The trade-off between folder depth and discoverability is a recurring theme in project organisation. Too shallow and the top-level folder becomes a cluttered list of dozens of unrelated items. Too deep and any file requires many clicks to reach.

The sweet spot of three to four levels of nesting balances both concerns. Each level contains a manageable number of items (typically ten to thirty), and any individual file is reachable in three to four clicks from the project root.

Bulk folder creation with PowerShell

When scaffolding a new project, creating thirty folders one at a time is tedious. PowerShell can create an entire structure in seconds.

Open a PowerShell prompt in the project root folder (Shift + right-click in File Explorer and choose Open in Terminal on Windows 11, or Open PowerShell window here on Windows 10), then run:

$folders = @(
    '_Source\Models\Items',
    '_Source\Models\Vehicles',
    '_Source\Models\Props',
    '_Source\Textures\PSD',
    '_Source\Textures\References',
    '_Source\Audio',
    'Assets\Items',
    'Assets\Vehicles',
    'Assets\Props',
    'Assets\Animations',
    'Assets\Bundles',
    'Bundles\Items',
    'Bundles\Vehicles',
    'Workshop',
    'Backups'
)
foreach ($f in $folders) { New-Item -ItemType Directory -Path $f -Force | Out-Null }

The script creates every folder, including any necessary parent folders, in one execution. The -Force flag silently skips folders that already exist, so the same script can be re-run safely.

Best practice

Save the scaffolding script as scaffold.ps1 in your project root. When you start a new mod project, copy and run the script to lay down the structure. This is far more reliable than recreating the structure from memory every time.

Best practice

For scaffolding scripts that produce many folders, run with -Verbose once to confirm each folder is created. Subsequent runs can omit -Verbose for cleaner output. The verbose first run is the verification that the script matches the project specification.

Verifying a scaffolded folder structure

After running a scaffolding script, verify the folder structure matches the project specification:

# Verify the structure matches expected paths
$expected = @(
    '_Source\Models\Items',
    '_Source\Models\Vehicles',
    '_Source\Models\Props',
    '_Source\Textures\PSD',
    '_Source\Textures\References',
    '_Source\Audio',
    'Assets\Items',
    'Assets\Vehicles',
    'Assets\Props',
    'Assets\Animations',
    'Assets\Bundles',
    'Bundles\Items',
    'Bundles\Vehicles',
    'Workshop',
    'Backups'
)

foreach ($path in $expected) {
    if (Test-Path $path) {
        Write-Host "OK: $path" -ForegroundColor Green
    } else {
        Write-Host "MISSING: $path" -ForegroundColor Red
    }
}

The verification script checks each expected folder path and reports OK or MISSING. A complete OK report confirms the scaffold ran successfully. Any MISSING entries indicate the scaffold script needs adjustment or one or more folders failed to create.

Recovering from an accidentally placed folder

If you created a folder in the wrong location, you have three quick recovery options.

1. Press Ctrl + Z immediately. Windows undoes the most recent folder creation, removing the new folder.
2. Move the folder using Ctrl + X and Ctrl + V. Cut the new folder from the wrong location, navigate to the correct location, and paste.
3. Delete the new folder and recreate it. Press Delete to send the folder to the Recycle Bin, navigate to the correct location, and press Ctrl + Shift + N.

Common mistake

Creating a folder inside another folder you only meant to navigate into. If you double-click a folder by mistake and then create a new folder, you have placed the new folder one level too deep. Press Alt + Up to verify your current location before creating any folder.

Common mistake

Pressing Ctrl + Shift + N when the focus is on the navigation pane rather than the file list creates a folder at the navigation pane's selected location, not the file list's location. Click into the file list before pressing the shortcut.

Folder structure and build performance

For mod projects with thousands of files, folder structure affects build performance. Unity Editor and other tools scan project folders during build operations, and the scan time is proportional to the number of folders and files.

Project size	Recommended folder structure
Small (under 100 files)	Flat structure, minimal nesting
Medium (100 - 1,000 files)	Three-tier asset flow, two to three levels of nesting
Large (1,000 - 10,000 files)	Three-tier asset flow, three to four levels of nesting
Very large (10,000+ files)	Categorised structure with explicit grouping

The recommendation is to grow folder structure as the project grows. A small project does not need the full three-tier asset flow; the structural overhead is greater than the organisational benefit. A large project benefits from explicit grouping that prevents any single folder from accumulating thousands of files.

Folder structure evolution across project lifetime

A typical mod project's folder structure evolves through several phases.

Phase 1: Initial scaffold. The project starts with the recommended structure produced by the scaffolding script. Folders are mostly empty; the structure is aspirational.

Phase 2: Active development. The structure fills out as assets are produced. Some folders accumulate many files; others remain mostly empty.

Phase 3: Mid-project restructure. Halfway through the project, the modder may restructure folders to match the actual asset growth pattern. Folders that grew large may be split; folders that remained empty may be removed.

Phase 4: Pre-release consolidation. Before release, working files move into a tighter structure suitable for distribution. Scratch folders are cleared; archive folders absorb deprecated assets.

Phase 5: Post-release archive. After release, the project folder moves into an archive area. The structure is preserved exactly as it was at release for historical reference.

Best practice

Plan for the mid-project restructure from the start. The restructure is normal, not a failure of the initial scaffold. Build flexibility into your tooling so a restructure does not break build scripts or asset references.

Migrating existing projects to a better folder structure

Some mod projects start with an ad-hoc folder structure that evolves haphazardly. Migrating to a proper structure requires careful planning.

The migration approach:

1. Document the current structure. Take a complete inventory of existing folders and files. PowerShell's Get-ChildItem -Recurse produces a complete listing.
2. Design the target structure. Apply the recommended three-tier asset flow and naming conventions.
3. Map each existing file to its target location. Produce a mapping table that pairs each current path with its target path.
4. Test the mapping with a small sample. Move five to ten files according to the mapping and confirm the result.
5. Apply the mapping in bulk. Use a PowerShell script to move every file according to the mapping table.
6. Verify the migration. Confirm every expected file exists at its new location.
7. Update tool references. Update any tool configurations that reference the old paths.
8. Run the build pipeline. Confirm the build still produces correct outputs after the migration.

The migration is risky because tool references may break during step 7. Plan the migration for a moment when the project is in a stable state, and keep a complete backup of the pre-migration state.

Critical warning

Folder structure migrations break tool integrations. Any script, configuration, or external reference that points to an old path will fail after the migration. Inventory all such references before migrating, and update them as part of the migration.

Frequently asked questions

Can a folder name contain spaces? Yes, but be aware that paths with spaces require quoting in PowerShell and many command-line tools. Use spaces freely in user-facing top-level folders, but avoid them in folders you will reference from scripts.

Is there a limit to how many files a folder can hold? The technical limit on NTFS is over 4 billion files per folder, but File Explorer becomes slow with more than a few thousand. If a folder is approaching ten thousand files, restructure into subfolders.

Why does the New submenu sometimes have different items? Applications can register file types they create. Photoshop adds Photoshop Document, Office adds Word and Excel documents, and so on. The submenu reflects what is installed.

Can I make a folder that automatically organizes files? File Explorer has a built-in feature called Libraries that aggregates multiple folders into one virtual view, but there is no native auto-organization. Third-party tools such as DropIt or PowerShell scripts can implement automatic organization rules.

Why does creating a folder sometimes fail with an access-denied error? You may lack write permission for the parent folder. This is common in system directories such as C:\Program Files or in folders owned by other users. Run File Explorer as administrator, or choose a different parent folder that you have write access to.

Can I create a folder with the same name as an existing file? No. Files and folders share a single namespace within a parent folder. A folder cannot have the same name as a file in the same parent, and vice versa. Rename the existing file first if you need the name for a folder.

Why does my new folder sometimes appear at the bottom of the list instead of alphabetically? File Explorer sorts the folder list after a brief delay. A newly created folder may appear at the current cursor position until the sort updates. Press F5 to refresh and force the sort to apply immediately.

Can I create a folder structure across multiple drives at once with PowerShell? Yes. Specify absolute paths in the scaffolding script:

$folders = @(
    'C:\Project\Assets',
    'D:\Backups\Project',
    'E:\Archive\Project'
)
foreach ($f in $folders) { New-Item -ItemType Directory -Path $f -Force | Out-Null }

What is the difference between a folder and a directory? The two terms refer to the same concept. "Directory" is the older technical term from MS-DOS and Unix; "folder" is the modern Windows term introduced with Windows 95. The two are used interchangeably in this article.

Can I create a hidden folder? Create the folder normally, then right-click, Properties, and check the Hidden attribute. The folder is then hidden unless View → Hidden items is enabled. Folders whose names start with a period (such as .git) are not hidden by Windows convention; the period prefix is only treated as hidden on Linux and macOS.

Why does my new folder inherit specific permissions? A new folder inherits the parent folder's NTFS permissions by default. If the parent folder has specific permissions set, the new folder receives them. To customise the new folder's permissions, right-click, Properties, Security, and adjust.

Can I create a folder in the root of a drive? Yes, but you typically need administrator permission to create folders at the root of the system drive (C:\). Other drives' roots usually permit folder creation without administrator rights.

How can I create many folders at once with names from a text file? A PowerShell one-liner reads the names from a file and creates each as a folder:

Get-Content -Path 'C:\folders.txt' | ForEach-Object { New-Item -ItemType Directory -Path $_ -Force }

Best practices

• Default to Ctrl + Shift + N for all folder creation. The shortcut is the single fastest method.
• Establish a naming convention at project start and document it in a project README.
• Keep folder structures shallow. Three to four levels is the sweet spot for mod projects.
• Use PowerShell scaffolding scripts to create new project structures consistently.
• Use leading underscores or numeric prefixes to control sort order when default alphabetical sort is wrong for your project.
• Verify scaffolded structures with a script that checks each expected folder exists.
• Plan for mid-project restructures rather than treating them as failures.
• Build flexibility into tooling so a restructure does not break build scripts.
• Inventory tool references before migrating folder structures.
• Keep a complete backup of pre-migration state before restructuring.
• Document the folder structure in a README.txt so collaborators can navigate the project.

Appendix A: Folder creation troubleshooting matrix

Symptom	Likely cause	Resolution
Ctrl + Shift + N does nothing	Focus on navigation pane	Click into file list, retry
New folder created in wrong location	Focus on wrong folder	Press Alt + Up, verify location
New folder appears with strange name	Typed before rename mode focused	F2 to rename
Cannot create folder in this location	Permission issue	Run as administrator or choose different location
Folder created but immediately disappears	Antivirus quarantine	Add temporary exclusion, retry
Folder name fails validation	Reserved character or name	Choose name following filename rules
PowerShell scaffolding fails partway	Path too long or permission issue	Shorten paths or fix permissions
Created folder shows on wrong drive	Default location was different	Navigate to intended drive first
Multiple folders created at same level have same name	Numeric suffix collision	Rename collisions with F2
Right-click menu has no New submenu	Right-clicked a file instead of empty space	Right-click empty area

Appendix B: Folder structure templates for different mod project types

Different mod project types benefit from different folder structures. The templates below are starting points for common project shapes.

Template A: Item-only mod. A small mod containing only new items (no vehicles, no animations, no custom UI).

ItemMod\
├── README.txt
├── _Source\
│   ├── Models\
│   └── Textures\
├── Assets\
│   └── Items\
├── Bundles\
│   └── Items\
│       ├── 1000_Item1\
│       └── 1001_Item2\
├── Workshop\
└── Backups\

Template B: Mixed item and vehicle mod. A mid-sized mod containing items and vehicles.

MixedMod\
├── README.txt
├── _Source\
│   ├── Models\
│   │   ├── Items\
│   │   └── Vehicles\
│   ├── Textures\
│   └── Audio\
├── Assets\
│   ├── Items\
│   ├── Vehicles\
│   └── Animations\
├── Bundles\
│   ├── Items\
│   ├── Vehicles\
│   └── English.dat
├── Workshop\
└── Backups\

Template C: Map mod. A mod that ships a custom map for Unturned™.

MapMod\
├── README.txt
├── _Source\
│   ├── Heightmaps\
│   ├── Textures\
│   ├── Models\
│   │   ├── Props\
│   │   └── Vegetation\
│   └── Reference\
├── Map\
│   ├── Terrain\
│   ├── Objects\
│   ├── Spawns\
│   └── Resources\
├── Workshop\
└── Backups\

Template D: Total conversion mod. A large mod that overhauls many systems.

TCMod\
├── README.txt
├── _Source\
│   ├── Models\
│   ├── Textures\
│   ├── Audio\
│   └── Reference\
├── Assets\
│   ├── Items\
│   ├── Vehicles\
│   ├── Animations\
│   ├── UI\
│   └── Scripts\
├── Bundles\
│   ├── Items\
│   ├── Vehicles\
│   ├── UI\
│   └── English.dat
├── Map\
├── Workshop\
└── Backups\

Each template is a starting point. Adapt the template to your project's specifics rather than treating it as a strict rule. The principle is consistent: a three-tier asset flow from source to working to compiled, with separate folders for distribution staging and backups.

Appendix C: Folder creation glossary

• Folder. A container in the file system that holds files and other folders.
• Directory. Synonym for folder; the older technical term.
• Directory entry. The file-system record that names a folder.
• Subfolder. A folder inside another folder.
• Parent folder. The folder that directly contains a given folder.
• Root folder. The top-level folder of a drive (such as C:\).
• Project root. The top-level folder of a project.
• Scaffold. The initial folder structure of a project, created at project start.
• Three-tier asset flow. The recommended pattern of _Source → Assets → Bundles for mod projects.
• Naming convention. A consistent style for folder names.
• Path length. The total character count of a folder's full path.
• Sort prefix. A character or numeric prefix used to control alphabetical sort order.
• Tier-1 folder. A folder directly under the project root.
• Asset category folder. A folder within _Source, Assets, or Bundles that holds a specific asset type.

Appendix D: Project folder structure case studies

Real mod projects demonstrate how folder structure decisions play out across a project's lifetime. The case studies below are drawn from 57 Studios™ internal project retrospectives.

Case study A: The minimal-structure project. A small item-only mod kept all assets in a single Mod\ folder with no subfolders. The project shipped successfully but accumulated forty files in the single folder by the end. The modder reported that finding specific assets required scanning the file list each time. The retrospective recommended at least one level of subfolder grouping even for small projects.

Case study B: The over-structured project. A medium-sized mod was scaffolded with seven levels of nesting from the project root. Files routinely encountered the 260-character path limit. The modder restructured mid-project to a four-level depth and reported faster navigation and no more path-limit errors. The retrospective recommended four levels as the maximum for any mod project.

Case study C: The convention-shifted project. A large mod started with kebab-case folder names, then mid-project the modder switched to PascalCase. Half the folders had been renamed when a build script broke due to a hardcoded kebab-case path. The modder reverted the half-completed rename and finished the project with the original convention. The retrospective recommended either committing to the original convention or completing a convention shift in a single bulk operation with all references updated atomically.

Case study D: The scaffolded project. A mod project was scaffolded from a scaffold.ps1 script at project start. The script created the full recommended structure in three seconds. The modder reported that the consistency across projects (every project had the same structure) reduced the mental overhead of switching between projects. The retrospective recommended a scaffold script as the standard project-start practice.

Case study E: The migrated project. A mod project that had grown ad-hoc was migrated to the recommended structure mid-project. The migration took two days and broke three build scripts. The modder reported that the post-migration project was faster to work with but that the migration itself was costly. The retrospective recommended either using the recommended structure from project start or planning the migration as a major work item with dedicated time.

Appendix E: Scaffolding script for the recommended Unturned mod project structure

The complete scaffolding script for the recommended Unturned™ mod project structure:

# scaffold.ps1
# Creates the recommended folder structure for an Unturned mod project.
# Run from the project root folder.

$folders = @(
    '_Source\Models\Items',
    '_Source\Models\Vehicles',
    '_Source\Models\Props',
    '_Source\Textures\PSD',
    '_Source\Textures\References',
    '_Source\Audio',
    'Assets\Items',
    'Assets\Vehicles',
    'Assets\Props',
    'Assets\Animations',
    'Assets\Bundles',
    'Bundles\Items',
    'Bundles\Vehicles',
    'Workshop',
    'Backups'
)

Write-Host "Scaffolding mod project structure in $(Get-Location)" -ForegroundColor Cyan

foreach ($folder in $folders) {
    $path = Join-Path -Path (Get-Location) -ChildPath $folder
    if (Test-Path $path) {
        Write-Host "  Exists: $folder" -ForegroundColor Yellow
    } else {
        New-Item -ItemType Directory -Path $path -Force | Out-Null
        Write-Host "  Created: $folder" -ForegroundColor Green
    }
}

# Create starter files
$starterFiles = @{
    'README.txt' = "Mod project README`r`nCreated: $(Get-Date -Format 'yyyy-MM-dd')`r`n"
    'ChangeLog.txt' = "Change log`r`nCreated: $(Get-Date -Format 'yyyy-MM-dd')`r`n"
}

foreach ($name in $starterFiles.Keys) {
    $path = Join-Path -Path (Get-Location) -ChildPath $name
    if (-not (Test-Path $path)) {
        Set-Content -Path $path -Value $starterFiles[$name]
        Write-Host "  Created: $name" -ForegroundColor Green
    }
}

Write-Host "Scaffolding complete." -ForegroundColor Cyan

Save the script as scaffold.ps1 and run it from the desired project root folder. The script creates every folder in the recommended structure and produces starter README and ChangeLog files. The script is idempotent — re-running it after the structure exists produces no harmful effect.

Best practice

Maintain a single canonical version of the scaffolding script in a known location, such as C:\Tools\scaffold.ps1, and copy it into each new project root. This keeps the structure consistent across projects and lets you update the script in one place when the recommended structure evolves.

Next steps

You have completed the File Management section of the 57 Studios™ Modding Knowledge Base. You can now open File Explorer, navigate to any folder, configure visibility settings, copy, move, rename, and create folders. These eight skills cover every file system operation needed for Unturned™ mod development.

The next section moves into asset creation. Continue to How to Open Paint to begin learning pixel art for mod icons and textures.

For a recap of the file-management operations covered in this section, refer back to the foundational articles:

• How to Open File Explorer for the methods to launch File Explorer
• How to Navigate to a Folder for navigation techniques
• How to View File Extensions for the extension visibility configuration
• How to View Hidden Files for hidden-item visibility
• How to Copy a File for the methods of duplicating files
• How to Move a File for relocating files
• How to Rename a File for changing filenames

Appendix F: Long-term folder structure maintenance

A mod project's folder structure is not static. As the project evolves, the structure benefits from periodic maintenance to keep it aligned with the project's actual asset growth pattern.

Quarterly review: Once every three months during active development, review the folder structure for signs of misalignment. Folders that hold many more files than expected may benefit from a split. Folders that are mostly empty may be candidates for removal or consolidation.

Pre-release audit: Before any release, audit the folder structure to confirm distribution-ready folders (Bundles, Workshop) contain only files intended for distribution. Working files, scratch outputs, and reference assets should remain in non-distribution folders.

Post-release cleanup: After a release ships, clean up the project folder structure by archiving deprecated assets, removing empty folders, and updating the README to reflect the current structure.

Annual rationalisation: Once a year for long-running projects, rationalise the folder structure against the recommended template. Adjust any drift that has accumulated through ad-hoc folder additions.

The maintenance cadence is the difference between a project that remains navigable across years and one that becomes unworkable as it ages. Modders who maintain folder structure deliberately ship more reliably across long projects than modders who let the structure evolve haphazardly.

Best practice

Schedule folder-structure maintenance as a recurring calendar entry rather than treating it as an as-needed task. The cadence catches drift before it becomes painful and is far less costly than a major mid-project restructure.

The maintenance practice also has a documentation dimension. Each maintenance pass should produce a brief note recording what was changed and why. The notes accumulate into a project's structural history and serve as a reference for collaborators who need to understand why the project's folder layout looks the way it does. A modder returning to a project after a long break benefits from the notes; a collaborator joining mid-project benefits even more.

The combination of quarterly review, pre-release audit, post-release cleanup, and annual rationalisation produces a project whose folder structure remains coherent and navigable across years of development. The discipline pays back in faster navigation, fewer build-script failures, and easier collaboration. A modder who internalises the practice ships more reliably than one who does not.