Editor Asset Redirector Reference

Intermediate40-60 minutesWindowsNotepad++Unity Editor

The editor asset redirector system is a bulk-replacement mechanism that operates at the level editor layer of Unturned™. It allows a map author to replace every instance of a specific object, resource, material, or foliage asset with a different asset across an entire map, in a single operation, during map load in the level editor. The replacement is not temporary: when the map is saved after loading with an editor asset redirector file active, the replacements are written into the map file and become permanent. The redirector file can then be removed, and the map will continue to load with the replaced assets.

This article is the 57 Studios™ canonical reference for the editor asset redirector system. It covers the EditorAssetRedirectors.txt file format, the GUID-to-GUID mapping syntax, the comment and whitespace handling rules, the four asset categories that the system supports (objects, resources, materials, foliage), how the system differs from runtime redirector assets (which redirect asset references transparently and non-permanently), and the complete workflow for authoring, testing, and verifying an editor asset redirector file. The article assumes familiarity with GUIDs, the level editor, and the four asset categories that the redirector system operates on. Readers new to the asset system should read GUID Type Reference and Redirector Asset Reference before this article.

Documentation source: This article references Chapter 112 ("Editor Asset Redirectors") of the official Smartly Dressed Games modding documentation for the file format specification, the comment syntax, the arrow syntax, and the supported asset categories. Behaviour details are validated against the cohort's documented use of editor redirectors in map-authoring workflows.

Who this article is for

This article is written for Unturned™ map authors who need to replace assets in bulk across a level, who are migrating a map from one asset set to another, or who are standardising map content after a mod update that changed asset GUIDs. Readers should already understand the level editor, GUIDs, and the four asset categories (objects, resources, materials, foliage) that maps reference. If you are new to map authoring, read the Unturned™ level editor documentation before this article.

What you'll learn

• The file format specification for EditorAssetRedirectors.txt
• The GUID-to-GUID mapping syntax using the arrow (->) operator
• The comment syntax: // and # prefixes for ignored lines
• The four asset categories that the editor redirector system supports: objects, resources, materials, foliage
• How the redirector applies during level editor map load and how changes are saved permanently to the map file
• How editor redirectors differ from runtime redirector assets in behaviour, scope, and permanence
• The complete workflow for authoring and testing an editor redirector file
• How to verify that redirectors were applied correctly after map load
• Common mistakes and their documented corrections

Background: why editor asset redirectors exist

Map authoring in Unturned™ involves placing hundreds or thousands of asset references-objects that populate the landscape, resources that define harvestable nodes, materials that define surface appearances, and foliage that defines vegetation. Each placed reference is a GUID that points to an asset definition. When a map author needs to replace every instance of a specific asset (for example, replacing every Boulder_00 boulder with a Boulder_01 boulder across an entire map), the manual approach is to find and replace each placed instance individually in the level editor. On a large map with hundreds of placed boulders, this manual process is error-prone and can take hours.

The editor asset redirector system automates this process. The map author writes a simple text file listing the old GUIDs and their replacements, places the file in the Unturned™ folder, opens the map in the level editor, and saves the map. The editor reads the redirector file during map load, replaces every matching reference with the specified replacement, and the author saves the map with the replacements permanently written into the map file. What would have been a multi-hour manual operation completes in the time it takes to load and save the map.

The SDG documentation describes the system succinctly: "Editor Asset Redirectors allow for quickly replacing objects, resources, materials, or foliage assets in bulk. Redirects apply while loading a map in the level editor. Any changes are then kept when saving the map."

As shown in the sequence above, the redirector file acts at map-load time in the editor. The replacements are applied to the in-memory representation of the map, and when the map is saved, the new GUIDs are written into the map file permanently. The redirector file is not consulted when the map is loaded at game runtime-by that point, the map file already contains the replacement GUIDs.

File format specification

