sync: Running Two Async Tasks at the Same Time

Overview

sync is a Verse concurrency expression that runs two or more <suspends> branches simultaneously and only continues past the sync block once every branch has completed. It is the parallel counterpart to race (which stops as soon as the first branch finishes).

The game problem it solves: Many island moments need several things to happen at the same time. A player steps onto a dock pressure plate → you want to:

• Show a HUD countdown message that auto-hides after a few seconds, AND
• Run a trigger cooldown loop that limits how often the plate can fire

Without sync you'd have to chain those sequentially, making the second thing wait for the first. With sync both branches run in parallel and the code after the sync block only executes once both are truly done.

When to reach for it:

• Two independent timers that must both expire before the next phase starts
• Showing a HUD message while simultaneously waiting for a trigger reset
• Animating a cinematic AND waiting for a player input at the same time
• Any "all of the above must finish" parallel gate

API Reference

trigger_device

Used to relay events to other linked devices.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse). Inherited members are merged from trigger_base_device.

trigger_device<public> := class<concrete><final>(trigger_base_device):

Events (subscribe a handler to react):

Methods (call these to make the device act):

player

Full public surface, resolved verbatim from the live Epic digest (Verse.digest.verse). Inherited members are merged from agent.

player<native><public> := class<unique><persistent><module_scoped_var_weak_map_key><epic_internal>(agent):

hud_message_device

Used to show custom HUD messages to one or more agents.

Full public surface, resolved verbatim from the live Epic digest (Fortnite.digest.verse).

hud_message_device<public> := class<concrete><final>(creative_device_base):

Events (subscribe a handler to react):

Methods (call these to make the device act):

Walkthrough

Scenario: The Lagoon Dock Alarm

A 2D cel-shaded pirate island. A pressure-plate trigger sits on the dock. When a player steps on it:

1. A HUD message flashes "⚓ Dock Alarm! Pirates incoming!" for 4 seconds.
2. The trigger is disabled for 6 seconds (cooldown) so it can't be spammed.
3. Both things happen at the same time via sync. Only after both finish does the trigger re-enable.

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

# Attach this creative_device to a Verse Device actor in UEFN.
# Wire DockPlate -> a trigger_device placed on the dock.
# Wire AlarmHUD  -> a hud_message_device set to show for 0 sec (we control duration in code).
lagoon_dock_alarm := class(creative_device):

    # The pressure-plate trigger on the dock
    @editable DockPlate : trigger_device = trigger_device{}

    # HUD message device — set Display Time to 0 in its properties (we drive it from code)
    @editable AlarmHUD : hud_message_device = hud_message_device{}

    # Localised message helper
    AnchorMessage<localizes>(S : string) : message = "{S}"

    # Called once when the island starts
    OnBegin<override>()<suspends> : void =
        # Limit the plate to 1 trigger per cooldown window (max 1, resets via Enable below)
        DockPlate.SetMaxTriggerCount(1)
        # Subscribe — handler fires every time the plate is stepped on
        DockPlate.TriggeredEvent.Subscribe(OnDockStepped)

    # Handler: called by TriggeredEvent — receives ?agent
    OnDockStepped(MaybeAgent : ?agent) : void =
        # Disable the plate immediately so it can't double-fire
        DockPlate.Disable()
        # Kick off the parallel alarm logic in a new async task
        spawn { RunAlarm(MaybeAgent) }

    # Async helper: runs the HUD flash and the cooldown timer in parallel
    RunAlarm(MaybeAgent : ?agent)<suspends> : void =
        # Prepare the alarm text
        AlarmHUD.SetText(AnchorMessage("⚓ Dock Alarm! Pirates incoming!"))

        # sync: both branches run at the same time.
        # We only proceed past this block when BOTH branches are done.
        sync:
            # Branch 1 — show the HUD message for 4 seconds, then hide it
            block:
                if (A := MaybeAgent?):
                    AlarmHUD.Show(A)
                else:
                    AlarmHUD.Show()
                Sleep(4.0)
                AlarmHUD.Hide()

            # Branch 2 — enforce a 6-second cooldown on the trigger
            block:
                Sleep(6.0)

        # Both branches finished — re-arm the plate
        DockPlate.SetMaxTriggerCount(1)
        DockPlate.Enable()

