Meet Verse and UE6: Your First Magic Spell

1. What Verse Is: The New-Generation Programming Language of the Epic Ecosystem

Verse is a programming language built by Epic Games, and it is becoming an increasingly important programming tool across the Unreal Engine and UEFN ecosystem. If the engine editor is a giant LEGO workbench, Verse is the spell that breathes a soul into the bricks — why a button opens a door, why a countdown chimes, why the boss shows up the instant you step on a trigger: behind all of it, Verse is calling the shots.

It is not some lab experiment, either. Verse launched in March 2023 with UEFN (the creation environment for Fortnite) and has been running gameplay logic on tens of thousands of Fortnite islands ever since — which means it spent years in open beta in front of hundreds of millions of players before it ever reached you. Epic has also published a roadmap for gradually converging the UE5 and UEFN product lines into Unreal Engine 6, positioning Verse as an increasingly important gameplay programming tool along the way: in Epic’s words, it “transactionalizes C++” — a piece of logic either takes effect as a whole or is undone as a whole, as if it never happened (see the extra page) — with the goal of supporting massive persistent online experiences built by thousands of collaborating contributors. Per the official roadmap, Actors and Blueprints stay around in the early stages, Epic has promised migration tooling, and Verse represents the new direction in Epic’s plans.

Then there is its unusual pedigree: Verse is a functional logic language. It was conceived personally by Epic founder Tim Sweeney — by his own account, the language brewed in his head for roughly a decade. In December 2021, Simon Peyton Jones — the closest thing Haskell has to a founding father — joined Epic as an Engineering Fellow to work on the design, alongside Lennart Augustsson and a whole roster of functional-programming legends. An industrial language born for games, carrying top-shelf academic blood — that is a rarity in the entire history of programming languages, and it explains many of the “strange but wonderful” designs you will meet later.

2. Why It Is Worth Learning

Before we get hands-on, let’s answer the most practical question: why should I invest my time in Verse?

• ▢ It is betting on Epic’s roadmap: from Fortnite islands to bigger projects, Verse is becoming an increasingly general-purpose gameplay programming language across Epic’s development ecosystem. Every line you practice in UEFN today lays groundwork for the next generation’s core programming model in the Unreal ecosystem — there is no “learn it and watch it go obsolete.”
• ◇ Battle-tested: tens of thousands of published islands are its service record. Once you publish a map, players all over the world can find it and jump in; Epic also pays creators based on player engagement — writing Verse is not just a hobby, it is a real-money ticket into the creator economy.
• △ Crash-proof by design: Verse’s design philosophy is “failure is a condition” — plenty of operations that would crash a game on the spot in other languages simply, quietly “don’t succeed” in Verse. Changing a variable requires a magic word, data is immutable by default, and a whole pile of bugs get stopped at compile time before they ever get the chance to run and hurt anyone. We will unpack all of this over the next few lessons — consider it an Easter egg for now.
• ★ Beginner-friendly: this entire series translates programming concepts into game mechanics you already know — variables are backpack slots, events are trap triggers, functions are spell hotkeys. You need zero programming experience; knowing how to play games is enough.

3. Your First Verse: Run It First, Then Take It Apart Line by Line

Below is a complete Verse device that compiles and runs as-is — the classic Hello program generated by the official Verse Device template. Its entire mission: shout “Hello, world!” at the world when the game experience starts, and solve a math problem live while it’s at it. Don’t rush to understand every word — hit “Run next step” and watch, replay-style, how the code executes line by line.

Graph translation (Blueprint view): if you built this code in Blueprints, it would be a Blueprint class with creative_device as its parent, containing an Event BeginPlay; drag the execution wire out of BeginPlay, hook up a Print String node (contents: Hello, world!), then a second Print String (whose contents use {2 + 2} to compute 4 on the spot). The stepper below lights up those “nodes” for you, one line at a time.

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

# My first Verse device
hello_world_device := class(creative_device):

    OnBegin<override>()<suspends>:void =
        Print("Hello, world!")
        Print("2 + 2 = {2 + 2}")

See that? A handful of lines, and a “talking device” is complete. Now take it apart, one brick at a time:

• using { /Fortnite.com/Devices } — borrowing toolboxes. Verse’s abilities are packed into modules whose paths look like web addresses (/Fortnite.com, /Verse.org, /UnrealEngine.com); using hauls the toolboxes you need within reach before work starts. (Fun fact: Print itself comes from the /Verse.org/Verse module and works without an explicit import; the template’s third line, Diagnostics, imports other diagnostic tools.)
• hello_world_device := class(creative_device): — defining a new brick. := reads as “is defined as”: hello_world_device is defined as a class that inherits from creative_device. Mind the colon in := — it is a completely different beast from a lone =; see the pitfalls section.:= reads as “is defined as” — like right-clicking in the Content Browser to create a new Blueprint class and picking creative_device as its parent (just like making a Child Blueprint Class). Note the colon: it is not the same as a lone =, which means “compare for equality,” not “define”; see the pitfalls section.
• OnBegin<override>()<suspends>:void = — the starting whistle. It gets called automatically the moment the game experience begins — anything you want to happen at kickoff goes here. Don’t sweat the <override> and <suspends> in angle brackets for now; just remember “OnBegin is always written like this.” We take it apart properly next lesson.
• Print("...") — the echo spell. It prints text to the debug text area at the top-left of the screen and to UEFN’s Output Log — the “did my code actually run” power tool you will be using every single day.
• The line starting with # — a comment: a sticky note written for humans, which the machine skips entirely.

