Dedicated Server Testing and Validation

Intermediate40-60 minutesWindowsUnturnedUnity Editor

A map that passes local testing must be tested on a dedicated server before Workshop publication. Dedicated servers exercise several subsystems that the single-player client does not: network replication of entity state, server-authoritative loot table resolution, server-side navmesh validation, and the Workshop content download path. The 57 Studios cohort has documented multiple cases of maps that passed local testing with no errors and failed on a dedicated server within the first five minutes of a multiplayer session. The dedicated server test is the final quality gate before the map reaches players.

This article documents the 57 Studios™ workflow for dedicated server testing and asset validation. It covers installing and configuring a local dedicated server, copying the map to the server environment, running the comprehensive -ValidateAssets command-line check, interpreting server log output, and diagnosing the most common server-side failures: server not starting with the map, white textures on a clean server install, missing assets, navmesh validation errors, and spawn table resolution failures on the server.

Documentation source: This article synthesizes the official Smartly Dressed Games modding documentation for dedicated server setup, asset validation, and server log interpretation, combined with empirical validation across 57 Studios cohort mapping projects.

Prerequisites

• A map that has passed local testing in single-player. See the preceding article Local Map Testing for the local testing procedure.
• The Unturned Dedicated Server tool (U3DS) installed from Steam. See Setting Up an Unturned Server for the installation procedure.
• A text editor for reading log files and configuration files. The 57 Studios™ recommendation is Notepad++.
• Familiarity with the server console and command-line interface.
• A backup of the map's project folder before beginning the testing procedure.

What you will learn

• How to install the Unturned Dedicated Server tool and generate the default configuration files.
• How to copy the map to the server's Maps/ directory and configure Commands.dat.
• How to run the server with the map and interpret the startup log output.
• How to execute the -ValidateAssets command-line flag and resolve every validation error.
• How to interpret server log entries for asset loading, navmesh validation, and spawn table resolution.
• How to run multiplayer-specific test scenarios that single-player testing does not cover.
• How to diagnose and fix server not starting with the map, white textures, and missing asset errors.

Installing and configuring a dedicated server

The dedicated server test environment must be set up on the same machine as the author's game client to eliminate the network variable. A local dedicated server eliminates the possibility that the server's installation or network configuration is causing the failure.

Step 1: Install U3DS

1. Open the Steam Library.
2. From the Library dropdown, select Tools.
3. Find "Unturned Dedicated Server" (U3DS) in the tools list and install it.
4. On Windows, the default install location is C:\Program Files (x86)\Steam\steamapps\common\U3DS\.
5. The installer also places a server shortcut on the Steam Library's home page. This shortcut launches the server but must be configured first.

Step 2: Generate default configuration files

1. Launch the dedicated server once to generate the default configuration files.
2. From the Steam Library, select the "Unturned Dedicated Server" entry and click Play.
3. A console window opens showing the server startup sequence. The server generates the Servers/ directory and a set of default configuration files inside it.
4. Once the console reports "Server started successfully" and displays a server code, the configuration files are ready.
5. Type Shutdown in the server console and press Enter. The server shuts down cleanly and saves its configuration state.

Step 3: Locate the server configuration directory

The server configuration files are in the Servers/ subdirectory of the U3DS installation.

U3DS/
├── Servers/
│   └── Default/
│       ├── Commands.dat
│       ├── Config.json
│       └── WorkshopDownloadConfig.json
├── Extras/
├── ServerHelper.bat
└── ServerHelper.sh

For a first-time setup, the server creates a single server instance named Default. If multiple instances are needed, additional directories can be created in Servers/.

Copying map files to the server

The map files must be copied to the server's Maps/ directory. The server loads maps from this directory, not from the game client's Maps/ directory.

Step 1: Create the server Maps directory

If the Servers/Default/Maps/ directory does not exist, create it:

U3DS/Servers/Default/Maps/

Step 2: Copy the map folder

1. Navigate to the map's build output directory.
2. Copy the entire map folder.
3. Paste the folder into U3DS/Servers/Default/Maps/.
4. The folder structure should look like this:

U3DS/Servers/Default/Maps/YourMap/
├── Bundles/
├── Level/
├── Config.json
└── [other map files]

Step 3: Configure Commands.dat

