Migration Project: Translating a Whole Blueprint into Verse

1. The Source Material: One Blueprint, Ready for Translation

Translation needs an original. This graph is called BP_PressurePlate — the kind of small contraption you find in every map: step on it, the door opens; a few seconds later it shuts itself. Its parent class is Actor, the asset is a binary .uasset, and double-clicking it shows two things — the Variables panel in the bottom left, and the Event Graph in the middle.

The Variables panel has three rows. That eye icon column is Instance Editable: switch it on and the variable shows up in the Details panel of every instance in the level, so a designer can tune it without ever opening the Blueprint.

The Event Graph is a single execution line, seven nodes, strung left to right:

Read it straight through: step on it → check whether the door is closed → record the state → open → wait OpenDuration seconds → close → reset the state. You can picture the graph by now — seven boxes, one white line, a Delay with its little clock hanging off the right. The next six steps move that graph, block by block, into a .verse file.

One rule before you start: the first pass is faithful, not clever. You already know Verse has race, has option, has prettier ways to say this — but redesigning while translating means that when a bug shows up you cannot tell whether you translated it wrong or designed it wrong. Get the translation behaving exactly like the original first, then talk about refactoring. When to refactor, and into what, is the job of this lesson's advanced extra page.

2. Translating Section by Section: Six Steps Through the Whole Graph

Every step follows the same shape: this block of the original → these lines of Verse → why they correspond. The order matters — skeleton first, then data, then references, and only then the execution line. It is exactly the order you would build a new class in Blueprint.

Step 1: The Class Skeleton and Its Parent

This block of the original: the asset BP_PressurePlate itself. Class Settings says Parent Class = Actor.

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

pressure_plate_door := class(creative_device):

Why they correspond: the three Blueprint moves — right-click, New Blueprint Class, pick a parent, name it — collapse into one line of Verse, child_name := class(parent_name):. The three using lines have no Blueprint equivalent: the node palette lets you search for anything, while Verse wants you to declare which modules you are pulling in (Lesson 7). Naming changes too: the asset's BP_ prefix and PascalCase become snake_case pressure_plate_door (Lesson 4).

Why not Actor as the parent? Because the place Verse actually runs today is UEFN, and there a piece of Verse that can be dragged into a level and has an Event BeginPlay entry point is a subclass of creative_device (Lesson 6). Once UE6 merges UE5 and UEFN, Scene Graph's entity + component is a different skeleton — Lessons 26 and 27 covered it, and the Deep Dive extra takes this very device apart along those lines.

Step 2: Variables Panel → Fields

This block of the original: the first two rows of the Variables panel, IsOpen and OpenDuration.

    # Original: OpenDuration, Float, Instance Editable on
    @editable
    OpenDuration:float = 5.0

    # Original: IsOpen, Boolean, Instance Editable off
    var IsOpen:logic = false

Why they correspond: Blueprint has exactly one kind of variable and never asks whether it will change. Verse flips that — immutable by default, and only the ones that get Set are written var (Lesson 8). The test is mechanical, no judgment required: hit Find References on the variable in the original, and if anything wired into a Set node, write var; if not, do not. IsOpen is Set in squares ③ and ⑦, so it is a var; OpenDuration is only ever read, so it is not.

That eye icon is @editable (Lesson 22). The type mapping is just as direct: Boolean → logic, Float → float, Integer → int, String → string (Lessons 9, 10, 11). Note that Verse fields must be given a default value — which lines up neatly with the Default Value column in the Blueprint Variables panel.

Step 3: Actor Reference → An @editable Device Reference

This block of the original: the third row, TargetDoor, typed as a BP_Door Actor reference, defaulting to None, and once in the level you use the eyedropper in the Details panel to point it at the actual door. Plus one thing that is not in the Variables panel at all: the collision box on the plate itself — node ① Event ActorBeginOverlap hangs off it.

    # The original's collision box: the trigger source moves out to a device in the level
    @editable
    Plate:button_device = button_device{}

    # Original variables panel: TargetDoor, a BP_Door Actor reference
    @editable
    TargetDoor:barrier_device = barrier_device{}