Line-by-line explanation

Common patterns

Pattern 1 — Querying trigger state before a sync cooldown

Check how many triggers remain and log it to a HUD, then run a dual-branch sync that resets the trigger and updates the display.

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

# Shows remaining trigger count in HUD, then runs a sync cooldown + display clear.
lagoon_trigger_inspector := class(creative_device):

    @editable InspectTrigger : trigger_device = trigger_device{}
    @editable StatusHUD      : hud_message_device = hud_message_device{}

    CountMsg<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        # Give the trigger a max of 5 uses with a 2-second reset delay
        InspectTrigger.SetMaxTriggerCount(5)
        InspectTrigger.SetResetDelay(2.0)
        InspectTrigger.TriggeredEvent.Subscribe(OnInspect)

    OnInspect(MaybeAgent : ?agent) : void =
        spawn { ShowCountAndCooldown(MaybeAgent) }

    ShowCountAndCooldown(MaybeAgent : ?agent)<suspends> : void =
        # Read current state
        Remaining := InspectTrigger.GetTriggerCountRemaining()
        MaxCount  := InspectTrigger.GetMaxTriggerCount()
        ResetSec  := InspectTrigger.GetResetDelay()

        # Build a status string and push it to the HUD
        StatusHUD.SetText(CountMsg("Triggers left — check your HUD!"))
        if (A := MaybeAgent?):
            StatusHUD.Show(A)
        else:
            StatusHUD.Show()

        # sync: hide the HUD after 3 s AND wait for the reset delay simultaneously
        sync:
            block:
                Sleep(3.0)
                AlarmHide(MaybeAgent)
            block:
                Sleep(ResetSec)

    AlarmHide(MaybeAgent : ?agent) : void =
        if (A := MaybeAgent?):
            StatusHUD.Hide(A)
        else:
            StatusHUD.Hide()

Pattern 2 — Transmit-delay inspection + parallel HUD flash

Read GetTransmitDelay and GetDisplayTime, then use sync so the HUD message and a transmit-delay sleep run together. This pattern is useful when you need the HUD to stay up exactly as long as the transmit delay.

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

# Reads the trigger's transmit delay and the HUD's display time,
# then syncs a HUD flash with the transmit window.
lagoon_transmit_sync := class(creative_device):

    @editable SignalTrigger : trigger_device      = trigger_device{}
    @editable FlashHUD      : hud_message_device  = hud_message_device{}

    TransmitMsg<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        # Configure a 3-second transmit delay on the trigger
        SignalTrigger.SetTransmitDelay(3.0)
        SignalTrigger.TriggeredEvent.Subscribe(OnSignal)

    OnSignal(MaybeAgent : ?agent) : void =
        spawn { SyncFlashWithTransmit(MaybeAgent) }

    SyncFlashWithTransmit(MaybeAgent : ?agent)<suspends> : void =
        TransmitSec := SignalTrigger.GetTransmitDelay()
        HudSec      := FlashHUD.GetDisplayTime()

        # Show a "Signal transmitting..." message
        FlashHUD.SetText(TransmitMsg("📡 Signal transmitting to the cove..."))

        # sync: HUD flash branch vs transmit-delay branch — both run in parallel
        sync:
            # Branch A: show HUD, wait for its display time, then hide
            block:
                if (A := MaybeAgent?):
                    FlashHUD.Show(A)
                else:
                    FlashHUD.Show()
                Sleep(HudSec)
                if (A := MaybeAgent?):
                    FlashHUD.Hide(A)
                else:
                    FlashHUD.Hide()

            # Branch B: wait for the full transmit delay
            block:
                Sleep(TransmitSec)

        # Only here once BOTH the HUD has hidden AND the transmit delay has elapsed
        # Safe to fire the trigger programmatically now
        SignalTrigger.Trigger()

