Verse Wiki — the Verse handbook for Blueprint authors
Reference

Blueprint ↔ Verse Glossary

You know what you want — you just don't know what it's called in Verse. This is the most-looked-up page on the site: six grouped Blueprint → Verse tables, then an alphabetical Verse → Blueprint reverse index. Every row carries a difference note and a lesson number. Use it as a dictionary — look it up, jump off.

How to Use This Table

This page runs in two directions. Starting from Blueprint — you already have the node, the panel, the asset type in your head, and you only want to know how it's written in Verse: read sections one through six, grouped by domain. Starting from Verse — you hit an unfamiliar word in the docs, in an error, or in someone else's code and want to know which Blueprint concept it maps to: jump straight to the reverse index at the bottom, sorted alphabetically.

Three sentences on how to read a row:

A note on wording: for every row that touches UE6 and Scene Graph, the status is stated at the top of that section. What has already happened is stated plainly; what has been promised but not delivered says "not yet released"; what hasn't been announced says "not yet announced".

1. Types and Containers

Everything you can pick from the Variable Type dropdown, plus the handful of assets you create by right-clicking.

What it's called in Blueprint How it's written in Verse Notes Lesson
Blueprint Class (the asset) my_class := class: Not an asset — a declaration inside a .verse file, with no thumbnail and no asset path. Still single inheritance, still multiple interfaces. Lesson 20
Child Blueprint Class my_child := class(my_base): The parent goes in the parentheses. Exactly one parent, and overriding an inherited member requires <override>. Lesson 20
Structure (the asset) point := struct: Value semantics, same as Blueprint. But a Verse struct can't hold var fields and can't have methods — it's stricter. Lesson 21
Enumeration (the asset) suit := enum{Clubs, Hearts} No hidden integer behind it — you can't convert to a number or a string, and you can't compare with < or >. Branching on it is case's job. Lesson 11
Blueprint Interface (BPI) rideable := interface: Identical concept. Every implementing method needs <override>, and there's no "Message call vs direct call" split. Lesson 21
Integer int Just a rename. One surprise: integer ÷ integer doesn't give you an integer, it gives the exact fraction type rational — use Floor / Ceil to get back. Lesson 9
Float float Literals must carry a decimal point (1.0, never 1). int and float do not auto-convert the way Blueprint does — mixing them is a compile error. Lesson 9
Boolean logic Renamed, and used differently. It can't be an if condition by itself — you write if (IsOpen?), and that question mark translates "true / false" into "goes through / doesn't". Lesson 11
String string Double quotes, interpolation with braces: "HP: {Hp}". Underneath it's an array of char, so everything array-ish (length, indexing, slicing) works on it too. Lesson 10
Text (localizable) message (produced by <localizes>) Verse doesn't make localization a "variable type" you pick. You write a constant or function marked <localizes>, and what it evaluates to is a message — the type UI wants. Lesson 22
Name (FName, for fast comparison) No equivalent UE's String / Text / Name split doesn't exist in Verse. When you need "a fixed set of identifiers", the right answer is enum, not strings used as tags. Lesson 11
Array []int / array{1, 2, 3} Verse arrays are immutable values — "changing an array" swaps in a whole new one, and there's no Add / Push. Indexing can fail: if (X := A[0]):. Out of range doesn't crash the game. Lesson 16
Map [string]int / map{"k" => 1} Both reading and writing can fail, so even a write has to live inside an if. Key types must be "comparable". No Remove — deleting means rebuilding. Lesson 17
Set No built-in equivalent Verse does not provide a set type. The idiom is [t]logic (that is, map(t, logic)) — use the keys, treat the values as filler. Uniqueness is on you. Lesson 17
Object Reference (the pin) Just write the type name, e.g. my_door There's no separate "reference type" syntax — class instances are reference semantics by nature, so you pass the same instance, not a copy. Lesson 20
"This reference might be null" / Accessed None ?my_door (an option) "Might not be there" is written into the type. You unwrap with X? inside an if. Runtime Accessed None crashes simply don't exist in Verse — the compiler makes you handle it. Lesson 18
Cast To … (and that Cast Failed pin) if (P := player[Agent]): Square brackets are the "this step might not go through" marker. A failed cast doesn't error and doesn't crash — it quietly walks into else, which is exactly what that red pin does. Lesson 12
A function with several output pins tuple(float, float) Blueprint hands back several values through several return pins; Verse bundles them into one tuple. Index with parentheses R(0), and the index must be a literal. Lesson 18
Vector / Rotator / Transform vector3 / rotation / transform Supplied by /UnrealEngine.com/Temporary/SpatialMath, so you have to using it first. The Temporary in that path is a reminder: this API will move house. Lesson 7