You can now read a real piece of Verse code line by line — the exact spot where plenty of people stall out on “page one.”

4. Indentation Is the Code Block: 4 Spaces = One Squad

You may have noticed a detail: there are no curly braces anywhere marking off “which code belongs to whom” (the braces after using are module-path syntax, not a code block), and no semicolons at the ends of lines.there is not a single bracket marking off “which code belongs to whom,” and no closing punctuation at the ends of lines — you never used those in Blueprints anyway, so don’t go looking. (The braces after using are module-path syntax, not a code block.) Verse relies on indentation — every 4 spaces of extra indent to the right says “I answer to the level above.” Like a formation: whoever stands in the column behind the squad leader is on the squad.

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

indent_demo := class(creative_device):

    OnBegin<override>()<suspends>:void =
        Print("I am indented under OnBegin, so I belong to OnBegin")
        Print("I line up with the line above, so we are the same squad")

Read the formation: OnBegin is indented 4 spaces, so it belongs to the class indent_demo; the two Print lines are indented another 4 spaces, so they both belong to OnBegin and will run one after the other at kickoff. Break the formation — miss a single space, or let a Tab sneak in — and the compiler throws an error, because it can no longer tell who that line answers to.

Three survival tips: ① always indent with 4 spaces, never mix Tabs and spaces; ② code at the same level must line up exactly; ③ in VS Code (Epic’s officially recommended Verse editor — the Verse extension installs alongside UEFN), pressing Tab converts to spaces automatically, so type away. Indentation is not decoration; it is the syntax itself.

5. Common Pitfalls: Reflexes You Bring from Other LanguagesWhere Blueprints and Verse Think Differently

If you have touched C++, JavaScript, or Python, a few reflexes will trip you up over and over in week one; if you are a pure beginner, congratulations — these traps simply don’t exist for you. Let’s nail them to the wall in advance:

You are coming over from wiring Blueprints, so strictly speaking you carry no bad habits from other text languages — but the points below are exactly where Blueprint intuition and Verse part ways. A quick look now saves a few faceplants later:

• Using = for assignment. In Verse, := is “is defined as”; a lone = is a failable equality comparison. Write X = 5 when you meant assignment and you get, at best, a compile error — at worst, semantics that are nothing like what you intended. This is Verse’s single biggest break from nearly every mainstream language; Lesson 4 settles that score in full.
• Assuming the equals sign means “assign.” In Blueprints you never typed an equals sign — changing a variable’s value was always dragging in a Set node. In Verse, assigning a new value is written set X = 5 (that is your Set node); a lone = is a failable equality comparison, not assignment. Mix them up and you get anything from a compile error to logic that runs completely off the rails; Lesson 4 settles that score.
• Hunting for semicolons and curly braces. No semicolons, no block braces — the code block is the indentation itself. The most common error for arrivals from C-family languages is misaligned indentation.
• Looking for a “scope” symbol. Verse has no semicolons and no curly braces to fence off a code block — which lines form a group is decided entirely by indentation alignment (covered in the previous section). In Blueprints, structure came from wires and node placement; in Verse, it comes from indentation. Don’t let it drift.
• Assuming the code ran because the Build succeeded. A successful compile only means the code is legal; Print output appears only after you launch a session (playtest session). Clicking Build and then staring blankly at the log is a rite of passage every newcomer goes through.
• Slipping on case. Verse is fully case-sensitive: print("hi") will not compile; it must be Print. The official naming convention is worth memorizing right now: types use lowercase snake_case (like creative_device); functions, variables, and other identifiers use PascalCase (like Print, OnBegin).
• Typing the wrong case. Verse is strictly case-sensitive: print("hi") fails to compile; it has to be capital-P Print. Two naming habits are all you need: devices and types are all lowercase with underscores (like creative_device); function and variable names capitalize each word (like Print, OnBegin) — the same kind of care you already put into naming variables and functions in Blueprints.
• Reaching for the UE C++ docs to find APIs. Inside UEFN, Verse can use the module APIs Epic explicitly exposes — not any random corner of the engine. Treat the Verse API Reference as the source of truth.
• Guessing what Verse can do from the Blueprint node list. A node you can wire in Blueprints does not necessarily have a same-name equivalent in Verse — Verse only opens up the capabilities Epic explicitly exposes (think of it as the official “available list”). Look features up in the Verse API Reference; don’t transplant Blueprint node names.

6. Level Challenge

Lesson 1’s boss fight is here (relax — it’s slime-tier). Answer correctly to earn a star ★; wrong answers cost no HP and you can retry forever.

Further Reading