The Glossary: What Everything in Blueprints Is Called in Verse

1. What Blocks You Isn't Syntax — It's Names

You already know how to make a door that opens: add a Boolean called IsOpen in the variables panel, Bind the button's event in Event BeginPlay, wire a Branch into the callback, and hang a Set node on the branch that passes. You could wire that up with your eyes closed.

In Verse you're doing the same thing. What actually stops you is a different question: that Boolean type — what do I pick in the dropdown? Search the docs and you won't find bool — because in Verse it's called logic. You aren't stuck on the concept. You just didn't know it changed names.

That "I know what I want, I don't know what it's called" stall will hit you dozens of times in your first two weeks of Verse. None of them are hard, and every one of them costs you ten minutes. This lesson clears all of them at once: six tables, more than fifty terms, looked up once.

Every table has three columns: what it's called in Blueprints / what it's called in Verse / the difference. The first two columns are for lookups. The third column is the valuable part — plenty of terms look like a clean one-to-one match and then behave differently, and you only find out the hard way. Bookmark this page and keep it open while you write.

2. Types and Containers

Start with the group you'll look up most: everything you can pick from the Variable Type dropdown.

The three rows worth memorizing here are Boolean, String and Set. The first two are "renamed and behaves differently"; the third is "simply absent". The rest translate more or less straight across.

3. Variables and Data

Group two is the variables panel itself: creating, reading, writing, exposing, permissions. This group maps the most cleanly — nearly every row is a straight translation.

That last row deserves a second look: Blueprints has no concept of an immutable variable — every variable can take a Set node. Verse flipped the default. That's not pedantry; it's so that anyone opening your code can tell at a glance which values are set in stone and which are live.

4. Flow

Group three is the nodes on the execution wire. This is where the differences are largest, because Verse treats "failure" as a first-class citizen — a lot of what Blueprints solves with Booleans and Is Valid runs on a different mechanism here.

There's also a category Blueprints simply doesn't have: running several lines at once. To "count down while waiting for a player to step on a plate", Blueprints makes you assemble it from Timelines or Tick; Verse builds sync (everyone finishes), race (first one wins), rush (first result, everyone still finishes) and branch (fork a line off) into the language itself. That group gets its own chapter in Chapter 7.

5. Functions and Events

Group four is "how code is organized and how it gets triggered". The Event Dispatcher row is usually the first one people need during a migration.

6. Engine Objects: Today, and Where UE6 Is Headed

This group needs its status spelled out first, or the lookups will mislead you.

Today (August 2026): the only place Verse actually runs is UEFN, where "a thing in the level" is a creative_device. Where UE6 is headed: Epic built a brand-new gameplay framework for UE6 called Scene Graph, built from the ground up on Verse, where entities hold components — and it is already usable in UEFN today. At the same time Epic has been explicit: Actors and Blueprints are fully supported in UE6 Early Access (targeting late 2027) and the early releases after it; deprecation waits until Scene Graph is mature enough, with no date set. Epic has committed to shipping conversion tools before any deprecation, but they have not been released.

So the Verse column below gives two answers: what you write today, and where things are headed.

This is the group where outdated articles will lead you astray fastest. To judge whether a tutorial is current, check whether it mentions entities and components at all. Scene Graph's full worldview is Chapter 8; here you only need to remember one thing: the Actor row is not a rename, it's a different way of organizing everything.

7. No Counterpart: The Systems That Aren't Verse's Job

Sooner or later a lookup comes up empty. There are two kinds of empty: "Verse hasn't done it yet", and "this was never Verse's job". The five below are the second kind — they are separate systems, outside the scope of what Verse replaces, and there will never be an answer to "how do I write a Timeline in Verse".

Seeing that boundary clearly saves an enormous amount of anxiety. "Will my Blueprint skills become worthless?" — this table answers half the question for free: everything you've built up in materials, animation, VFX and sequencing has nothing to do with Verse, and is therefore entirely unaffected. Verse only replaces the gameplay-logic slice — which is exactly what the first six tables cover.