Why they correspond: this is the square that needs the most thought. A Blueprint Actor reference defaults to None, and forgetting to bind it gets you that universally hated runtime Accessed None. A Verse @editable device reference must be given a default value (barrier_device{} is an empty placeholder), so it is never null at compile time — forgetting to bind shows up as "I pressed it and nothing happened" instead of a crash. Slightly harder to spot, impossible to crash on. The type that genuinely expresses "might not be there" in Verse is option (Lesson 18) — that is this language's direct answer to Accessed None.

One thing has to be said plainly: that collision box has no one-to-one translation. Verse gives you nothing to subscribe to for "my Actor was overlapped by someone"; the trigger source has to be a real device in the level that broadcasts an event. So this step moves the collision box out into a device slot. This lesson demonstrates it with the verified button_device.InteractedWithEvent; if you use a trigger or zone style device instead, check the event name against the official Verse API Reference before you write it.

Step 4: Event Binding → Registering a Listener

This block of the original: node ①, Event ActorBeginOverlap.

    OnBegin<override>()<suspends>:void =
        Print("Pressure plate translation online, waiting for a trigger.")
        spawn{ PlateLoop() }

Why they correspond: a Blueprint event node is mounted for you by the engine — you drag Event ActorBeginOverlap into the graph, wire it up, and registration is already done. You never even noticed there was a registration step. Verse has no such auto-mounting: you have to find an entry point and register the listener yourself. That entry point is OnBegin, the override of Event BeginPlay.

There are two ways to register (Lesson 25): Event.Subscribe(Function) maps exactly onto Blueprint's Bind Event — when the event fires, that function runs; Event.Await() instead parks the current execution line right there. The original says "each trigger reruns the string of nodes below", so loop + Await() matches its shape better — one lap of the loop equals one trigger in the original. And since loop hogs whichever line it sits on, you spawn a permanent line to run it (Lesson 24), and OnBegin clocks out once registration is done.

Step 5: Branch → if; Delay → Sleep

This block of the original: node ② Branch and node ⑤ Delay, the two joints in the execution line.

    PlateLoop()<suspends>:void =
        loop:
            Plate.InteractedWithEvent.Await()
            if (not IsOpen?):
                OpenDoor()
                Sleep(OpenDuration)
                CloseDoor()

Branch → if: a Blueprint Branch has one Boolean condition pin and two exits. What goes inside Verse's if parentheses is not a Boolean value but a check that either goes through or does not — officially, a failure context (Lesson 12). So a logic variable needs a ? to turn into an interrogation: IsOpen? goes through when it is true, fails when it is false (Lesson 11). The original hangs a NOT on the condition pin, so the negation is not IsOpen?. The string of nodes off the True pin becomes the block indented under the colon; the original leaves the False pin empty, so the translation writes no else.

Delay → Sleep: Blueprint's Delay is a Latent node with the little clock in the corner. In Verse it is called Sleep(seconds), fed OpenDuration directly — the same act as dragging the variable onto the Duration pin.

But here is the rule Blueprint authors most often miss: anything that can wait may only live inside a function wearing <suspends>. The original can drop a Delay into any Event Graph because Blueprint Event Graphs allow Latent nodes by default; Verse writes that permission into the function signature — the <suspends> in PlateLoop()<suspends>:void is the written licence saying "this function graph may contain nodes with the little clock" (Lesson 23). Delete it and Sleep and Await() stop compiling on the spot. Conversely, the two small functions in the next step carry no <suspends>, because they wait for nothing and return in one breath.

Step 6: Wrapping Up, and the Full Listing

This block of the original: squares ③④ and squares ⑥⑦.

    OpenDoor():void =
        set IsOpen = true
        TargetDoor.Disable()
        Print("Door open, countdown running.")

    CloseDoor():void =
        set IsOpen = false
        TargetDoor.Enable()
        Print("Door closed, plate reset.")

Why they correspond: ③④ and ⑥⑦ are the same shape (record the state + toggle that door) appearing twice, so they get packaged into two small functions — in Blueprint you would Collapse to Function for exactly the same reason. set is the Set node, and not one of them may be dropped (Lesson 8).

There is also a polarity trap here: a barrier device's Enable() means "the barrier exists", i.e. the door is closed; Disable() means "the barrier vanishes", i.e. the door is open — the exact opposite of what the original's Open() / Close() read like. Node-by-node translation gets this square backwards remarkably often. Seal it inside a function name and the graph only ever says "open door" and "close door" — no more mental inversion.

Six steps, all the parts. The next section assembles them into the complete .verse file and runs it line by line.

