Verse Island

Verse Tags in Fortnite: Runtime Object Discovery Without Property Wiring

Verse tags give you a runtime-queryable labeling system for Creative devices, props, and entities, letting you locate and operate on groups of objects without manually wiring device references through editable properties. This is a meaningful workflow shift: instead of maintaining brittle arrays of @editable device references in UEFN, you tag objects in the editor (or programmatically at runtime for entities) and query them on demand. The tag system is hierarchical via class inheritance, so a query for a parent tag automatically matches all child tags.

What Changed

The /Verse.org/Simulation/Tags module introduces a tag base class. You define your own tags by deriving from it, giving each tag class a meaningful name. Tags can be multi-level — a child tag class satisfies queries for any ancestor tag class.

using { /Verse.org/Simulation/Tags }

# Top-level abstract tag — never assigned directly
vehicle_tag := class<abstract>(tag){}

# Mid-level abstract tag
motorcycle_tag := class<abstract>(vehicle_tag){}

# Concrete assignable tags
ducati_tag   := class(motorcycle_tag){}
triumph_tag  := class(motorcycle_tag){}

What can be tagged and where:

Object Type	In-Editor	At Runtime (Verse)
Props	✓	✗
Devices	✓	✗
Verse-authored devices	✓	✗
Entities (Scene Graph)	✓	✓

You assign tags to Creative devices and props in UEFN by adding a Verse Tag Markup component via Add New Component in the Details panel, then populating the Tags field. For Scene Graph entities you can do the same in the editor, or call tag mutation APIs directly in Verse at runtime.

The primary query API is FindCreativeObjectsWithTag, which returns all currently tagged objects matching the given tag (or any of its subclasses). A single object can carry multiple tags and will surface in queries for any of them.

What You Can Build

1. Difficulty-Scaled Obstacle Courses With Zero Hardcoded References

Previously, toggling a set of hazard devices based on player-chosen difficulty required either an @editable array for each difficulty tier or a centralized device manager. With tags you define tiers as tag subclasses and query at activation time.

using { /Verse.org/Simulation/Tags }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /Fortnite.com/Devices }

difficulty_tag   := class<abstract>(tag){}
easy_tag         := class(difficulty_tag){}
hard_tag         := class(difficulty_tag){}

# Called when the player commits to a difficulty
ActivateTier(Difficulty : tag) : void =
    Objects := FindCreativeObjectsWithTag(Difficulty)
    for (Obj : Objects):
        if (Device := barrier_device[Obj]):
            Device.Enable()

Tag your barrier devices in UEFN with easy_tag or hard_tag, then call ActivateTier(easy_tag{}) or ActivateTier(hard_tag{}). No property arrays to maintain; adding a new barrier is as simple as tagging it in the editor.

2. Runtime Entity Group Management

Because entities support tag mutation at runtime, you can build emergent grouping logic — for example, dynamically marking entities as "active threats" and querying that set each wave.

using { /Verse.org/Simulation/Tags }
using { /Verse.org/SceneGraph }

active_threat_tag := class(tag){}

# Mark an entity as a threat when it spawns
MarkAsThreat(E : entity) : void =
    if (TagComponent := E.GetTagComponent[]):
        TagComponent.AddTag(active_threat_tag{})

# Collect all current threats for wave logic
GetAllThreats() : []entity =
    var Threats : []entity = array{}
    Objects := FindCreativeObjectsWithTag(active_threat_tag{})
    for (Obj : Objects):
        if (E := entity[Obj]):
            set Threats = Threats + array{E}
    return Threats

# Clean up when a threat is neutralized
ClearThreat(E : entity) : void =
    if (TagComponent := E.GetTagComponent[]):
        TagComponent.RemoveTag(active_threat_tag{})

This pattern lets you maintain a live, queryable roster of active entities without a manually synchronized array, and it degrades cleanly — removed entities simply stop appearing in future queries.

3. Polymorphic Device Operations via Tag Hierarchy

Because FindCreativeObjectsWithTag respects inheritance, you can write a single activation sweep that operates on a heterogeneous mix of device types, dispatching on the actual type after retrieval.

using { /Verse.org/Simulation/Tags }
using { /Fortnite.com/Devices }

zone_element_tag  := class<abstract>(tag){}
zone_light_tag    := class(zone_element_tag){}
zone_barrier_tag  := class(zone_element_tag){}

ActivateZone() : void =
    # One query surfaces both lights and barriers
    Objects := FindCreativeObjectsWithTag(zone_element_tag{})
    for (Obj : Objects):
        if (Light := customizable_light_device[Obj]):
            Light.TurnOn()
        else if (Barrier := barrier_device[Obj]):
            Barrier.Enable()

Tag your lights with zone_light_tag and your barriers with zone_barrier_tag. Because both inherit from zone_element_tag, a single query retrieves them all. Adding a new device type to the zone later requires only tagging it in UEFN — no Verse code changes needed.

Verse Tags in Fortnite