The four rows worth memorising here are Boolean, Text/Name, Set and Object Reference. The first two are "renamed plus behaves differently", the third is "simply absent", and the fourth is "the concept got folded into the type system". The rest translate more or less directly.

2. Variables and Data

The variable panel itself: creating, reading, writing, exposing, permissions. This group maps the most cleanly — but the default is flipped.

What it's called in Blueprint How it's written in Verse Notes Lesson
Variables panel (My Blueprint › Variables) A field declaration one indent inside the class There is no panel. Whatever indent level a declaration sits at is the scope it belongs to — "this variable belongs to this class" is expressed by indentation itself. Lesson 8
Get node Just write the name Reading a value needs no node at all. Writing the name is reading it. Lesson 8
Set node set Health = 80 set is a required keyword. Drop it and a lone = becomes "test for equality", which produces an error a newcomer can't parse. Compound forms: += -= *=. Lesson 8
Default Value (that column) The = 100 at the declaration Declarations inside functions and at module scope must be initialised on the spot; class fields may skip it, which makes them required when constructing an instance. Lesson 20
Instance Editable (the little eye) @editable Exposes the field to the Details panel; once it's in the level you can change values and wire references without recompiling. Requirement: the field needs a default value. Lesson 25
Expose on Spawn Archetype syntax my_class{Field := 3} Verse has no new. When you construct, you fill in the fields that had no default inside the braces — that's "passing arguments at spawn". Lesson 20
Private / Protected / Public (the dropdown) <private> <protected> <public> <internal> The default is not public — it's <internal> (visible within the module). Anything meant to cross folders needs <public> on both the module and the member. Lesson 22
"Read by anyone, written by me" (Blueprint can't) var<protected> Ammo<public>:int = 0 Verse can split "who may read" from "who may write": read it anywhere, set it only from inside. Blueprint's dropdown has one setting for both. Lesson 22
Local Variable (inside a function) var Count:int = 0 in the body Locals are immutable by default too — no var means a local constant. Scope follows indentation; leave the indent and it's gone. Lesson 8
Const (Blueprint variables can't) Write nothing at all Verse has no const keyword, because immutable is the default. It's mutability you have to ask for, with a var. Lesson 8
The By Ref checkbox on a parameter No equivalent Parameters are read-only, full stop. Want to modify one? Copy it into a local var. Want to send a result back? Return a value properly. Lesson 19
Variable Category / Tooltip / grouping No language-level equivalent Organisation comes from comments (# and <# … #>) and from how you split files and modules — not from panel metadata. Lesson 7
Naming habits like BP_MyDoor / bIsOpen Type my_door, member IsOpen Verse's split: type names (class / struct / enum / interface) are snake_case, values and functions are PascalCase. No b prefix convention. Lesson 4

The row to stare at is Const. Blueprint has no concept of an immutable variable — every variable can take a Set. Verse flipped the default. That isn't pedantry: when someone opens your code, they can see at a glance which values are fixed and which are live.

3. Control Flow

The nodes on the execution wire. This group differs the most, because Verse treats failure as a first-class citizen: a lot of what you solve in Blueprint with Booleans and Is Valid works on a different mechanism here.

What it's called in Blueprint How it's written in Verse Notes Lesson
Event BeginPlay OnBegin<override>()<suspends>:void = It carries <suspends>, so it can wait seconds, wait on events, and generally act as one long suspendable wire — usually holding an entire game loop. BeginPlay can't do that. Lesson 6
Event EndPlay OnEnd<override>():void = Runs when the experience ends. Epic's own warning: don't count on anything you spawn in OnEnd getting a chance to finish. Lesson 6
Event Tick No per-frame callback; use loop + Sleep(0.0) Verse doesn't hand you a Tick event. "Do this every frame" means writing the loop yourself, where Sleep(0.0) waits exactly one frame. Lesson 23
Branch (True / False) if (condition): … else: Verse's if doesn't take a Boolean, it takes "does this step go through". Failed casts, out-of-range indices and missing keys all land in the same else. Lesson 12
Feeding a Boolean into Branch's Condition pin if (IsOpen?): Bare if (IsOpen) doesn't compile. The trailing question mark translates a logic into "goes through / doesn't". Lesson 11
Select node (pick one of two) Max := if (A > B) then A else B if is an expression in its own right and evaluates to a value — no need for a separate ternary operator. Lesson 12
Sequence node Write the lines in order No equivalent node. Lines at the same indent already run top to bottom — the white execution wire is, at heart, just ordering. Lesson 5
ForEach Loop for (X : Items): The whole for accumulates a new array as it runs, so "collect results as you go" is free. Lesson 14
ForEach Loop with Index for (I -> X : Items): Index starts at 0. Don't confuse the arrows: => builds map pairs, -> reads them out. Lesson 14
For Loop (numeric range) for (I := 0..9): The range includes both ends, and it's the same keyword as ForEach — Verse merged Blueprint's two loops into one. Lesson 14
Filtering inside a loop body (a Branch in Blueprint) for (X : Items, X > 0): The filter goes right after the comma; an iteration that doesn't pass is simply skipped. This is Verse's continue. Lesson 14
While Loop loop: with break Verse has no while and no continue. The condition moves inside the body: if (…): break. break belongs to loop only — you can't use it in a for. Lesson 15
Delay (the latent node with the little clock) Sleep(1.0) It only holds up its own wire; the game keeps running. The calling function must carry <suspends>, which is why it can't go inside an if condition. Lesson 23
Retriggerable Delay No equivalent node; restart the timer with race The idiom is to race "the timer" against "the reset signal" — when the signal arrives the whole thing starts over. Lesson 24
Is Valid / Is Valid? if (D := MaybeDoor?): "Might be empty" isn't a runtime check, it's part of the type (?t). The compiler forces you to handle it, which is why Accessed None crashes don't exist in Verse. Lesson 18
Switch on Enum case (Phase): Branches must cover every value of the enum, or carry a _ => fallback, or it won't compile — miss one and the compiler names it. Lesson 11
Switch on Int / Switch on String case also branches on literals Types you can't exhaust (integers, strings) require a _ => fallback branch. Lesson 11
Return Node Implicit return (the last expression in the body) Most of the time you write nothing. Use return only to leave early — but return is forbidden inside a failable <decides> function body. Lesson 19
Do Once No built-in node; gate it with a var The idiom is if (not Done?): set Done = true; …, or a one-shot event wait instead. Lesson 12
Flip Flop set Flag = if (Flag?) then false else true There's no negation operator to reach for: not in Verse turns a failure into a success, it doesn't produce a logic value, so you can't use it to flip a variable. Lesson 11
Gate / MultiGate No built-in node Track the state in a var yourself. "Several wires, first one wins" is race's job. Lesson 24
Print String Print("...") Comes from /UnrealEngine.com/Temporary/Diagnostics, so using it first. Interpolation works directly: Print("HP: {Hp}"). Lesson 6
"Cleanup that must run once this section ends" defer: Blueprint has no node for this — you wire it to every exit by hand. defer registers once and runs no matter which exit you take. Lesson 15

Two things in this group have no Blueprint counterpart at all. First, failure: Branch gives you True and False, while Verse's if also catches "this step didn't go through", which folds casts, indexing and map lookups into one mechanism. Second, running several wires at once: doing "count down while waiting for the player to step on the plate" in Blueprint means hand-wiring it through Tick, whereas Verse builds sync / race / rush / branch into the language.

4. Functions and Events

How code gets organised and how it gets triggered. The Event Dispatcher rows are the ones you'll reach for first when migrating.

What it's called in Blueprint How it's written in Verse Notes Lesson
Function (a Blueprint function) Add(A:int, B:int):int = A + B Parameter list, return type and body on one line. Whatever it evaluates to last is the return value. Lesson 19
"This function might fail" (Blueprint has nothing) IsBig(X:int)<transacts><decides>:void = A <decides> function is called with square brackets, IsBig[200], and only from a place where failure is allowed. It must appear together with <transacts>. Lesson 22
Default value on an input pin Award(?Points:int = 1):void = A ? prefix makes it a named optional parameter; you call it as Award(?Points := 10). Positional parameters can't have defaults. Lesson 19
Pure node (green, no execution pins) Effect specifiers <computes> / <converges> Blueprint ticks a Pure checkbox; Verse declares the effect in the signature. The difference is that Verse checks whether your declaration is true — declare purity and you can't sneak in a write. Lesson 22
Macro No equivalent Macros exist partly because node graphs make execution wires awkward to reuse. In Verse an ordinary function is enough. Lesson 19
Blueprint Function Library <public> functions at module scope No dedicated "library" asset needed. Every folder in the project is automatically a module; mark a function <public> and others can use it. Lesson 7
Custom Event An ordinary method on the class "Event" and "function" are two different concepts in Verse. Nine times out of ten a Blueprint custom event translates to a method. Lesson 25
Event Dispatcher MyEvent : event(int) = event(int){} Events are first-class values in Verse: they can be fields, parameters, or array elements. Blueprint dispatchers can only hang off a class. Lesson 25
Call (broadcast a dispatcher) MyEvent.Signal(Payload) Same "shout once", and it can carry a payload. Lesson 25
Bind Event Button.InteractedWithEvent.Subscribe(OnPressed) The callback's parameters must match what the event hands over. Bind exactly once — binding twice stacks up and fires several times per press. Lesson 25
Unbind Event Handle.Cancel() Subscribe hands back a cancelable handle; keep it or you can't unbind. Lesson 25
"Stop here and wait for this event" (Blueprint has nothing) MyEvent.Await() A Blueprint event can only start a separate execution wire; it can't suspend in the middle of a function. Await() lets the code stop where it is, and it reads completely differently. Lesson 23
Implements Interface + Interface Call my_class := class(my_iface): with <override> methods No "Message call vs direct call" split — there's one way to call it, and the compiler already guarantees the other side implemented it. Lesson 21
The Override dropdown on a parent function <override> Required when you override an inherited member; forget it and you get an error. Call the parent's version with (super:)Method(). Lesson 20
Latent node / Async Action A function marked <suspends> In Blueprint async is "a special power certain nodes have"; in Verse it's a label in the signature that any function can apply for. Lesson 23
"Run several wires at once" (hand-wired through Tick) sync / race / rush / branch / spawn Concurrency is a built-in expression, not a plugin and not a node. The first four need a suspending context; spawn is the only one usable from synchronous code. Lesson 24

5. Engine Objects and Frameworks · Today, in UEFN

This group needs its status stated up front, or looking things up will mislead you.

Today (August 2026): the only place Verse actually runs is UEFN, where it has been in production since March 2023. In UEFN, "the thing you put in the level" is a creative_device; your class inherits from it, and it only really runs once you drag it from the Content Browser into the level.

What it's called in Blueprint How it's written in Verse Notes Lesson
Actor (something you can place in a level) my_device := class(creative_device): Today's answer. Drag in several copies and you get several instances, each running its own code. Lesson 6
Dragging a Blueprint into the level Build Verse Code, then drag the device in from the Content Browser Compiling ≠ running. Code that's completely correct but never dragged into the level is one of the two classic beginner traps. Lesson 6
Details panel Fields exposed with @editable The panel is a mirror of the code, not a second copy of the data. No @editable in the code, no row in the panel. Lesson 25
Level Blueprint No equivalent: make a device and place it Verse has no special "level script" container. The upside is that a device can be copied, reused, and carried into another map. Lesson 6
World Outliner UEFN's Outliner (an editor tool) It's a tool, not a language concept. Verse code can't see the Outliner — only the references wired to it in the panel. Lesson 6
Spawn Actor from Class Idiom: place the device up front, enable it from code UEFN can't conjure arbitrary devices out of nothing today. That's a limitation of the current tooling, not of the language. Lesson 25
Get All Actors of Class No equivalent today Reaching another device means wiring the reference in the panel via @editable. Perfect code plus a forgotten wire is the other big trap. Lesson 25
Pawn / Character fort_character (Agent.GetFortCharacter[]) The square brackets say this step might not go through (the player may already be eliminated), so it has to live in an if. Lesson 25
Instigator pin / Player Controller agent and player agent is the abstraction "something that can cause things"; player is the more specific human player. Device events usually hand you an agent, and converting takes if (P := player[Agent]). Lesson 25
GameMode / GameState / PlayerState No language-level equivalent In UEFN those responsibilities sit with Fortnite's own gameplay framework and its devices — they're not classes you define in Verse. Lesson 25
SaveGame / Save Game Object A module-scope weak_map(player, t) plus <persistable> "Outside the class" is itself the save switch. Each player gets their own copy, and it survives leaving and rejoining. Lesson 28
GameInstance (data carried across levels) Module-scope variables; across sessions, <persistable> There's no GameInstance object. Data that has to outlive one round either lives at module scope or goes through persistence. Lesson 28
Actor Component / Scene Component No direct equivalent in today's UEFN device style The component model arrives with UE6's Scene Graph — see the next section. To reuse behaviour today, use inheritance or lift the logic into module-scope functions. Lesson 20

6. Engine Objects and Frameworks · Where UE6 Is Heading: Scene Graph

Status, once, clearly: UE6 merges UE5 and UEFN into a single engine, with Early Access targeted at the end of 2027. Scene Graph is UE6's new gameplay framework, built on Verse from the ground up, using entities that hold components. It ships in UEFN today as Beta, and Epic's own documentation says to be careful about shipping with it.

Three things to keep straight so outdated articles don't mislead you: Actors and Blueprints are fully supported in UE6 Early Access and the early releases, deprecation waits until Scene Graph is mature enough and has no date; Epic has committed to shipping conversion tools before deprecation, but has not released them yet; and Verse will get its own visual scripting layer (the community calls it Visual Verse), whose form Epic has not yet announced.

What it's called in Blueprint How it's written in Verse Notes Lesson
Actor entity An Actor is the root of an inheritance tree and you add capability by deriving a subclass; an entity is a nearly empty container and you add capability by attaching components. That's a different model, not a rename. Lesson 26
Actor Component / Scene Component my_comp := class<final_super>(component): Same name, different job: in Scene Graph, components are the only place behaviour and data live. <final_super> is required by Epic — without it the class can't be added to an entity. Lesson 27
Add Component Entity.AddComponents(...) Only one component of a given type per entity. Lesson 27
Get Component by Class if (M := Entity.GetComponent[mesh_component]): The square brackets mean it might not go through — this entity may not have that component. Lesson 27
GetOwner() inside a component Entity (a data member on component) A component already knows which entity it's attached to — just write Entity. Lesson 27
Event BeginPlay (on a component) OnBeginSimulation<override>():void = Components have a series of lifetime functions (added to scene / begin simulation / end simulation / about to be removed); override the one you need. Lesson 27
"The component's long-lived async logic" OnSimulate<override>()<suspends>:void= Loops, event waits and anything that takes time go in this function. Lesson 27
Event Tick (on a component) TickEvents.PrePhysics / TickEvents.PostPhysics Components carry a TickEvents member; hang callbacks on it to get per-frame timing. Lesson 27
A prefab asset / a packaged group of Actors prefab (a class deriving from entity) Epic's wording: in Scene Graph, a class that derives from entity is also known as a prefab. Edit the prefab and every instance follows. Lesson 26
Attach To / Detach AddEntities() / RemoveFromParent() / GetParent() The entity hierarchy isn't just "where things sit" — it is the data structure, and components find each other through it. Lesson 26
Actor Tag / Component Tag AddTag() / ContainsTag() / RemoveTag() Entities come with a tag interface you can query and remove by. Lesson 26
Broadcasting a notification along the hierarchy SendUp() / SendDown() Sends a scene event up or down the entity tree, picked up by OnReceive() on components along the way. Lesson 26
@editable on a component @editable (identical to the device style) Component fields expose to the panel exactly the same way, so that part doesn't have to be relearned when you move from devices to components. Lesson 27

The API names in this section come from Epic's official Verse API documentation for the /Verse.org/SceneGraph module and from the Scene Graph tutorial pages. Scene Graph is still in Beta and signatures and members may change — when you write code, the official documentation is the authority.

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

There are two kinds of "not in the dictionary". One is "Verse hasn't built it yet". The other is "this was never Verse's job". The entries below are the second kind — they are separate systems, outside what Verse is meant to replace, and there will never be an answer to "how do I write a Timeline in Verse".

What it's called in Blueprint How it's written in Verse Notes Lesson
Construction Script No equivalent It runs at edit time — nudge it in the level and it recomputes. Verse doesn't take part in edit-time construction today; its code runs at play time. Lesson 4
Timeline No equivalent A Timeline is a curve asset plus a player. Verse has Sleep and loops and can interpolate by hand, but there's no curve editor — curves belong to the animation and sequencing systems. Lesson 15
Animation Blueprint / AnimGraph / state machines No equivalent State machines, blend spaces and bone control are a whole separate animation system. Verse can tell it to change state; it won't replace it. Lesson 4
Material Graph / Material Function No equivalent Material nodes compile to shaders that run on the GPU. That isn't the same kind of thing as gameplay logic. Lesson 4
Niagara No equivalent The VFX system has its own editor and its own execution model. Verse's role is to light the fuse at the right moment. Lesson 4
Reroute nodes / Comment boxes / node alignment Indentation and comments Graph layout tools have no meaning in text code. Tidiness comes from indentation, naming and comments instead. Lesson 7
Blueprint Nativization No equivalent That's "turn the graph into C++ for speed". Verse is already text code, so the step doesn't exist. Lesson 1

Seeing this boundary clearly saves a lot of anxiety. "Will my Blueprint skills be obsolete?" is half-answered by this table alone: everything you've built up in materials, animation, VFX and sequencing has nothing to do with Verse, and is therefore entirely unaffected. What Verse replaces is the gameplay logic layer — precisely what the first six sections cover.

8. Reverse Index: Verse → Blueprint

The other direction: you hit a word in the docs, in an error, or in someone else's code and want to know which Blueprint concept it maps to. Sorted by how it's written in Verse — symbols first, then alphabetically.

How it's written in Verse In one sentence The Blueprint concept Lesson
:= Define and initialise, first time only; the type can be omitted and inferred. Creating a variable and filling in its default Lesson 8
= An equality test, not an assignment; there is no == in Verse at all. Equal node Lesson 13
<> Not equal; like =, it only lives where failure is allowed. Not Equal node Lesson 13
? (trailing query) Two jobs in one: after a logic it asks "is this true"; after an option it unwraps the value. Both can fail. A Boolean used as a condition / Is Valid Lesson 11
[] (bracket call) The "careful, this step can fail" marker: indexing, map lookups, <decides> calls and casts all use it. That Cast Failed pin Lesson 12
{} (archetype) my_class{Field := 3} constructs an instance, filling in fields that had no default. Verse has no new. Spawn Actor from Class + Expose on Spawn Lesson 20
@editable Exposes a field to the Details panel so values change without recompiling; the field needs a default. The Instance Editable eye Lesson 25
agent The abstraction "something that can cause things to happen"; device events usually hand you one. Instigator pin Lesson 25
and / or / not The three words that combine "goes through / doesn't". No && || !; a comma also means and. AND / OR / NOT nodes Lesson 13
archetype Verse's way of constructing instances — the my_class{…} brace form. Filling in required fields in Details, then spawning Lesson 20
array An ordered run of same-typed values, immutable; "changing" it swaps in a new one. Indexing can fail. Array Lesson 16
Await() Stop right here until an event fires, then carry on — only inside a suspending context. Blueprint has none: events can only start a new wire Lesson 23
block Bundles several lines into "one wire", typically for each arm of a race or sync. One output of a Sequence Lesson 24
branch Splits off a wire and lets the main line continue; the split wire is cleaned up when the enclosing scope ends. Blueprint has none: a spawn with someone minding it Lesson 24
break Leaves a loop. It belongs to loop only — you can't use it in a for. Break node Lesson 15
cancelable The handle Subscribe hands back; call Cancel() to unbind. Unbind Event Lesson 25
case Branch on a value; cover every enum member or add a _ => fallback. Switch on Enum / Switch on Int Lesson 11
class Bundles data (fields) and behaviour (methods) into something you can instantiate repeatedly; reference semantics, single inheritance. Blueprint Class Lesson 20
comparable The family of types that can be tested for equality. Why care? Map keys must come from it. Whether something can be a Map key Lesson 17
component Where behaviour and data live in Scene Graph; custom ones are class<final_super>(component). Beta — the official docs are the authority. Actor Component Lesson 27
<computes> / <varies> / <converges> Three grades of "no side effects", pick one; write nothing and you get "cannot roll back". The Pure checkbox (but checked by the compiler) Lesson 22
<concrete> Every field has a default, so my_class{} constructs it empty-handed; required for custom @editable classes. "This class can go straight into the panel" Lesson 22
creative_device Today's base class for anything you place in a UEFN level: my_device := class(creative_device):. Actor / Blueprint Actor Lesson 6
<decides> Makes a function failable, called with square brackets; must appear with <transacts>. Blueprint has none; a cast's two exits is the closest Lesson 22
defer "The wire that always runs last before leaving this scope" — it counts as long as control flow reached and registered it. Blueprint has none: you wire every exit by hand Lesson 15
entity Scene Graph's container; almost no behaviour of its own, capability comes from components. Beta — the official docs are the authority. Actor Lesson 26
enum A set of named options; no hidden integer, no conversion to number or text. Enumeration asset Lesson 11
event(t) The event itself: Signal(X) broadcasts, Subscribe(F) registers a callback, Await() suspends until it fires. Event Dispatcher Lesson 25
expression Everything you write in Verse evaluates to a value — even if and for — which is why you never need a Return node. Blueprint's "execution node vs data pin" split, erased Lesson 3
failure context The places allowed to hold a step that might not go through: an if condition, a for header, the operands of not / or, a <decides> body, and option{…}. No Blueprint counterpart Lesson 12
<final> The class can't be inherited from / the member can't be overridden. "Don't derive from me" Lesson 22
<final_super> Scene Graph's hard requirement: a custom component must derive directly from component, or it can't be added to an entity. The official docs are the authority. No Blueprint counterpart Lesson 27
float Decimals; literals need a decimal point, and there's no auto-conversion with int. Float Lesson 9
for Runs through things one by one, with an optional filter; the whole for accumulates a new array. ForEach Loop and For Loop, merged Lesson 14
fort_character The player's body in the world, obtained via Agent.GetFortCharacter[] (which can fail). Character / Pawn Lesson 25
if Asks "does the thing in the parentheses go through", not "is this Boolean true"; it's an expression, so it evaluates to a value. Branch (plus Select and Cast rolled in) Lesson 12
implicit return The last value a function body computes is automatically the return value; return is forbidden inside <decides> bodies. Return Node (usually unnecessary) Lesson 19
int Integers. Integer ÷ integer gives the exact fraction rational; use Floor / Ceil to get back. Integer Lesson 9
interface Signatures only, no implementation; whoever adopts it fills them in (each with <override>). A class can adopt several. Blueprint Interface (BPI) Lesson 21
<localizes> Wraps an interpolated string into a message, which is the type UI text wants. Text (localizable) Lesson 22
logic true / false. To use one as a condition, add the question mark: Flag?. Boolean Lesson 11
loop A wire that loops back on itself forever; you leave via break or return. A synchronous loop that never pauses trips the infinite-loop error. A While Loop whose condition is always True Lesson 15
map A key → value register; both lookups and writes can fail, so even writes go inside an if. Map (TMap) Lesson 17
message The localizable text type, produced by constants or functions marked <localizes>. Text Lesson 22
Mod[A, B] Remainder. Verse has no %, and the brackets remind you this step can fail. Modulo node Lesson 13
module A bundle of code others can depend on. Every folder in the project is automatically a module of the same name. Enabling a plugin / referencing another folder's assets Lesson 7
OnBegin / OnEnd A device's start and finish. OnBegin carries <suspends>, so it can hold a whole game loop. Event BeginPlay / Event EndPlay Lesson 6
option (?t) A box that may hold something or may be empty; false is empty, option{42} fills it, X? takes it out. A possibly-null object reference + Is Valid Lesson 18
<override> Required when overriding an inherited member; call the parent's version with (super:)Method(). The Override dropdown on a function Lesson 20
<persistable> The "eligible for saving" credential: the class must be <final> and hold only immutable fields. The fields of a SaveGame Object Lesson 28
player A human player, a more specific kind of agent; convert with if (P := player[Agent]). Cast to Player Lesson 25
prefab Epic's wording: in Scene Graph, a class deriving from entity is a prefab — reusable and nestable. Beta — the official docs are the authority. A packaged group of Actors / a Blueprint prefab Lesson 26
Print Writes a line to the log, with interpolation: Print("HP: {Hp}"). Requires using the Diagnostics module. Print String Lesson 6
race Several wires run at once, the first to finish wins, the rest are cut at their next suspension point. The standard way to write a timeout. Blueprint has none: hand-wired through Tick Lesson 24
rational The exact fraction type; it's what integer ÷ integer produces. Blueprint has none: division there hands you a Float Lesson 9
rush Takes the first result like race, except the losing wires aren't cut and run to completion. Blueprint has none Lesson 24
Self Inside a method, "this instance of me". The Self pin Lesson 20
set Give a variable a new value. Forget the set and the compiler reads your assignment as an equality test. Set node Lesson 8
simulation update Synonymous with tick or frame — the finest grain of Verse's flow of time, and the floor on Sleep's precision. One frame / one Tick Lesson 23
Sleep(x) Holds the current wire for a number of seconds, and only that wire. Sleep(0.0) waits exactly one frame. Delay node Lesson 23
spawn{ Fn() } Splits off a new wire and carries on immediately; the only concurrency form usable from synchronous code. Blueprint has none: "start another execution wire" is closest Lesson 24
speculative execution How a failure context runs: try boldly, and if the whole check doesn't go through, discard every change made along the way. Blueprint has none: a Set is spilt milk Lesson 12
string Text in double quotes, with brace interpolation "HP: {Hp}". Underneath it's an array of char. String Lesson 10
struct A small bundle of pure data with value semantics (copied wholesale); no var fields, no methods. Structure asset Lesson 21
Subscribe Attaches a callback to an event and returns a cancelable; bind exactly once, because binding twice stacks. Bind Event Lesson 25
<suspends> A function's async licence: its body may wait and suspend across frames. Only callable directly from another suspending context. Latent nodes (the ones with the little clock) Lesson 23
sync Several wires run together and everything must finish before continuing; results are bundled into a tuple in written order. Blueprint has none Lesson 24
task The handle on the wire spawn split off; you can Await() it. It has no ready-made Cancel. Blueprint has none Lesson 24
<transacts> Declares "everything I do can be undone". A failure context only admits functions that can take it back. No Blueprint counterpart Lesson 22
tuple Bundles a fixed number of possibly-different-typed values; index with parentheses, and the index must be a literal. A function's several output pins Lesson 18
<unique> Gives every instance an identity, so they can be compared and used as map keys — which is exactly how player works. "Is this the same object reference?" Lesson 20
using { … } Brings a module's public contents into the current file; the braces aren't optional. Enabling a plugin / adding a module dependency Lesson 7
var The request for "this value will change later". No var means a constant — the single biggest default difference from Blueprint. Blueprint variables are mutable by default Lesson 8
weak_map map's odd cousin: can't be iterated, won't tell you its count. Put it at module scope keyed by player and it's a save file. SaveGame Lesson 28

Didn't find it? Two possibilities. Either it belongs to the "not Verse's job" systems in section seven, or it's a Scene Graph term — and that group is still Beta, so names and signatures are whatever Epic's official documentation says.