1. Open U3DS/Servers/Default/Commands.dat in Notepad++.
2. Find the Map command line (or add it if it does not exist).
3. Set it to the map's folder name:

Map YourMap

The Map command value is case-sensitive and must match the folder name exactly. If the folder is named MyMap, the command must be Map MyMap.

4. Optionally configure other startup commands:

Map YourMap
Port 27015
Name "Test Server - YourMap"
MaxPlayers 4

5. Save the file. The server reads Commands.dat at startup and executes each line as a console command.

Step 4: Configure WorkshopDownloadConfig.json

For the local server test, the WorkshopDownloadConfig.json file should be empty or should not reference the map's Workshop entry. The goal is to test the map in isolation from the Workshop distribution pipeline.

{
  "File_IDs": []
}

Local map files are loaded directly from the Maps/ directory. The server does not need a Workshop entry to load them.

Running server tests

Step 1: Launch the server

1. Navigate to the U3DS installation directory.
2. Double-click ServerHelper.bat (Windows) or run ./ServerHelper.sh (Linux).
3. The server console opens and displays the startup sequence.

Step 2: Observe the startup log

The server startup log shows the map loading process. The following key lines indicate a successful load:

Loading level: YourMap
Loading level: 100%
Server code: [code]
Server started successfully

The "Loading level: 100%" message indicates that the map's terrain and assets loaded without errors. The server code is the connection code that clients use to join the server.

Step 3: Join the server from the game client

1. Launch the Unturned™ game client.
2. Click Connect in the main menu.
3. Select the LAN tab or click Connect Directly.
4. Enter the server code displayed in the server console.
5. Click Connect. The client downloads the map from the server and loads it.

Step 4: Execute the verification command sequence

Once connected to the server, repeat the verification command sequence from the local test:

Command	What it tests	Server-specific behavior
/spawn	Player spawn on server	Player appears at a random spawn point from the server's set
/zombie	Zombie spawn and navmesh	Zombie spawns and pathfinding is computed server-side
/give <table>	Spawn table resolution	Table is resolved server-authoritatively
/vehicle	Vehicle spawn table	Vehicle spawns on server and replicates to client
/cycle 0-7	Time of day on server	Time is synchronized to all connected clients

Step 5: Test multiplayer-specific scenarios

After the command sequence passes, test the scenarios that single-player testing did not cover.

Test scenario	What it exercises	Expected result
Two players in adjacent regions	Network replication across zones	Both players see each other; zombies are synchronized
Two players in the same region	Network replication within a single zone	Both players see the same zombies at the same positions
Server restart with a player's saved position	Save and restore of player state	Player respawns at the correct position on the same map
Player joins while another is active	Late-join network synchronization	Joining player sees the same world state as the active player
Player disconnected mid-session	Graceful network interruption handling	Remaining players continue without visible errors
All players disconnect and reconnect	World state integrity across empty-server periods	Lootable containers have correctly regenerated items
Server run continuously for 4+ hours	Memory and resource leak detection	Server does not crash; framerate does not degrade

The cohort recommendation for dedicated server testing is to run the map for a minimum of 8 continuous hours with at least two concurrent players. Memory leak patterns that only surface after 3-6 hours of continuous runtime will not be caught by a 30-minute test session.

ValidateAssets command

The -ValidateAssets command-line flag instructs Unturned™ to run a comprehensive set of health checks on every asset in the map. It is the single most important quality gate before Workshop publication.

How to run ValidateAssets

1. Locate the Unturned™ executable. On a default Windows installation, this is at C:\Program Files (x86)\Steam\steamapps\common\Unturned\Unturned.exe.
2. Create a shortcut to Unturned.exe on the desktop.
3. Right-click the shortcut and select Properties.
4. In the Target field, append -ValidateAssets after the existing path. The full value should be similar to: "C:\Program Files (x86)\Steam\steamapps\common\Unturned\Unturned.exe" -ValidateAssets
5. Launch Unturned™ through the modified shortcut.
6. Load the map in single-player mode.
7. The validation runs during the loading screen. Progress is visible in the log output.
8. After the map loads, open the Asset Errors menu from the in-game menu or check Client.log at %LOCALAPPDATA%\Unturned\Logs\Client.log.

What ValidateAssets checks