8. Putting the Dictionary to Work: Every Word in One Snippet

Reading tables doesn't stick. The device below is that door from the opening — nineteen lines that use nearly every word you just looked up. Click "Run Next Step"; each step tells you what that line is called in Blueprints.

using { /Fortnite.com/Devices }
using { /UnrealEngine.com/Temporary/Diagnostics }

door_device := class(creative_device):

    @editable
    OpenButton:button_device = button_device{}

    var IsOpen:logic = false

    OnBegin<override>()<suspends>:void =
        OpenButton.InteractedWithEvent.Subscribe(OnPressed)

    OnPressed(Agent:agent):void =
        if (IsOpen?):
            Print("The door is already open")
        else:
            set IsOpen = true
            Print("The door opened")

Count them: class, @editable, object reference, var, logic, OnBegin, Subscribe, callback method, if, ?, set, Print — twelve terms, every one of them findable in the tables above. That's how this dictionary is meant to be used: hit something you don't recognize, go back and read that row's third column.

9. Three Traps: Same Name, Different Thing

The dangerous part of a lookup isn't coming up empty. It's finding a word that looks identical and doesn't mean the same thing. Three you need to know in advance:

Trap one: Verse's boolean isn't called bool, and it can't be a condition on its own. It's logic, with exactly true and false — so far, identical to Boolean. But if won't take it: Verse's if asks "does this step get through", not "is this value true". So you add a question mark: if (IsOpen?). Forgetting it is the most common day-one error, and the message won't tell you a question mark is missing.

Trap two: Verse's = is a comparison, not an assignment. Blueprint authors don't fall into this easily (there's no equals sign to type in Blueprints), but the moment you've read code in any other language your hands will type Score = 100 on their own. In Verse that line means "question: does Score equal 100?" — and Verse has no == at all. Keep three symbols straight: := declares for the first time, set … = changes a value (the Set node), and a lone = asks a question. Whenever "failure context" appears in a compile error, first check whether a set went missing.

Trap three: Scene Graph's component and Blueprints' Actor Component share a name, not a model. Both are "a chunk of capability attached to something". But in the Blueprint world the protagonist is the Actor: it's a class you can derive from, it carries plenty of logic itself, and components are accessories. In the Scene Graph world an entity is nearly an empty shell, all data and behavior live in components, and "what this thing is" is answered by "which components it has" rather than "which class it derives from". Same word — accessory on one side, everything on the other. That gap is big enough to deserve its own page; see the extras below.

10. Naming Style: The Casing Needs Translating Too

One more layer of translation gets overlooked: the shape of the names themselves. UE has a prefix system (BP_, S_, E_); Verse has no prefixes, but it does assign clear jobs to casing.

One line to remember it by: types are lowercase with underscores, everything else is capitalized. See my_door and you know it's a type; see MyDoor and you know it's a value or a function — a rule that makes half of any Verse file readable without context. The full renaming table and an exercise are in extra x3.

Blueprint Cross-Reference

The whole lesson is comparison tables; this section is about how to read them. Any lookup lands in one of three buckets: direct (same thing, new name), approximate (the concept exists, the syntax and the edges differ), and no counterpart (it belongs to another system). Knowing which bucket you're in matters more than memorizing the translation.

Why is there an "approximate" bucket at all? Because Verse isn't a node-by-node transcription of Blueprints — it's a different design: failure was turned into control flow, immutability into the default, concurrency into part of the language. Any term touching those three is guaranteed not to map one-to-one.

So the right way to use these tables is three steps: one, find your thing in column one; two, take the syntax from column two; three, always read column three. Skip column three and you'll write code that compiles and behaves wrong — far harder to track down than code that doesn't compile.

Level Challenge

Dictionary read — three lookup questions to finish. Correct answers earn a star ★; wrong answers can be retried forever, zero penalty.

Further Reading