Pattern 3 — Disable / Enable gate with a ClearAllMessages cleanup

A one-shot trigger on the clifftop: fire once, clear all HUD messages and wait for a cooldown in parallel, then re-enable.

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

# One-shot clifftop trigger: fires once, clears HUD and waits cooldown in sync, then re-enables.
clifftop_oneshot := class(creative_device):

    @editable ClifftopTrigger : trigger_device     = trigger_device{}
    @editable AlertHUD        : hud_message_device = hud_message_device{}

    AlertMsg<localizes>(S : string) : message = "{S}"

    OnBegin<override>()<suspends> : void =
        ClifftopTrigger.SetMaxTriggerCount(1)
        ClifftopTrigger.TriggeredEvent.Subscribe(OnClifftopFired)

    OnClifftopFired(MaybeAgent : ?agent) : void =
        ClifftopTrigger.Disable()
        spawn { CooldownAndClear(MaybeAgent) }

    CooldownAndClear(MaybeAgent : ?agent)<suspends> : void =
        AlertHUD.SetText(AlertMsg("🏴‍☠️ Clifftop beacon lit! Retreat to the cove!"))
        if (A := MaybeAgent?):
            AlertHUD.Show(A)
        else:
            AlertHUD.Show()

        # sync: clear all messages after 5 s AND enforce an 8 s cooldown
        sync:
            block:
                Sleep(5.0)
                AlertHUD.ClearAllMessages()
            block:
                Sleep(8.0)

        # Re-arm for next round
        ClifftopTrigger.SetMaxTriggerCount(1)
        ClifftopTrigger.Enable()

Gotchas

1. sync requires every branch to be <suspends>

sync only makes sense with async branches. Each sub-expression inside sync must be (or call) a <suspends> expression. If you accidentally put a plain synchronous call as the only thing in a branch, it completes instantly — which is fine, but it means that branch doesn't actually contribute any wait time. Wrap non-suspending setup in block: alongside a Sleep if you need the branch to hold.

2. ?agent unwrap — always check before calling agent-specific methods

TriggeredEvent is listenable(?agent), so your handler receives MaybeAgent : ?agent. You must unwrap it with if (A := MaybeAgent?): before passing it to AlarmHUD.Show(A) or AlarmHUD.Hide(A). Passing a ?agent directly where an agent is expected is a compile error.

3. message parameters are NOT raw strings

hud_message_device.SetText and the Show(Agent, Message, ...) overload take a message, not a string. You cannot pass a string literal directly. Declare a localized helper:

MyText<localizes>(S : string) : message = "{S}"

Then call SetText(MyText("Hello lagoon!")). There is no StringToMessage function.

4. SetMaxTriggerCount clamps to [0, 20]

Passing a value outside [0, 20] is silently clamped. 0 means unlimited triggers — not zero triggers. If you want a one-shot trigger, pass 1.

5. spawn vs direct <suspends> call in event handlers

Event handler methods (subscribed via .Subscribe(...)) are not themselves <suspends>, so you cannot Sleep or call sync directly inside them. Always spawn { MyAsyncHelper(...) } to launch async work from a synchronous handler.

6. sync waits for the longest branch

Unlike race (which exits on the first branch to finish), sync waits for all branches. If one branch sleeps for 10 seconds and another for 2 seconds, the code after sync runs after 10 seconds. Design your branch durations intentionally — the longest branch is your bottleneck.

7. GetTriggerCountRemaining returns 0 when unlimited

If GetMaxTriggerCount() returns 0 (unlimited), then GetTriggerCountRemaining() also returns 0 — not some large number. Check GetMaxTriggerCount() first if you need to distinguish "unlimited" from "zero remaining".