Validation check	What it tests	Common resolution
Navmesh Readable	Object navmeshes have CPU Readable flag in Unity	Enable CPU Readable on the navmesh in Unity import settings; rebake and re-export
Mesh Readable	Non-navmesh meshes do not have CPU Readable	Disable CPU Readable on meshes that are not navmesh objects
Missing Meshes	Mesh filters reference a valid mesh; mesh renderers have a mesh filter	Locate the object in the editor; assign the correct mesh to the mesh filter
Mesh Vertex Counts	Meshes with unusually high vertex counts are flagged	Reduce polygon count; apply LOD groups; remove unused faces
Missing Materials	Renderers have at least one material assigned	Assign a material to every renderer
Material Counts	Renderers with excessive material counts are flagged	Merge materials where possible
Texture Readable	Most textures do not need CPU Readable	Disable CPU Readable on textures that are not shirt, pants, or UI textures
Texture NPOT	Textures should have power-of-two dimensions	Rescale or pad textures to the nearest power of two
Audio Samples	Long audio clips with high sample rates are flagged	Reduce sample rate or clip length

How to fix validation errors

1. Read the first error in the validation output. Each error includes the asset path and the specific issue.
2. Open the referenced asset in the Unity Editor or the modeling tool, depending on the error type.
3. Fix the specific issue. For a missing mesh, assign the correct mesh. For a CPU Readable flag, enable or disable it in the import settings.
4. Rebuild the asset bundle and re-export the map.
5. Re-run -ValidateAssets to confirm the fix succeeded.
6. Repeat until all errors are resolved.

The cohort recommendation is to fix errors in the order they appear in the validation output, because a single broken reference can cascade into multiple dependent errors. A map that produces zero validation errors after the fix pass is ready for the local testing verification.

Server log interpretation

The server log (Server_<ID>.log) is the primary diagnostic tool for server-side failures. The log is located at U3DS/Servers/Default/Server_<ID>.log on Windows.

Key log message patterns

Log message	Meaning	Severity	Action required
Loading level: 100%	Map loaded successfully	Info	None
Could not find asset for GUID	A .dat file references a GUID not present in any loaded mod	Error	Open the referencing .dat; correct or remove the GUID reference
Map file not found	Server cannot locate the map folder	Error	Confirm map folder exists in Servers/Default/Maps/; confirm Map command matches folder name
Failed to load level asset	Level .asset is missing or malformed	Error	Inspect level .asset; confirm all bundle references are valid
Bundle not found	Master bundle or .unity3d file is missing	Error	Confirm bundle file is present; confirm MasterBundle.dat is correct
Asset bundle GUID collision	Two loaded bundles have duplicate GUIDs	Error	Rebuild one of the conflicting bundles to generate new GUIDs
Navmesh overlap detected	Two navmesh bounds intersect	Warning	Adjust bounds to remove overlaps; rebake
Spawn table entry not found	Spawn table references non-existent item or vehicle	Warning	Remove or correct the non-existent ID reference
Config version mismatch	Config.json version differs between server and Workshop cache	Warning	Re-upload map with incremented version number
MasterBundle.dat not found	Expected MasterBundle.dat in bundle directory	Error	Create MasterBundle.dat with correct fields
Shader not found; applying fallback	Custom shader not available on server's rendering path	Warning	Replace custom shader with vanilla-compatible shader; rebuild bundle

Reading the log for map-specific issues

1. Open Server_<ID>.log in Notepad++.
2. Search for the map's folder name. All log entries related to the map should appear in sequence during the startup phase.
3. Search for "Error" and "Warning" strings. Each error and warning should be evaluated for impact on gameplay.
4. Search for "missing" and "not found" strings. These indicate asset resolution failures.
5. Pay particular attention to the sequence of log entries between "Loading level: [map name]" and "Loading level: 100%". Errors during this window indicate map-specific loading failures.

Server not starting with the map: diagnostic workflow

When the server fails to start or crashes immediately when the map is specified in Commands.dat, the cause is almost always in the map's file structure, asset references, or configuration.

Diagnostic flowchart

Common server startup failures