The editor asset redirector file must be named EditorAssetRedirectors.txt and must be placed in the Unturned™ folder (the game's installation root directory, not a mod folder). The file uses a plain-text line-oriented format with three rules for line handling and one rule for the mapping syntax.

File location

The file must be located at the following path relative to the Unturned™ installation directory:

Unturned/EditorAssetRedirectors.txt

The typical full path on a Windows installation is:

C:\Program Files (x86)\Steam\steamapps\common\Unturned\EditorAssetRedirectors.txt

The editor looks for the file at this exact path and name. Renaming the file, moving it to a subfolder, or placing it inside a mod folder causes the editor to ignore it. The file is editor-only; it does not need to be distributed to players or included in a Workshop submission.

Line handling rules

The SDG documentation specifies three rules for how the editor parses lines in the file:

Rule	Behaviour
Empty lines	Ignored. The editor skips lines that contain no characters or only whitespace characters.
Lines starting with //	Ignored. Treated as comments. The // must be at the very beginning of the line (no leading whitespace before the comment marker, though this is not explicitly enforced).
Lines starting with #	Ignored. Treated as comments. Same behaviour as // lines.
All other lines	Parsed as redirector rules. Must contain exactly two GUIDs separated by the arrow operator ->.

The comment syntax supports two prefixes (// and #) so that map authors can choose whichever syntax is more familiar. Both prefixes are equivalent; there is no behavioural difference between a // comment and a # comment. The cohort convention is to use // for explanatory comments and # for temporarily disabled redirector rules.

Mapping syntax

Each redirector rule is a single line containing two GUIDs separated by the arrow operator ->. The format is:

<source GUID> -> <target GUID>

The source GUID (left of the arrow) is the GUID that currently exists in the map - the GUID that the author wants to replace. The target GUID (right of the arrow) is the GUID that should replace it. The arrow operator must be exactly -> (hyphen followed by greater-than sign) with at least one space on each side, though the SDG documentation's example uses a single space before and after the arrow.

Example from the SDG documentation:

// Replace Boulder_00 with Boulder_01
6125b4de591b44359237f6d7191dd919 -> ee402fc9debe4f03bffb31a49eb04fb7

In this example, every placed instance of the asset with GUID 6125b4de591b44359237f6d7191dd919 (Boulder_00) is replaced with the asset with GUID ee402fc9debe4f03bffb31a49eb04fb7 (Boulder_01) when the map loads in the level editor.

GUID format in the redirector file

The GUIDs in the editor redirector file must be the full 32-character hexadecimal string with no hyphens, matching the same format used in .dat and .asset files. The editor performs a byte-level comparison of the GUID strings. A typo of a single hex digit produces a mismatch and the redirector rule has no effect.

The GUIDs must exist in the loaded asset set at the time the map is opened in the editor. The source GUID must correspond to an asset that is placed in the map; the target GUID must correspond to an asset that exists in the loaded content (vanilla or mod) and is of a compatible asset type (object, resource, material, or foliage). The editor does not validate asset type compatibility at redirector load time; an invalid replacement (e.g., replacing a resource with an object GUID) may produce unpredictable behaviour and should be avoided.

Supported asset categories

The SDG documentation lists four asset categories that the editor redirector system supports. The system does not support items, vehicles, effects, or other asset categories. Only objects, resources, materials, and foliage can be bulk-replaced.

Asset category	What it controls	Example use case
Objects	Placed world objects: boulders, buildings, props, level geometry	Replace every Boulder_00 with Boulder_01 across a map
Resources	Harvestable resource nodes: trees, rocks, ore deposits, water sources	Replace every Maple_0 tree with Maple_3 tree
Materials	Surface materials: grass, dirt, rock, concrete, metal	Replace all Grass_0 material references with Grass_1
Foliage	Vegetation instances: grass tufts, bushes, small plants	Replace all Bush_Small_0 with Bush_Small_1

The category that the replacement operates on is determined by the asset type of the source GUID. The editor determines the asset type by looking up the source GUID in the asset registry and reading the asset's Type field. A source GUID that points to an object asset triggers object replacement; a source GUID that points to a resource asset triggers resource replacement.

Supported categories only

The editor does not support redirecting items, vehicles, effects, spawn tables, or any asset category not listed above. Attempting to redirect an item GUID (e.g., replacing one gun with another gun at map level) will have no effect, because items are not placed in maps. Item replacement must be done through runtime redirector assets or by changing the item's own .dat or .asset file.

Example EditorAssetRedirectors.txt files

Example 1: Basic object replacement

Replace all instances of two boulder types with newer variants across a map:

// Replace old boulder variants with updated boulder models
6125b4de591b44359237f6d7191dd919 -> ee402fc9debe4f03bffb31a49eb04fb7

// Replace old Maple_0 with Maple_3
63cb368c94b14000aabc5325b048cfa3 -> 011d1369cd56497488827b44509b0b4b

# 7f8a2c1d5e3b4f9a0b6c8d2e4f1a3b5c -> 9e3f7d1c5b8a4e0f2a6c4d8b1e3f0a5b  // disabled - not ready for this replacement yet

The file has two active redirector rules (the // lines are comments) and one disabled rule (the # line is a comment that contains a rule the author may re-enable later by removing the # prefix).

Example 2: Bulk foliage swap

Replace all instances of several foliage types in a single operation:

// Foliage replacement for biome conversion
// Replacing forest undergrowth with desert scrub

// Small bush replacements
61a2b4de591b44359237f6d7191dd800 -> f4e5d4c3b2a10987fedcba9876543201
61a2b4de591b44359237f6d7191dd801 -> f4e5d4c3b2a10987fedcba9876543202

// Grass tuft replacements
71b2c5ef602c5546a348e7f8202ee911 -> a1b2c3d4e5f64a7b8c9d0e1f2a3b4c500
71b2c5ef602c5546a348e7f8202ee912 -> a1b2c3d4e5f64a7b8c9d0e1f2a3b4c501

// Tall grass replacements
81c3d6ff713d6657b459f8f9313ffa22 -> b2c3d4e5f6a7b8c9d0e1f2a3b4c5d601

This example demonstrates the pattern for a biome conversion: every forest undergrowth foliage asset is mapped to a corresponding desert scrub foliage asset. The comments document the purpose of each block of rules. The map author opens the map in the editor after placing this file, saves the map, and the foliage biome conversion is complete.

Example 3: Material standardization

Replace several deprecated surface materials with their canonical replacements:

// Material standardization pass
// Deprecated Grass_0 and Grass_Old -> current Grass_Standard
a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5 -> z9y8x7w6v5u4t3s2r1q0p9o8n7m6
b1c2d3e4f5a6b7c8d9e0f1a2b3c4d6 -> z9y8x7w6v5u4t3s2r1q0p9o8n7m6

// Deprecated Dirt_Old -> current Dirt_Standard
c2d3e4f5a6b7c8d9e0f1a2b3c4d5e7 -> y9x8w7v6u5t4s3r2q1p0o9n8m7l6

In this example, two deprecated grass materials and one deprecated dirt material are mapped to their current standard counterparts. Note that two different source GUIDs both map to the same target GUID (z9y8x7w6v5u4t3s2r1q0p9o8n7m6). Multiple source GUIDs can map to the same target GUID, which is the pattern for consolidating multiple deprecated assets into a single replacement asset.

How editor redirectors differ from runtime redirector assets

The editor asset redirector system and the runtime redirector asset system serve different purposes and operate at different layers of the Unturned™ engine. Confusing the two is a common mistake for new map authors.

Property	Runtime redirector asset	Editor asset redirector
File format	.asset file	EditorAssetRedirectors.txt
File location	Inside a mod's Bundles/ folder	In the Unturned installation root folder
When it applies	At game runtime, every time a reference is resolved	At level editor map load time only
Permanence	Transparent and non-permanent; original reference is saved	Permanent; changes written to the map file on save
Scope	Any asset reference (GUID or legacy ID) that points to the redirector	Only objects, resources, materials, and foliage placed in a map
Asset type constraint	None; any asset type can be redirected	Limited to objects, resources, materials, foliage
Distribution	Must be included in mod distribution for redirector to work	Used locally by the map author; not distributed to players
Removal safety	Cannot be removed without breaking dependent references	Can be removed after map is saved; map contains permanent replacements
Purpose	Long-term identity indirection and collision resolution	One-time bulk asset replacement during map authoring

The critical distinction is permanence. A runtime redirector must remain loaded for as long as any reference passes through it; removing the redirector breaks those references. An editor redirector is consumed during map load in the editor, its replacements are written permanently into the map file, and the redirector file can be deleted immediately after the map is saved. The editor redirector is a one-time transformation tool; the runtime redirector is ongoing identity infrastructure.

Workflow: authoring and applying an editor asset redirector

The following workflow documents the cohort procedure for authoring and applying an editor asset redirector file.

Step 1: Identify the assets to replace

Open the map in the level editor. Use the editor's object browser, resource browser, or material browser to identify the specific assets that need replacement. Note the exact GUID of each asset. The GUID can typically be found in the asset's properties panel or by inspecting the asset's source .asset or .dat file.

Step 2: Identify the replacement assets

Confirm the target assets exist in the loaded content and note their GUIDs. The target assets must be of the same category as the source assets (object to object, resource to resource, material to material, foliage to foliage). If the replacement assets are from a mod, the mod must be loaded before the map is opened in the editor.

Step 3: Create the EditorAssetRedirectors.txt file

Create a new text file at Unturned/EditorAssetRedirectors.txt. Use a plain-text editor (Notepad++ is the cohort recommendation) and save the file with UTF-8 encoding. Write one redirector rule per line, using the <source GUID> -> <target GUID> syntax. Add comment lines with // or # to document the purpose of each rule.

Step 4: Verify the file syntax

Before opening the map, verify the redirector file for common syntax errors:

• Each active rule line has exactly one -> arrow with a GUID on each side.
• There are no extra spaces inside the GUIDs (32 hex characters each, no separators).
• Comment lines correctly start with // or #.
• No blank lines contain accidental invisible characters (rare but possible on some editors).

Step 5: Open the map in the level editor

Launch Unturned™ and open the map in the level editor. The editor reads the EditorAssetRedirectors.txt file during the map load process and applies the replacements to the in-memory map representation. The editor does not display any confirmation message that redirectors were applied; the replacement is silent.

Step 6: Verify the replacements

After the map loads, visually verify that the replacements were applied correctly:

• Navigate to a location where the old asset was placed and confirm the new asset appears instead.
• Open the object/resource/material browser and confirm the old asset's count decreased and the new asset's count increased accordingly.
• If a replacement did not apply, check that the source GUID in the redirector file exactly matches the asset's GUID in the map.

Step 7: Save the map

Save the map in the level editor. The save operation writes the replacement GUIDs into the map file permanently. The original GUIDs are no longer present in the map file (unless some instances of the old asset were not placed and therefore had nothing to replace).

Step 8: Close and reopen the map without the redirector file

To confirm the replacements are permanent, close the level editor, delete or rename the EditorAssetRedirectors.txt file (so it is not active on the next load), reopen the map in the editor, and confirm the replacement assets are still present. If the old assets have returned, the save in Step 7 did not complete correctly. If the new assets are present, the replacements were written permanently.

Step 9: Distribute the map

The map file now contains the new GUIDs. The EditorAssetRedirectors.txt file is not needed by players who load the map at game runtime. It can remain on the map author's computer for future use or be deleted.

The flowchart above documents the complete author-to-verification cycle. The verification steps (E and J) are the most important quality gates; skipping them can result in a map that works correctly on the author's machine (where the redirector file is active) but breaks for players (who do not have the redirector file).

Editor redirectors and mod dependency management

The editor redirector system operates at the editor layer, not the mod layer. This has implications for how map authors manage mod dependencies when using redirectors to standardise map content.

Scenario: replacing mod assets with vanilla equivalents

A map author has a map that references assets from a mod. The author wants to remove the mod dependency and replace every mod asset reference with a vanilla equivalent. The editor redirector workflow for this scenario is:

1. Load the mod (so the source GUIDs exist in the asset registry).
2. Create an EditorAssetRedirectors.txt file mapping each mod asset GUID to its vanilla replacement GUID.
3. Open the map in the level editor. The editor applies the replacements during map load.
4. Save the map. The map file now contains vanilla GUIDs rather than mod GUIDs.
5. Close the editor, remove the mod, and reopen the map. The map loads without the mod because all mod-specific GUIDs have been replaced.

This workflow is the primary use case for editor redirectors in the 57 Studios™ cohort: migrating a map from a mod-dependent state to a vanilla-only state, or from one mod asset set to another.

Scenario: standardising across multiple maps in a map series

A map series (e.g., three connected maps that form a larger world) may share many of the same placed assets. If the series author decides to replace a specific object type across all three maps, the editor redirector workflow saves enormous time:

1. Create a single EditorAssetRedirectors.txt file with the replacement rules.
2. Open Map 1 in the editor, save, close.
3. Open Map 2 in the editor, save, close.
4. Open Map 3 in the editor, save, close.
5. Remove the redirector file.
6. All three maps now contain the replacement GUIDs.

Without the editor redirector, the author would need to manually replace every instance of the old object in each of the three maps-a process that could take days on large maps. With the editor redirector, the same task completes in the time it takes to open and save three map files.

Editor redirectors and the Unity asset pipeline

Map authors who use Unity to author custom objects, resources, materials, or foliage should understand how the editor redirector system interacts with the Unity-to-Unturned asset pipeline.

When a custom object is exported from Unity and imported into Unturned™ as a mod asset, it receives a GUID in its .asset or .dat file. This GUID is the identity that the map references when the object is placed. If the author later exports a revised version of the same object from Unity and imports it as a new mod asset (with a new GUID), all existing map references still point to the old GUID. The editor redirector bridges this gap: the author adds a rule mapping the old GUID to the new GUID, opens the map, saves it, and the map now references the new GUID.

This workflow is particularly valuable during iterative map development, where objects may be revised and re-exported multiple times. Rather than replacing every placed instance of an object each time it is updated, the author accumulates redirector rules as objects are revised, applies them all in a single editor session before the map's final release, and ships the map with the latest GUIDs for every object.

Best practice: accumulate redirector rules in a versioned file

The cohort recommendation for iterative map development is to maintain a versioned EditorAssetRedirectors.txt file as part of the map project's source files:

MyMap_Project/
├── EditorAssetRedirectors.txt   <- redirector rules, version-controlled
├── MyMap.unity                   <- Unity project for custom assets
├── MyMap_export/                 <- exported map file
└── README.md

Each time an asset's GUID changes during development, add a rule to the redirector file. Before a release build, apply all accumulated rules by opening the map in the editor with the redirector file active and saving. After the release, archive the redirector file as a record of the GUID migration history. This practice ensures that no old GUID references survive into the released map and that the GUID migration history is documented for future maintainers.

Editor redirectors and the level editor's undo system

The level editor's undo system does not track changes made by the editor redirector during map load. The redirector replacements are applied before the map is displayed in the editor, before the undo stack is initialised for the editing session. Pressing Ctrl+Z (Undo) after loading a map with redirectors applied will not revert the redirector replacements.

This has a practical consequence: if the author loads a map with redirectors active, realises a replacement was incorrect, and wants to revert it, there is no undo path. The author must:

1. Close the map without saving (to preserve the pre-redirector state).
2. Correct the redirector file (fix the incorrect GUID or remove the offending rule).
3. Reopen the map with the corrected redirector file active.
4. Save the map.

Alternatively, if the incorrect replacement was discovered after saving, the author must restore the map from a backup (if one was made before the redirector session) or manually replace the incorrectly redirected assets back to their original form. The cohort recommendation is to always back up the map file before applying a redirector session, especially when the redirector file is large or the replacements are complex.

Common mistakes and their corrections

Mistake	Consequence	Correction
File named incorrectly (e.g., EditorRedirectors.txt)	Editor does not find the file; no replacements applied	Rename to exactly EditorAssetRedirectors.txt
File placed in wrong folder (e.g., Bundles/)	Editor does not find the file	Move to the Unturned installation root folder
GUID contains hyphens	GUID comparison fails; no replacement	Strip hyphens; use 32 hex characters only
Single hex digit typo in GUID	GUID comparison fails; no replacement	Copy-paste the GUID from the asset's source file to avoid typos
Arrow syntax incorrect (e.g., => instead of ->)	Line not parsed as redirector rule	Use exact -> syntax with spaces
Replacing resource with object GUID	Unpredictable behaviour; may crash editor	Confirm source and target are same asset category
Comment line without // or # prefix	Line parsed as redirector rule; garbled GUID comparison	Prefix comment lines with // or #
Source GUID does not exist in loaded content	No replacement; rule silently ignored	Confirm source asset's mod is loaded
Target GUID does not exist in loaded content	Replacement produces broken reference; object disappears	Confirm target asset's mod is loaded
Saving map without verifying replacements	Map may contain broken references if target GUID was invalid	Always verify replacements visually before saving

The most common mistake is the file placement error: the author places EditorAssetRedirectors.txt in a mod folder (expecting it to be discovered like .asset and .dat files) rather than in the Unturned installation root folder. The file is editor-global, not mod-scoped, and must be in the root folder.

Frequently asked questions

Does the editor redirector file need to be distributed with the map?

No. The editor redirector file is consumed during map load in the level editor. Once the map is saved, the replacement GUIDs are written into the map file permanently. Players who download the map from the Steam Workshop do not need the EditorAssetRedirectors.txt file. The file is a local authoring tool, not a runtime dependency.

Can I redirect an asset to a GUID from a mod that is not loaded?

No. Both the source GUID and the target GUID must exist in the loaded asset set at the time the map is opened in the editor. If the target GUID does not exist (because the mod that contains it is not loaded), the redirector rule has no effect or produces a broken reference. Load all required mods before opening the map in the editor.

Does the redirector apply to assets placed after the map is loaded?

No. The redirector applies during the map load process, before the map is displayed in the editor. Assets placed manually after the map has loaded (during the current editing session) are not affected by the redirector file. If you need to replace assets placed during the current session, use the editor's built-in replacement tools or re-open the map with the redirector file active.

Can I use the editor redirector to replace items in a map?

No. Items (guns, melee weapons, magazines, clothing, consumables) are not placed directly in maps. Items exist in player inventories, spawn tables, and loot containers. The editor redirector system operates on placed map references only: objects, resources, materials, and foliage. To replace items globally, use a runtime redirector asset or change the item's .dat/.asset file.

What happens if the source GUID does not appear anywhere in the map?

The redirector rule has no effect. The editor scans the map for references to the source GUID, finds none, and the rule is silently ignored. There is no harm in having unused redirector rules in the file, but they add clutter. Remove rules that are no longer needed.

Can multiple source GUIDs map to the same target GUID?

Yes. This is a common pattern for consolidating multiple deprecated or old assets into a single replacement asset. For example, three different boulder variants can all be mapped to a single new boulder model. Each source GUID gets its own line in the redirector file, all pointing to the same target GUID.

Can one source GUID map to multiple target GUIDs?

No. A redirector rule maps one source GUID to one target GUID. If you need to split the instances of a source asset across multiple target assets (e.g., half the boulders become Boulder_01 and half become Boulder_02), you cannot do this with editor redirectors alone. You would need to perform a single replacement (all boulders become Boulder_01) and then manually replace half of them to Boulder_02 in the editor.

Does the editor redirector change spawn tables or blueprint recipes?

No. The editor redirector changes only asset references that are placed in the map file: objects, resources, materials, and foliage. Spawn tables, blueprint recipes, NPC configurations, and other data files are not affected. If a spawn table references Boulder_00 by GUID and you replace every placed Boulder_00 in the map with Boulder_01, the spawn table will still reference Boulder_00 and will still spawn Boulder_00 (if it is still loaded) or fail to spawn anything (if Boulder_00 has been removed from the loaded content).

Is there a limit on the number of redirector rules in the file?

No. There is no documented limit on the number of lines or rules in the EditorAssetRedirectors.txt file. The cohort has tested files with upwards of 200 rules without issues. Very large files (thousands of lines) have not been tested but are unlikely to cause problems, as the editor processes the file once at map load time and the per-rule processing cost is negligible.

Can I use the editor redirector to replace vehicle spawns on a map?

No. Vehicles are not placed as objects, resources, materials, or foliage. Vehicle spawns are defined in a separate spawn table or in the map's vehicle configuration. The editor redirector system does not support vehicle replacement. To change vehicle spawns, edit the vehicle spawn configuration directly.

Does the editor redirector work on dedicated servers?

The editor redirector is an editor-only feature. It operates during map load in the level editor, which runs on the client, not on a dedicated server. A server administrator cannot use the editor redirector to change assets on a live server. The map must be edited on a client installation, saved with the replacements, and then the updated map file must be uploaded to the server.

How do I find the GUID of an asset in the level editor?

The GUID of a placed asset is typically visible in the asset's properties panel in the level editor. Select the asset in the editor, open the properties panel, and look for a GUID or Asset field. If the editor does not display the GUID directly, you can find it by opening the asset's source file (in the Bundles/ folder) and reading the GUID field from the .dat or .asset file. For vanilla assets, the GUID is in the shipped game files; for mod assets, it is in the mod's files.

Can I use wildcards or partial GUID matches in the redirector file?

No. The editor performs an exact string comparison of the full 32-character GUID. There is no wildcard syntax, no regex support, and no partial matching. Each source GUID must be written in full. If a mod update changes an asset's GUID, every redirector rule that references the old GUID must be updated to reference the new GUID.

How do I test the redirector file without modifying my main map?

Make a copy of the map file before beginning. Apply the redirector rules to the copy, verify the results, and if the results are correct, apply the same rules to the main map. If the results are incorrect, delete the copy and fix the redirector file without having affected the main map. Backing up the map before every redirector session is the cohort's recommended defensive practice.

Can editor redirectors replace assets that were placed by a spawn table at runtime?

No. Editor redirectors operate on asset references that are permanently written into the map file during authoring. Assets spawned at runtime by a spawn table are not in the map file and are not affected. If a spawn table spawns Boulder_00 and the map has an editor redirector that replaces placed Boulder_00 references with Boulder_01, the placed boulders change but the spawn table continues to spawn Boulder_00. The spawn table itself must be edited to change what it spawns.

Does the order of rules in the redirector file matter?

No. The editor processes all rules and applies all matching replacements. If two rules reference the same source GUID (which should not happen in a well-formed file), the behaviour is undefined and may vary by Unturned™ version. The cohort recommendation is to ensure each source GUID appears exactly once in the file, so that there is no ambiguity about which target GUID a given source replaces.

Can I redirect foliage instances that were procedurally generated?

If the foliage was placed procedurally (through the level editor's foliage-painting tools) and the foliage references are saved as part of the map data, the editor redirector will replace them. If the foliage is generated at runtime by a procedural system that does not reference saved map data, the redirector has no effect. The key distinction is whether the foliage GUID is stored in the map file: stored GUIDs are replaced; runtime-generated GUIDs are not.

Appendix A: Editor asset redirector quick-reference card

Property	Value
File name	EditorAssetRedirectors.txt (exact name required)
File location	Unturned installation root folder
File format	Plain text, UTF-8
Mapping syntax	<source GUID> -> <target GUID>
Comment syntax	// or # at start of line
Empty lines	Ignored
Supported categories	Objects, resources, materials, foliage
Unsupported categories	Items, vehicles, effects, spawn tables, NPCs
When applied	During map load in the level editor
Permanence	Permanent after map save
Distribution	Not required; local authoring tool only
GUID format	32 hex characters, no hyphens

Appendix B: Verification checklist after applying editor redirectors

Before distributing a map that was processed with editor asset redirectors, verify the following:

• [ ] The map was saved in the level editor after the redirectors were applied.
• [ ] The EditorAssetRedirectors.txt file was removed or renamed before a test load.
• [ ] The map was reopened in the editor without the redirector file and the replacement assets are present.
• [ ] A visual spot-check of several locations confirmed the old assets are replaced with the new assets.
• [ ] The object/resource/material browser counts show the expected changes (old count decreased, new count increased).
• [ ] No assets are missing or appear as error placeholders (checkerboard textures or missing-object indicators).
• [ ] Spawn tables and other data files still reference the correct assets (they are not affected by the editor redirector; confirm they reference the new GUIDs if the old assets were removed).
• [ ] The map loads correctly in a fresh Unturned™ instance without the redirector file.
• [ ] A colleague or test player has loaded the map and confirmed the assets appear as expected.

Appendix C: Diagnostic table for editor asset redirector problems

Symptom	Most likely cause	Resolution
Replacements not applied after opening map	File not found by editor	Confirm file is named EditorAssetRedirectors.txt and is in the Unturned root folder
Some replacements applied, others not	GUID typo in source GUID for the failed rule	Compare source GUID in redirector file against asset's actual GUID
Old assets still visible after replacement	Map was not saved after applying redirectors	Re-open map with redirector file, save map, remove redirector file, re-verify
Target asset appears as checkerboard or error placeholder	Target GUID does not exist in loaded content	Confirm the mod containing the target asset is loaded
Editor crashes on map load with redirector file active	Invalid replacement (wrong asset category)	Remove the offending rule; confirm source and target are same category
Map works on author's machine but not on test machine	Redirector file still active on author's machine, masking broken references	Remove redirector file from author's machine and test again
File syntax looks correct but no replacements applied	Invisible characters in file (BOM, non-breaking spaces, wrong line endings)	Re-save file as UTF-8 without BOM in Notepad++; use // for comments only
Replacements applied but wrong asset count	Some old assets were already replaced in a previous session	Confirm the source GUID still exists in the map before applying

Appendix D: External references

• Smartly Dressed Games official modding documentation - Chapter 112: Editor Asset Redirectors - the authoritative source for the EditorAssetRedirectors.txt file format, the arrow syntax, the comment rules, and the supported asset categories.
• Unturned on Steam - the Unturned™ store page and community hub.
• GUID Type Reference - the companion data-types article covering the 128-bit GUID identity system.
• Redirector Asset Reference - the previous article; covers the runtime redirector asset type that operates at game runtime rather than at editor load time.
• Legacy ID Availability - covers the legacy ID system and the Export Asset IDs tool for finding asset GUIDs.
• Asset Definitions Reference - the .asset file format reference.

Document history

Version	Date	Author	Notes
1.0	2025-05-18	57 Studios	Initial publication. Complete editor asset redirector reference: file format, mapping syntax, supported categories, comparison with runtime redirectors, full authoring workflow, diagnostic table.

Cross-references

• Redirector Asset Reference - the previous article; covers the runtime redirector asset that operates transparently at game runtime.
• GUID Type Reference - the companion data-types article covering GUID generation, format, and lifecycle.
• Legacy ID Availability - covers the Export Asset IDs tool used to find asset GUIDs for redirector rules.
• Asset Definitions Reference - the .asset file format reference.
• Smartly Dressed Games modding documentation - official field reference for editor asset redirectors.
• Unturned on Steam - game page and community hub.