3. Run It Line by Line: Map the Translation Back to the Graph

Below is the complete Verse translation of BP_PressurePlate, 43 lines. Every step in the run panel tells you which node of the original this line came from — click "Run Next Step" and map it all the way back.

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

# Verse translation of BP_PressurePlate — node map in this lesson's Blueprint Comparison
pressure_plate_door := class(creative_device):

    # The original's collision box: trigger source moves out to a device in the level
    @editable
    Plate:button_device = button_device{}

    # Original variables panel: TargetDoor, BP_Door Actor reference, Instance Editable on
    @editable
    TargetDoor:barrier_device = barrier_device{}

    # Original variables panel: OpenDuration, Float, Instance Editable on
    @editable
    OpenDuration:float = 5.0

    # Original variables panel: IsOpen, Boolean, Instance Editable off
    var IsOpen:logic = false

    OnBegin<override>()<suspends>:void =
        Print("Pressure plate translation online, waiting for a trigger.")
        spawn{ PlateLoop() }

    PlateLoop()<suspends>:void =
        loop:
            Plate.InteractedWithEvent.Await()
            if (not IsOpen?):
                OpenDoor()
                Sleep(OpenDuration)
                CloseDoor()

    OpenDoor():void =
        set IsOpen = true
        TargetDoor.Disable()
        Print("Door open, countdown running.")

    CloseDoor():void =
        set IsOpen = false
        TargetDoor.Enable()
        Print("Door closed, plate reset.")

One semantic difference is worth writing down. In the original, Event ActorBeginOverlap fires every time, and node ② Branch is the doorman that turns repeat triggers away. In the translation, until loop winds back to line 29 a new trigger is never caught at all — the structure blocks re-entry by itself, which makes IsOpen redundant as a doorman. Copy it anyway; do not delete it yet. Faithful on the first pass, redesign on the second. That is exactly what the advanced extra page is about.

4. The 5 Places Translation Goes Wrong

These five are not a random list — they are the squares a Blueprint author almost always trips on during a first translation. Each one names the lesson to go back to.

5. What Does Not Translate

An honest migration lesson has to include this section. The things below are not "written differently in Verse" — they are outside Verse's job description. Hunting for an equivalent will only cost you an afternoon.

Listing these is not about dampening enthusiasm; it is about drawing the boundary correctly on a real project: only part of any Blueprint is gameplay logic, and the rest is art, animation and editor tooling. The former is what you migrate.

On the timeline, here are the facts once more, in the official phrasing: Actor and Blueprint are fully supported in UE6 Early Access (targeted for late 2027) and the early releases after it; deprecation waits until Scene Graph is mature enough, with no date given. Epic has committed to shipping conversion tools before deprecation, but they have not been released. So the hand translation taught here is, short term, training in reading both sides, and long term, the standing to review what a conversion tool produces — a tool can move structure, but it cannot move design intent, and you have to be able to see which parts need rewriting.

Blueprint Cross-Reference

The whole of BP_PressurePlate, node by node and variable by variable. The differences column is the point — it explains why some squares are not a change of spelling but a change of thinking.

Read the table end to end and you will find the differences cluster in three places: mutability must be declared (var), checks must be able to fail (? and failure contexts), and waiting needs a licence (<suspends>). These three are not Verse being difficult — they are Verse pulling three classes of "blows up at runtime" problems (changed the wrong state, dereferenced nothing, waited where waiting was not allowed) forward into compile time. The cost is a few extra keywords; the payoff is that those three crashes get caught the moment you hit Build.

There is one more difference that is not syntax at all: a Blueprint is a binary asset, so two people editing the same Event Graph usually have to pick a winner; a .verse file is text — diffable, reviewable, mergeable line by line, and readable and writable by AI. Which happens to be the next lesson's subject.

6. Level Challenge

First put the three key pieces of the translation back, then answer three questions. Correct answers earn a star ★; wrong answers can be retried forever.

# Fill in three blanks: the badge that legalizes Delay, the Set node keyword, and Delay itself
PlateLoop()<____>:void =
    loop:
        Plate.InteractedWithEvent.Await()
        if (not IsOpen?):
            ____ IsOpen = true
            TargetDoor.Disable()
            ____(OpenDuration)
            set IsOpen = false
            TargetDoor.Enable()

Further Reading