Symptom	Most likely cause	Resolution
Server reports "Map file not found"	Commands.dat Map value does not match folder name	Correct the Map value to match the folder name exactly
Server reports "Failed to load level asset"	Level .asset is corrupted or missing Bundle field	Restore level .asset from backup; confirm Bundle field
Server reports "Bundle not found"	Master bundle file is missing or misnamed	Rebuild bundle; confirm file name matches MasterBundle.dat
Server starts but immediately stops responding	Malformed .dat file in the map causes a parse error during asset loading	Run -ValidateAssets; check Server_[ID].log for parsing errors
Server starts but displays no map geometry	Server-side asset loading failed and defaulted to empty level	Check the server console for asset-load error messages
Server starts but clients cannot connect	Port is blocked or server is not fully initialized	Check firewall settings; confirm server reports "Server started successfully"

White textures on server: diagnostic workflow

When custom assets have correct textures locally but appear white on the server, the server is missing the asset bundle or the bundle path is incorrect.

Root causes

Cause	Typical scenario	Fix
Asset bundle not copied to server	Map was copied to server's Maps/ without the Bundles/ directory	Copy the entire map folder including Bundles/
Wrong bundle path in level .asset	Level .asset references a bundle path that works on local machine but not on server	Use relative paths in the level .asset; confirm Asset_Prefix in MasterBundle.dat
Bundle rebuilt after copy	Map was updated in the editor and the bundle was rebuilt, but the server still has the old bundle	Re-copy the entire map folder to the server
MasterBundle.dat missing	Map uses a master bundle but the server does not have MasterBundle.dat	Create MasterBundle.dat with the correct Asset_Bundle_Name and Asset_Prefix

Resolution procedure

1. Confirm that the map folder on the server includes the Bundles/ directory (or Level/Bundles/ depending on the map's structure).
2. Confirm the MasterBundle.dat file exists in the bundle directory and has correct fields:
   • Asset_Bundle_Name: The filename of the master bundle (e.g., mymap.masterbundle).
   • Asset_Prefix: The file path to the folder selected as an AssetBundle in Unity (e.g., Assets/MyMapBundles).
3. Rebuild the asset bundle in Unity Editor.
4. Copy the rebuilt bundle to the server's bundle directory.
5. Restart the server.
6. If textures are still white, run -ValidateAssets and check for missing material or texture errors.

Multiplayer-specific validation

The multiplayer test covers network replication and server-authoritative validation paths that single-player testing does not exercise.

Network replication validation

Test	Procedure	Expected result
Player visibility	Two players stand in the same area. Both players move.	Each player sees the other player's movement in real time
Zombie synchronization	One player aggroes a zombie. The other player observes the zombie's behavior.	Both players see the zombie at the same position with the same behavior
Loot synchronization	One player loots a container. The other player inspects the same container.	The second player sees the container as empty or partially looted
Vehicle synchronization	One player enters a vehicle and drives. The other player observes.	Both players see the vehicle at the same position with the same velocity
Weather synchronization	The time of day advances on the server.	Both players see the same lighting and weather conditions

Server-authoritative validation

Test	Procedure	Expected result
Spawn table authority	A player requests an item from a spawn point. The server resolves the table and spawns the item.	The item appears at the spawn point on both the requesting player's and all other players' clients
Navmesh authority	A zombie paths to a player. The server computes the navmesh path.	The zombie follows the same path as observed on all connected clients
Config.json authority	The server applies Config.json overrides.	All connected players experience the same gravity, HUD visibility, and gameplay parameters

Frequently asked questions

Why does my server fail to start with the map?

The most common causes are: the Commands.dat Map value does not match the folder name exactly (case-sensitive), the level .asset file is missing or malformed, or the master bundle file is missing from the server's Bundles/ directory. Check the Server_[ID].log file for the specific error message.

Why are my custom assets white on the server?

The asset bundle containing the custom textures was not copied to the server, or the bundle was rebuilt after it was copied. Rebuild the asset bundle, copy the entire map folder to the server's Maps/ directory, and restart the server.

How do I run ValidateAssets on the dedicated server?

The -ValidateAssets flag is a client-side operation. It must be run by launching the game client with the flag, not by passing it to the dedicated server executable. Load the map in single-player through the ValidateAssets-enabled client to run the checks against the map's assets.

My server starts but shows no map geometry. What is wrong?

The server-side asset loading failed and defaulted to an empty level. Check the server console for asset-load error messages during the startup sequence. The most common cause is a missing or broken master bundle reference in the level .asset file.

Everything works locally but fails on the server. Why?

The most common cause is a path difference between the local Maps/ directory and the server's Maps/ directory. The map's level .asset file may reference asset bundle paths that resolve correctly on the local machine but not on the server. Use relative paths in all asset references.

How long should I test my map on a dedicated server before publishing?

The 57 Studios cohort recommendation is a minimum of 8 continuous hours with at least two concurrent players. Memory leak patterns and network replication issues surface only under sustained use.

Can I test the map on a server without installing the full U3DS tool?

The dedicated server test must be performed using the U3DS tool. Hosting from the game client is not an adequate substitute because the game client's server hosting mode does not exercise all the subsystems that the dedicated server does.

How do I test with Workshop dependencies on the server?

If the map depends on other Workshop items, add their file IDs to WorkshopDownloadConfig.json on the server. The server will download the dependent items from the Workshop when it starts. The 57 Studios cohort recommendation is to test once without dependencies and once with dependencies to isolate dependency-related issues.

My server log shows "Could not find asset for GUID" errors. What should I do?

Each "Could not find asset for GUID" error indicates that a .dat file in the map references a GUID that is not present in any loaded mod or asset bundle. Open the referencing .dat file, find the GUID entry, and verify that the GUID exists in the referenced asset bundle. If the GUID is incorrect, correct it. If the asset is missing, add it to the bundle or remove the reference.

What is the difference between client-side and server-side asset validation?

Client-side validation (-ValidateAssets) checks mesh, material, texture, and audio quality. Server-side validation (the checks performed when the server loads the map) checks asset resolution, GUID matching, bundle existence, and spawn table integrity. Both must pass for the map to be considered validated.

Best practices

• Test on a dedicated server before every Workshop publication, not only the first publication. Game updates can break server-side compatibility even if the map has not changed.
• Run -ValidateAssets before every major build and fix all reported errors before proceeding to server testing.
• Test with at least two concurrent players for a minimum of 8 continuous hours. Memory leaks and network replication issues surface only under sustained use.
• Keep the server's map files synchronized with the editor's build output. A mismatch between the editor version and the server version produces confusing diagnostic results.
• Maintain a dedicated test server separate from the production server. The test server allows iterative testing without disrupting live players.
• Document the server configuration (Commands.dat, Config.json settings) in the map project file so that the configuration can be reproduced on any server.
• Check the server log after every test session. Errors that do not produce visible in-game symptoms are still recorded in the log.
• Test with a clean Workshop install (subscribed from a separate Steam account) to confirm the Workshop distribution pipeline works correctly.
• Increment the Config.json version number for every Workshop update. The server uses the version number to detect stale cached versions.
• Communicate with server operators about configuration requirements in the Workshop description.

Advanced considerations

Workshop distribution pipeline testing

After the map passes local and dedicated server testing, the Workshop distribution pipeline must be tested. Subscribe to the map through a separate Steam account (or a clean Workshop cache) and confirm the map downloads and loads correctly from the Workshop rather than from a local file copy.

The Workshop distribution test catches issues that local server testing does not: compressed file extraction errors, missing file references in the Workshop package, and cache invalidation problems.

Procedure:

1. Set the Workshop entry visibility to Friends-only or Unlisted.
2. From a separate Steam account, navigate to the Workshop entry and subscribe.
3. Launch Unturned and confirm the map appears in the level list.
4. Install the map on the dedicated server through the WorkshopDownloadConfig.json mechanism.
5. Join the server and confirm the map loads from the Workshop download.

Multi-server testing

For maps intended to run on a network of multiple servers (a hub-and-spoke configuration or a server cluster), test the map on a representative subset of the server cluster. Issues that appear on one server configuration (Windows server, Linux server, server with specific mods loaded) may not appear on another configuration.

Server startup time benchmarking

Record the time from the moment the server executable starts to the moment the server reports "Server started successfully." This total startup time includes:

1. The Unity engine initialization phase (5-15 seconds).
2. The asset bundle loading phase (varies by bundle size; 10-60 seconds for a typical custom map).
3. The navmesh validation phase (1-5 seconds).
4. The spawn table registration phase (1-3 seconds).
5. The world save loading phase (if a previous save exists; 1-10 seconds).

A map that takes more than 120 seconds to start on a mid-range server machine (2020-era CPU, SSD storage, 16 GB RAM) may have performance issues that affect gameplay beyond the startup phase. The two most common causes of slow startup are oversized asset bundles (over 500 MB) and excessive spawn point counts (over 10,000 item spawn points).

Server log archiving

The server log (Server_<ID>.log) is overwritten each time the server starts. To preserve a record of test sessions, archive the log file after each test session before starting a new one.

The 57 Studios cohort recommendation for log archiving is:

1. After each test session, copy Server_<ID>.log to a dedicated archive location: YourMap/Testing/Logs/Server_<ID>_YYYY-MM-DD.log.
2. Rename the archived log to include the test date and map version.
3. Keep the archived logs for the map's entire development lifecycle. When a regression appears in a later version, the archived logs provide a baseline for comparison.

Performance benchmarking

Record the server's CPU usage, memory usage, and tick rate during the 8-hour test session. Compare the results against a baseline of a vanilla official map running on the same server hardware. A custom map that consumes significantly more server resources than the vanilla baseline may need optimization before publication.

Appendix A: Server configuration reference

File	Location	Purpose
Commands.dat	Servers/Default/Commands.dat	Startup command sequence for the server instance
Config.json	Servers/Default/Config.json	Server-wide configuration settings
WorkshopDownloadConfig.json	Servers/Default/WorkshopDownloadConfig.json	Workshop file IDs for automatic download
Server_<ID>.log	Servers/Default/Server_<ID>.log	Primary log file for server diagnostics

Appendix B: ValidateAssets error resolution reference

Error type	Resolution
Navmesh not readable	Enable CPU Readable on the navmesh in Unity import settings; rebake
Mesh not readable	Disable CPU Readable on non-navmesh meshes
Missing mesh	Assign a valid mesh to the mesh filter component
Mesh vertex count too high	Reduce polygon count; apply LOD groups
Missing material	Assign a material to every renderer that needs one
Material count too high	Merge materials where possible
Texture readable should be disabled	Disable CPU Readable on non-UI textures
Texture not power-of-two	Rescale or pad textures to power-of-two dimensions
Audio sample rate too high	Reduce sample rate or clip length

Appendix C: Server log error message reference

Error message	Meaning	Resolution
Could not find asset for GUID	.dat file references a GUID not in any loaded mod or bundle	Correct or remove the GUID reference in the .dat file
Map file not found	Server cannot locate the map folder	Confirm folder exists in Servers/Default/Maps/; check Map command
Failed to load level asset	Level .asset is missing or malformed	Restore or fix the level .asset file
Bundle not found	Master bundle or .unity3d file missing	Confirm bundle file is present; check MasterBundle.dat
Asset bundle GUID collision	Two loaded bundles have duplicate GUIDs	Rebuild one of the conflicting bundles
Navmesh overlap detected	Two navmesh bounds intersect	Separate bounds and rebake
Spawn table entry not found	Spawn table references non-existent item	Remove or correct the invalid reference
MasterBundle.dat not found	MasterBundle.dat missing from bundle directory	Create MasterBundle.dat with correct fields
Shader not found; applying fallback	Custom shader not available	Replace with vanilla-compatible shader

Cross-references

• Local Map Testing - the previous article; covers the local testing procedure that must pass before dedicated server testing begins.
• Map Loading Failures - the next article in the mapping series; covers advanced loading failure diagnostics.
• Setting Up an Unturned Server - the full dedicated server setup guide that this article's installation section summarizes.
• Workshop Content on Dedicated Servers - the Workshop download configuration for dedicated servers.
• Server Config Files - the server-side Commands.dat, Players.dat, and Config.json reference for server operators.
• Workshop Upload Process - the comprehensive composite article that this dedicated server testing procedure was extracted from.
• Curated Maps Guide - the curated maps program requirements that include asset validation requirements.
• Asset Load Failure Reference - the diagnostic reference for asset load failures that may surface during server testing.
• Smartly Dressed Games Modding Documentation - the official server setup, validation, and asset creation documentation.
• Unturned on Steam - the base game and community hub.

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Complete dedicated server testing and validation guide with server setup, ValidateAssets, log interpretation, multiplayer testing, and diagnostic procedures.